Struct auto_diff::var::Var

pub struct Var { /* private fields */ }

Var can be thought as the value it holds plus a link to the computation graph. Majority of operators are methods on Var.

Implementations

impl Var

pub fn new(input: &[f64], dim: &[usize]) -> Var

pub fn new_f64(input: &[f64], dim: &[usize]) -> Var

pub fn new_f32(input: &[f32], dim: &[usize]) -> Var

pub fn size(&self) -> Vec<usize>

pub fn numel(&self) -> usize

pub fn get_f32(&self, o: &[usize]) -> f32

pub fn set_f32(&self, o: &[usize], v: f32)

pub fn get_f64(&self, o: &[usize]) -> f64

pub fn set_f64(&self, o: &[usize], v: f64)

pub fn set(&self, o: &Var)

pub fn fill(size: &[usize], fill_value: &Var) -> Var

pub fn fill_f32(size: &[usize], fill_value: f32) -> Var

pub fn fill_f64(size: &[usize], fill_value: f64) -> Var

pub fn zeros(dim: &[usize]) -> Var

pub fn ones(dim: &[usize]) -> Var

pub fn eye(n: usize, m: usize) -> Var

pub fn empty(dim: &[usize]) -> Var

pub fn from_record_f32(&self, row: usize, record: &[f32])

Fill row by row.

pub fn from_record_f64(&self, row: usize, record: &[f64])

pub fn rand_usize(
    rng: &mut StdRng,
    dim: &[usize],
    left: usize,
    right: usize
) -> Var

pub fn normal_f64(rng: &mut StdRng, dim: &[usize], mean: f64, std: f64) -> Var

pub fn normal_f32(rng: &mut StdRng, dim: &[usize], mean: f32, std: f32) -> Var

pub fn normal(rng: &mut StdRng, dim: &[usize], mean: f64, std: f64) -> Var

pub fn uniform_f64(rng: &mut StdRng, dim: &[usize], from: f64, to: f64) -> Var

pub fn uniform_f32(rng: &mut StdRng, dim: &[usize], from: f32, to: f32) -> Var

pub fn uniform(rng: &mut StdRng, dim: &[usize], from: f64, to: f64) -> Var

pub fn add(&self, other: &Var) -> Result<Var, AutoDiffError>

pub fn sub(&self, other: &Var) -> Result<Var, AutoDiffError>

pub fn mul(&self, other: &Var) -> Result<Var, AutoDiffError>

pub fn div(&self, other: &Var) -> Result<Var, AutoDiffError>

pub fn matmul(&self, other: &Var) -> Result<Var, AutoDiffError>

pub fn elu(&self, alpha: Var) -> Result<Var, AutoDiffError>

pub fn relu(&self) -> Result<Var, AutoDiffError>

pub fn sigmoid(&self) -> Result<Var, AutoDiffError>

pub fn mse_loss(&self, other: &Var) -> Result<Var, AutoDiffError>

pub fn bce_with_logits_loss(&self, other: &Var) -> Result<Var, AutoDiffError>

pub fn cross_entropy_loss(&self, other: &Var) -> Result<Var, AutoDiffError>

pub fn abs(&self) -> Result<Var, AutoDiffError>

pub fn acos(&self) -> Result<Var, AutoDiffError>

pub fn asin(&self) -> Result<Var, AutoDiffError>

pub fn atan(&self) -> Result<Var, AutoDiffError>

pub fn ceil(&self) -> Result<Var, AutoDiffError>

pub fn cos(&self) -> Result<Var, AutoDiffError>

pub fn cosh(&self) -> Result<Var, AutoDiffError>

pub fn exp(&self) -> Result<Var, AutoDiffError>

pub fn expm1(&self) -> Result<Var, AutoDiffError>

pub fn floor(&self) -> Result<Var, AutoDiffError>

pub fn frac(&self) -> Result<Var, AutoDiffError>

pub fn log(&self) -> Result<Var, AutoDiffError>

pub fn log10(&self) -> Result<Var, AutoDiffError>

pub fn log1p(&self) -> Result<Var, AutoDiffError>

pub fn log1pexp(&self) -> Result<Var, AutoDiffError>

pub fn log2(&self) -> Result<Var, AutoDiffError>

pub fn neg(&self) -> Result<Var, AutoDiffError>

pub fn reciprocal(&self) -> Result<Var, AutoDiffError>

pub fn round(&self) -> Result<Var, AutoDiffError>

pub fn rsqrt(&self) -> Result<Var, AutoDiffError>

pub fn sign(&self) -> Result<Var, AutoDiffError>

pub fn sin(&self) -> Result<Var, AutoDiffError>

pub fn sinh(&self) -> Result<Var, AutoDiffError>

pub fn sqrt(&self) -> Result<Var, AutoDiffError>

pub fn tan(&self) -> Result<Var, AutoDiffError>

pub fn tanh(&self) -> Result<Var, AutoDiffError>

pub fn trunc(&self) -> Result<Var, AutoDiffError>

