Struct candle_core::Tensor

pub struct Tensor(_);

The core struct for manipulating tensors.

use candle_core::{Tensor, DType, Device};

let a = Tensor::arange(0f32, 6f32, &Device::Cpu)?.reshape((2, 3))?;
let b = Tensor::arange(0f32, 12f32, &Device::Cpu)?.reshape((3, 4))?;

let c = a.matmul(&b)?;

Tensors are reference counted with Arc so cloning them is cheap.

Implementations

impl Tensor

pub fn backward(&self) -> Result<GradStore>

impl Tensor

pub fn conv1d( &self, kernel: &Self, padding: usize, stride: usize, dilation: usize, groups: usize ) -> Result<Self>

Applies a 1D convolution over the input tensor.

pub fn conv2d( &self, kernel: &Self, padding: usize, stride: usize, dilation: usize, groups: usize ) -> Result<Self>

Applies a 2D convolution over the input tensor.

pub fn conv_transpose2d( &self, kernel: &Self, padding: usize, output_padding: usize, stride: usize, dilation: usize ) -> Result<Self>

Applies a 2D transposed convolution over the input tensor.

impl Tensor

pub fn write_bytes<W: Write>(&self, f: &mut W) -> Result<()>

impl Tensor

pub fn read_npy<T: AsRef<Path>>(path: T) -> Result<Self>

Reads a npy file and return the stored multi-dimensional array as a tensor.

pub fn read_npz<T: AsRef<Path>>(path: T) -> Result<Vec<(String, Self)>>

Reads a npz file and returns the stored multi-dimensional arrays together with their names.

pub fn read_npz_by_name<T: AsRef<Path>>( path: T, names: &[&str] ) -> Result<Vec<Self>>

Reads a npz file and returns the stored multi-dimensional arrays for some specified names.

pub fn write_npy<T: AsRef<Path>>(&self, path: T) -> Result<()>

Writes a multi-dimensional array in the npy format.

pub fn write_npz<S: AsRef<str>, T: AsRef<Tensor>, P: AsRef<Path>>( ts: &[(S, T)], path: P ) -> Result<()>

Writes multiple multi-dimensional arrays using the npz format.

impl Tensor

pub fn save_safetensors<P: AsRef<Path>>( &self, name: &str, filename: P ) -> Result<()>

impl Tensor

pub fn from_raw_buffer( data: &[u8], dtype: DType, shape: &[usize], device: &Device ) -> Result<Self>

impl Tensor

pub fn dims0(&self) -> Result<()>

impl Tensor

pub fn dims1(&self) -> Result<usize>

impl Tensor

pub fn dims2(&self) -> Result<(usize, usize)>

impl Tensor

pub fn dims3(&self) -> Result<(usize, usize, usize)>

impl Tensor

pub fn dims4(&self) -> Result<(usize, usize, usize, usize)>

impl Tensor

pub fn dims5(&self) -> Result<(usize, usize, usize, usize, usize)>

impl Tensor

pub fn ones<S: Into<Shape>>( shape: S, dtype: DType, device: &Device ) -> Result<Self>

Creates a new tensor filled with ones.

use candle_core::{Tensor, DType, Device};
let a = Tensor::ones((2, 3), DType::F32, &Device::Cpu)?;
let b = Tensor::from_slice(&[1.0f32, 1.0, 1.0, 1.0, 1.0, 1.0], (2, 3), &Device::Cpu)?;
// a == b

pub fn ones_like(&self) -> Result<Self>

Creates a new tensor filled with ones with same shape, dtype, and device as the other tensor.

use candle_core::{Tensor, DType, Device};
let a = Tensor::zeros((2, 3), DType::F32, &Device::Cpu)?;
let b = a.ones_like()?;
// b == a + 1

pub fn zeros<S: Into<Shape>>( shape: S, dtype: DType, device: &Device ) -> Result<Self>

Creates a new tensor filled with zeros.

use candle_core::{Tensor, DType, Device};
let a = Tensor::zeros((2, 3), DType::F32, &Device::Cpu)?;
let b = Tensor::from_slice(&[0.0f32, 0.0, 0.0, 0.0, 0.0, 0.0], (2, 3), &Device::Cpu)?;
// a == b

pub fn zeros_like(&self) -> Result<Self>

Creates a new tensor filled with ones with same shape, dtype, and device as the other tensor.

use candle_core::{Tensor, DType, Device};
let a = Tensor::zeros((2, 3), DType::F32, &Device::Cpu)?;
let b = a.zeros_like()?;
// b is on CPU f32.

