Struct autograd::tensor::Tensor

pub struct Tensor<T: Float>(pub Rc<TensorCore<T>>);

Symbolic multi-dimensional array.

Methods

impl<T: Float> Tensor<T>

pub fn get_persistent_array(&self) -> Option<&NdArray<T>>

Returns a reference to the persistent array.

Returns Some if this tensor is made from ag::variable or ag::constant.

pub unsafe fn get_persistent_array_mut(&self) -> Option<&mut NdArray<T>>

Returns a mutable reference to the persistent array.

Returns Some if this tensor is made from ag::variable.

pub fn has_persistent_array(&self) -> bool

Returns True if this tensor is made from ag::variable or ag::constant.

impl<T: Float> Tensor<T>

pub fn builder() -> TensorBuilder<T>

pub fn eval<'k, 'v>(&self, feeds: &'v [Feed<'k, 'v, T>]) -> Option<NdArray<T>>

Evaluates this tensor as an ndarray object.

extern crate ndarray;
extern crate autograd as ag;

let a = ag::zeros(&[2]);

assert_eq!(a.eval(&[]), Some(ndarray::arr1(&[0., 0.]).into_dyn()));

See also eval.

pub fn shape(&self) -> Tensor<T>

Returns the (symbolic) shape of this tensor.

extern crate autograd as ag;

let ref x: ag::Tensor<f32> = ag::zeros(&[2, 3]);
let ref s = x.shape();

assert_eq!(&[2., 3.], s.eval(&[]).unwrap().as_slice().unwrap());

See also shape.

pub fn rank(&self) -> Tensor<T>

Returns the (symbolic) rank of this tensor.

extern crate ndarray;
extern crate autograd as ag;

let ref x: ag::Tensor<f32> = ag::zeros(&[2, 3, 4]);
let ref r = x.rank();

assert_eq!(3., r.eval(&[]).unwrap()[ndarray::IxDyn(&[])]);

See also rank.

pub fn size(&self) -> Tensor<T>

Returns the (symbolic) size of this tensor.

extern crate ndarray;
extern crate autograd as ag;

let ref a: ag::Tensor<f32> = ag::zeros(&[4, 3]);
let ref b = a.size();

assert_eq!(12., b.eval(&[]).unwrap()[ndarray::IxDyn(&[])]);

See also size.

pub fn with(&self, hook: Hook<T>) -> Tensor<T>

Registers a simple hook for a Tensor computation.

Pre-defined hooks are

• Print - prints the evaluation result of this tensor.
• PrintShape - prints the evaluated shape of this tensor.

See also

• with_fn
• p
• ps

extern crate autograd as ag;

let a: ag::Tensor<f32> = ag::zeros(&[4, 2]).with(ag::Hook::Print);
let b: ag::Tensor<f32> = ag::ones(&[2, 3]).with(ag::Hook::PrintShape);
let c = ag::matmul(a, b);

c.eval(&[]);
// Zeros:
// [[0.0, 0.0],
// [0.0, 0.0],
// [0.0, 0.0],
// [0.0, 0.0]] shape=[4, 2], strides=[2, 1], layout=C (0x1)

// Shape of Ones:
// [2, 3]

pub fn with_fn(&self, hook: Box<dyn Fn(&ArrayViewD<T>)>) -> Tensor<T>

Registers a hook for a Tensor computation.

See also

• with
• p
• ps

extern crate autograd as ag;

let a: ag::Tensor<f32> = ag::ones(&[4, 2]);
let b: ag::Tensor<f32> = ag::zeros(&[2, 3]);
let c = ag::matmul(a, b).with_fn(Box::new(|arr| println!("My shape: {:?}", arr.shape())));

c.eval(&[]);
// My shape: [4, 3]

pub fn p(&self) -> Tensor<T>

Shorthand for Tensor::with(crate::Hook::Print)

See with

extern crate autograd as ag;

let a: ag::Tensor<f32> = ag::zeros(&[4, 2]).p();
a.eval(&[]);
// Zeros:
// [[0.0, 0.0],
// [0.0, 0.0],
// [0.0, 0.0],
// [0.0, 0.0]] shape=[4, 2], strides=[2, 1], layout=C (0x1)

pub fn ps(&self) -> Tensor<T>

Shorthand for Tensor::with(crate::Hook::PrintShape)

See with

extern crate autograd as ag;

let a: ag::Tensor<f32> = ag::zeros(&[2, 3]).ps();
a.eval(&[]);
// Shape of Zeros:
// [2, 3]

impl<T: Float> Tensor<T>

pub fn get(&self, i: isize) -> Tensor<T>

Looks up a symbolic element from this tensor.

Index i can be negative.

extern crate ndarray;
extern crate autograd as ag;

let ref a = ag::variable(ndarray::arr2(&[[2., 3.], [4., 5.]]));
let ref b = a.get(2);

assert_eq!(b.eval(&[]).unwrap()[ndarray::IxDyn(&[])], 4.);

Methods from Deref<Target = Rc<TensorCore<T>>>

Trait Implementations

impl<T: Float> ArrayLike<T> for Tensor<T>

fn as_tensor(&self) -> Tensor<T>

impl<'a, T: Float> Ord for &'a Tensor<T>

fn cmp(&self, other: &&'a Tensor<T>) -> Ordering

Compares the addresses of the two tensors. This can be used for ordering-based data structures (e.g. BinaryTree).

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<T: Float> Clone for Tensor<T>

fn clone(&self) -> Tensor<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Float> Eq for Tensor<T>

impl<T: Float> PartialEq<Tensor<T>> for Tensor<T>

fn eq(&self, other: &Tensor<T>) -> 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: Float> AsRef<Tensor<T>> for Tensor<T>

fn as_ref(&self) -> &Tensor<T>

Performs the conversion.

impl<'a, T: Float> PartialOrd<&'a Tensor<T>> for &'a Tensor<T>

fn partial_cmp(&self, other: &&'a Tensor<T>) -> Option<Ordering>

Compares the addresses of the two tensors. This can be used for ordering-based data structures (e.g. BinaryTree).

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Float> DerefMut for Tensor<T>

fn deref_mut<'a>(&'a mut self) -> &'a mut Rc<TensorCore<T>>

Mutably dereferences the value.

impl<T: Float> Display for Tensor<T>

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

Formats the value using the given formatter.

impl<T: Float> Debug for Tensor<T>

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

Formats the value using the given formatter.

impl<T: Float> Div<T> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, T: Float> Div<T> for &'a Tensor<T>

type Output = Tensor<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Float> Div<Tensor<T>> for f64

type Output = Tensor<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, T: Float> Div<&'a Tensor<T>> for f64

type Output = Tensor<T>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Tensor<T>) -> Self::Output

Performs the / operation.

impl<T: Float> Div<Tensor<T>> for f32

type Output = Tensor<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, T: Float> Div<&'a Tensor<T>> for f32

type Output = Tensor<T>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Tensor<T>) -> Self::Output

