Struct auto_diff::tensor::gen_tensor::GenTensor

pub struct GenTensor<T> { /* fields omitted */ }

Naive tensor implementation, single thread

Implementations

impl<T> GenTensor<T> where
    T: Float, 

pub fn new() -> GenTensor<T>

Creation Ops

pub fn new_raw(data: &[T], shape: &[usize]) -> GenTensor<T>

Create a tensor with given Vec.

pub fn index2dimpos(&self, index: usize) -> Vec<usize>

Convert 1 dim index to multi-dim index.

pub fn dimpos2index(&self, dimpos: &[usize]) -> usize

Convert multi-dim index to 1 dim index.

pub fn zeros(size: &[usize]) -> GenTensor<T>

pub fn zeros_like(&self) -> GenTensor<T>

pub fn ones(size: &[usize]) -> GenTensor<T>

pub fn ones_like(&self) -> GenTensor<T>

pub fn arange(end: usize) -> GenTensor<T>

pub fn empty(shape: &[usize]) -> GenTensor<T>

pub fn fill(d: T, shape: &[usize]) -> GenTensor<T>

Create a tensor filled with the same value d

let m1 = GenTensor::<f64>::fill(1., &vec![3,5,2]);

pub fn from_record(&mut self, row: usize, record: &[f32]) -> Result<(), ()>

assign a row.

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

Right dimension changes fastest. Right dimension has the stride 1.

let m1 = GenTensor::<f64>::new_raw(&vec![0.; 3*5*2], &vec![3,5,2]);
assert_eq!(m1.stride(), vec![10,2,1]);

pub fn get(&self, o: &[usize]) -> T

Return value at the index of the tensor.

let m1 = GenTensor::<f64>::new_raw(&vec![1.,2.,3.,4.,5.,6.], &vec![2,3]);
assert_eq!(m1.get(&vec![1,1]), 5.);

pub fn set(&mut self, o: &[usize], v: T)

pub fn set_1d(&mut self, o: usize, v: T)

pub fn get_mut(&mut self, o: &[usize]) -> &mut T

pub fn get_raw(&self) -> Vec<T>

dump the underlying vec

pub fn get_u8(&self) -> Option<Vec<u8>>

pub fn get_scale(&self) -> T

dump the single value in the tensor if it is the single value in the tensor.

pub fn get_n(&self) -> GenTensor<T>

get NCHW elements, always return the size of left most dimension.

pub fn get_c(&self) -> GenTensor<T>

get NCHW elements, always return the size of second left most dimension.

pub fn get_d(&self) -> GenTensor<T>

get NCDHW elements, will require the self.dim has 5 dimensions.

pub fn get_h(&self) -> GenTensor<T>

get NCDHW elements, will require the self.dim has 5 dimensions or 4 dimensions.

pub fn get_w(&self) -> GenTensor<T>

get NCDHW elements, will require the self.dim has 5 dimensions or 4 dimensions.

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

Returns the size of the self tensor.

pub fn get_data(&self) -> &Vec<T>

pub fn get_data_mut(&mut self) -> &mut Vec<T>

pub fn numel(&self) -> usize

Returns the total number of elements in the input tensor

pub fn numel_tensor(&self) -> GenTensor<T>

Returns the total number of elements in the input tensor

pub fn get_patch(
    &self,
    range: &[(usize, usize)],
    step: Option<&[usize]>
) -> GenTensor<T>

Return portion of the image. Every range of each dim with inclusive start and exclusive end.

pub fn set_patch(
    &mut self,
    val: &GenTensor<T>,
    range: &[(usize, usize)],
    step: Option<&[usize]>
)

pub fn _iter_patch<F>(
    &self,
    dim: Option<&[usize]>,
    keep_dim: bool,
    closure: F
) -> GenTensor<T> where
    F: Fn(&[T]) -> T, 

pub fn _dim_statistic<F>(
    &self,
    dim: usize,
    keepdim: bool,
    closure: F
) -> GenTensor<T> where
    F: Fn(usize, usize, usize, usize, usize) -> T, 

pub fn abs(&self) -> GenTensor<T>

pub fn acos(&self) -> GenTensor<T>

pub fn asin(&self) -> GenTensor<T>

pub fn atan(&self) -> GenTensor<T>

pub fn ceil(&self) -> GenTensor<T>

pub fn clamp(&self, min: T, max: T) -> GenTensor<T>

pub fn cos(&self) -> GenTensor<T>

pub fn cosh(&self) -> GenTensor<T>

pub fn exp(&self) -> GenTensor<T>

pub fn expm1(&self) -> GenTensor<T>

pub fn floor(&self) -> GenTensor<T>

pub fn frac(&self) -> GenTensor<T>

pub fn log(&self) -> GenTensor<T>

pub fn log10(&self) -> GenTensor<T>

pub fn log1p(&self) -> GenTensor<T>

pub fn log1pexp(&self) -> GenTensor<T>

Better log(1 + exp(x)) see https://cran.r-project.org/web/packages/Rmpfr/vignettes/log1mexp-note.pdf

pub fn log2(&self) -> GenTensor<T>