pub fn rand<S: Into<Shape>, T: FloatDType>( lo: T, up: T, s: S, device: &Device ) -> Result<Self>

Creates a new tensor initialized with values sampled uniformly between lo and up.

pub fn rand_like(&self, lo: f64, up: f64) -> Result<Self>

pub fn randn_like(&self, mean: f64, stdev: f64) -> Result<Self>

pub fn randn<S: Into<Shape>, T: FloatDType>( mean: T, std: T, s: S, device: &Device ) -> Result<Self>

Creates a new tensor initialized with values sampled from a normal distribution with the specified mean and standard deviation std.

pub fn new<A: NdArray>(array: A, device: &Device) -> Result<Self>

Creates a new tensor on the specified device using the content and shape of the input.

pub fn from_iter<D: WithDType>( iter: impl IntoIterator<Item = D>, device: &Device ) -> Result<Self>

Creates a new 1D tensor from an iterator.

pub fn arange<D: WithDType>(start: D, end: D, device: &Device) -> Result<Self>

Creates a new 1D tensor with values from the interval [start, end) taken with a common difference 1 from start.

pub fn arange_step<D: WithDType>( start: D, end: D, step: D, device: &Device ) -> Result<Self>

Creates a new 1D tensor with values from the interval [start, end) taken with a common difference step from start.

pub fn from_vec<S: Into<Shape>, D: WithDType>( data: Vec<D>, shape: S, device: &Device ) -> Result<Self>

Creates a new tensor initialized with values from the input vector. The number of elements in this vector must be the same as the number of elements defined by the shape. If the device is cpu, no data copy is made.

pub fn from_slice<S: Into<Shape>, D: WithDType>( array: &[D], shape: S, device: &Device ) -> Result<Self>

Creates a new tensor initialized with values from the input slice. The number of elements in this vector must be the same as the number of elements defined by the shape.

pub fn add(&self, rhs: &Self) -> Result<Self>

pub fn mul(&self, rhs: &Self) -> Result<Self>

pub fn sub(&self, rhs: &Self) -> Result<Self>

pub fn div(&self, rhs: &Self) -> Result<Self>

pub fn maximum(&self, rhs: &Self) -> Result<Self>

pub fn minimum(&self, rhs: &Self) -> Result<Self>

pub fn broadcast_add(&self, rhs: &Self) -> Result<Self>

pub fn broadcast_mul(&self, rhs: &Self) -> Result<Self>

pub fn broadcast_sub(&self, rhs: &Self) -> Result<Self>

pub fn broadcast_div(&self, rhs: &Self) -> Result<Self>

pub fn broadcast_maximum(&self, rhs: &Self) -> Result<Self>

pub fn broadcast_minimum(&self, rhs: &Self) -> Result<Self>

pub fn recip(&self) -> Result<Self>

pub fn neg(&self) -> Result<Self>

pub fn exp(&self) -> Result<Self>

pub fn log(&self) -> Result<Self>

pub fn sin(&self) -> Result<Self>

pub fn cos(&self) -> Result<Self>

pub fn abs(&self) -> Result<Self>

pub fn sqr(&self) -> Result<Self>

pub fn sqrt(&self) -> Result<Self>

pub fn gelu(&self) -> Result<Self>

pub fn relu(&self) -> Result<Self>

pub fn to_scalar<S: WithDType>(&self) -> Result<S>

Retrieves the single scalar value hold in the tensor. If the tensor contains multiple dimensions, an error is returned instead.

pub fn to_vec0<S: WithDType>(&self) -> Result<S>

An alias for to_scalar.

pub fn repeat<S: Into<Shape>>(&self, shape: S) -> Result<Tensor>

Repeat this tensor along the specified dimensions.

pub fn affine(&self, mul: f64, add: f64) -> Result<Self>

This operation multiplies the input tensor by mul then adds add and return the result. The input values mul and add are casted to the appropriate type so some rounding might be performed.

use candle_core::{Tensor, Device};
let a = Tensor::new(&[[0f32, 1.], [2., 3.]], &Device::Cpu)?;
let a = a.affine(4., -2.)?;
assert_eq!(a.to_vec2::<f32>()?, &[[-2.0, 2.0], [6.0, 10.0]]);

pub fn elu(&self, alpha: f64) -> Result<Self>

Applies the Exponential Linear Unit (ELU) function on each element of the input tensor.

pub fn powf(&self, e: f64) -> Result<Self>

Raise the tensor to some float exponent e.

pub fn chunk<D: Dim>(&self, chunks: usize, dim: D) -> Result<Vec<Self>>

