Struct burn_ndarray::NdArray

pub struct NdArray<E = f32> { /* private fields */ }

Tensor backend that uses the ndarray crate for executing tensor operations.

This backend is compatible with CPUs and can be compiled for almost any platform, including wasm, arm, and x86.

Trait Implementations

impl<E: FloatNdArrayElement> ActivationOps<NdArray<E>> for NdArray<E>

fn relu<const D: usize>(tensor: NdArrayTensor<E, D>) -> NdArrayTensor<E, D>

Applies the ReLU activation function.

fn relu_backward<const D: usize>( output: <B as Backend>::TensorPrimitive<D>, grad: <B as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<D>

Applies the ReLU activation function backward.

fn gelu<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<D>

Applies the Gelu activation function.

fn gelu_backward<const D: usize>( x: <B as Backend>::TensorPrimitive<D>, grad: <B as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<D>

Applies the Gelu activation function backward.

impl<E: FloatNdArrayElement> Backend for NdArray<E>

type Device = NdArrayDevice

Device type.

type FullPrecisionElem = f32

Full precision float element type.

type FullPrecisionBackend = NdArray

Pointer to another backend that have a full precision float element type

type TensorPrimitive<const D: usize> = NdArrayTensor<E, D>

Tensor primitive to be used for all float operations.

type FloatElem = E

Float element type.

type IntTensorPrimitive<const D: usize> = NdArrayTensor<i64, D>

Tensor primitive to be used for all int operations.

type IntElem = i64

Int element type.

type BoolTensorPrimitive<const D: usize> = NdArrayTensor<bool, D>

Tensor primitive to be used for all bool operations.

fn ad_enabled() -> bool

If autodiff is enabled.

fn name() -> String

Name of the backend.

fn seed(seed: u64)

Seed the backend.

fn sync(_device: &Self::Device)

Sync the backend, ensure that all computation are finished.

impl<E: FloatNdArrayElement> BoolTensorOps<NdArray<E>> for NdArray<E>

fn bool_from_data<const D: usize>( data: Data<bool, D>, _device: &NdArrayDevice ) -> NdArrayTensor<bool, D>

Creates a tensor from the data structure.

fn bool_shape<const D: usize>( tensor: &<NdArray<E> as Backend>::BoolTensorPrimitive<D> ) -> Shape<D>

Returns the shape of the tensor.

fn bool_into_data<const D: usize>( tensor: <NdArray<E> as Backend>::BoolTensorPrimitive<D> ) -> Reader<Data<bool, D>>

Converts the tensor to a data structure.

fn bool_to_device<const D: usize>( tensor: NdArrayTensor<bool, D>, _device: &NdArrayDevice ) -> NdArrayTensor<bool, D>

Moves the tensor to the device.

fn bool_reshape<const D1: usize, const D2: usize>( tensor: NdArrayTensor<bool, D1>, shape: Shape<D2> ) -> NdArrayTensor<bool, D2>

Reshapes the tensor.

fn bool_slice<const D1: usize, const D2: usize>( tensor: NdArrayTensor<bool, D1>, ranges: [Range<usize>; D2] ) -> NdArrayTensor<bool, D1>

Gets the values from the tensor for the given ranges.

fn bool_into_int<const D: usize>( tensor: <NdArray<E> as Backend>::BoolTensorPrimitive<D> ) -> NdArrayTensor<i64, D>

Converts bool tensor to int tensor.

fn bool_device<const D: usize>( _tensor: &<NdArray<E> as Backend>::BoolTensorPrimitive<D> ) -> <NdArray<E> as Backend>::Device

Gets the device of the tensor.

fn bool_empty<const D: usize>( shape: Shape<D>, _device: &<NdArray<E> as Backend>::Device ) -> <NdArray<E> as Backend>::BoolTensorPrimitive<D>

Creates a new bool tensor.

fn bool_slice_assign<const D1: usize, const D2: usize>( tensor: <NdArray<E> as Backend>::BoolTensorPrimitive<D1>, ranges: [Range<usize>; D2], value: <NdArray<E> as Backend>::BoolTensorPrimitive<D1> ) -> <NdArray<E> as Backend>::BoolTensorPrimitive<D1>

Sets the values in the tensor for the given ranges.

fn bool_cat<const D: usize>( tensors: Vec<<NdArray<E> as Backend>::BoolTensorPrimitive<D>>, dim: usize ) -> <NdArray<E> as Backend>::BoolTensorPrimitive<D>

Concatenates the tensors along the given dimension.

fn bool_equal<const D: usize>( lhs: <NdArray<E> as Backend>::BoolTensorPrimitive<D>, rhs: <NdArray<E> as Backend>::BoolTensorPrimitive<D> ) -> <NdArray<E> as Backend>::BoolTensorPrimitive<D>

Equates the two tensors.

fn bool_not<const D: usize>( tensor: <NdArray<E> as Backend>::BoolTensorPrimitive<D> ) -> <NdArray<E> as Backend>::BoolTensorPrimitive<D>

Inverses boolean values.

fn bool_into_float<const D: usize>( tensor: <NdArray<E> as Backend>::BoolTensorPrimitive<D> ) -> <NdArray<E> as Backend>::TensorPrimitive<D>

Converts bool tensor to float tensor.

fn bool_swap_dims<const D: usize>( tensor: <NdArray<E> as Backend>::BoolTensorPrimitive<D>, dim1: usize, dim2: usize ) -> <NdArray<E> as Backend>::BoolTensorPrimitive<D>

Swaps two dimensions of a bool tensor.

fn bool_to_data<const D: usize>( tensor: &<B as Backend>::BoolTensorPrimitive<D> ) -> Reader<Data<bool, D>>

Gets the data from the tensor.

fn bool_repeat<const D: usize>( tensor: <B as Backend>::BoolTensorPrimitive<D>, dim: usize, times: usize ) -> <B as Backend>::BoolTensorPrimitive<D>

Repeats one dimension of the tensor a given number of times along that dimension.

fn bool_transpose<const D: usize>( tensor: <B as Backend>::BoolTensorPrimitive<D> ) -> <B as Backend>::BoolTensorPrimitive<D>

Transposes a bool tensor.

impl<E: Clone> Clone for NdArray<E>

fn clone(&self) -> NdArray<E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E: Debug> Debug for NdArray<E>

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

Formats the value using the given formatter.

impl<E: Default> Default for NdArray<E>

fn default() -> NdArray<E>

Returns the “default value” for a type.

impl<E: FloatNdArrayElement> IntTensorOps<NdArray<E>> for NdArray<E>

fn int_from_data<const D: usize>( data: Data<i64, D>, _device: &NdArrayDevice ) -> NdArrayTensor<i64, D>

Creates a tensor from the data structure.

fn int_shape<const D: usize>(tensor: &NdArrayTensor<i64, D>) -> Shape<D>

Returns the shape of the tensor.

fn int_into_data<const D: usize>( tensor: NdArrayTensor<i64, D> ) -> Reader<Data<i64, D>>

Converts the tensor to a data structure.

fn int_to_device<const D: usize>( tensor: NdArrayTensor<i64, D>, _device: &NdArrayDevice ) -> NdArrayTensor<i64, D>

Moves the tensor to the given device.

fn int_reshape<const D1: usize, const D2: usize>( tensor: NdArrayTensor<i64, D1>, shape: Shape<D2> ) -> NdArrayTensor<i64, D2>

Reshapes the tensor.

fn int_slice<const D1: usize, const D2: usize>( tensor: NdArrayTensor<i64, D1>, ranges: [Range<usize>; D2] ) -> NdArrayTensor<i64, D1>

Gets the element at the given indices.

fn int_device<const D: usize>( _tensor: &NdArrayTensor<i64, D> ) -> <NdArray<E> as Backend>::Device

Gets the device of the tensor.

fn int_empty<const D: usize>( shape: Shape<D>, _device: &<NdArray<E> as Backend>::Device ) -> NdArrayTensor<i64, D>

Creates a new int tensor.

fn int_mask_where<const D: usize>( tensor: NdArrayTensor<i64, D>, mask: NdArrayTensor<bool, D>, source: NdArrayTensor<i64, D> ) -> NdArrayTensor<i64, D>

Fills the tensor with values from the source tensor if the mask is true at the given indices.

fn int_mask_fill<const D: usize>( tensor: NdArrayTensor<i64, D>, mask: NdArrayTensor<bool, D>, value: i64 ) -> NdArrayTensor<i64, D>

Fills the tensor with the given value if the mask is true at the given indices.

fn int_slice_assign<const D1: usize, const D2: usize>( tensor: NdArrayTensor<i64, D1>, ranges: [Range<usize>; D2], value: NdArrayTensor<i64, D1> ) -> NdArrayTensor<i64, D1>

Sets the element at the given indices.

fn int_cat<const D: usize>( tensors: Vec<NdArrayTensor<i64, D>>, dim: usize ) -> NdArrayTensor<i64, D>

Concatenates the given tensors along the given dimension.

fn int_equal<const D: usize>( lhs: NdArrayTensor<i64, D>, rhs: NdArrayTensor<i64, D> ) -> NdArrayTensor<bool, D>

Elementwise equality comparison.

fn int_equal_elem<const D: usize>( lhs: NdArrayTensor<i64, D>, rhs: i64 ) -> NdArrayTensor<bool, D>

Elementwise equality comparison with a scalar.

fn int_greater<const D: usize>( lhs: NdArrayTensor<i64, D>, rhs: NdArrayTensor<i64, D> ) -> NdArrayTensor<bool, D>

Elementwise greater than comparison.

fn int_greater_elem<const D: usize>( lhs: NdArrayTensor<i64, D>, rhs: i64 ) -> NdArrayTensor<bool, D>

Elementwise greater than comparison with a scalar.

fn int_greater_equal<const D: usize>( lhs: NdArrayTensor<i64, D>, rhs: NdArrayTensor<i64, D> ) -> NdArrayTensor<bool, D>

Elementwise greater than or equal comparison.

fn int_greater_equal_elem<const D: usize>( lhs: NdArrayTensor<i64, D>, rhs: i64 ) -> NdArrayTensor<bool, D>

Elementwise greater than or equal comparison with a scalar.

fn int_lower<const D: usize>( lhs: NdArrayTensor<i64, D>, rhs: NdArrayTensor<i64, D> ) -> NdArrayTensor<bool, D>

Elementwise less than comparison.

fn int_lower_elem<const D: usize>( lhs: NdArrayTensor<i64, D>, rhs: i64 ) -> NdArrayTensor<bool, D>

Elementwise less than comparison with a scalar.

fn int_lower_equal<const D: usize>( lhs: NdArrayTensor<i64, D>, rhs: NdArrayTensor<i64, D> ) -> NdArrayTensor<bool, D>

Elementwise less than or equal comparison.

fn int_lower_equal_elem<const D: usize>( lhs: NdArrayTensor<i64, D>, rhs: i64 ) -> NdArrayTensor<bool, D>

Elementwise less than or equal comparison with a scalar.

fn int_add<const D: usize>( lhs: NdArrayTensor<i64, D>, rhs: NdArrayTensor<i64, D> ) -> NdArrayTensor<i64, D>

Elementwise addition.

fn int_add_scalar<const D: usize>( lhs: NdArrayTensor<i64, D>, rhs: i64 ) -> NdArrayTensor<i64, D>

Elementwise addition with a scalar.

fn int_sub<const D: usize>( lhs: NdArrayTensor<i64, D>, rhs: NdArrayTensor<i64, D> ) -> NdArrayTensor<i64, D>

Elementwise subtraction.

fn int_sub_scalar<const D: usize>( lhs: NdArrayTensor<i64, D>, rhs: i64 ) -> NdArrayTensor<i64, D>

Elementwise subtraction with a scalar.

fn int_mul<const D: usize>( lhs: NdArrayTensor<i64, D>, rhs: NdArrayTensor<i64, D> ) -> NdArrayTensor<i64, D>

Elementwise multiplication.

fn int_mul_scalar<const D: usize>( lhs: NdArrayTensor<i64, D>, rhs: i64 ) -> NdArrayTensor<i64, D>

Elementwise multiplication with a scalar.

fn int_div<const D: usize>( lhs: NdArrayTensor<i64, D>, rhs: NdArrayTensor<i64, D> ) -> NdArrayTensor<i64, D>

Elementwise division.

fn int_div_scalar<const D: usize>( lhs: NdArrayTensor<i64, D>, rhs: i64 ) -> NdArrayTensor<i64, D>

Elementwise division with a scalar.

fn int_neg<const D: usize>( tensor: NdArrayTensor<i64, D> ) -> NdArrayTensor<i64, D>

Elementwise negation.

fn int_zeros<const D: usize>( shape: Shape<D>, device: &<NdArray<E> as Backend>::Device ) -> NdArrayTensor<i64, D>

Creates a tensor of zeros.

fn int_ones<const D: usize>( shape: Shape<D>, device: &<NdArray<E> as Backend>::Device ) -> NdArrayTensor<i64, D>

Creates a tensor of ones.

fn int_full<const D: usize>( shape: Shape<D>, fill_value: i64, device: &<NdArray<E> as Backend>::Device ) -> NdArrayTensor<i64, D>

Creates a tensor filled with given value.

fn int_sum<const D: usize>( tensor: NdArrayTensor<i64, D> ) -> NdArrayTensor<i64, 1>

Sums all elements in the tensor.

fn int_sum_dim<const D: usize>( tensor: NdArrayTensor<i64, D>, dim: usize ) -> NdArrayTensor<i64, D>

Sums all elements in the tensor along a dimension.

fn int_mean<const D: usize>( tensor: NdArrayTensor<i64, D> ) -> NdArrayTensor<i64, 1>

Computes the mean of all elements in the tensor.

fn int_mean_dim<const D: usize>( tensor: NdArrayTensor<i64, D>, dim: usize ) -> NdArrayTensor<i64, D>

Computes the mean of all elements in the tensor along a dimension.

fn int_gather<const D: usize>( dim: usize, tensor: NdArrayTensor<i64, D>, indices: NdArrayTensor<i64, D> ) -> NdArrayTensor<i64, D>

Gather elements from the tensor at the given indices.

fn int_scatter<const D: usize>( dim: usize, tensor: NdArrayTensor<i64, D>, indices: NdArrayTensor<i64, D>, value: NdArrayTensor<i64, D> ) -> NdArrayTensor<i64, D>

Scatter a given value to the tensor at the given indices.

fn int_select<const D: usize>( tensor: NdArrayTensor<i64, D>, dim: usize, indices: NdArrayTensor<i64, 1> ) -> NdArrayTensor<i64, D>

Select tensor elements along the given dimension corresponding to the given indices.

fn int_select_assign<const D: usize>( tensor: NdArrayTensor<i64, D>, dim: usize, indices: NdArrayTensor<i64, 1>, value: NdArrayTensor<i64, D> ) -> NdArrayTensor<i64, D>

Assign the selected elements along the given dimension corresponding to the given indices to the given value.

fn int_argmax<const D: usize>( tensor: NdArrayTensor<i64, D>, dim: usize ) -> NdArrayTensor<i64, D>

Gets the indices of the maximum elements along a dimension.

fn int_argmin<const D: usize>( tensor: NdArrayTensor<i64, D>, dim: usize ) -> NdArrayTensor<i64, D>

Gets the indices of the minimum elements along a dimension.

fn int_clamp_min<const D: usize>( tensor: NdArrayTensor<i64, D>, min: i64 ) -> NdArrayTensor<i64, D>

Clamps a tensor under a minimum value.

fn int_clamp_max<const D: usize>( tensor: NdArrayTensor<i64, D>, max: i64 ) -> NdArrayTensor<i64, D>

Clamps a tensor over a maximum value.

fn int_clamp<const D: usize>( tensor: NdArrayTensor<i64, D>, min: i64, max: i64 ) -> NdArrayTensor<i64, D>

Clamps a tensor between a minimum and maximum value.

fn int_abs<const D: usize>( tensor: NdArrayTensor<i64, D> ) -> NdArrayTensor<i64, D>

Returns a new tensor with absolute values.

fn int_into_float<const D: usize>( tensor: <NdArray<E> as Backend>::IntTensorPrimitive<D> ) -> <NdArray<E> as Backend>::TensorPrimitive<D>

Converts int tensor to float tensor.

fn int_swap_dims<const D: usize>( tensor: <NdArray<E> as Backend>::IntTensorPrimitive<D>, dim1: usize, dim2: usize ) -> <NdArray<E> as Backend>::IntTensorPrimitive<D>

Swaps two dimensions of an int tensor.

fn int_to_data<const D: usize>( tensor: &<B as Backend>::IntTensorPrimitive<D> ) -> Reader<Data<<B as Backend>::IntElem, D>>

Gets the data from the tensor.

fn int_repeat<const D: usize>( tensor: <B as Backend>::IntTensorPrimitive<D>, dim: usize, times: usize ) -> <B as Backend>::IntTensorPrimitive<D>

Repeats the tensor along the given dimension the given number of times.

fn int_max<const D: usize>( tensor: <B as Backend>::IntTensorPrimitive<D> ) -> <B as Backend>::IntTensorPrimitive<1>

Gets the maximum element in the tensor.

fn int_max_dim<const D: usize>( tensor: <B as Backend>::IntTensorPrimitive<D>, dim: usize ) -> <B as Backend>::IntTensorPrimitive<D>

Gets the maximum element in the tensor along a dimension.

fn int_max_dim_with_indices<const D: usize>( tensor: <B as Backend>::IntTensorPrimitive<D>, dim: usize ) -> (<B as Backend>::IntTensorPrimitive<D>, <B as Backend>::IntTensorPrimitive<D>)

Gets the maximum elements and corresponding indices along a dimension.

fn int_min<const D: usize>( tensor: <B as Backend>::IntTensorPrimitive<D> ) -> <B as Backend>::IntTensorPrimitive<1>

Gets the minimum element in the tensor.

fn int_min_dim<const D: usize>( tensor: <B as Backend>::IntTensorPrimitive<D>, dim: usize ) -> <B as Backend>::IntTensorPrimitive<D>

Gets the minimum elements in the tensor along a dimension.

fn int_min_dim_with_indices<const D: usize>( tensor: <B as Backend>::IntTensorPrimitive<D>, dim: usize ) -> (<B as Backend>::IntTensorPrimitive<D>, <B as Backend>::IntTensorPrimitive<D>)

Gets the minimum elements and corresponding indices along a dimension.

fn int_transpose<const D: usize>( tensor: <B as Backend>::IntTensorPrimitive<D> ) -> <B as Backend>::IntTensorPrimitive<D>

Transposes an int tensor.

impl<E: FloatNdArrayElement> ModuleOps<NdArray<E>> for NdArray<E>

fn conv2d( x: NdArrayTensor<E, 4>, weight: NdArrayTensor<E, 4>, bias: Option<NdArrayTensor<E, 1>>, options: ConvOptions<2> ) -> NdArrayTensor<E, 4>

Two dimensional convolution.

fn conv_transpose2d( x: NdArrayTensor<E, 4>, weight: NdArrayTensor<E, 4>, bias: Option<NdArrayTensor<E, 1>>, options: ConvTransposeOptions<2> ) -> NdArrayTensor<E, 4>

Two dimensional transposed convolution.

fn avg_pool2d( x: NdArrayTensor<E, 4>, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], count_include_pad: bool ) -> NdArrayTensor<E, 4>

Two dimensional avg pooling.

fn avg_pool2d_backward( x: NdArrayTensor<E, 4>, grad: NdArrayTensor<E, 4>, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], count_include_pad: bool ) -> NdArrayTensor<E, 4>

