Trait rai_core::GenericValue

pub trait GenericValue<Kind, Tensors, Gradient> {
    // Required methods
    fn gv_tensors(&self) -> Tensors;
    fn gv_grad(tensors: &Tensors, grad_map: &HashMap<usize, Tensor>) -> Gradient;
    fn gv_grad_map(
        tensors: &Tensors,
        grad: Gradient,
        out: &mut HashMap<usize, Tensor>
    );
}

Required Methods

fn gv_tensors(&self) -> Tensors

fn gv_grad(tensors: &Tensors, grad_map: &HashMap<usize, Tensor>) -> Gradient

fn gv_grad_map( tensors: &Tensors, grad: Gradient, out: &mut HashMap<usize, Tensor> )

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl GenericValue<Basic, (), ()> for Option<bool>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for Option<f32>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for Option<f64>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for Option<i8>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for Option<i16>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for Option<i32>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for Option<i64>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for Option<i128>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for Option<isize>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for Option<u8>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for Option<u16>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for Option<u32>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for Option<u64>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for Option<u128>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for Option<()>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for Option<usize>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for Option<bf16>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for Option<f16>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for bool

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for f32

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for f64

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for i8

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for i16

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for i32

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for i64

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for i128

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for isize

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for u8

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for u16

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for u32

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for u64

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for u128

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for ()

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for usize

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for bf16

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, (), ()> for f16

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl GenericValue<Basic, HashMap<usize, Tensor>, HashMap<usize, Tensor>> for HashMap<usize, Tensor>

fn gv_tensors(&self) -> HashMap<usize, Tensor>

fn gv_grad( tensors: &HashMap<usize, Tensor>, grad_map: &HashMap<usize, Tensor> ) -> HashMap<usize, Tensor>

fn gv_grad_map( tensors: &HashMap<usize, Tensor>, grad: HashMap<usize, Tensor>, out: &mut HashMap<usize, Tensor> )

impl<'a, A, T, G, X> GenericValue<Array<A>, T, G> for &'a X

where X: GenericValue<Array<A>, T, G>,

fn gv_tensors(&self) -> T

fn gv_grad(tensors: &T, grad_map: &HashMap<usize, Tensor>) -> G

fn gv_grad_map(tensors: &T, grad: G, out: &mut HashMap<usize, Tensor>)

impl<'a, A, T, G, X> GenericValue<Tuple<A>, T, G> for &'a X

where X: GenericValue<Tuple<A>, T, G>,

fn gv_tensors(&self) -> T

fn gv_grad(tensors: &T, grad_map: &HashMap<usize, Tensor>) -> G

fn gv_grad_map(tensors: &T, grad: G, out: &mut HashMap<usize, Tensor>)

impl<'a, T, G, X> GenericValue<Basic, T, G> for &'a X

where X: GenericValue<Basic, T, G>,

fn gv_tensors(&self) -> T

fn gv_grad(tensors: &T, grad_map: &HashMap<usize, Tensor>) -> G

fn gv_grad_map(tensors: &T, grad: G, out: &mut HashMap<usize, Tensor>)

impl<'a, T, G, X> GenericValue<Basic, T, G> for &'a mut X

where X: GenericValue<Basic, T, G>,

fn gv_tensors(&self) -> T

fn gv_grad(tensors: &T, grad_map: &HashMap<usize, Tensor>) -> G

fn gv_grad_map(tensors: &T, grad: G, out: &mut HashMap<usize, Tensor>)

impl<A> GenericValue<Tuple<(A,)>, <A as ValueSpec>::Tensors, <A as ValueSpec>::Gradient> for (A,)

where A: Value, A::Tensors: TensorIter,

fn gv_tensors(&self) -> A::Tensors

fn gv_grad( tensors: &A::Tensors, grad_map: &HashMap<usize, Tensor> ) -> A::Gradient