Split a tensor into the specified number of chunks, this may return less chunks than specificed.

pub fn narrow<D: Dim>(&self, dim: D, start: usize, len: usize) -> Result<Self>

Returns a new tensor that is a narrowed version of the input, the dimension dim ranges from start to start + len.

pub fn sum_keepdim<D: Dims>(&self, sum_dims: D) -> Result<Self>

Returns the sum of all elements in the input tensor. The sum is performed over all the input dimensions.

The resulting tensor has a shape that is similar to the shape of the input tensor, except that the number of elements for each dimension index in sum_dims is 1.

use candle_core::{Tensor, Device};
let a = Tensor::new(&[[0f32, 1.], [2., 3.]], &Device::Cpu)?;
let s = a.sum_keepdim(0)?;
assert_eq!(s.to_vec2::<f32>()?, &[[2., 4.]]);
let s = a.sum_keepdim(1)?;
assert_eq!(s.to_vec2::<f32>()?, &[[1.], [5.]]);
let s = a.sum_keepdim((0, 1))?;
assert_eq!(s.to_vec2::<f32>()?, &[[6.]]);

pub fn sum<D: Dims>(&self, sum_dims: D) -> Result<Self>

Returns the sum of all elements in the input tensor. The sum is performed over all the input dimensions and compared to sum_keepdim these dimensions are squeezed rather than kept.

pub fn mean_keepdim<D: Dims>(&self, mean_dims: D) -> Result<Self>

Returns the mean of all elements in the input tensor. The mean is performed over all the input dimensions.

The resulting tensor has a shape that is similar to the shape of the input tensor, except that the number of elements for each dimension index in mean_dims is 1.

use candle_core::{Tensor, Device};
let a = Tensor::new(&[[0f32, 1.], [2., 3.]], &Device::Cpu)?;
let s = a.mean_keepdim(0)?;
assert_eq!(s.to_vec2::<f32>()?, &[[1., 2.]]);
let s = a.mean_keepdim(1)?;
assert_eq!(s.to_vec2::<f32>()?, &[[0.5], [2.5]]);
let s = a.mean_keepdim((0, 1))?;
assert_eq!(s.to_vec2::<f32>()?, &[[1.5]]);

pub fn mean<D: Dims>(&self, mean_dims: D) -> Result<Self>

Returns the mean of all elements in the input tensor. The mean is performed over all the input dimensions and compared to mean_keepdim these dimensions are squeezed rather than kept.

pub fn max_keepdim<D: Dim>(&self, dim: D) -> Result<Self>

pub fn max<D: Dim>(&self, dim: D) -> Result<Self>

pub fn min_keepdim<D: Dim>(&self, dim: D) -> Result<Self>

pub fn min<D: Dim>(&self, dim: D) -> Result<Self>

pub fn argmax_keepdim<D: Dim>(&self, dim: D) -> Result<Self>

pub fn argmax<D: Dim>(&self, dim: D) -> Result<Self>

pub fn argmin_keepdim<D: Dim>(&self, dim: D) -> Result<Self>

pub fn argmin<D: Dim>(&self, dim: D) -> Result<Self>

pub fn cmp(&self, rhs: &Self, op: CmpOp) -> Result<Self>

pub fn eq(&self, rhs: &Self) -> Result<Self>

pub fn ne(&self, rhs: &Self) -> Result<Self>

pub fn lt(&self, rhs: &Self) -> Result<Self>

pub fn gt(&self, rhs: &Self) -> Result<Self>

pub fn ge(&self, rhs: &Self) -> Result<Self>

pub fn le(&self, rhs: &Self) -> Result<Self>

pub fn upsample_nearest2d( &self, target_h: usize, target_w: usize ) -> Result<Self>

pub fn avg_pool2d<T: ToUsize2>(&self, sz: T) -> Result<Self>

pub fn avg_pool2d_with_stride<T: ToUsize2>( &self, kernel_size: T, stride: T ) -> Result<Self>

pub fn max_pool2d<T: ToUsize2>(&self, sz: T) -> Result<Self>

pub fn max_pool2d_with_stride<T: ToUsize2>( &self, kernel_size: T, stride: T ) -> Result<Self>

pub fn matmul(&self, rhs: &Self) -> Result<Self>

Returns the matrix-multiplication of the input tensor with the other provided tensor.

Arguments

• self - A tensor with dimensions b1, b2, ..., bi, m, k.
• rhs - A tensor with dimensions b1, b2, ..., bi, k, n.

The resulting tensor has dimensions b1, b2, ..., bi, m, n.