Backward pass for the avg pooling 2d operation.

fn max_pool2d( x: NdArrayTensor<E, 4>, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], dilation: [usize; 2] ) -> NdArrayTensor<E, 4>

Two dimensional max pooling.

fn max_pool2d_with_indices( x: NdArrayTensor<E, 4>, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], dilation: [usize; 2] ) -> MaxPool2dWithIndices<NdArray<E>>

Two dimensional max pooling with indices.

fn max_pool2d_with_indices_backward( x: NdArrayTensor<E, 4>, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], dilation: [usize; 2], output_grad: NdArrayTensor<E, 4>, indices: NdArrayTensor<i64, 4> ) -> MaxPool2dBackward<NdArray<E>>

Backward pass for the max pooling 2d operation.

fn adaptive_avg_pool2d( x: NdArrayTensor<E, 4>, output_size: [usize; 2] ) -> NdArrayTensor<E, 4>

Two dimensional adaptive avg pooling.

fn adaptive_avg_pool2d_backward( x: NdArrayTensor<E, 4>, grad: NdArrayTensor<E, 4> ) -> NdArrayTensor<E, 4>

Backward pass for the adaptive avg pooling 2d operation.

fn embedding( weights: <B as Backend>::TensorPrimitive<2>, indices: <B as Backend>::IntTensorPrimitive<2> ) -> <B as Backend>::TensorPrimitive<3>

