Struct zyx::tensor::Variable

pub struct Variable<S> { /* private fields */ }

Variable

Variable holds data and it’s gradient.

Implementations

impl<S> Variable<S>

pub fn backward(&mut self)where
    S: Add<i32, Output = S> + Zeros,

Variable backward

Calls backward function on Variable. This results in Variable’s gradient being increased by one. We take Variable with mutable reference, so that we have exclusive access during mutation of gradient.

x.grad += 1;

Example

use zyx::prelude::*;
let mut x = 3.with_grad();
x.backward();
assert_eq!(x.grad(), &1);

And gradient gets accumulated if we call backward again.

x.backward();
assert_eq!(x.grad(), &2);

impl<S> Variable<S>

pub fn data(&self) -> &S

Access Variable’s data buffer

impl<S> Variable<S>

pub fn grad(&self) -> &Gradient<S>

Access Tensor’s grad buffer

impl<S> Variable<S>

pub fn register_hook<HOOK>(
    &self,
    hook: HOOK
) -> Tensor<S, GradHookV<'_, S, HOOK>>where
    S: Clone,
    HOOK: FnOnce(S),

Add custom FnOnce closure that will receive Buffer’s gradient during backward pass. The hook is stored in the result, so make sure to do all operations on this result, otherwise your hook will not be called.

Trait Implementations

impl<'g, XS, YS> Add<&'g Variable<YS>> for &'g Variable<XS>where
    XS: Clone + Add<YS>,
    YS: Clone,

type Output = Tensor<<XS as Add<YS>>::Output, AddBackwardVV<'g, XS, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for Buffer<bool>where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<Buffer<bool> as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for Buffer<f32>where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<Buffer<f32> as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for Buffer<f64>where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<Buffer<f64> as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for Buffer<i128>where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<Buffer<i128> as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for Buffer<i32>where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<Buffer<i32> as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for Buffer<i64>where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<Buffer<i64> as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for Buffer<u128>where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<Buffer<u128> as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for Buffer<u16>where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<Buffer<u16> as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for Buffer<u32>where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<Buffer<u32> as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for Buffer<u64>where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<Buffer<u64> as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for Buffer<u8>where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<Buffer<u8> as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, XS, YS, XF> Add<&'g Variable<YS>> for Tensor<XS, XF>where
    XS: Add<YS> + DType,
    YS: Clone + DType,

type Output = Tensor<<XS as Add<YS>>::Output, AddBackwardTV<'g, YS, XF>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for boolwhere
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<bool as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for f32where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<f32 as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for f64where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<f64 as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for i128where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<i128 as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for i16where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<i16 as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for i32where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<i32 as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for i64where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<i64 as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for i8where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<i8 as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for isizewhere
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<isize as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for u128where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<u128 as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for u16where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<u16 as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for u32where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<u32 as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for u64where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<u64 as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for u8where
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<u8 as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, YS> Add<&'g Variable<YS>> for usizewhere
    Self: Add<YS>,
    YS: Clone + DType,

type Output = Tensor<<usize as Add<YS>>::Output, AddBackwardSV<'g, YS>>

The resulting type after applying the + operator.