pub fn max_pair(&self, other: &Var) -> Result<Var, AutoDiffError>

pub fn min_pair(&self, other: &Var) -> Result<Var, AutoDiffError>

pub fn arg_sort(
    &self,
    dim: usize,
    descending: bool
) -> Result<Var, AutoDiffError>

pub fn eq_elem(&self, other: &Var) -> Result<Var, AutoDiffError>

pub fn equal(&self, other: &Var) -> Result<Var, AutoDiffError>

pub fn ge(&self, other: &Var) -> Result<Var, AutoDiffError>

pub fn gt(&self, other: &Var) -> Result<Var, AutoDiffError>

pub fn le(&self, other: &Var) -> Result<Var, AutoDiffError>

pub fn lt(&self, other: &Var) -> Result<Var, AutoDiffError>

pub fn ne(&self, other: &Var) -> Result<Var, AutoDiffError>

pub fn cat(&self, other: &[Var], dim: usize) -> Result<Var, AutoDiffError>

pub fn chunk(
    &self,
    chunks: usize,
    dim: usize
) -> Result<Vec<Var>, AutoDiffError>

pub fn conditional_select(&self, x: &Var, y: &Var) -> Result<Var, AutoDiffError>

pub fn gather(&self, dim: usize, index: Var) -> Result<Var, AutoDiffError>

pub fn index_select(&self, dim: usize, index: Var) -> Result<Var, AutoDiffError>

pub fn index_exclude(
    &self,
    dim: usize,
    index: Var
) -> Result<Var, AutoDiffError>

pub fn permute(&self, dim: &[usize]) -> Result<Var, AutoDiffError>

pub fn repeat(&self, dim: &[usize]) -> Result<Var, AutoDiffError>

pub fn reshape(&self, new_shape: &[usize]) -> Result<Var, AutoDiffError>

pub fn split(
    &self,
    sections: &[usize],
    dim: usize
) -> Result<Vec<Var>, AutoDiffError>

pub fn squeeze(&self, dim: Option<usize>) -> Result<Var, AutoDiffError>

pub fn t(&self) -> Result<Var, AutoDiffError>

pub fn take(&self, index: &[usize]) -> Result<Var, AutoDiffError>

pub fn unsqueeze(&self, dim: usize) -> Result<Var, AutoDiffError>

pub fn stack(&self, other: &[Var], dim: usize) -> Result<Var, AutoDiffError>

pub fn det(&self) -> Result<Var, AutoDiffError>

pub fn inv(&self) -> Result<Var, AutoDiffError>

pub fn normalize_unit(&self) -> Result<Var, AutoDiffError>

pub fn argmax(
    &self,
    dim: Option<&[usize]>,
    keepdim: bool
) -> Result<Var, AutoDiffError>

pub fn argmin(
    &self,
    dim: Option<&[usize]>,
    keepdim: bool
) -> Result<Var, AutoDiffError>

pub fn logsumexp(
    &self,
    dim: Option<&[usize]>,
    keepdim: bool
) -> Result<Var, AutoDiffError>

pub fn mean(
    &self,
    dim: Option<&[usize]>,
    keepdim: bool
) -> Result<Var, AutoDiffError>

pub fn prod(
    &self,
    dim: Option<&[usize]>,
    keepdim: bool
) -> Result<Var, AutoDiffError>

pub fn std(
    &self,
    dim: Option<&[usize]>,
    keepdim: bool
) -> Result<Var, AutoDiffError>

pub fn sum(
    &self,
    dim: Option<&[usize]>,
    keepdim: bool
) -> Result<Var, AutoDiffError>

pub fn var(
    &self,
    dim: Option<&[usize]>,
    keepdim: bool
) -> Result<Var, AutoDiffError>

pub fn max(
    &self,
    dim: Option<&[usize]>,
    keepdim: bool
) -> Result<Var, AutoDiffError>

pub fn min(
    &self,
    dim: Option<&[usize]>,
    keepdim: bool
) -> Result<Var, AutoDiffError>

pub fn get_patch(
    &self,
    range: &[(usize, usize)],
    step: Option<&[usize]>
) -> Result<Var, AutoDiffError>

pub fn view(&self, new_shape: &[usize]) -> Result<Var, AutoDiffError>

pub fn set_grad(&self, use_gradient: bool)

Use gradient or not, default is to use.

pub fn reset_net(&self)

Reset net in the background.

pub fn grad(&self) -> Result<Var, AutoDiffError>

The current gradient for the Var.

pub fn bp(&self) -> Result<(), AutoDiffError>

pub fn step(&self, opt: &mut dyn Optimizer) -> Result<(), AutoDiffError>

pub fn rerun(&self) -> Result<(), AutoDiffError>

pub fn dump_net(&self) -> Rc<RefCell<Net>>

Trait Implementations

impl Clone for Var

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Var

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

Formats the value using the given formatter.

impl Display for Var

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

Formats the value using the given formatter.

impl PartialEq<Var> for Var

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Eq for Var