pub fn neg(&self) -> GenTensor<T>

pub fn pow(&self, n: T) -> GenTensor<T>

pub fn reciprocal(&self) -> GenTensor<T>

pub fn round(&self) -> GenTensor<T>

pub fn rsqrt(&self) -> GenTensor<T>

pub fn sigmoid(&self) -> GenTensor<T>

pub fn sign(&self) -> GenTensor<T>

pub fn sin(&self) -> GenTensor<T>

pub fn sinh(&self) -> GenTensor<T>

pub fn sqrt(&self) -> GenTensor<T>

pub fn square(&self) -> GenTensor<T>

pub fn tan(&self) -> GenTensor<T>

pub fn tanh(&self) -> GenTensor<T>

pub fn trunc(&self) -> GenTensor<T>

pub fn _right_broadcast<F>(&self, o: &GenTensor<T>, closure: F) -> GenTensor<T> where
    F: Fn(&T, &T) -> T, 

pub fn add(&self, o: &GenTensor<T>) -> GenTensor<T>

element-wise add with right-hand broadcast.

let m1 = GenTensor::<f64>::new_raw(&vec![1.,2.,3.,4.,], &vec![2,2]);
let m2 = GenTensor::<f64>::new_raw(&vec![1.,2.,3.,4.,], &vec![2,2]);
let m3 = m1.add(&m2);
assert_eq!(m3.get(&vec![0,0]), 2.);
assert_eq!(m3.get(&vec![1,1]), 8.);

pub fn sub(&self, o: &GenTensor<T>) -> GenTensor<T>

pub fn mul(&self, o: &GenTensor<T>) -> GenTensor<T>

pub fn div(&self, o: &GenTensor<T>) -> GenTensor<T>

pub fn mm(&self, o: &GenTensor<T>) -> GenTensor<T>

matrix multiplication

let m1 = GenTensor::<f64>::new_raw(&vec![1.,2.,3.,4.,5.,6.], &vec![3,2]);
let m2 = GenTensor::<f64>::new_raw(&vec![2.,3.,4.,5.,6.,7.], &vec![2,3]);
let mut result = m1.mm(&m2);
assert!(result == GenTensor::<f64>::new_raw(&vec![12.,15.,18.,26.,33.,40.,40.,51.,62.,], &vec![3,3]), "");

pub fn matmul(&self, o: &GenTensor<T>) -> GenTensor<T>

matrix multiplication of two tensor

pub fn outer(&self, o: &GenTensor<T>, avg: Option<bool>) -> GenTensor<T>

outer product of right-most dimensions.

pub fn squared_error(t1: &Self, t2: &Self) -> GenTensor<T>

pub fn all_close(&self, o: &GenTensor<T>) -> GenTensor<T>

pub fn arg_sort(&self, dim: usize, descending: bool) -> GenTensor<T>

pub fn eq_t(&self, o: &GenTensor<T>) -> GenTensor<T>

Computes element-wise equality use eq_t instead, as eq is reserved for == overloading.

let m1 = GenTensor::<f64>::new_raw(&vec![1.,2.,3.,4.,5.,6.], &vec![3,2]);
let m2 = GenTensor::<f64>::new_raw(&vec![1.,2.,3.,4.,5.,6.], &vec![3,2]);
assert_eq!(m1.eq_t(&m2).get(&vec![0,0]), 1.);
assert_eq!(m1.eq_t(&m2).get(&vec![2,1]), 1.);

pub fn equal(&self, o: &GenTensor<T>) -> bool

true if two tensors have the same size and elements, false otherwise.

let m1 = GenTensor::<f64>::fill(1., &vec![3,5,2]);
let m2 = GenTensor::<f64>::fill(1., &vec![3,5,2]);
assert_eq!(m1.equal(&m2), true)

pub fn ge(&self, o: &GenTensor<T>) -> GenTensor<T>

pub fn gt(&self, o: &GenTensor<T>) -> GenTensor<T>

pub fn le(&self, o: &GenTensor<T>) -> GenTensor<T>

pub fn lt(&self, o: &GenTensor<T>) -> GenTensor<T>

pub fn ne(&self, o: &GenTensor<T>) -> GenTensor<T>

Trait Implementations

impl<T> Clone for GenTensor<T> where
    T: Float, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> CompareTensor for GenTensor<T> where
    T: Float, 

type TensorType = GenTensor<T>

fn max_pair(&self, o: &GenTensor<T>) -> GenTensor<T>

fn min_pair(&self, o: &GenTensor<T>) -> GenTensor<T>

impl<T> Convolution for GenTensor<T> where
    T: Float, 

type TensorType = GenTensor<T>

fn conv2d(
    &self,
    filter: &GenTensor<T>,
    stride: (usize, usize),
    padding: (usize, usize),
    dilation: (usize, usize),
    padding_mode: PaddingMode
) -> Self::TensorType

fn conv2d_grad(
    &self,
    filter: &GenTensor<T>,
    stride: (usize, usize),
    padding: (usize, usize),
    dilation: (usize, usize),
    padding_mode: PaddingMode,
    output_grad: &GenTensor<T>
) -> (Self::TensorType, Self::TensorType)