fn add(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the + operation.

impl<'g, XS, YS, YF> Add<Tensor<YS, YF>> for &'g Variable<XS>where
    XS: Clone + Add<YS>,
    YS: 'g,

type Output = Tensor<<XS as Add<YS>>::Output, AddBackwardVT<'g, XS, YF>>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the + operation.

impl<'g, XS, YS> Add<YS> for &'g Variable<XS>where
    XS: Clone + Add<YS>,
    YS: DType,

type Output = Tensor<<XS as Add<YS>>::Output, AddBackwardVS<'g, XS>>

The resulting type after applying the + operator.

fn add(self, rhs: YS) -> Self::Output

Performs the + operation.

impl<S: Clone> Clone for Variable<S>

fn clone(&self) -> Variable<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S, S2> ConvertFrom<Variable<S2>> for Variable<S>where
    S: ConvertFrom<S2>,
    S2: Clone,

Conversions between devices and types

fn cfrom(x: Variable<S2>) -> Self

Converts input into output type

impl<S: Debug> Debug for Variable<S>

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

Formats the value using the given formatter.

impl<S: Default> Default for Variable<S>

fn default() -> Variable<S>

Returns the “default value” for a type.

impl<S> Display for Variable<S>where
    S: Display,

Display Variable

Shows Variable and it’s gradient.

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

Formats the value using the given formatter.

impl<'g, XS, YS> Div<&'g Variable<YS>> for &'g Variable<XS>where
    XS: Clone + Div<YS> + DType,
    YS: Clone + DType,
    <XS as Div<YS>>::Output: Clone,

type Output = Tensor<<XS as Div<YS>>::Output, DivBackwardVV<'g, <XS as Div<YS>>::Output, XS, YS, YS>>

The resulting type after applying the / operator.

fn div(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the / operation.

impl<'g, XS, YS, XF> Div<&'g Variable<YS>> for Tensor<XS, XF>where
    XS: Div<YS> + DType,
    YS: Clone + DType,
    <XS as Div<YS>>::Output: Clone,

type Output = Tensor<<XS as Div<YS>>::Output, DivBackwardTV<'g, <XS as Div<YS>>::Output, YS, YS, XF>>

The resulting type after applying the / operator.

fn div(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the / operation.

impl<'g, XS, YS, YF> Div<Tensor<YS, YF>> for &'g Variable<XS>where
    XS: Clone + Div<YS>,
    YS: Clone,
    <XS as Div<YS>>::Output: Clone,

type Output = Tensor<<XS as Div<YS>>::Output, DivBackwardVT<'g, <XS as Div<YS>>::Output, XS, YS, YF>>

The resulting type after applying the / operator.

fn div(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the / operation.

impl<'g, XS, YS> Div<YS> for &'g Variable<XS>where
    XS: Clone + Div<YS>,
    YS: Clone + DType,

type Output = Tensor<<XS as Div<YS>>::Output, DivBackwardVS<'g, XS, YS>>

The resulting type after applying the / operator.

fn div(self, rhs: YS) -> Self::Output

Performs the / operation.

impl<'g, S> Exp for &'g Variable<S>where
    S: Clone + Exp,
    <S as Exp>::Output: Clone,

type Output = Tensor<<S as Exp>::Output, ExpBackwardV<'g, <S as Exp>::Output, S>>

Output of the Exp operation.

fn exp(self) -> Self::Output

Apply Exp operation on given input.

impl<'g, S> Expand for &'g Variable<S>where
    S: Clone + Expand + GetShape,

type Output = Tensor<<S as Expand>::Output, ExpandBackwardV<'g, S>>

Output of the Expand operation.

fn expand(self, shape: impl IntoShape) -> Self::Output

Apply Expand operation on given input.

impl<S> GetShape for Variable<S>where
    S: GetShape,

fn shape(&self) -> Shape

Get shape of input tensor.

impl<S, T> IntoVec<T> for Variable<S>where
    S: Clone + IntoVec<T>,

fn to_vec(&self) -> Vec<T>

Returns values from tensor as a Vec with row-major order.

impl<'g, S> Ln for &'g Variable<S>where
    S: Clone + Ln,

type Output = Tensor<<S as Ln>::Output, LnBackwardV<'g, S, S>>

Output of the Ln operation.

fn ln(self) -> Self::Output

Apply Ln operation on given input.

impl<'g, XS, YS> MatMul<&'g Variable<YS>> for &'g Variable<XS>where
    XS: Clone + MatMul<YS>,
    YS: Clone,

type Output = Tensor<<XS as MatMul<YS>>::Output, MatMulBackwardVV<'g, XS, XS, YS, YS>>

Output of the MatMul operation.

fn matmul(self, rhs: &'g Variable<YS>) -> Self::Output

Apply MatMul operation on given input.

impl<'g, XS, XF, YS> MatMul<&'g Variable<YS>> for Tensor<XS, XF>where
    XS: Clone + MatMul<YS>,
    YS: Clone,

type Output = Tensor<<XS as MatMul<YS>>::Output, MatMulBackwardTV<'g, YS, XS, YS, XF>>

Output of the MatMul operation.

fn matmul(self, rhs: &'g Variable<YS>) -> Self::Output

Apply MatMul operation on given input.

impl<'g, XS, YS, YF> MatMul<Tensor<YS, YF>> for &'g Variable<XS>where
    XS: Clone + MatMul<YS>,
    YS: Clone,

type Output = Tensor<<XS as MatMul<YS>>::Output, MatMulBackwardVT<'g, XS, XS, YS, YF>>

Output of the MatMul operation.

fn matmul(self, rhs: Tensor<YS, YF>) -> Self::Output

Apply MatMul operation on given input.

impl<'g, XS, YS> MatMul<YS> for &'g Variable<XS>where
    XS: Clone + MatMul<YS>,
    YS: Clone + DType,

type Output = Tensor<<XS as MatMul<YS>>::Output, MatMulBackwardVS<'g, XS, YS>>

Output of the MatMul operation.

fn matmul(self, rhs: YS) -> Self::Output

Apply MatMul operation on given input.

impl<'g, S> Max for &'g Variable<S>where
    S: Clone + Max + GetShape,

type Output = Tensor<<S as Max>::Output, MaxBackwardV<'g, S>>

Output of the Max operation.

fn max(self, dims: impl IntoDims) -> Self::Output

Apply Max operation on given input.

impl<'g, S> Min for &'g Variable<S>where
    S: Clone + Min + GetShape,

type Output = Tensor<<S as Min>::Output, MinBackwardV<'g, S>>

Output of the Min operation.

fn min(self, dims: impl IntoDims) -> Self::Output

Apply Min operation on given input.

impl<'g, XS, YS> Mul<&'g Variable<YS>> for &'g Variable<XS>where
    XS: Clone + Mul<YS>,
    YS: Clone,

type Output = Tensor<<XS as Mul<YS>>::Output, MulBackwardVV<'g, XS, XS, YS, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for Buffer<bool>where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<Buffer<bool> as Mul<YS>>::Output, MulBackwardSV<'g, Buffer<bool>, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for Buffer<f32>where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<Buffer<f32> as Mul<YS>>::Output, MulBackwardSV<'g, Buffer<f32>, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for Buffer<f64>where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<Buffer<f64> as Mul<YS>>::Output, MulBackwardSV<'g, Buffer<f64>, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for Buffer<i128>where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<Buffer<i128> as Mul<YS>>::Output, MulBackwardSV<'g, Buffer<i128>, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for Buffer<i32>where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<Buffer<i32> as Mul<YS>>::Output, MulBackwardSV<'g, Buffer<i32>, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for Buffer<i64>where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<Buffer<i64> as Mul<YS>>::Output, MulBackwardSV<'g, Buffer<i64>, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for Buffer<u128>where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<Buffer<u128> as Mul<YS>>::Output, MulBackwardSV<'g, Buffer<u128>, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for Buffer<u16>where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<Buffer<u16> as Mul<YS>>::Output, MulBackwardSV<'g, Buffer<u16>, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for Buffer<u32>where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<Buffer<u32> as Mul<YS>>::Output, MulBackwardSV<'g, Buffer<u32>, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for Buffer<u64>where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<Buffer<u64> as Mul<YS>>::Output, MulBackwardSV<'g, Buffer<u64>, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for Buffer<u8>where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<Buffer<u8> as Mul<YS>>::Output, MulBackwardSV<'g, Buffer<u8>, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, XS, YS, XF> Mul<&'g Variable<YS>> for Tensor<XS, XF>where
    XS: Clone + Mul<YS>,
    YS: Clone,

type Output = Tensor<<XS as Mul<YS>>::Output, MulBackwardTV<'g, XS, YS, YS, XF>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for boolwhere
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<bool as Mul<YS>>::Output, MulBackwardSV<'g, bool, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for f32where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<f32 as Mul<YS>>::Output, MulBackwardSV<'g, f32, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for f64where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<f64 as Mul<YS>>::Output, MulBackwardSV<'g, f64, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for i128where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<i128 as Mul<YS>>::Output, MulBackwardSV<'g, i128, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for i16where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<i16 as Mul<YS>>::Output, MulBackwardSV<'g, i16, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for i32where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<i32 as Mul<YS>>::Output, MulBackwardSV<'g, i32, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for i64where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<i64 as Mul<YS>>::Output, MulBackwardSV<'g, i64, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for i8where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<i8 as Mul<YS>>::Output, MulBackwardSV<'g, i8, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for isizewhere
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<isize as Mul<YS>>::Output, MulBackwardSV<'g, isize, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for u128where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<u128 as Mul<YS>>::Output, MulBackwardSV<'g, u128, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for u16where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<u16 as Mul<YS>>::Output, MulBackwardSV<'g, u16, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for u32where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<u32 as Mul<YS>>::Output, MulBackwardSV<'g, u32, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for u64where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<u64 as Mul<YS>>::Output, MulBackwardSV<'g, u64, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for u8where
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<u8 as Mul<YS>>::Output, MulBackwardSV<'g, u8, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, YS> Mul<&'g Variable<YS>> for usizewhere
    Self: Mul<YS>,
    YS: Clone,

type Output = Tensor<<usize as Mul<YS>>::Output, MulBackwardSV<'g, usize, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the * operation.

impl<'g, XS, YS, F> Mul<Tensor<YS, F>> for &'g Variable<XS>where
    XS: Clone + Mul<YS>,
    YS: Clone,

type Output = Tensor<<XS as Mul<YS>>::Output, MulBackwardVT<'g, XS, XS, YS, F>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<YS, F>) -> Self::Output

Performs the * operation.

impl<'g, XS, YS> Mul<YS> for &'g Variable<XS>where
    YS: Clone + DType,
    XS: Clone + Mul<YS>,

type Output = Tensor<<XS as Mul<YS>>::Output, MulBackwardVS<'g, XS, YS>>

The resulting type after applying the * operator.

fn mul(self, rhs: YS) -> Self::Output

Performs the * operation.

impl<'g, S> Neg for &'g Variable<S>where
    S: Clone + Neg,

type Output = Tensor<<S as Neg>::Output, NegBackwardV<'g, S>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<S> Ones for Variable<S>where
    S: Ones + Zeros,

Initialize tensor filled with zeros

fn ones(shape: impl IntoShape) -> Self

Create new tensor initialized with ones.

impl<S> Parameters for &mut Variable<S>where
    S: Clone + Mul<f64> + Sub<<S as Mul<f64>>::Output, Output = S>,

fn step<Optim>(self, optim: &Optim)where
    Optim: Optimizer,

Update Parameter’s data

fn zero_grad(&mut self)

Zero Parameter’s gradients

impl<'g, S> Permute for &'g Variable<S>where
    S: Clone + Permute,

type Output = Tensor<<S as Permute>::Output, PermuteBackwardV<'g, S>>

Output of the Permute operation.

fn permute(self, dims: impl IntoDims) -> Self::Output

Apply Permute operation on given input.

impl<'g, XS, YS> Pow<&'g Variable<YS>> for &'g Variable<XS>where
    XS: Clone + Pow<YS> + Ln,
    YS: Clone + Mul<<XS as Pow<YS>>::Output>,
    <XS as Pow<YS>>::Output: Clone,
    <YS as Mul<<XS as Pow<YS>>::Output>>::Output: Div<XS>,
    <XS as Pow<YS>>::Output: Mul<<XS as Ln>::Output>,

type Output = Tensor<<XS as Pow<YS>>::Output, PowBackwardVV<'g, XS, <<YS as Mul<<XS as Pow<YS>>::Output>>::Output as Div<XS>>::Output, YS, <<XS as Pow<YS>>::Output as Mul<<XS as Ln>::Output>>::Output>>

Output of the Pow operation.

fn pow(self, rhs: &'g Variable<YS>) -> Self::Output

Apply Pow operation on given input.

impl<'g, XS, YS, XF> Pow<&'g Variable<YS>> for Tensor<XS, XF>where
    XS: Clone + Pow<YS> + Ln,
    YS: Clone + Mul<<XS as Pow<YS>>::Output>,
    <XS as Pow<YS>>::Output: Clone,
    <YS as Mul<<XS as Pow<YS>>::Output>>::Output: Div<XS>,
    <XS as Pow<YS>>::Output: Mul<<XS as Ln>::Output>,

type Output = Tensor<<XS as Pow<YS>>::Output, PowBackwardTV<'g, YS, <<YS as Mul<<XS as Pow<YS>>::Output>>::Output as Div<XS>>::Output, <<XS as Pow<YS>>::Output as Mul<<XS as Ln>::Output>>::Output, XF>>

Output of the Pow operation.

fn pow(self, rhs: &'g Variable<YS>) -> Self::Output

Apply Pow operation on given input.

impl<'g, XS, YS, YF> Pow<Tensor<YS, YF>> for &'g Variable<XS>where
    XS: Clone + Pow<YS> + Ln,
    YS: Clone + Mul<<XS as Pow<YS>>::Output>,
    <XS as Pow<YS>>::Output: Clone,
    <YS as Mul<<XS as Pow<YS>>::Output>>::Output: Div<XS>,
    <XS as Pow<YS>>::Output: Mul<<XS as Ln>::Output>,

type Output = Tensor<<XS as Pow<YS>>::Output, PowBackwardVT<'g, XS, <<YS as Mul<<XS as Pow<YS>>::Output>>::Output as Div<XS>>::Output, <<XS as Pow<YS>>::Output as Mul<<XS as Ln>::Output>>::Output, YF>>

Output of the Pow operation.

fn pow(self, rhs: Tensor<YS, YF>) -> Self::Output

Apply Pow operation on given input.

impl<'g, XS, YS> Pow<YS> for &'g Variable<XS>where
    XS: Clone + Pow<YS>,
    YS: Clone + DType + Mul<<XS as Pow<YS>>::Output>,
    <YS as Mul<<XS as Pow<YS>>::Output>>::Output: Div<XS>,
    <XS as Pow<YS>>::Output: Clone,

type Output = Tensor<<XS as Pow<YS>>::Output, PowBackwardVS<'g, XS, <<YS as Mul<<XS as Pow<YS>>::Output>>::Output as Div<XS>>::Output>>

Output of the Pow operation.

fn pow(self, rhs: YS) -> Self::Output

Apply Pow operation on given input.

impl<'g, S> ReLU for &'g Variable<S>where
    S: Clone + ReLU,

type Output = Tensor<<S as ReLU>::Output, ReLUBackwardV<'g, S, S>>

Output of the ReLU operation.

fn relu(self) -> Self::Output

Apply ReLU operation on given input.

impl<'g, S> Reshape for &'g Variable<S>where
    S: Clone + Reshape + GetShape,

type Output = Tensor<<S as Reshape>::Output, ReshapeBackwardV<'g, S>>

Output of the Reshape operation.

fn reshape(self, shape: impl IntoShape) -> Self::Output

Apply Reshape operation on given input.

impl<'g, XS, YS> Sub<&'g Variable<YS>> for &'g Variable<XS>where
    XS: Clone + Sub<YS>,
    YS: Clone,

type Output = Tensor<<XS as Sub<YS>>::Output, SubBackwardVV<'g, XS, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for Buffer<bool>where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<Buffer<bool> as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for Buffer<f32>where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<Buffer<f32> as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for Buffer<f64>where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<Buffer<f64> as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for Buffer<i128>where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<Buffer<i128> as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for Buffer<i32>where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<Buffer<i32> as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for Buffer<i64>where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<Buffer<i64> as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for Buffer<u128>where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<Buffer<u128> as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for Buffer<u16>where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<Buffer<u16> as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for Buffer<u32>where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<Buffer<u32> as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for Buffer<u64>where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<Buffer<u64> as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for Buffer<u8>where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<Buffer<u8> as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, XS, YS, XF> Sub<&'g Variable<YS>> for Tensor<XS, XF>where
    XS: Clone + Sub<YS>,
    YS: Clone,

type Output = Tensor<<XS as Sub<YS>>::Output, SubBackwardTV<'g, YS, XF>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for boolwhere
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<bool as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for f32where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<f32 as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for f64where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<f64 as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for i128where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<i128 as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for i16where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<i16 as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for i32where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<i32 as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for i64where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<i64 as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for i8where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<i8 as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for isizewhere
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<isize as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for u128where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<u128 as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for u16where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<u16 as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for u32where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<u32 as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for u64where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<u64 as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for u8where
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<u8 as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, YS> Sub<&'g Variable<YS>> for usizewhere
    Self: Sub<YS>,
    YS: Clone + DType,

type Output = Tensor<<usize as Sub<YS>>::Output, SubBackwardSV<'g, YS>>

The resulting type after applying the - operator.

fn sub(self, rhs: &'g Variable<YS>) -> Self::Output

Performs the - operation.

impl<'g, XS, YS, YF> Sub<Tensor<YS, YF>> for &'g Variable<XS>where
    XS: Clone + Sub<YS>,

type Output = Tensor<<XS as Sub<YS>>::Output, SubBackwardVT<'g, XS, YF>>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<YS, YF>) -> Self::Output

Performs the - operation.

impl<'g, XS, YS> Sub<YS> for &'g Variable<XS>where
    XS: Clone + Sub<YS>,
    YS: DType,

type Output = Tensor<<XS as Sub<YS>>::Output, SubBackwardVS<'g, XS>>

The resulting type after applying the - operator.

fn sub(self, rhs: YS) -> Self::Output

Performs the - operation.

impl<'g, S> Sum for &'g Variable<S>where
    S: Clone + Sum + GetShape,

type Output = Tensor<<S as Sum>::Output, SumBackwardV<'g, S>>

Output of the Sum operation.

fn sum(self, dims: impl IntoDims) -> Self::Output

Apply Sum operation on given input.

impl<'g, S> Tanh for &'g Variable<S>where
    S: Clone + Tanh,
    <S as Tanh>::Output: Clone,

type Output = Tensor<<S as Tanh>::Output, TanhBackwardV<'g, <S as Tanh>::Output, S>>

Output of the Tanh operation.

fn tanh(self) -> Self::Output

Apply Tanh operation on given input.

impl<S> Zeros for Variable<S>where
    S: Zeros,

Initialize tensor filled with zeros

fn zeros(shape: impl IntoShape) -> Self

Create new tensor initialized with zeros.