Struct burn_tensor::Tensor

pub struct Tensor<B: Backend, const D: usize> { /* private fields */ }

A tensor or a n-dimensional array.

Implementations

impl<B> Tensor<B, 1>where
    B: Backend,

pub fn arange(range: Range<usize>) -> Tensor<B::IntegerBackend, 1>

Returns a new integer tensor on the default device which values are generated from the given range.

pub fn arange_device(
    range: Range<usize>,
    device: B::Device
) -> Tensor<B::IntegerBackend, 1>

Returns a new integer tensor on the specified device which values are generated from the given range.

impl<B> Tensor<B, 1>where
    B: Backend,

pub fn single_value(&self) -> B::Elem

Returns the first value of the tensor.

impl<const D: usize, B> Tensor<B, D>where
    B: Backend,

pub fn from_primitive(tensor: B::TensorPrimitive<D>) -> Self

pub fn into_primitive(self) -> B::TensorPrimitive<D>

pub fn reshape<const D2: usize, S: Into<Shape<D2>>>(
    &self,
    shape: S
) -> Tensor<B, D2>

Reshape the tensor to have the given shape.

Panics

If the tensor can not be reshape to the given shape.

pub fn to_device(&self, device: B::Device) -> Self

Returns a new tensor on the given device.

pub fn device(&self) -> B::Device

Returns the device of the current tensor.

pub fn exp(&self) -> Self

Applies element wise exponential operation.

y = e^x

pub fn log(&self) -> Self

Applies element wise natural log operation ln.

y = log(x)

pub fn erf(&self) -> Self

Applies the error function element wise.

y = erf(x)

pub fn powf(&self, value: f32) -> Self

Applies element wise power operation.

y = x^a

pub fn sqrt(&self) -> Self

Applies element wise root square operation.

pub fn shape(&self) -> &Shape<D>

Returns the shape of the current tensor.

pub fn dims(&self) -> [usize; D]

Returns the dimensions of the current tensor.

Equivalent to tensor.shape().dims.

pub fn into_data(self) -> Data<B::Elem, D>

Returns the data of the current tensor.

pub fn to_data(&self) -> Data<B::Elem, D>

Returns the data of the current tensor without taking ownership.

pub fn from_data(data: Data<B::Elem, D>) -> Self

Create a tensor from the given data.

pub fn from_data_device(data: Data<B::Elem, D>, device: B::Device) -> Self

Create a tensor from the given data on the given device.

pub fn from_floats<A: Into<Data<f32, D>>>(floats: A) -> Self

Create a tensor from floats (f32).

Example

use burn_tensor::backend::Backend;
use burn_tensor::Tensor;

fn example<B: Backend>() {
    let _ = Tensor::<B, 1>::from_floats([1.0, 2.0]);
    let _ = Tensor::<B, 2>::from_floats([[1.0, 2.0], [3.0, 4.0]]);
}

pub fn zeros_like(&self) -> Self

Returns a new tensor with the same shape and device as the current tensor filled with zeros.

pub fn ones_like(&self) -> Self

Returns a new tensor with the same shape and device as the current tensor filled with ones.

pub fn random_like(&self, distribution: Distribution<B::Elem>) -> Self

Returns a new tensor with the same shape and device as the current tensor filled random values sampled from the given distribution.

pub fn one_hot(index: usize, num_classes: usize) -> Self

Create a one hot tensor.

Example

use burn_tensor::backend::Backend;
use burn_tensor::Tensor;

fn example<B: Backend>() {
    let one_hot = Tensor::<B, 1>::one_hot(2, 10);
    println!("{}", one_hot.to_data());
    // [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
}

pub fn add(&self, other: &Self) -> Self

Applies element wise addition operation.

y = x2 + x1

pub fn add_scalar<E: ElementConversion>(&self, other: E) -> Self

Applies element wise addition operation with a scalar.

y = x + s

pub fn sub(&self, other: &Self) -> Self

Applies element wise substraction operation.

y = x2 - x1

pub fn sub_scalar<E: ElementConversion>(&self, other: E) -> Self

Applies element wise substraction operation with a scalar.

y = x - s

pub fn transpose(&self) -> Self

Applies the transpose operation.

On matrix and higher dimension tensor, it swap the last two dimensions.

Panics

If the tensor is of 1 dimension or less.

pub fn swap_dims(&self, dim1: usize, dim2: usize) -> Self

Swap two dimensions.

Panics

If the dimensions exceed the shape of than the tensor.

pub fn matmul(&self, other: &Self) -> Self

Applies the matrix multiplication operation.

C = AB

Panics

If the two tensors dont’ have a compatible shape.

pub fn neg(&self) -> Self

Switch sign of each element in the tensor.

y = -x

pub fn mul(&self, other: &Self) -> Self

Applies element wise multiplication operation.

y = x2 * x1

pub fn mul_scalar<E: ElementConversion>(&self, other: E) -> Self

Applies element wise multiplication operation with scalar.

y = x2 * x1

pub fn div(&self, other: &Self) -> Self

Applies element wise division operation.

y = x2 / x1

pub fn div_scalar<E: ElementConversion>(&self, other: E) -> Self