Embedding operation.

fn embedding_backward( weights: <B as Backend>::TensorPrimitive<2>, output_grad: <B as Backend>::TensorPrimitive<3>, indices: <B as Backend>::IntTensorPrimitive<2> ) -> <B as Backend>::TensorPrimitive<2>

Embedding backward operation.

fn conv1d( x: <B as Backend>::TensorPrimitive<3>, weight: <B as Backend>::TensorPrimitive<3>, bias: Option<<B as Backend>::TensorPrimitive<1>>, options: ConvOptions<1> ) -> <B as Backend>::TensorPrimitive<3>

One dimensional convolution.

fn conv1d_backward( x: <B as Backend>::TensorPrimitive<3>, weight: <B as Backend>::TensorPrimitive<3>, bias: Option<<B as Backend>::TensorPrimitive<1>>, output_grad: <B as Backend>::TensorPrimitive<3>, options: ConvOptions<1> ) -> Conv1dBackward<B>

Backward pass for the conv1d operation.

fn conv2d_backward( x: <B as Backend>::TensorPrimitive<4>, weight: <B as Backend>::TensorPrimitive<4>, bias: Option<<B as Backend>::TensorPrimitive<1>>, output_grad: <B as Backend>::TensorPrimitive<4>, options: ConvOptions<2> ) -> Conv2dBackward<B>