Performs the / operation.

impl<T: Float> Div<Tensor<T>> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, T: Float> Div<&'a Tensor<T>> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor<T>) -> Self::Output

Performs the / operation.

impl<'a, T: Float> Div<Tensor<T>> for &'a Tensor<T>

type Output = Tensor<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, 'b, T: Float> Div<&'a Tensor<T>> for &'b Tensor<T>

type Output = Tensor<T>

The resulting type after applying the / operator.

fn div(self, rhs: &Tensor<T>) -> Self::Output

Performs the / operation.

impl<T: Float> Add<T> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, T: Float> Add<T> for &'a Tensor<T>

type Output = Tensor<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Float> Add<Tensor<T>> for f64

type Output = Tensor<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, T: Float> Add<&'a Tensor<T>> for f64

type Output = Tensor<T>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Tensor<T>) -> Self::Output

Performs the + operation.

impl<T: Float> Add<Tensor<T>> for f32

type Output = Tensor<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, T: Float> Add<&'a Tensor<T>> for f32

type Output = Tensor<T>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Tensor<T>) -> Self::Output

Performs the + operation.

impl<T: Float> Add<Tensor<T>> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, T: Float> Add<&'a Tensor<T>> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor<T>) -> Self::Output

Performs the + operation.

impl<'a, T: Float> Add<Tensor<T>> for &'a Tensor<T>

type Output = Tensor<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b, T: Float> Add<&'a Tensor<T>> for &'b Tensor<T>

type Output = Tensor<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Tensor<T>) -> Self::Output

Performs the + operation.

impl<T: Float> Sub<T> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, T: Float> Sub<T> for &'a Tensor<T>

type Output = Tensor<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Float> Sub<Tensor<T>> for f64

type Output = Tensor<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, T: Float> Sub<&'a Tensor<T>> for f64

type Output = Tensor<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Tensor<T>) -> Self::Output

Performs the - operation.

impl<T: Float> Sub<Tensor<T>> for f32

type Output = Tensor<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, T: Float> Sub<&'a Tensor<T>> for f32

type Output = Tensor<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Tensor<T>) -> Self::Output

Performs the - operation.

impl<T: Float> Sub<Tensor<T>> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, T: Float> Sub<&'a Tensor<T>> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor<T>) -> Self::Output

Performs the - operation.

impl<'a, T: Float> Sub<Tensor<T>> for &'a Tensor<T>

type Output = Tensor<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, 'b, T: Float> Sub<&'a Tensor<T>> for &'b Tensor<T>

type Output = Tensor<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Tensor<T>) -> Self::Output

Performs the - operation.

impl<T: Float> Mul<T> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T: Float> Mul<T> for &'a Tensor<T>

type Output = Tensor<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Float> Mul<Tensor<T>> for f64

type Output = Tensor<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T: Float> Mul<&'a Tensor<T>> for f64

type Output = Tensor<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Tensor<T>) -> Self::Output

Performs the * operation.

impl<T: Float> Mul<Tensor<T>> for f32

type Output = Tensor<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T: Float> Mul<&'a Tensor<T>> for f32

type Output = Tensor<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Tensor<T>) -> Self::Output

Performs the * operation.

impl<T: Float> Mul<Tensor<T>> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T: Float> Mul<&'a Tensor<T>> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor<T>) -> Self::Output

Performs the * operation.

impl<'a, T: Float> Mul<Tensor<T>> for &'a Tensor<T>

type Output = Tensor<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T: Float> Mul<&'a Tensor<T>> for &'b Tensor<T>

type Output = Tensor<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Tensor<T>) -> Self::Output

Performs the * operation.

impl<T: Float> Deref for Tensor<T>

type Target = Rc<TensorCore<T>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.