Applies element wise division operation with scalar.

y = x2 / x1

pub fn mean(&self) -> Tensor<B, 1>

Aggregate all elements in the tensor with the mean operation.

pub fn sum(&self) -> Tensor<B, 1>

Aggregate all elements in the tensor with the sum operation.

pub fn mean_dim(&self, dim: usize) -> Self

Aggregate all elements along the given dimension or axis in the tensor with the mean operation.

pub fn sum_dim(&self, dim: usize) -> Self

Aggregate all elements along the given dimension or axis in the tensor with the sum operation.

pub fn var(&self, dim: usize) -> Self

Calculate the variance along the given dimension.

pub fn var_bias(&self, dim: usize) -> Self

Calculate the variance along the given dimension without applying the Bessel’s correction.

pub fn var_mean(&self, dim: usize) -> (Self, Self)

Calculate the variance along the given dimension and also returns the mean.

pub fn var_mean_bias(&self, dim: usize) -> (Self, Self)

Calculate the variance along the given dimension without applying the Bessel’s correction and also returns the mean.

pub fn equal(&self, other: &Self) -> BoolTensor<B, D>

Applies element wise equal comparison and returns a boolean tensor.

Panics

If the two tensors don’t have the same shape.

pub fn greater(&self, other: &Self) -> BoolTensor<B, D>

Applies element wise greater comparison and returns a boolean tensor.

Panics

If the two tensors don’t have the same shape.

pub fn greater_equal(&self, other: &Self) -> BoolTensor<B, D>

Applies element wise greater-equal comparison and returns a boolean tensor.

Panics

If the two tensors don’t have the same shape.

pub fn lower(&self, other: &Self) -> BoolTensor<B, D>

Applies element wise lower comparison and returns a boolean tensor.

Panics

If the two tensors don’t have the same shape.

pub fn lower_equal(&self, other: &Self) -> BoolTensor<B, D>

Applies element wise lower-equal comparison and returns a boolean tensor.

Panics

If the two tensors don’t have the same shape.

pub fn equal_scalar<E: ElementConversion>(&self, other: E) -> BoolTensor<B, D>

Applies element wise equal comparison and returns a boolean tensor.

pub fn greater_scalar<E: ElementConversion>(&self, other: E) -> BoolTensor<B, D>

Applies element wise greater comparison and returns a boolean tensor.

pub fn greater_equal_scalar<E: ElementConversion>(
    &self,
    other: E
) -> BoolTensor<B, D>

Applies element wise greater-equal comparison and returns a boolean tensor.

pub fn lower_scalar<E: ElementConversion>(&self, other: E) -> BoolTensor<B, D>

Applies element wise lower comparison and returns a boolean tensor.

pub fn lower_equal_scalar<E: ElementConversion>(
    &self,
    other: E
) -> BoolTensor<B, D>

Applies element wise lower-equal comparison and returns a boolean tensor.

pub fn random<S: Into<Shape<D>>>(
    shape: S,
    distribution: Distribution<B::Elem>
) -> Self

Create a random tensor of the given shape where each element is sampled from the given distribution.

pub fn zeros<S: Into<Shape<D>>>(shape: S) -> Self

Create a tensor of the given shape where each element is zero.

pub fn zeros_device<S: Into<Shape<D>>>(shape: S, device: B::Device) -> Self

Create a tensor of the given shape where each element is zero.

pub fn ones<S: Into<Shape<D>>>(shape: S) -> Self

Create a tensor of the given shape where each element is one.

pub fn ones_device<S: Into<Shape<D>>>(shape: S, device: B::Device) -> Self

Create a tensor of the given shape where each element is one.

pub fn index<const D2: usize>(&self, indexes: [Range<usize>; D2]) -> Self

Returns a tensor containing the elements selected from the given ranges.

Panics

If a range exceeds the number of elements on a dimension.

Example

use burn_tensor::backend::Backend;
use burn_tensor::{Tensor, Shape};

fn example<B: Backend>() {
    let tensor = Tensor::<B, 3>::ones(Shape::new([2, 3, 3]));
    let tensor_indexed = tensor.index([0..1, 0..3, 1..2]);
    println!("{:?}", tensor_indexed.shape());
    // Shape { dims: [1, 3, 2] }
}

pub fn index_assign<const D2: usize>(
    &self,
    indexes: [Range<usize>; D2],
    values: &Self
) -> Self

Returns a copy of the current tensor with the selected elements changed to the new ones at the selected indexes.

Panics

• If a range exceeds the number of elements on a dimension.
• If the given values don’t match the given ranges.

Example

use burn_tensor::backend::Backend;
use burn_tensor::{Tensor, Shape};

fn example<B: Backend>() {
    let tensor = Tensor::<B, 3>::ones(Shape::new([2, 3, 3]));
    let values = Tensor::<B, 3>::zeros(Shape::new([1, 1, 1]));
    let tensor_indexed = tensor.index_assign([0..1, 0..1, 0..1], &values);
    println!("{:?}", tensor_indexed.shape());
    // Shape { dims: [2, 3, 3] }
}

