Struct zyx_cpu::Tensor

source ·

pub struct Tensor<B>where
    B: Backend,
{ /* private fields */ }

Expand description

Tensor is the core object of zyx. It is multidimensional array.

Implementations§

source §

impl Tensor
where B: Backend,

source

pub fn id(&self) -> Id

Tensor’s unique identification. All tensors on one backend will always have different ids.

source

pub fn shape(&self) -> Shape

Returns the shape of the self tensor.

let dev = zyx_opencl::device()?;
let x = dev.tensor([[2, 3, 1], [4, 1, 3]]);
assert_eq!(x.shape(), [2, 3]);

source

pub fn numel(&self) -> usize

Returns number of elements in the self tensor.

let dev = zyx_opencl::device()?;
let x = dev.tensor([[2, 3, 1], [4, 1, 3]]);
assert_eq!(x.numel(), 6);

source

pub fn dtype(&self) -> DType

Returns the dtype of the self tensor.

let dev = zyx_opencl::device()?;
let x = dev.tensor([[2, 3, 1], [4, 1, 3]]);
assert_eq!(x.dtype(), zyx_opencl::DType::I32);

source

pub fn rank(&self) -> usize

Returns the rank of the self tensor. This is the number of tensor’s dimensions.

let dev = zyx_opencl::device()?;
let x = dev.tensor([[2, 3, 1], [4, 1, 3]]);
assert_eq!(x.rank(), 2);

source

pub fn backend(&self) -> B

Returns the backend of the self tensor.

let dev = zyx_opencl::device()?;
let x = dev.tensor([[2, 3, 1], [4, 1, 3]]);
let y = x.backend().randn([2, 4, 3], zyx_opencl::DType::F32);

source

pub fn detach(&self) -> Tensor

Detach gradient tape from tensor. This means that resulting tensor is a shallow copy of self, but it’s gradient will be ones. Result of this operation can only be differentiated by itself.

let dev = zyx_opencl::device()?;
let x = dev.tensor([2, 3]);
let y = &x + &x;
let g = y.backward([&x]).pop().unwrap().unwrap();
assert_eq!(g, [2, 2]);
let z = y.detach();
let g = z.backward([&z]).pop().unwrap().unwrap();
assert_eq!(g, [1, 1]);
let g = z.backward([&x]).pop().unwrap();
assert_eq!(g, None);

source

pub fn to_vec<T>(&self) -> Result<Vec<T>, ZyxError>
where T: Scalar,

Load tensor from backend into vector

let dev = zyx_opencl::device()?;
let x = dev.tensor([[2, 3, 1], [4, 1, 3]]);
let xvec: Vec<i32> = x.to_vec()?;
assert_eq!(xvec, vec![2, 3, 1, 4, 1, 3]);

source

pub fn item<T>(&self) -> Result<T, ZyxError>
where T: Scalar,

Returns first element stored in this tensor. Usually used for tensors with exactly one element. Error is returned if self tensor contains zero elements or if backend returns error.

let dev = zyx_opencl::device()?;
let x = dev.tensor([[2, 3, 1], [4, 1, 3]]);
let xitem: i32 = x.item()?;
assert_eq!(xitem, 2);

source

pub fn backward<'a>( &'a self, sources: impl IntoIterator<Item = &'a Tensor> ) -> Vec<Option<Tensor>>
where B: 'a,

Returns gradients of self w.r.t. sources.

let dev = zyx_opencl::device()?;
let x = dev.tensor([3., 2., 1.]);
let y = x.exp() + &x;
let x_grad = y.backward([&x]).into_iter().next().unwrap().unwrap();
assert_eq!(x_grad, [21.0855369, 8.3890561, 3.7182818]);

source

pub fn cast(&self, dtype: DType) -> Tensor

Cast self into dtype.

let dev = zyx_opencl::device()?;
let x = dev.tensor([[3, 4, 2], [4, 5, 2]]);
let y = x.cast(DType::F32);
assert_eq!(y.dtype(), DType::F32);
assert_eq!(y, [[3f32, 4., 2.], [4., 5., 2.]]);

source

pub fn relu(&self) -> Tensor