pub fn broadcast_matmul(&self, rhs: &Self) -> Result<Self>

Matrix-multiplication with broadcasting support.

Compared to matmul the two matrixes are allowed to have different dimensions as long as they are compatible for broadcast. E.g. if self has shape (j, 1, n, k) and rhs has shape (l, k, m), the output will have shape (j, l, n, m).

pub fn where_cond(&self, on_true: &Self, on_false: &Self) -> Result<Self>

Returns a tensor with the same shape as the input tensor, the values are taken from on_true if the input tensor value is not zero, and on_false at the positions where the input tensor is equal to zero.

pub fn embedding(&self, ids: &Self) -> Result<Self>

Returns a tensor with the values from the self tensor at the index corresponding to the values hold in the ids tensor.

Arguments

• self - A tensor with dimensions v, h.
• ids - A tensor with dimensions s and with integer values between 0 and v (exclusive).

The resulting tensor has dimensions s, h. s is called the sequence length, v the vocabulary size, and h the hidden size.

use candle_core::{Tensor, Device};
let values = Tensor::new(&[[0f32, 1.], [2., 3.], [4., 5.]], &Device::Cpu)?;
let ids = Tensor::new(&[2u32, 1u32, 2u32], &Device::Cpu)?;
let emb = values.embedding(&ids)?;
assert_eq!(emb.to_vec2::<f32>()?, &[[4., 5.], [2., 3.], [4., 5.]]);

pub fn scatter_add<D: Dim>( &self, indexes: &Self, source: &Self, dim: D ) -> Result<Self>

pub fn index_add<D: Dim>( &self, indexes: &Self, source: &Self, dim: D ) -> Result<Self>

pub fn gather<D: Dim>(&self, indexes: &Self, dim: D) -> Result<Self>

pub fn index_select<D: Dim>(&self, indexes: &Self, dim: D) -> Result<Self>

pub fn strided_index(&self) -> StridedIndex<'_>

Returns an iterator over position of the elements in the storage when ranging over the index tuples in lexicographic order.

pub fn strided_blocks(&self) -> StridedBlocks<'_>

Similar to strided_index but returns the position of the start of each contiguous block as well as the length of the contiguous blocks. For a contiguous tensor, the index iterator will only return the start offset and the size would be the number of elements in the tensor.

pub fn to_vec1<S: WithDType>(&self) -> Result<Vec<S>>

Returns the data contained in a 1D tensor as a vector of scalar values.

pub fn to_vec2<S: WithDType>(&self) -> Result<Vec<Vec<S>>>

Returns the data contained in a 2D tensor as a vector of vector of scalar values.

pub fn to_vec3<S: WithDType>(&self) -> Result<Vec<Vec<Vec<S>>>>

Returns the data contained in a 3D tensor.

pub fn dtype(&self) -> DType

The dtype for the elements stored in the input tensor.

pub fn device(&self) -> &Device

The device on which the input tensor is located.

pub fn shape(&self) -> &Shape

The tensor shape, i.e. dimension sizes on each axis.

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

The dimension size for this tensor on each axis.

pub fn dim<D: Dim>(&self, dim: D) -> Result<usize>

The dimension size for a specified dimension index.

pub fn layout(&self) -> &Layout

The layout of the input tensor, this stores both the shape of the tensor as well as the strides and the start offset to apply to the underlying storage.

pub fn stride(&self) -> &[usize]

pub fn rank(&self) -> usize

The number of dimensions for this tensor, 0 for a scalar tensor, 1 for a 1D tensor, etc.

pub fn elem_count(&self) -> usize

The number of elements stored in this tensor.

pub fn id(&self) -> TensorId

The unique identifier for this tensor.

pub fn is_variable(&self) -> bool

Whether this tensor is a variable or not. A variable is a tensor for which gradient is tracked and on which backpropagation can be performed.

pub fn sum_all(&self) -> Result<Tensor>

Computes the sum of all the elements in this tensor and returns a tensor holding this scalar with zero dimensions.

use candle_core::{Tensor, Device};
let tensor = Tensor::new(&[[0f32, 1.], [2., 3.], [4., 5.]], &Device::Cpu)?;
let tensor = tensor.sum_all()?;
assert_eq!(tensor.to_scalar::<f32>()?, 15.);

pub fn flatten<D1: Dim, D2: Dim>( &self, start_dim: D1, end_dim: D2 ) -> Result<Tensor>

Flattens the input tensor on the dimension indexes from start_dim to end_dim (both inclusive).