Backward pass for the conv2d operation.

fn conv_transpose1d( x: <B as Backend>::TensorPrimitive<3>, weight: <B as Backend>::TensorPrimitive<3>, bias: Option<<B as Backend>::TensorPrimitive<1>>, options: ConvTransposeOptions<1> ) -> <B as Backend>::TensorPrimitive<3>

One dimensional transposed convolution.

fn conv_transpose1d_backward( x: <B as Backend>::TensorPrimitive<3>, weight: <B as Backend>::TensorPrimitive<3>, bias: Option<<B as Backend>::TensorPrimitive<1>>, output_grad: <B as Backend>::TensorPrimitive<3>, options: ConvTransposeOptions<1> ) -> Conv1dBackward<B>

Backward pass for the conv transpose 1d operation.

fn conv_transpose2d_backward( x: <B as Backend>::TensorPrimitive<4>, weight: <B as Backend>::TensorPrimitive<4>, bias: Option<<B as Backend>::TensorPrimitive<1>>, output_grad: <B as Backend>::TensorPrimitive<4>, options: ConvTransposeOptions<2> ) -> Conv2dBackward<B>

Backward pass for the conv transpose 2d operation.

fn unfold4d( x: <B as Backend>::TensorPrimitive<4>, kernel_size: [usize; 2], options: UnfoldOptions ) -> <B as Backend>::TensorPrimitive<3>

