Trait rai_core::Differentiable

pub trait Differentiable {
    type Tensors: TensorIter + 'static;
    type Gradient;

    // Required methods
    fn tensors(&self) -> Self::Tensors;
    fn grad(
        tensors: &Self::Tensors,
        grad_map: &HashMap<usize, Tensor>
    ) -> Self::Gradient;
    fn grad_map(
        tensors: &Self::Tensors,
        grad: Self::Gradient,
        out: &mut HashMap<usize, Tensor>
    );
}

Required Associated Types

type Tensors: TensorIter + 'static

type Gradient

Required Methods

fn tensors(&self) -> Self::Tensors

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

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

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<'a, T> Differentiable for &'a T

where T: Differentiable,

type Tensors = <T as Differentiable>::Tensors

type Gradient = <T as Differentiable>::Gradient

fn tensors(&self) -> Self::Tensors

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

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

impl<A> Differentiable for (A,)

where A: Differentiable, A::Tensors: TensorIter,

type Tensors = <A as Differentiable>::Tensors

type Gradient = <A as Differentiable>::Gradient

fn tensors(&self) -> Self::Tensors

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

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

impl<A, B> Differentiable for (A, B)

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

type Tensors = (<A as Differentiable>::Tensors, <B as Differentiable>::Tensors)

type Gradient = (<A as Differentiable>::Gradient, <B as Differentiable>::Gradient)

fn tensors(&self) -> Self::Tensors

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

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

impl<A, B, C> Differentiable for (A, B, C)

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

type Tensors = (<A as Differentiable>::Tensors, <B as Differentiable>::Tensors, <C as Differentiable>::Tensors)

type Gradient = (<A as Differentiable>::Gradient, <B as Differentiable>::Gradient, <C as Differentiable>::Gradient)

fn tensors(&self) -> Self::Tensors

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

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

impl<A, B, C, D> Differentiable for (A, B, C, D)

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

type Tensors = (<A as Differentiable>::Tensors, <B as Differentiable>::Tensors, <C as Differentiable>::Tensors, <D as Differentiable>::Tensors)

type Gradient = (<A as Differentiable>::Gradient, <B as Differentiable>::Gradient, <C as Differentiable>::Gradient, <D as Differentiable>::Gradient)

fn tensors(&self) -> Self::Tensors

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

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

impl<A, B, C, D, E> Differentiable for (A, B, C, D, E)

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

type Tensors = (<A as Differentiable>::Tensors, <B as Differentiable>::Tensors, <C as Differentiable>::Tensors, <D as Differentiable>::Tensors, <E as Differentiable>::Tensors)

type Gradient = (<A as Differentiable>::Gradient, <B as Differentiable>::Gradient, <C as Differentiable>::Gradient, <D as Differentiable>::Gradient, <E as Differentiable>::Gradient)

fn tensors(&self) -> Self::Tensors

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

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

impl<A, B, C, D, E, F> Differentiable for (A, B, C, D, E, F)

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

type Tensors = (<A as Differentiable>::Tensors, <B as Differentiable>::Tensors, <C as Differentiable>::Tensors, <D as Differentiable>::Tensors, <E as Differentiable>::Tensors, <F as Differentiable>::Tensors)

type Gradient = (<A as Differentiable>::Gradient, <B as Differentiable>::Gradient, <C as Differentiable>::Gradient, <D as Differentiable>::Gradient, <E as Differentiable>::Gradient, <F as Differentiable>::Gradient)

fn tensors(&self) -> Self::Tensors

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

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

impl<A, B, C, D, E, F, G> Differentiable for (A, B, C, D, E, F, G)

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

type Tensors = (<A as Differentiable>::Tensors, <B as Differentiable>::Tensors, <C as Differentiable>::Tensors, <D as Differentiable>::Tensors, <E as Differentiable>::Tensors, <F as Differentiable>::Tensors, <G as Differentiable>::Tensors)

type Gradient = (<A as Differentiable>::Gradient, <B as Differentiable>::Gradient, <C as Differentiable>::Gradient, <D as Differentiable>::Gradient, <E as Differentiable>::Gradient, <F as Differentiable>::Gradient, <G as Differentiable>::Gradient)

fn tensors(&self) -> Self::Tensors

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

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

impl<A, B, C, D, E, F, G, H> Differentiable for (A, B, C, D, E, F, G, H)

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

type Tensors = (<A as Differentiable>::Tensors, <B as Differentiable>::Tensors, <C as Differentiable>::Tensors, <D as Differentiable>::Tensors, <E as Differentiable>::Tensors, <F as Differentiable>::Tensors, <G as Differentiable>::Tensors, <H as Differentiable>::Tensors)

type Gradient = (<A as Differentiable>::Gradient, <B as Differentiable>::Gradient, <C as Differentiable>::Gradient, <D as Differentiable>::Gradient, <E as Differentiable>::Gradient, <F as Differentiable>::Gradient, <G as Differentiable>::Gradient, <H as Differentiable>::Gradient)