Returns a new tensor with the rectified linear unit function applied to the elements of self.

source

pub fn sin(&self) -> Tensor

Returns a new tensor with the sine of the elements of self.

source

pub fn cos(&self) -> Tensor

Returns a new tensor with the cosine of the elements of self.

source

pub fn ln(&self) -> Tensor

Returns a new tensor with the natural logarithm of the elements of self. Due to performance reasons, this function does not check if self fits into domain of ln(x). Result on out of domain numbers is implementation defined (when x <= 0).

source

pub fn exp(&self) -> Tensor

Returns a new tensor with the exponential of the elements of self.

source

pub fn tanh(&self) -> Tensor

Returns a new tensor with the hyperbolic tangent of the elements of self.

source

pub fn sqrt(&self) -> Tensor

Returns a new tensor with the square root of the elements of self. Due to performance reasons, this function does not check if self fits into domain of ln(x). Result on out of domain numbers is implementation defined (when x < 0).

source

pub fn reciprocal(&self) -> Tensor

Returns 1/self

source

pub fn rsqrt(&self) -> Tensor

Returns 1/self.sqrt()

source

pub fn dropout(&self, probability: impl Scalar) -> Tensor

Returns a new tensor with each element of self randomly zeroed with given probability.

source

pub fn abs(&self) -> Tensor

Returns a new tensor with the absolute value of the elements of self.

source

pub fn sigmoid(&self) -> Tensor

Returns a new tensor with the sigmoid (logistic function) of the elements of self.

source

pub fn swish(&self) -> Tensor

Returns a new tensor with the swish/silu of the elements of self.

source

pub fn mish(&self) -> Tensor

Returns a new tensor with the mish of the elements of self.

source

pub fn softplus(&self, beta: impl Scalar, threshold: impl Scalar) -> Tensor

Returns a new tensor with the softplus of the elements of self.

source

pub fn tan(&self) -> Tensor

Returns a new tensor with the tangent of the elements of self.

source

pub fn leaky_relu(&self, neg_slope: impl Scalar) -> Tensor

Returns a new tensor with the leaky relu of the elements of self.

source

pub fn elu(&self, alpha: impl Scalar) -> Tensor

Returns a new tensor with the elu of the elements of self.

source

pub fn selu(&self) -> Tensor

Returns a new tensor with the selu of the elements of self.

source

pub fn celu(&self, alpha: impl Scalar) -> Tensor

Returns a new tensor with the celu of the elements of self.

source

pub fn gelu(&self) -> Tensor

Returns a new tensor with the gelu of the elements of self.

source

pub fn quick_gelu(&self) -> Tensor

Returns a new tensor with the quick gelu of the elements of self.

source

pub fn softmax(&self, axes: impl IntoAxes) -> Tensor

Returns a new tensor with the softmax of the elements of self.

source

pub fn ln_softmax(&self, axes: impl IntoAxes) -> Tensor

Returns a new tensor with the log softmax of the elements of self.

source

pub fn l1_loss(&self, target: impl IntoTensor) -> Tensor

Measures the mean absolute error (MAE) between each element in the input self and target.

source

pub fn mse_loss(&self, target: impl IntoTensor) -> Tensor

Measures the mean squared error (MSE) between each element in the input self and target.

source

pub fn cross_entropy_loss( &self, target: impl IntoTensor, axes: impl IntoAxes ) -> Tensor

Computes the cross entropy loss between self logits and target. This function expects self to contain probabilities for each class.

source

pub fn pow(&self, exponent: impl IntoTensor) -> Tensor

Exponentiation on self

source

pub fn cmplt(&self, rhs: impl IntoTensor) -> Tensor

Elementwise compare less than between self and rhs

source

pub fn where_( &self, if_true: impl IntoTensor, if_false: impl IntoTensor ) -> Tensor

Returns a new tensor with the true values replaced with if_true and the false values replaced with if_false.

source

pub fn cosine_similarity( &self, rhs: impl IntoTensor, eps: impl IntoTensor ) -> Tensor

Returns cosine_similarity between self and rhs, computed along axes.

source

pub fn dot(&self, rhs: impl IntoTensor) -> Tensor