pub fn flatten_to<D: Dim>(&self, end_dim: D) -> Result<Tensor>

Flattens the input tensor on the dimension indexes from 0 to end_dim (inclusive).

pub fn flatten_from<D: Dim>(&self, start_dim: D) -> Result<Tensor>

Flattens the input tensor on the dimension indexes from start_dim (inclusive) to the last dimension.

pub fn flatten_all(&self) -> Result<Tensor>

Flattens the input tensor by reshaping it into a one dimension tensor.

use candle_core::{Tensor, Device};
let tensor = Tensor::new(&[[0f32, 1.], [2., 3.], [4., 5.]], &Device::Cpu)?;
let tensor = tensor.flatten_all()?;
assert_eq!(tensor.to_vec1::<f32>()?, &[0., 1., 2., 3., 4., 5.]);

pub fn get(&self, i: usize) -> Result<Tensor>

Returns the sub-tensor fixing the index at i on the first dimension.

use candle_core::{Tensor, Device};
let tensor = Tensor::new(&[[0f32, 1.], [2., 3.], [4., 5.]], &Device::Cpu)?;
let t = tensor.get(0)?;
assert_eq!(t.to_vec1::<f32>()?, &[0., 1.]);
let t = tensor.get(1)?;
assert_eq!(t.to_vec1::<f32>()?, &[2., 3.]);

pub fn t(&self) -> Result<Tensor>

Returns a tensor that is a transposed version of the input, the two last dimensions of the input are swapped.

use candle_core::{Tensor, Device};
let tensor = Tensor::new(&[[0f32, 1.], [2., 3.], [4., 5.]], &Device::Cpu)?;
let tensor = tensor.t()?;
assert_eq!(tensor.to_vec2::<f32>()?, &[[0.0, 2.0, 4.0], [1.0, 3.0, 5.0]]);

pub fn transpose<D1: Dim, D2: Dim>(&self, dim1: D1, dim2: D2) -> Result<Tensor>

Returns a tensor that is a transposed version of the input, the given dimensions are swapped.

pub fn permute<D: Dims>(&self, dims: D) -> Result<Tensor>

Returns a tensor with the same data as the input where the dimensions have been permuted. dims must be a permutation, i.e. include each dimension index exactly once.

use candle_core::{Tensor, Device};
let tensor = Tensor::arange(0u32, 120u32, &Device::Cpu)?.reshape((2, 3, 4, 5))?;
assert_eq!(tensor.dims(), &[2, 3, 4, 5]);
let tensor = tensor.permute((2, 3, 1, 0))?;
assert_eq!(tensor.dims(), &[4, 5, 3, 2]);

pub fn is_contiguous(&self) -> bool

Returns true if the data is stored in a C contiguous (aka row major) way.

pub fn is_fortran_contiguous(&self) -> bool

Returns true if the data is stored in a Fortran contiguous (aka column major) way.

pub fn copy(&self) -> Result<Tensor>

Compared to clone, this copies the actual storage but may fail because of running out of memory.

pub fn detach(&self) -> Result<Tensor>

Returns a new tensor detached from the current graph, gradient are not propagated through this new node. The storage of this tensor is shared with the initial tensor.

pub fn to_device(&self, device: &Device) -> Result<Tensor>

If the target device is the same as the tensor device, only a shallow copy is performed.

pub fn broadcast_left<S: Into<Shape>>(&self, left_shape: S) -> Result<Self>

Returns a new tensor duplicating data from the original tensor. New dimensions are inserted on the left.

pub fn broadcast_as<S: Into<Shape>>(&self, shape: S) -> Result<Self>

Broadcast the input tensor to the target shape. This returns an error if the input shape is not compatible with the target shape.

If the input shape is i_1, i_2, ... i_k, the target shape has to have k dimensions or more and shape j_1, ..., j_l, t_1, t_2, ..., t_k. The dimensions j_1 to j_l can have any value, the dimension t_a must be equal to i_a if i_a is different from 1. If i_a is equal to 1, any value can be used.

pub fn expand<S: Into<Shape>>(&self, shape: S) -> Result<Self>

An alias for broadcast_as.

pub fn to_dtype(&self, dtype: DType) -> Result<Self>

Casts the input tensor to the target dtype.

use candle_core::{Tensor, Device};
let tensor = Tensor::new(3.14159265358979f64, &Device::Cpu)?;
assert_eq!(tensor.to_scalar::<f64>()?, 3.14159265358979);
let tensor = tensor.to_dtype(candle_core::DType::F32)?;
assert_eq!(tensor.to_scalar::<f32>()?, 3.1415927);