fn conv_gen(
    &self,
    filter: &GenTensor<T>,
    stride: &[usize],
    padding: &[usize],
    dilation: &[usize],
    padding_mode: PaddingMode
) -> GenTensor<T>

fn conv_grad_gen(
    &self,
    filter: &GenTensor<T>,
    stride: &[usize],
    padding: &[usize],
    dilation: &[usize],
    padding_mode: PaddingMode,
    output_grad: &GenTensor<T>
) -> (GenTensor<T>, GenTensor<T>)

impl Debug for GenTensor<f32>

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

Formats the value using the given formatter.

impl Debug for GenTensor<f64>

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

Formats the value using the given formatter.

impl Display for GenTensor<f32>

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

Formats the value using the given formatter.

impl Display for GenTensor<f64>

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

Formats the value using the given formatter.

impl<T> Eq for GenTensor<T> where
    T: Float, 

impl<T> IndexSlicing for GenTensor<T> where
    T: Float, 

type TensorType = GenTensor<T>

fn cat(&self, tensors: &[&Self::TensorType], dim: usize) -> Self::TensorType

Concatenates the given sequence of seq tensors in the given dimension.

fn chunk(&self, chunks: usize, dim: usize) -> Vec<Self::TensorType>

Splits a tensor into a specific number of chunks.

fn gather(&self, dim: usize, index: &Self::TensorType) -> Self::TensorType

fn index_select(&self, dim: usize, index: &Self::TensorType) -> Self::TensorType

fn reshape(&self, new_shape: &[usize]) -> Self::TensorType

fn split(&self, sections: &[usize], dim: usize) -> Vec<Self::TensorType>

Splits the tensor into chunks. Each chunk is a view of the original tensor.

fn squeeze(&self, dim: Option<usize>) -> Self::TensorType

fn stack(tensors: &[&Self], dim: usize) -> Self::TensorType

Concatenates sequence of tensors along a new dimension.

All tensors need to be of the same size.

let m1 = GenTensor::<f64>::new_raw(&vec![1.,2.,3.,4.,5.,6.], &vec![3,2]);
let m2 = GenTensor::<f64>::new_raw(&vec![2.,3.,4.,5.,6.,7.], &vec![3,2]);
let result = GenTensor::<f64>::stack(&vec![&m1, &m2], 1);
let raw = result.get_raw();
for i in raw {
    println!("{}", i);
}
assert_eq!(*result.size(), vec![3,2,2]);

fn take(&self, index: &[usize]) -> Self::TensorType

Returns a new tensor with the elements of input at the given indices. The input tensor is treated as if it were viewed as a 1-D tensor. The result takes the same shape as the indices.

fn permute(&self, dims: &[usize]) -> Self::TensorType

Permute the dimensions of this tensor.

let mut m1 = GenTensor::<f64>::fill(1., &vec![2, 3, 5]);
m1.permute(&vec![2, 0, 1]);

fn unsqueeze(&self, dim: usize) -> Self::TensorType

fn conditional_select(
    &self,
    x: &Self::TensorType,
    y: &Self::TensorType
) -> Self::TensorType

fn repeat(&self, sizes: &[usize]) -> Self::TensorType

impl<T> PartialEq<GenTensor<T>> for GenTensor<T> where
    T: Float, 

let m1 = GenTensor::<f64>::fill(1., &vec![3,5,2]);
let m2 = GenTensor::<f64>::fill(1., &vec![3,5,2]);
assert_eq!(m1==m2, true)

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

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

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T> ReduceTensor for GenTensor<T> where
    T: Float, 

type TensorType = GenTensor<T>

fn argmax(&self, dim: Option<&[usize]>, keep_dim: bool) -> Self::TensorType

fn argmin(&self, dim: Option<&[usize]>, keep_dim: bool) -> Self::TensorType

fn dist()

fn logsumexp(&self, dim: Option<&[usize]>, keep_dim: bool) -> Self::TensorType

fn mean(&self, dim: Option<&[usize]>, keep_dim: bool) -> GenTensor<T>

Returns the mean value of the tensor along dim row.

fn median()

fn mode()

fn norm()

fn prod(&self, dim: Option<&[usize]>, keep_dim: bool) -> GenTensor<T>

fn std(&self, dim: Option<&[usize]>, keep_dim: bool) -> GenTensor<T>

fn std_mean()

fn sum(&self, dim: Option<&[usize]>, keep_dim: bool) -> GenTensor<T>

Returns the sum of all elements.

let m1 = GenTensor::<f64>::new_raw(&vec![1.,2.,3.,4.,], &vec![2,2]);
assert_eq!(m1.sum(None, false).get_scale(), 10.);

fn unique()

fn unique_consecutive()

fn var(&self, dim: Option<&[usize]>, keep_dim: bool) -> GenTensor<T>

fn var_mean()

fn max(&self, dim: Option<&[usize]>, keep_dim: bool) -> Self::TensorType

fn min(&self, dim: Option<&[usize]>, keep_dim: bool) -> Self::TensorType