Dot product (mathematical multiplication) of self and rhs.

let dev = zyx_opencl::device()?;
let x = dev.tensor([[3, 4, 2], [4, 5, 2]]);
let y = dev.tensor([[3], [1], [4]]);
assert_eq!(x.dot(y), [[21], [25]]);

source

pub fn reshape(&self, shape: impl Into<Shape>) -> Tensor

Reshape self to shape.

§Panics

Following must hold: self.numel() == shape.numel()

source

pub fn expand(&self, shape: impl Into<Shape>) -> Tensor

Expand self into bigger shape

source

pub fn pad( &self, padding: impl IntoIterator<Item = (i64, i64)>, value: impl IntoTensor ) -> Tensor

Constant padding

This can both add and remove values from tensor. Negative padding removes values, positive padding adds values.

Pad last dimension by (1, 2)

use zyx_opencl;
let dev = zyx_opencl::device()?;
let x = dev.tensor([[2, 3],
                    [4, 1]]);
let z = x.pad([(1, 2)], 0);
std::println!("{}", z);
assert_eq!(z, [[0, 2, 3, 0, 0],
               [0, 4, 1, 0, 0]]);

Pad last dimension by (2, -1) and second last dimension by (1, 1)

let z = x.pad([(2, -1), (1, 1)], 0);
println!("z: {z}");
assert_eq!(z, [[0, 0, 0],
               [0, 0, 2],
               [0, 0, 4],
               [0, 0, 0]]);

§Panics

T must be of the same dtype as Tensor’s dtype, otherwise this function panics.

source

pub fn permute(&self, axes: impl IntoAxes) -> Tensor

Reorder axes of self

source

pub fn transpose(&self) -> Tensor

Swap last two axes of self. If self has rank == 1 and numel == n, then result will have shape /[n, 1/]

source

pub fn flatten(&self, axes: impl FlattenAxes) -> Tensor

Flatten. Joins axes into one dimension,

source

pub fn sum(&self, axes: impl IntoAxes) -> Tensor

Reduce self by summing along axes. Shape is not squeezed.

use zyx_opencl;
let dev = zyx_opencl::device()?;
let x = dev.tensor([[2, 3], [4, 1]]);
let z = x.sum(-1);
assert_eq!(z.shape(), [2, 1]);
let z = x.sum(0);
assert_eq!(z.shape(), [1, 2]);
let z = x.sum(..);
assert_eq!(z.shape(), [1, 1]);

source

pub fn max(&self, axes: impl IntoAxes) -> Tensor

Reduce self by maximizing along axes. Shape is not squeezed.

use zyx_opencl;
let dev = zyx_opencl::device()?;
let x = dev.tensor([[2, 3], [4, 1]]);
let z = x.max(-1);
assert_eq!(z.shape(), [2, 1]);
let z = x.max(0);
assert_eq!(z.shape(), [1, 2]);
let z = x.max(..);
assert_eq!(z.shape(), [1, 1]);

source

pub fn mean(&self, axes: impl IntoAxes) -> Tensor

Reduce self by calculating mean along axes

source

pub fn var(&self, axes: impl IntoAxes) -> Tensor

Reduce self by calculating variance along axes

source

pub fn std(&self, axes: impl IntoAxes) -> Tensor

Reduce self by calculating standard deviation along axes

source

pub fn norm(&self, axes: impl IntoAxes, p: impl Scalar) -> Tensor

Reduce self by calculating norm along axes

source

pub fn product(&self, axes: impl IntoAxes) -> Tensor

Reduce self by calculating product of elements along axes

source

pub fn diagonal(&self) -> Tensor

Get elements on diagonal of square matrix

source

pub fn get(&self, index: impl IntoIndex) -> Tensor

Tensor indexing.

Tensors can be indexed by tuples of any combination of values or ranges of i64. If indexing along more than 8 dimensions, use &[Range<i64>] or &[i64]

use zyx_opencl;
let dev = zyx_opencl::device()?;
let x = dev.tensor([[2, 3, 4],
                    [4, 1, 8]]);
let y: i32 = x.get((-1, -3)).item()?;
assert_eq!(y, 4);