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

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so 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>>,