fn gv_grad_map( tensors: &A::Tensors, grad: A::Gradient, out: &mut HashMap<usize, Tensor> )

impl<A, B> GenericValue<Tuple<(A, B)>, (<A as ValueSpec>::Tensors, <B as ValueSpec>::Tensors), (<A as ValueSpec>::Gradient, <B as ValueSpec>::Gradient)> for (A, B)

where A: Value, B: Value, (A::Tensors, B::Tensors): TensorIter,

fn gv_tensors(&self) -> (A::Tensors, B::Tensors)

fn gv_grad( tensors: &(A::Tensors, B::Tensors), grad_map: &HashMap<usize, Tensor> ) -> (A::Gradient, B::Gradient)

fn gv_grad_map( tensors: &(A::Tensors, B::Tensors), grad: (A::Gradient, B::Gradient), out: &mut HashMap<usize, Tensor> )

impl<A, B, C> GenericValue<Tuple<(A, B, C)>, (<A as ValueSpec>::Tensors, <B as ValueSpec>::Tensors, <C as ValueSpec>::Tensors), (<A as ValueSpec>::Gradient, <B as ValueSpec>::Gradient, <C as ValueSpec>::Gradient)> for (A, B, C)

where A: Value, B: Value, C: Value, (A::Tensors, B::Tensors, C::Tensors): TensorIter,

fn gv_tensors(&self) -> (A::Tensors, B::Tensors, C::Tensors)

fn gv_grad( tensors: &(A::Tensors, B::Tensors, C::Tensors), grad_map: &HashMap<usize, Tensor> ) -> (A::Gradient, B::Gradient, C::Gradient)

fn gv_grad_map( tensors: &(A::Tensors, B::Tensors, C::Tensors), grad: (A::Gradient, B::Gradient, C::Gradient), out: &mut HashMap<usize, Tensor> )

impl<A, B, C, D> GenericValue<Tuple<(A, B, C, D)>, (<A as ValueSpec>::Tensors, <B as ValueSpec>::Tensors, <C as ValueSpec>::Tensors, <D as ValueSpec>::Tensors), (<A as ValueSpec>::Gradient, <B as ValueSpec>::Gradient, <C as ValueSpec>::Gradient, <D as ValueSpec>::Gradient)> for (A, B, C, D)

where A: Value, B: Value, C: Value, D: Value, (A::Tensors, B::Tensors, C::Tensors, D::Tensors): TensorIter,

fn gv_tensors(&self) -> (A::Tensors, B::Tensors, C::Tensors, D::Tensors)

fn gv_grad( tensors: &(A::Tensors, B::Tensors, C::Tensors, D::Tensors), grad_map: &HashMap<usize, Tensor> ) -> (A::Gradient, B::Gradient, C::Gradient, D::Gradient)

fn gv_grad_map( tensors: &(A::Tensors, B::Tensors, C::Tensors, D::Tensors), grad: (A::Gradient, B::Gradient, C::Gradient, D::Gradient), out: &mut HashMap<usize, Tensor> )

impl<A, B, C, D, E> GenericValue<Tuple<(A, B, C, D, E)>, (<A as ValueSpec>::Tensors, <B as ValueSpec>::Tensors, <C as ValueSpec>::Tensors, <D as ValueSpec>::Tensors, <E as ValueSpec>::Tensors), (<A as ValueSpec>::Gradient, <B as ValueSpec>::Gradient, <C as ValueSpec>::Gradient, <D as ValueSpec>::Gradient, <E as ValueSpec>::Gradient)> for (A, B, C, D, E)

where A: Value, B: Value, C: Value, D: Value, E: Value, (A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors): TensorIter,

fn gv_tensors( &self ) -> (A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors)

fn gv_grad( tensors: &(A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors), grad_map: &HashMap<usize, Tensor> ) -> (A::Gradient, B::Gradient, C::Gradient, D::Gradient, E::Gradient)