Four-dimensional unfolding.

fn avg_pool1d( x: <B as Backend>::TensorPrimitive<3>, kernel_size: usize, stride: usize, padding: usize, count_include_pad: bool ) -> <B as Backend>::TensorPrimitive<3>

One dimensional avg pooling.

fn avg_pool1d_backward( x: <B as Backend>::TensorPrimitive<3>, grad: <B as Backend>::TensorPrimitive<3>, kernel_size: usize, stride: usize, padding: usize, count_include_pad: bool ) -> <B as Backend>::TensorPrimitive<3>

Backward pass for the avg pooling 1d operation.

fn adaptive_avg_pool1d( x: <B as Backend>::TensorPrimitive<3>, output_size: usize ) -> <B as Backend>::TensorPrimitive<3>

One dimensional adaptive avg pooling.

fn adaptive_avg_pool1d_backward( x: <B as Backend>::TensorPrimitive<3>, grad: <B as Backend>::TensorPrimitive<3> ) -> <B as Backend>::TensorPrimitive<3>

Backward pass for the adaptive avg pooling 1d operation.

fn max_pool1d( x: <B as Backend>::TensorPrimitive<3>, kernel_size: usize, stride: usize, padding: usize, dilation: usize ) -> <B as Backend>::TensorPrimitive<3>