pub fn mask_fill<E: ElementConversion>(
    &self,
    mask: &BoolTensor<B, D>,
    value: E
) -> Self

Fill each element with the given value based on the given mask.

pub fn to_full_precision(&self) -> Tensor<B::FullPrecisionBackend, D>

Returns a tensor with full precision based on the selected backend.

pub fn from_full_precision(tensor: Tensor<B::FullPrecisionBackend, D>) -> Self

Returns a tensor on the selected backend from a full precision tensor.

pub fn argmax(&self, dim: usize) -> Tensor<B::IntegerBackend, D>

Applies the argmax function along the given dimension and returns an integer tensor.

Example

use burn_tensor::backend::Backend;
use burn_tensor::{Tensor, Shape};

fn example<B: Backend>() {
    let tensor = Tensor::<B, 3>::ones(Shape::new([2, 3, 3]));
    let tensor = tensor.argmax(1);
    println!("{:?}", tensor.shape());
    // Shape { dims: [2, 1, 3] }
}

pub fn argmin(&self, dim: usize) -> Tensor<B::IntegerBackend, D>

Applies the argmin function along the given dimension and returns an integer tensor.

Example

use burn_tensor::backend::Backend;
use burn_tensor::{Tensor, Shape};

fn example<B: Backend>() {
    let tensor = Tensor::<B, 3>::ones(Shape::new([2, 3, 3]));
    let tensor = tensor.argmin(1);
    println!("{:?}", tensor.shape());
    // Shape { dims: [2, 1, 3] }
}

pub fn cat(tensors: Vec<Self>, dim: usize) -> Self

Concatenates all tensors into a new one along the given dimension.

Panics

If all tensors don’t have the same shape.

pub fn detach(self) -> Self

Detach the current tensor from the autodiff graph. This function does nothing when autodiff is not enabled. This can be used in batchers or elsewere to ensure that previous operations are not considered in the autodiff graph.

pub fn unsqueeze<const D2: usize>(&self) -> Tensor<B, D2>

Unsqueeze the current tensor. Create new dimensions to fit the given size.

Panics

If the output size is higher than the current tensor.

Example

use burn_tensor::backend::Backend;
use burn_tensor::{Tensor, Shape};

fn example<B: Backend>() {
    let tensor = Tensor::<B, 2>::ones(Shape::new([3, 3]));
    let tensor = tensor.unsqueeze::<4>();
    println!("{:?}", tensor.shape());
    // Shape { dims: [1, 1, 3, 3] }
}

pub fn repeat(&self, dim: usize, times: usize) -> Self

Repeat the tensor along the given dimension.

Panics

If the selected dimension more than one item.

impl<const D: usize, B: ADBackend> Tensor<B, D>

pub fn backward(&self) -> B::Gradients

pub fn grad(&self, grads: &B::Gradients) -> Option<Tensor<B::InnerBackend, D>>

pub fn inner(&self) -> Tensor<B::InnerBackend, D>

pub fn update(&mut self, other_inner: Tensor<B::InnerBackend, D>)

pub fn from_inner(inner: Tensor<B::InnerBackend, D>) -> Self

Trait Implementations

impl<E, const D: usize, B> Add<E> for Tensor<B, D>where
    E: ElementConversion,
    B: Backend,

type Output = Tensor<B, D>

The resulting type after applying the + operator.

fn add(self, other: E) -> Self

Performs the + operation.

impl<const D: usize, B> Add<Tensor<B, D>> for Tensor<B, D>where
    B: Backend,

type Output = Tensor<B, D>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<B: Clone + Backend, const D: usize> Clone for Tensor<B, D>where
    B::TensorPrimitive<D>: Clone,

fn clone(&self) -> Tensor<B, D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B: Debug + Backend, const D: usize> Debug for Tensor<B, D>where
    B::TensorPrimitive<D>: Debug,

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

Formats the value using the given formatter.

impl<E, const D: usize, B> Div<E> for Tensor<B, D>where
    E: ElementConversion,
    B: Backend,

type Output = Tensor<B, D>

The resulting type after applying the / operator.

fn div(self, other: E) -> Self

Performs the / operation.

impl<const D: usize, B> Div<Tensor<B, D>> for Tensor<B, D>where
    B: Backend,

type Output = Tensor<B, D>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<E, const D: usize, B> Mul<E> for Tensor<B, D>where
    E: ElementConversion,
    B: Backend,

type Output = Tensor<B, D>

The resulting type after applying the * operator.

fn mul(self, other: E) -> Self

Performs the * operation.

impl<const D: usize, B> Mul<Tensor<B, D>> for Tensor<B, D>where
    B: Backend,

type Output = Tensor<B, D>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, const D: usize, B> Sub<E> for Tensor<B, D>where
    E: ElementConversion,
    B: Backend,

type Output = Tensor<B, D>

The resulting type after applying the - operator.

fn sub(self, other: E) -> Self

Performs the - operation.

impl<const D: usize, B> Sub<Tensor<B, D>> for Tensor<B, D>where
    B: Backend,

type Output = Tensor<B, D>

The resulting type after applying the - operator.

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

Performs the - operation.