fn gv_grad_map( tensors: &(A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors), grad: (A::Gradient, B::Gradient, C::Gradient, D::Gradient, E::Gradient), out: &mut HashMap<usize, Tensor> )

impl<A, B, C, D, E, F> GenericValue<Tuple<(A, B, C, D, E, F)>, (<A as ValueSpec>::Tensors, <B as ValueSpec>::Tensors, <C as ValueSpec>::Tensors, <D as ValueSpec>::Tensors, <E as ValueSpec>::Tensors, <F as ValueSpec>::Tensors), (<A as ValueSpec>::Gradient, <B as ValueSpec>::Gradient, <C as ValueSpec>::Gradient, <D as ValueSpec>::Gradient, <E as ValueSpec>::Gradient, <F as ValueSpec>::Gradient)> for (A, B, C, D, E, F)

where A: Value, B: Value, C: Value, D: Value, E: Value, F: Value, (A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors): TensorIter,

fn gv_tensors( &self ) -> (A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors)

fn gv_grad( tensors: &(A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors), grad_map: &HashMap<usize, Tensor> ) -> (A::Gradient, B::Gradient, C::Gradient, D::Gradient, E::Gradient, F::Gradient)

fn gv_grad_map( tensors: &(A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors), grad: (A::Gradient, B::Gradient, C::Gradient, D::Gradient, E::Gradient, F::Gradient), out: &mut HashMap<usize, Tensor> )

impl<A, B, C, D, E, F, G> GenericValue<Tuple<(A, B, C, D, E, F, G)>, (<A as ValueSpec>::Tensors, <B as ValueSpec>::Tensors, <C as ValueSpec>::Tensors, <D as ValueSpec>::Tensors, <E as ValueSpec>::Tensors, <F as ValueSpec>::Tensors, <G as ValueSpec>::Tensors), (<A as ValueSpec>::Gradient, <B as ValueSpec>::Gradient, <C as ValueSpec>::Gradient, <D as ValueSpec>::Gradient, <E as ValueSpec>::Gradient, <F as ValueSpec>::Gradient, <G as ValueSpec>::Gradient)> for (A, B, C, D, E, F, G)

where A: Value, B: Value, C: Value, D: Value, E: Value, F: Value, G: Value, (A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors): TensorIter,

fn gv_tensors( &self ) -> (A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors)

fn gv_grad( tensors: &(A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors), grad_map: &HashMap<usize, Tensor> ) -> (A::Gradient, B::Gradient, C::Gradient, D::Gradient, E::Gradient, F::Gradient, G::Gradient)

fn gv_grad_map( tensors: &(A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors), grad: (A::Gradient, B::Gradient, C::Gradient, D::Gradient, E::Gradient, F::Gradient, G::Gradient), out: &mut HashMap<usize, Tensor> )

impl<A, B, C, D, E, F, G, H> GenericValue<Tuple<(A, B, C, D, E, F, G, H)>, (<A as ValueSpec>::Tensors, <B as ValueSpec>::Tensors, <C as ValueSpec>::Tensors, <D as ValueSpec>::Tensors, <E as ValueSpec>::Tensors, <F as ValueSpec>::Tensors, <G as ValueSpec>::Tensors, <H as ValueSpec>::Tensors), (<A as ValueSpec>::Gradient, <B as ValueSpec>::Gradient, <C as ValueSpec>::Gradient, <D as ValueSpec>::Gradient, <E as ValueSpec>::Gradient, <F as ValueSpec>::Gradient, <G as ValueSpec>::Gradient, <H as ValueSpec>::Gradient)> for (A, B, C, D, E, F, G, H)

where A: Value, B: Value, C: Value, D: Value, E: Value, F: Value, G: Value, H: Value, (A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors, H::Tensors): TensorIter,

fn gv_tensors( &self ) -> (A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors, H::Tensors)