One dimensional max pooling.

fn max_pool1d_with_indices( x: <B as Backend>::TensorPrimitive<3>, kernel_size: usize, stride: usize, padding: usize, dilation: usize ) -> MaxPool1dWithIndices<B>

One dimensional max pooling with indices.

fn max_pool1d_with_indices_backward( x: <B as Backend>::TensorPrimitive<3>, kernel_size: usize, stride: usize, padding: usize, dilation: usize, output_grad: <B as Backend>::TensorPrimitive<3>, indices: <B as Backend>::IntTensorPrimitive<3> ) -> MaxPool1dBackward<B>

Backward pass for the max pooling 1d operation.

impl<E: FloatNdArrayElement> TensorOps<NdArray<E>> for NdArray<E>

fn from_data<const D: usize>( data: Data<E, D>, _device: &NdArrayDevice ) -> NdArrayTensor<E, D>

Creates a new tensor from the data structure.

fn random<const D: usize>( shape: Shape<D>, distribution: Distribution, device: &NdArrayDevice ) -> NdArrayTensor<E, D>

Creates a new tensor with random values.

fn shape<const D: usize>(tensor: &NdArrayTensor<E, D>) -> Shape<D>

Gets the shape of the tensor.

fn into_data<const D: usize>( tensor: NdArrayTensor<E, D> ) -> Reader<Data<<NdArray<E> as Backend>::FloatElem, D>>

Converts the tensor to a data structure.

fn device<const D: usize>(_tensor: &NdArrayTensor<E, D>) -> NdArrayDevice

Gets the device of the tensor.

fn to_device<const D: usize>( tensor: NdArrayTensor<E, D>, _device: &NdArrayDevice ) -> NdArrayTensor<E, D>

Moves the tensor to the given device.

fn empty<const D: usize>( shape: Shape<D>, device: &<NdArray<E> as Backend>::Device ) -> NdArrayTensor<E, D>

Creates an empty tensor with the given shape.

fn add<const D: usize>( lhs: NdArrayTensor<E, D>, rhs: NdArrayTensor<E, D> ) -> NdArrayTensor<E, D>

Adds two tensors together.

fn add_scalar<const D: usize>( lhs: NdArrayTensor<E, D>, rhs: E ) -> NdArrayTensor<E, D>

Adds a scalar to a tensor.

fn sub<const D: usize>( lhs: NdArrayTensor<E, D>, rhs: NdArrayTensor<E, D> ) -> NdArrayTensor<E, D>

Subtracts two tensors.

fn sub_scalar<const D: usize>( lhs: NdArrayTensor<E, D>, rhs: E ) -> NdArrayTensor<E, D>

Subtracts a scalar from a tensor.

fn mul<const D: usize>( lhs: NdArrayTensor<E, D>, rhs: NdArrayTensor<E, D> ) -> NdArrayTensor<E, D>

Multiplies two tensors together element-wise.

fn mul_scalar<const D: usize>( lhs: NdArrayTensor<E, D>, rhs: E ) -> NdArrayTensor<E, D>

Multiplies a tensor by a scalar.

fn div<const D: usize>( lhs: NdArrayTensor<E, D>, rhs: NdArrayTensor<E, D> ) -> NdArrayTensor<E, D>

Divides two tensors element-wise.

fn div_scalar<const D: usize>( lhs: NdArrayTensor<E, D>, rhs: E ) -> NdArrayTensor<E, D>

Divides a tensor by a scalar.

fn matmul<const D: usize>( lhs: NdArrayTensor<E, D>, rhs: NdArrayTensor<E, D> ) -> NdArrayTensor<E, D>

Multiplies two tensors together using matrix multiplication.

fn neg<const D: usize>(tensor: NdArrayTensor<E, D>) -> NdArrayTensor<E, D>

Negates a tensor element-wise.

fn recip<const D: usize>(tensor: NdArrayTensor<E, D>) -> NdArrayTensor<E, D>

Calculates the reciprocals elementwise

fn swap_dims<const D: usize>( tensor: NdArrayTensor<E, D>, dim1: usize, dim2: usize ) -> NdArrayTensor<E, D>

Swaps two dimensions of a tensor.

fn reshape<const D1: usize, const D2: usize>( tensor: NdArrayTensor<E, D1>, shape: Shape<D2> ) -> NdArrayTensor<E, D2>

Reshapes a tensor.

fn gather<const D: usize>( dim: usize, tensor: NdArrayTensor<E, D>, indices: NdArrayTensor<i64, D> ) -> NdArrayTensor<E, D>

Gather elements from a tensor.

fn scatter<const D: usize>( dim: usize, tensor: NdArrayTensor<E, D>, indices: NdArrayTensor<i64, D>, value: NdArrayTensor<E, D> ) -> NdArrayTensor<E, D>

Scatter elements into a tensor.

fn select<const D: usize>( tensor: NdArrayTensor<E, D>, dim: usize, indices: NdArrayTensor<i64, 1> ) -> NdArrayTensor<E, D>

Select tensor elements along the given dimension corresponding for the given indices.