fn tensors(&self) -> Self::Tensors

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

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

impl<A, B, C, D, E, F, G, H, I> Differentiable for (A, B, C, D, E, F, G, H, I)

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

type Tensors = (<A as Differentiable>::Tensors, <B as Differentiable>::Tensors, <C as Differentiable>::Tensors, <D as Differentiable>::Tensors, <E as Differentiable>::Tensors, <F as Differentiable>::Tensors, <G as Differentiable>::Tensors, <H as Differentiable>::Tensors, <I as Differentiable>::Tensors)

type Gradient = (<A as Differentiable>::Gradient, <B as Differentiable>::Gradient, <C as Differentiable>::Gradient, <D as Differentiable>::Gradient, <E as Differentiable>::Gradient, <F as Differentiable>::Gradient, <G as Differentiable>::Gradient, <H as Differentiable>::Gradient, <I as Differentiable>::Gradient)

fn tensors(&self) -> Self::Tensors

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

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

impl<A, B, C, D, E, F, G, H, I, J> Differentiable for (A, B, C, D, E, F, G, H, I, J)

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

type Tensors = (<A as Differentiable>::Tensors, <B as Differentiable>::Tensors, <C as Differentiable>::Tensors, <D as Differentiable>::Tensors, <E as Differentiable>::Tensors, <F as Differentiable>::Tensors, <G as Differentiable>::Tensors, <H as Differentiable>::Tensors, <I as Differentiable>::Tensors, <J as Differentiable>::Tensors)

type Gradient = (<A as Differentiable>::Gradient, <B as Differentiable>::Gradient, <C as Differentiable>::Gradient, <D as Differentiable>::Gradient, <E as Differentiable>::Gradient, <F as Differentiable>::Gradient, <G as Differentiable>::Gradient, <H as Differentiable>::Gradient, <I as Differentiable>::Gradient, <J as Differentiable>::Gradient)

fn tensors(&self) -> Self::Tensors

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

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

impl<A, B, C, D, E, F, G, H, I, J, K> Differentiable for (A, B, C, D, E, F, G, H, I, J, K)

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

type Tensors = (<A as Differentiable>::Tensors, <B as Differentiable>::Tensors, <C as Differentiable>::Tensors, <D as Differentiable>::Tensors, <E as Differentiable>::Tensors, <F as Differentiable>::Tensors, <G as Differentiable>::Tensors, <H as Differentiable>::Tensors, <I as Differentiable>::Tensors, <J as Differentiable>::Tensors, <K as Differentiable>::Tensors)

type Gradient = (<A as Differentiable>::Gradient, <B as Differentiable>::Gradient, <C as Differentiable>::Gradient, <D as Differentiable>::Gradient, <E as Differentiable>::Gradient, <F as Differentiable>::Gradient, <G as Differentiable>::Gradient, <H as Differentiable>::Gradient, <I as Differentiable>::Gradient, <J as Differentiable>::Gradient, <K as Differentiable>::Gradient)

fn tensors(&self) -> Self::Tensors

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

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

impl<A, B, C, D, E, F, G, H, I, J, K, L> Differentiable for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: Differentiable, B: Differentiable, C: Differentiable, D: Differentiable, E: Differentiable, F: Differentiable, G: Differentiable, H: Differentiable, I: Differentiable, J: Differentiable, K: Differentiable, L: Differentiable, (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,

type Tensors = (<A as Differentiable>::Tensors, <B as Differentiable>::Tensors, <C as Differentiable>::Tensors, <D as Differentiable>::Tensors, <E as Differentiable>::Tensors, <F as Differentiable>::Tensors, <G as Differentiable>::Tensors, <H as Differentiable>::Tensors, <I as Differentiable>::Tensors, <J as Differentiable>::Tensors, <K as Differentiable>::Tensors, <L as Differentiable>::Tensors)

type Gradient = (<A as Differentiable>::Gradient, <B as Differentiable>::Gradient, <C as Differentiable>::Gradient, <D as Differentiable>::Gradient, <E as Differentiable>::Gradient, <F as Differentiable>::Gradient, <G as Differentiable>::Gradient, <H as Differentiable>::Gradient, <I as Differentiable>::Gradient, <J as Differentiable>::Gradient, <K as Differentiable>::Gradient, <L as Differentiable>::Gradient)

fn tensors(&self) -> Self::Tensors

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

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

impl<const N: usize, T> Differentiable for [T; N]

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

type Tensors = [<T as Differentiable>::Tensors; N]

type Gradient = [<T as Differentiable>::Gradient; N]

fn tensors(&self) -> Self::Tensors

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

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

Implementors

impl Differentiable for Tensor

type Tensors = Tensor

type Gradient = Tensor

impl<T> Differentiable for Aux<T>

type Tensors = ()

type Gradient = ()