fn gv_grad( tensors: &(A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors, H::Tensors), grad_map: &HashMap<usize, Tensor> ) -> (A::Gradient, B::Gradient, C::Gradient, D::Gradient, E::Gradient, F::Gradient, G::Gradient, H::Gradient)

fn gv_grad_map( tensors: &(A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors, H::Tensors), grad: (A::Gradient, B::Gradient, C::Gradient, D::Gradient, E::Gradient, F::Gradient, G::Gradient, H::Gradient), out: &mut HashMap<usize, Tensor> )

impl<A, B, C, D, E, F, G, H, I> GenericValue<Tuple<(A, B, C, D, E, F, G, H, I)>, (<A as ValueSpec>::Tensors, <B as ValueSpec>::Tensors, <C as ValueSpec>::Tensors, <D as ValueSpec>::Tensors, <E as ValueSpec>::Tensors, <F as ValueSpec>::Tensors, <G as ValueSpec>::Tensors, <H as ValueSpec>::Tensors, <I as ValueSpec>::Tensors), (<A as ValueSpec>::Gradient, <B as ValueSpec>::Gradient, <C as ValueSpec>::Gradient, <D as ValueSpec>::Gradient, <E as ValueSpec>::Gradient, <F as ValueSpec>::Gradient, <G as ValueSpec>::Gradient, <H as ValueSpec>::Gradient, <I as ValueSpec>::Gradient)> for (A, B, C, D, E, F, G, H, I)

where A: Value, B: Value, C: Value, D: Value, E: Value, F: Value, G: Value, H: Value, I: Value, (A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors, H::Tensors, I::Tensors): TensorIter,

fn gv_tensors( &self ) -> (A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors, H::Tensors, I::Tensors)

fn gv_grad( tensors: &(A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors, H::Tensors, I::Tensors), grad_map: &HashMap<usize, Tensor> ) -> (A::Gradient, B::Gradient, C::Gradient, D::Gradient, E::Gradient, F::Gradient, G::Gradient, H::Gradient, I::Gradient)

fn gv_grad_map( tensors: &(A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors, H::Tensors, I::Tensors), grad: (A::Gradient, B::Gradient, C::Gradient, D::Gradient, E::Gradient, F::Gradient, G::Gradient, H::Gradient, I::Gradient), out: &mut HashMap<usize, Tensor> )

impl<A, B, C, D, E, F, G, H, I, J> GenericValue<Tuple<(A, B, C, D, E, F, G, H, I, J)>, (<A as ValueSpec>::Tensors, <B as ValueSpec>::Tensors, <C as ValueSpec>::Tensors, <D as ValueSpec>::Tensors, <E as ValueSpec>::Tensors, <F as ValueSpec>::Tensors, <G as ValueSpec>::Tensors, <H as ValueSpec>::Tensors, <I as ValueSpec>::Tensors, <J as ValueSpec>::Tensors), (<A as ValueSpec>::Gradient, <B as ValueSpec>::Gradient, <C as ValueSpec>::Gradient, <D as ValueSpec>::Gradient, <E as ValueSpec>::Gradient, <F as ValueSpec>::Gradient, <G as ValueSpec>::Gradient, <H as ValueSpec>::Gradient, <I as ValueSpec>::Gradient, <J as ValueSpec>::Gradient)> for (A, B, C, D, E, F, G, H, I, J)

where A: Value, B: Value, C: Value, D: Value, E: Value, F: Value, G: Value, H: Value, I: Value, J: Value, (A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors, H::Tensors, I::Tensors, J::Tensors): TensorIter,

fn gv_tensors( &self ) -> (A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors, H::Tensors, I::Tensors, J::Tensors)

fn gv_grad( tensors: &(A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors, H::Tensors, I::Tensors, J::Tensors), grad_map: &HashMap<usize, Tensor> ) -> (A::Gradient, B::Gradient, C::Gradient, D::Gradient, E::Gradient, F::Gradient, G::Gradient, H::Gradient, I::Gradient, J::Gradient)