fn select_assign<const D: usize>( tensor: NdArrayTensor<E, D>, dim: usize, indices: NdArrayTensor<i64, 1>, value: NdArrayTensor<E, D> ) -> NdArrayTensor<E, D>

Assign the selected elements along the given dimension corresponding for the given indices to the given value.

fn slice<const D1: usize, const D2: usize>( tensor: NdArrayTensor<E, D1>, ranges: [Range<usize>; D2] ) -> NdArrayTensor<E, D1>

Select tensor elements corresponding for the given ranges.

fn slice_assign<const D1: usize, const D2: usize>( tensor: NdArrayTensor<E, D1>, ranges: [Range<usize>; D2], value: NdArrayTensor<E, D1> ) -> NdArrayTensor<E, D1>

Assign the selected elements corresponding for the given ranges to the given value.

fn mask_where<const D: usize>( tensor: NdArrayTensor<E, D>, mask: NdArrayTensor<bool, D>, value: NdArrayTensor<E, D> ) -> NdArrayTensor<E, D>

Update the given tensor with the value tensor where the mask is true.

fn mask_fill<const D: usize>( tensor: NdArrayTensor<E, D>, mask: NdArrayTensor<bool, D>, value: E ) -> NdArrayTensor<E, D>

Update the given tensor with the value where the mask is true.

fn equal<const D: usize>( lhs: NdArrayTensor<E, D>, rhs: NdArrayTensor<E, D> ) -> NdArrayTensor<bool, D>

Equal comparison of two tensors.

fn equal_elem<const D: usize>( lhs: NdArrayTensor<E, D>, rhs: E ) -> NdArrayTensor<bool, D>

Equal comparison of a tensor and a scalar.

fn greater<const D: usize>( lhs: NdArrayTensor<E, D>, rhs: NdArrayTensor<E, D> ) -> NdArrayTensor<bool, D>

Greater than comparison of two tensors.

fn greater_elem<const D: usize>( lhs: NdArrayTensor<E, D>, rhs: E ) -> NdArrayTensor<bool, D>

Greater than comparison of a tensor and a scalar.

fn greater_equal<const D: usize>( lhs: NdArrayTensor<E, D>, rhs: NdArrayTensor<E, D> ) -> NdArrayTensor<bool, D>

Greater than or equal comparison of two tensors.

fn greater_equal_elem<const D: usize>( lhs: NdArrayTensor<E, D>, rhs: E ) -> NdArrayTensor<bool, D>

Greater than or equal comparison of a tensor and a scalar.

fn lower<const D: usize>( lhs: NdArrayTensor<E, D>, rhs: NdArrayTensor<E, D> ) -> NdArrayTensor<bool, D>

Less than comparison of two tensors.

fn lower_elem<const D: usize>( lhs: NdArrayTensor<E, D>, rhs: E ) -> NdArrayTensor<bool, D>

Less than comparison of a tensor and a scalar.

fn lower_equal<const D: usize>( lhs: NdArrayTensor<E, D>, rhs: NdArrayTensor<E, D> ) -> NdArrayTensor<bool, D>

Less than or equal comparison of two tensors.

fn lower_equal_elem<const D: usize>( lhs: NdArrayTensor<E, D>, rhs: E ) -> NdArrayTensor<bool, D>

Less than or equal comparison of a tensor and a scalar.

fn detach<const D: usize>(tensor: NdArrayTensor<E, D>) -> NdArrayTensor<E, D>

Detaches a tensor from the computation graph.

fn mean<const D: usize>(tensor: NdArrayTensor<E, D>) -> NdArrayTensor<E, 1>

Mean of all elements in a tensor.

fn sum<const D: usize>(tensor: NdArrayTensor<E, D>) -> NdArrayTensor<E, 1>

Sum of all elements in a tensor.

fn mean_dim<const D: usize>( tensor: NdArrayTensor<E, D>, dim: usize ) -> NdArrayTensor<E, D>

Mean of all elements in a tensor along a dimension.

fn sum_dim<const D: usize>( tensor: NdArrayTensor<E, D>, dim: usize ) -> NdArrayTensor<E, D>

Sum of all elements in a tensor along a dimension.

fn to_full_precision<const D: usize>( tensor: &NdArrayTensor<E, D> ) -> NdArrayTensor<f32, D>

Converts a tensor to full precision.

fn from_full_precision<const D: usize>( tensor: NdArrayTensor<f32, D> ) -> NdArrayTensor<E, D>

Converts a tensor from full precision.

fn argmax<const D: usize>( tensor: NdArrayTensor<E, D>, dim: usize ) -> NdArrayTensor<i64, D>

Gets the indices of the maximum elements of a tensor along an axis.

fn argmin<const D: usize>( tensor: NdArrayTensor<E, D>, dim: usize ) -> NdArrayTensor<i64, D>

Gets the indices of the minimum elements of a tensor along an axis.

fn exp<const D: usize>(tensor: NdArrayTensor<E, D>) -> NdArrayTensor<E, D>

Returns a new tensor with exponential values.