pub fn contiguous(&self) -> Result<Tensor>

Returns a tensor that is in row major order. This is the same as the original tensor if it was already contiguous, otherwise a copy is triggered.

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

Reshape returns a tensor with the target shape provided that the number of elements of the original tensor is the same. If the input tensor is contiguous, this is a view on the original data. Otherwise this uses a new storage and copies the data over, the returned tensor is always contiguous.

let a = Tensor::zeros((2, 3), DType::F32, &Device::Cpu)?;

let c = a.reshape((1, 6))?;
assert_eq!(c.shape().dims(), &[1, 6]);

let c = a.reshape((3, 2))?;
assert_eq!(c.shape().dims(), &[3, 2]);

pub fn squeeze<D: Dim>(&self, dim: D) -> Result<Self>

Creates a new tensor with the specified dimension removed if its size was one.

let a = Tensor::zeros((2, 3, 1), DType::F32, &Device::Cpu)?;

let c = a.squeeze(2)?;
assert_eq!(c.shape().dims(), &[2, 3]);

let c = a.squeeze(D::Minus1)?;
assert_eq!(c.shape().dims(), &[2, 3]);

pub fn unsqueeze<D: Dim>(&self, dim: D) -> Result<Self>

Creates a new tensor with a dimension of size one inserted at the specified position.

let a = Tensor::zeros((2, 3), DType::F32, &Device::Cpu)?;

let c = a.unsqueeze(0)?;
assert_eq!(c.shape().dims(), &[1, 2, 3]);

let c = a.unsqueeze(D::Minus1)?;
assert_eq!(c.shape().dims(), &[2, 3, 1]);

pub fn stack<A: AsRef<Tensor>, D: Dim>(args: &[A], dim: D) -> Result<Self>

Stacks two or more tensors along a particular dimension.

All tensors must have the same rank, and the output has one additional rank

let a = Tensor::zeros((2, 3), DType::F32, &Device::Cpu)?;
let b = Tensor::zeros((2, 3), DType::F32, &Device::Cpu)?;

let c = Tensor::stack(&[&a, &b], 0)?;
assert_eq!(c.shape().dims(), &[2, 2, 3]);

let c = Tensor::stack(&[&a, &b], 2)?;
assert_eq!(c.shape().dims(), &[2, 3, 2]);

pub fn cat<A: AsRef<Tensor>, D: Dim>(args: &[A], dim: D) -> Result<Self>

Concatenates two or more tensors along a particular dimension.

All tensors must of the same rank, and the output will have the same rank

let a = Tensor::zeros((2, 3), DType::F32, &Device::Cpu)?;
let b = Tensor::zeros((2, 3), DType::F32, &Device::Cpu)?;

let c = Tensor::cat(&[&a, &b], 0)?;
assert_eq!(c.shape().dims(), &[4, 3]);

let c = Tensor::cat(&[&a, &b], 1)?;
assert_eq!(c.shape().dims(), &[2, 6]);

pub fn pad_with_zeros<D: Dim>( &self, dim: D, left: usize, right: usize ) -> Result<Self>

pub fn apply<M: Module>(&self, m: &M) -> Result<Self>