fn gv_grad_map( tensors: &(A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors, H::Tensors, I::Tensors, J::Tensors), grad: (A::Gradient, B::Gradient, C::Gradient, D::Gradient, E::Gradient, F::Gradient, G::Gradient, H::Gradient, I::Gradient, J::Gradient), out: &mut HashMap<usize, Tensor> )

impl<A, B, C, D, E, F, G, H, I, J, K> GenericValue<Tuple<(A, B, C, D, E, F, G, H, I, J, K)>, (<A as ValueSpec>::Tensors, <B as ValueSpec>::Tensors, <C as ValueSpec>::Tensors, <D as ValueSpec>::Tensors, <E as ValueSpec>::Tensors, <F as ValueSpec>::Tensors, <G as ValueSpec>::Tensors, <H as ValueSpec>::Tensors, <I as ValueSpec>::Tensors, <J as ValueSpec>::Tensors, <K as ValueSpec>::Tensors), (<A as ValueSpec>::Gradient, <B as ValueSpec>::Gradient, <C as ValueSpec>::Gradient, <D as ValueSpec>::Gradient, <E as ValueSpec>::Gradient, <F as ValueSpec>::Gradient, <G as ValueSpec>::Gradient, <H as ValueSpec>::Gradient, <I as ValueSpec>::Gradient, <J as ValueSpec>::Gradient, <K as ValueSpec>::Gradient)> for (A, B, C, D, E, F, G, H, I, J, K)

where A: Value, B: Value, C: Value, D: Value, E: Value, F: Value, G: Value, H: Value, I: Value, J: Value, K: Value, (A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors, H::Tensors, I::Tensors, J::Tensors, K::Tensors): TensorIter,

fn gv_tensors( &self ) -> (A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors, H::Tensors, I::Tensors, J::Tensors, K::Tensors)

fn gv_grad( tensors: &(A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors, H::Tensors, I::Tensors, J::Tensors, K::Tensors), grad_map: &HashMap<usize, Tensor> ) -> (A::Gradient, B::Gradient, C::Gradient, D::Gradient, E::Gradient, F::Gradient, G::Gradient, H::Gradient, I::Gradient, J::Gradient, K::Gradient)

fn gv_grad_map( tensors: &(A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors, H::Tensors, I::Tensors, J::Tensors, K::Tensors), grad: (A::Gradient, B::Gradient, C::Gradient, D::Gradient, E::Gradient, F::Gradient, G::Gradient, H::Gradient, I::Gradient, J::Gradient, K::Gradient), out: &mut HashMap<usize, Tensor> )

impl<A, B, C, D, E, F, G, H, I, J, K, L> GenericValue<Tuple<(A, B, C, D, E, F, G, H, I, J, K, L)>, (<A as ValueSpec>::Tensors, <B as ValueSpec>::Tensors, <C as ValueSpec>::Tensors, <D as ValueSpec>::Tensors, <E as ValueSpec>::Tensors, <F as ValueSpec>::Tensors, <G as ValueSpec>::Tensors, <H as ValueSpec>::Tensors, <I as ValueSpec>::Tensors, <J as ValueSpec>::Tensors, <K as ValueSpec>::Tensors, <L as ValueSpec>::Tensors), (<A as ValueSpec>::Gradient, <B as ValueSpec>::Gradient, <C as ValueSpec>::Gradient, <D as ValueSpec>::Gradient, <E as ValueSpec>::Gradient, <F as ValueSpec>::Gradient, <G as ValueSpec>::Gradient, <H as ValueSpec>::Gradient, <I as ValueSpec>::Gradient, <J as ValueSpec>::Gradient, <K as ValueSpec>::Gradient, <L as ValueSpec>::Gradient)> for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: Value, B: Value, C: Value, D: Value, E: Value, F: Value, G: Value, H: Value, I: Value, J: Value, K: Value, L: Value, (A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors, H::Tensors, I::Tensors, J::Tensors, K::Tensors, L::Tensors): TensorIter,