fn log<const D: usize>(tensor: NdArrayTensor<E, D>) -> NdArrayTensor<E, D>

Returns a new tensor with natural logarithm values.

fn log1p<const D: usize>(tensor: NdArrayTensor<E, D>) -> NdArrayTensor<E, D>

Returns a new tensor with logarithm values of (1 + Xi).

fn powf<const D: usize>( tensor: NdArrayTensor<E, D>, value: f32 ) -> NdArrayTensor<E, D>

Returns a new tensor with values raised to the power of value.

fn sqrt<const D: usize>(tensor: NdArrayTensor<E, D>) -> NdArrayTensor<E, D>

Returns a new tensor with square root values.

fn abs<const D: usize>(tensor: NdArrayTensor<E, D>) -> NdArrayTensor<E, D>

Returns a new tensor with absolute values.

fn cos<const D: usize>(tensor: NdArrayTensor<E, D>) -> NdArrayTensor<E, D>

Returns a new tensor with cosine values.

fn sin<const D: usize>(tensor: NdArrayTensor<E, D>) -> NdArrayTensor<E, D>

Returns a new tensor with sine values.

fn tanh<const D: usize>(tensor: NdArrayTensor<E, D>) -> NdArrayTensor<E, D>

Returns a new tensor with tangent values.

fn erf<const D: usize>(tensor: NdArrayTensor<E, D>) -> NdArrayTensor<E, D>

Returns a new tensor with the error function values.

fn cat<const D: usize>( tensors: Vec<NdArrayTensor<E, D>>, dim: usize ) -> NdArrayTensor<E, D>

Catcatenates tensors along a dimension.

fn clamp_min<const D: usize>( tensor: NdArrayTensor<E, D>, min: E ) -> NdArrayTensor<E, D>

Clamps a tensor under a minimum value.

fn clamp_max<const D: usize>( tensor: NdArrayTensor<E, D>, max: E ) -> NdArrayTensor<E, D>

Clamps a tensor over a maximum value.

fn clamp<const D: usize>( tensor: NdArrayTensor<E, D>, min: E, max: E ) -> NdArrayTensor<E, D>

Clamps a tensor between a minimum and maximum value.

fn into_int<const D: usize>( tensor: <NdArray<E> as Backend>::TensorPrimitive<D> ) -> <NdArray<E> as Backend>::IntTensorPrimitive<D>

Converts float tensor to int tensor.

fn zeros<const D: usize>( shape: Shape<D>, device: &<B as Backend>::Device ) -> <B as Backend>::TensorPrimitive<D>

Creates a new tensor with zeros.

fn ones<const D: usize>( shape: Shape<D>, device: &<B as Backend>::Device ) -> <B as Backend>::TensorPrimitive<D>

Creates a new tensor with ones.

fn full<const D: usize>( shape: Shape<D>, fill_value: <B as Backend>::FloatElem, device: &<B as Backend>::Device ) -> <B as Backend>::TensorPrimitive<D>

Creates a tensor filled with given value.

fn to_data<const D: usize>( tensor: &<B as Backend>::TensorPrimitive<D> ) -> Reader<Data<<B as Backend>::FloatElem, D>>

Converts the tensor to a data structure.

fn arange( range: Range<usize>, device: &<B as Backend>::Device ) -> <B as Backend>::IntTensorPrimitive<1>

Creates a new tensor with values from the given range.

fn arange_step( range: Range<usize>, step: usize, device: &<B as Backend>::Device ) -> <B as Backend>::IntTensorPrimitive<1>

Creates a new tensor with values from the given range with the given step size.

fn repeat<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D>, dim: usize, times: usize ) -> <B as Backend>::TensorPrimitive<D>

Repeat the tensor along the given dimension.

fn transpose<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<D>

Transposes a tensor.

fn set_require_grad<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D>, _require_grad: bool ) -> <B as Backend>::TensorPrimitive<D>

Sets the require_grad flag of a tensor.

fn is_require_grad<const D: usize>( _tensor: &<B as Backend>::TensorPrimitive<D> ) -> bool

Returns the require_grad flag of a tensor.

fn max<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<1>

Gets the maximum element of a tensor.

fn max_dim<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D>, dim: usize ) -> <B as Backend>::TensorPrimitive<D>

Gets the maximum elements of a tensor along an axis.

fn max_dim_with_indices<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D>, dim: usize ) -> (<B as Backend>::TensorPrimitive<D>, <B as Backend>::IntTensorPrimitive<D>)

Gets the maximum elements of a tensor along an axis and their indices.

fn min<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D> ) -> <B as Backend>::TensorPrimitive<1>

Gets the minimum element of a tensor.

fn min_dim<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D>, dim: usize ) -> <B as Backend>::TensorPrimitive<D>

Gets the minimum elements of a tensor along an axis.

fn min_dim_with_indices<const D: usize>( tensor: <B as Backend>::TensorPrimitive<D>, dim: usize ) -> (<B as Backend>::TensorPrimitive<D>, <B as Backend>::IntTensorPrimitive<D>)

Gets the minimum elements of a tensor along an axis and their indices.

impl<E: Copy> Copy for NdArray<E>