pub fn storage_and_layout(&self) -> (RwLockReadGuard<'_, Storage>, &Layout)

The storage used by this tensor, together with the layout to use to access it safely.

pub fn apply_op1_no_bwd<C: CustomOp1>(&self, c: &C) -> Result<Self>

Applies a unary custom op without backward support

pub fn apply_op2_no_bwd<C: CustomOp2>(&self, rhs: &Self, c: &C) -> Result<Self>

Applies a binary custom op without backward support

pub fn apply_op3_no_bwd<C: CustomOp3>( &self, t2: &Self, t3: &Self, c: &C ) -> Result<Self>

Applies a ternary custom op without backward support

pub fn apply_op1_arc( &self, c: Arc<Box<dyn CustomOp1 + Send + Sync>> ) -> Result<Self>

Applies a unary custom op.

pub fn apply_op1<C: 'static + CustomOp1 + Send + Sync>( &self, c: C ) -> Result<Self>

pub fn apply_op2_arc( &self, rhs: &Self, c: Arc<Box<dyn CustomOp2 + Send + Sync>> ) -> Result<Self>

Applies a binary custom op.

pub fn apply_op2<C: 'static + CustomOp2 + Send + Sync>( &self, r: &Self, c: C ) -> Result<Self>

pub fn apply_op3_arc( &self, t2: &Self, t3: &Self, c: Arc<Box<dyn CustomOp3 + Send + Sync>> ) -> Result<Self>

Applies a ternary custom op.

pub fn apply_op3<C: 'static + CustomOp3 + Send + Sync>( &self, t2: &Self, t3: &Self, c: C ) -> Result<Self>

Trait Implementations

impl<B: Borrow<Tensor>> Add<B> for &Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<B: Borrow<Tensor>> Add<B> for Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<B: Borrow<Tensor>> Add<Result<B, Error>> for &Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the + operator.

fn add(self, rhs: Result<B>) -> Self::Output

Performs the + operation.

impl<B: Borrow<Tensor>> Add<Result<B, Error>> for Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the + operator.

fn add(self, rhs: Result<B>) -> Self::Output

Performs the + operation.

impl Add<f64> for &Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<f64> for Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the + operator.

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

Performs the + operation.

impl AsRef<Tensor> for Tensor

fn as_ref(&self) -> &Tensor

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Tensor

fn clone(&self) -> Tensor

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Tensor

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

Formats the value using the given formatter.

impl Deref for Tensor

type Target = Tensor_

The resulting type after dereferencing.

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

Dereferences the value.

impl Display for Tensor

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

Formats the value using the given formatter.

impl<B: Borrow<Tensor>> Div<B> for &Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<B: Borrow<Tensor>> Div<B> for Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<B: Borrow<Tensor>> Div<Result<B, Error>> for &Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the / operator.

fn div(self, rhs: Result<B>) -> Self::Output

Performs the / operation.

impl<B: Borrow<Tensor>> Div<Result<B, Error>> for Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the / operator.

fn div(self, rhs: Result<B>) -> Self::Output

Performs the / operation.

impl Div<f64> for &Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<f64> for Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<A> IndexOp<(A,)> for Tensorwhere A: Into<TensorIndexer>,

fn i(&self, (A): (A,)) -> Result<Tensor, Error>

Returns a slicing iterator which are the chunks of data necessary to reconstruct the desired tensor.

impl<A, B> IndexOp<(A, B)> for Tensorwhere A: Into<TensorIndexer>, B: Into<TensorIndexer>,

fn i(&self, (A, B): (A, B)) -> Result<Tensor, Error>

Returns a slicing iterator which are the chunks of data necessary to reconstruct the desired tensor.

impl<A, B, C> IndexOp<(A, B, C)> for Tensorwhere A: Into<TensorIndexer>, B: Into<TensorIndexer>, C: Into<TensorIndexer>,

fn i(&self, (A, B, C): (A, B, C)) -> Result<Tensor, Error>

Returns a slicing iterator which are the chunks of data necessary to reconstruct the desired tensor.

impl<A, B, C, D> IndexOp<(A, B, C, D)> for Tensorwhere A: Into<TensorIndexer>, B: Into<TensorIndexer>, C: Into<TensorIndexer>, D: Into<TensorIndexer>,

fn i(&self, (A, B, C, D): (A, B, C, D)) -> Result<Tensor, Error>

Returns a slicing iterator which are the chunks of data necessary to reconstruct the desired tensor.

impl<A, B, C, D, E> IndexOp<(A, B, C, D, E)> for Tensorwhere A: Into<TensorIndexer>, B: Into<TensorIndexer>, C: Into<TensorIndexer>, D: Into<TensorIndexer>, E: Into<TensorIndexer>,

fn i(&self, (A, B, C, D, E): (A, B, C, D, E)) -> Result<Tensor, Error>

Returns a slicing iterator which are the chunks of data necessary to reconstruct the desired tensor.

impl<A, B, C, D, E, F> IndexOp<(A, B, C, D, E, F)> for Tensorwhere A: Into<TensorIndexer>, B: Into<TensorIndexer>, C: Into<TensorIndexer>, D: Into<TensorIndexer>, E: Into<TensorIndexer>, F: Into<TensorIndexer>,

fn i(&self, (A, B, C, D, E, F): (A, B, C, D, E, F)) -> Result<Tensor, Error>

Returns a slicing iterator which are the chunks of data necessary to reconstruct the desired tensor.

impl<A, B, C, D, E, F, G> IndexOp<(A, B, C, D, E, F, G)> for Tensorwhere A: Into<TensorIndexer>, B: Into<TensorIndexer>, C: Into<TensorIndexer>, D: Into<TensorIndexer>, E: Into<TensorIndexer>, F: Into<TensorIndexer>, G: Into<TensorIndexer>,

fn i( &self, (A, B, C, D, E, F, G): (A, B, C, D, E, F, G) ) -> Result<Tensor, Error>

Returns a slicing iterator which are the chunks of data necessary to reconstruct the desired tensor.

impl<T> IndexOp<T> for Tensorwhere T: Into<TensorIndexer>,

fn i(&self, index: T) -> Result<Tensor, Error>

Returns a slicing iterator which are the chunks of data necessary to reconstruct the desired tensor.

impl<B: Borrow<Tensor>> Mul<B> for &Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<B: Borrow<Tensor>> Mul<B> for Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<B: Borrow<Tensor>> Mul<Result<B, Error>> for &Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the * operator.

fn mul(self, rhs: Result<B>) -> Self::Output

Performs the * operation.

impl<B: Borrow<Tensor>> Mul<Result<B, Error>> for Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the * operator.

fn mul(self, rhs: Result<B>) -> Self::Output

Performs the * operation.

impl Mul<f64> for &Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f64> for Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<B: Borrow<Tensor>> Sub<B> for &Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<B: Borrow<Tensor>> Sub<B> for Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<B: Borrow<Tensor>> Sub<Result<B, Error>> for &Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the - operator.

fn sub(self, rhs: Result<B>) -> Self::Output

Performs the - operation.

impl<B: Borrow<Tensor>> Sub<Result<B, Error>> for Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the - operator.

fn sub(self, rhs: Result<B>) -> Self::Output

Performs the - operation.

impl Sub<f64> for &Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<f64> for Tensor

type Output = Result<Tensor, Error>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: WithDType> TryFrom<&[T]> for Tensor

type Error = Error

The type returned in the event of a conversion error.

fn try_from(v: &[T]) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: WithDType> TryFrom<&Tensor> for Vec<T>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: WithDType> TryFrom<&Tensor> for Vec<Vec<T>>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: WithDType> TryFrom<&Tensor> for Vec<Vec<Vec<T>>>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&Tensor> for bf16

type Error = Error

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&Tensor> for f16

type Error = Error

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&Tensor> for f32

type Error = Error

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&Tensor> for f64

type Error = Error

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&Tensor> for i64

type Error = Error

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&Tensor> for u32

type Error = Error

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&Tensor> for u8

type Error = Error

The type returned in the event of a conversion error.

fn try_from(tensor: &Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: WithDType> TryFrom<Tensor> for Vec<T>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: WithDType> TryFrom<Tensor> for Vec<Vec<T>>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: WithDType> TryFrom<Tensor> for Vec<Vec<Vec<T>>>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Tensor> for bf16

type Error = Error

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Tensor> for f16

type Error = Error

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Tensor> for f32

type Error = Error

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Tensor> for f64

type Error = Error

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Tensor> for i64

type Error = Error

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Tensor> for u32

type Error = Error

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Tensor> for u8

type Error = Error

The type returned in the event of a conversion error.

fn try_from(tensor: Tensor) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: WithDType> TryFrom<Vec<T, Global>> for Tensor

type Error = Error

The type returned in the event of a conversion error.

fn try_from(v: Vec<T>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<bf16> for Tensor

type Error = Error

The type returned in the event of a conversion error.

fn try_from(v: bf16) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<f16> for Tensor

type Error = Error

The type returned in the event of a conversion error.

fn try_from(v: f16) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<f32> for Tensor

type Error = Error

The type returned in the event of a conversion error.

fn try_from(v: f32) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<f64> for Tensor

type Error = Error

The type returned in the event of a conversion error.

fn try_from(v: f64) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<i64> for Tensor

type Error = Error

The type returned in the event of a conversion error.

fn try_from(v: i64) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<u32> for Tensor

type Error = Error

The type returned in the event of a conversion error.

fn try_from(v: u32) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<u8> for Tensor

type Error = Error

The type returned in the event of a conversion error.

fn try_from(v: u8) -> Result<Self, Self::Error>

Performs the conversion.

impl View for &Tensor

fn dtype(&self) -> Dtype

The Dtype of the tensor

fn shape(&self) -> &[usize]

The shape of the tensor

fn data(&self) -> Cow<'_, [u8]>

The data of the tensor

fn data_len(&self) -> usize

The length of the data, in bytes. This is necessary as this might be faster to get than data().len() for instance for tensors residing in GPU.

impl View for Tensor

fn dtype(&self) -> Dtype

The Dtype of the tensor

fn shape(&self) -> &[usize]

The shape of the tensor

fn data(&self) -> Cow<'_, [u8]>

The data of the tensor

fn data_len(&self) -> usize

The length of the data, in bytes. This is necessary as this might be faster to get than data().len() for instance for tensors residing in GPU.