fn gv_tensors( &self ) -> (A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors, H::Tensors, I::Tensors, J::Tensors, K::Tensors, L::Tensors)

fn gv_grad( tensors: &(A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors, H::Tensors, I::Tensors, J::Tensors, K::Tensors, L::Tensors), grad_map: &HashMap<usize, Tensor> ) -> (A::Gradient, B::Gradient, C::Gradient, D::Gradient, E::Gradient, F::Gradient, G::Gradient, H::Gradient, I::Gradient, J::Gradient, K::Gradient, L::Gradient)

fn gv_grad_map( tensors: &(A::Tensors, B::Tensors, C::Tensors, D::Tensors, E::Tensors, F::Tensors, G::Tensors, H::Tensors, I::Tensors, J::Tensors, K::Tensors, L::Tensors), grad: (A::Gradient, B::Gradient, C::Gradient, D::Gradient, E::Gradient, F::Gradient, G::Gradient, H::Gradient, I::Gradient, J::Gradient, K::Gradient, L::Gradient), out: &mut HashMap<usize, Tensor> )

impl<E> GenericValue<Basic, (), ()> for Result<bool, E>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl<E> GenericValue<Basic, (), ()> for Result<f32, E>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl<E> GenericValue<Basic, (), ()> for Result<f64, E>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl<E> GenericValue<Basic, (), ()> for Result<i8, E>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl<E> GenericValue<Basic, (), ()> for Result<i16, E>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl<E> GenericValue<Basic, (), ()> for Result<i32, E>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl<E> GenericValue<Basic, (), ()> for Result<i64, E>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl<E> GenericValue<Basic, (), ()> for Result<i128, E>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl<E> GenericValue<Basic, (), ()> for Result<isize, E>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl<E> GenericValue<Basic, (), ()> for Result<u8, E>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl<E> GenericValue<Basic, (), ()> for Result<u16, E>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl<E> GenericValue<Basic, (), ()> for Result<u32, E>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl<E> GenericValue<Basic, (), ()> for Result<u64, E>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl<E> GenericValue<Basic, (), ()> for Result<u128, E>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl<E> GenericValue<Basic, (), ()> for Result<(), E>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl<E> GenericValue<Basic, (), ()> for Result<usize, E>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl<E> GenericValue<Basic, (), ()> for Result<bf16, E>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl<E> GenericValue<Basic, (), ()> for Result<f16, E>

fn gv_tensors(&self)

fn gv_grad(_: &(), _: &HashMap<usize, Tensor>)

fn gv_grad_map(_: &(), _: (), _: &mut HashMap<usize, Tensor>)

impl<const N: usize, T> GenericValue<Array<[T; N]>, [<T as ValueSpec>::Tensors; N], [<T as ValueSpec>::Gradient; N]> for [T; N]

where T: Value, [T::Tensors; N]: TensorIter,

fn gv_tensors(&self) -> [T::Tensors; N]

fn gv_grad( tensors: &[T::Tensors; N], grad_map: &HashMap<usize, Tensor> ) -> [T::Gradient; N]

fn gv_grad_map( tensors: &[T::Tensors; N], grad: [T::Gradient; N], out: &mut HashMap<usize, Tensor> )

Implementors

impl GenericValue<Basic, Tensor, Tensor> for Tensor

impl<T> GenericValue<Basic, (), ()> for Aux<T>

impl<T> GenericValue<Module, (), ()> for T

where T: NonTrainableModule<Tensors = (), Gradient = ()>,

impl<T> GenericValue<Module, HashMap<usize, Tensor>, HashMap<usize, Tensor>> for T

where T: TrainableModule<Tensors = HashMap<usize, Tensor>, Gradient = HashMap<usize, Tensor>>,