Struct burn_ndarray::NdArrayBackend

pub struct NdArrayBackend<E> { /* private fields */ }

Trait Implementations

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

type Device = NdArrayDevice

Device type.

type FullPrecisionElem = f32

Full precision float element type.

type FullPrecisionBackend = NdArrayBackend<f32>

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.

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

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

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

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

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

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

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

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

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

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

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

fn bool_index_assign<const D1: usize, const D2: usize>( tensor: <NdArrayBackend<E> as Backend>::BoolTensorPrimitive<D1>, indexes: [Range<usize>; D2], value: <NdArrayBackend<E> as Backend>::BoolTensorPrimitive<D1> ) -> <NdArrayBackend<E> as Backend>::BoolTensorPrimitive<D1>

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

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

fn bool_equal_elem<const D: usize>( lhs: <NdArrayBackend<E> as Backend>::BoolTensorPrimitive<D>, rhs: bool ) -> <NdArrayBackend<E> as Backend>::BoolTensorPrimitive<D>

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

impl<E: Clone> Clone for NdArrayBackend<E>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E: Debug> Debug for NdArrayBackend<E>

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

Formats the value using the given formatter.

impl<E: Default> Default for NdArrayBackend<E>

fn default() -> NdArrayBackend<E>

Returns the “default value” for a type.

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

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

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

fn int_to_data<const D: usize>(tensor: &NdArrayTensor<i64, D>) -> Data<i64, D>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn int_index_select_assign<const D: usize>( tensor: NdArrayTensor<i64, D>, indexes: NdArrayTensor<i64, D>, value: NdArrayTensor<i64, D> ) -> NdArrayTensor<i64, D>

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

fn int_index_select_dim_assign<const D1: usize, const D2: usize>( tensor: NdArrayTensor<i64, D1>, dim: usize, indexes: NdArrayTensor<i64, 1>, value: NdArrayTensor<i64, D2> ) -> NdArrayTensor<i64, D1>

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

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

fn embedding( weights: NdArrayTensor<E, 2>, indexes: NdArrayTensor<i64, 2> ) -> NdArrayTensor<E, 3>

fn embedding_backward( weights: NdArrayTensor<E, 2>, output: NdArrayTensor<E, 3>, indexes: NdArrayTensor<i64, 2> ) -> NdArrayTensor<E, 2>

fn conv2d( x: NdArrayTensor<E, 4>, weight: NdArrayTensor<E, 4>, bias: Option<NdArrayTensor<E, 1>>, stride: [usize; 2], padding: [usize; 2] ) -> NdArrayTensor<E, 4>

Two dimensional convolution.

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

Two dimensional max pooling.

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

Two dimensional max pooling with indexes.

fn max_pool2d_with_indexes_backward( x: NdArrayTensor<E, 4>, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], output_grad: NdArrayTensor<E, 4>, indexes: NdArrayTensor<i64, 4> ) -> MaxPool2dBackward<NdArrayBackend<E>>

Backward pass for the max pooling 2d operation.

fn conv2d_backward( x: <B as Backend>::TensorPrimitive<4>, weight: <B as Backend>::TensorPrimitive<4>, bias: Option<<B as Backend>::TensorPrimitive<1>>, stride: [usize; 2], output_grad: <B as Backend>::TensorPrimitive<4> ) -> Conv2dBackward<B>

Backward pass for the conv2d operation.

fn conv1d( x: <B as Backend>::TensorPrimitive<3>, weight: <B as Backend>::TensorPrimitive<3>, bias: Option<<B as Backend>::TensorPrimitive<1>>, stride: usize, padding: usize ) -> <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>>, stride: usize, output_grad: <B as Backend>::TensorPrimitive<3> ) -> Conv1dBackward<B>

Backward pass for the conv1d operation.

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

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

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

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

fn to_data<const D: usize>( tensor: &NdArrayTensor<E, D> ) -> Data<<NdArrayBackend<E> as Backend>::FloatElem, D>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn index_select<const D: usize>( tensor: NdArrayTensor<E, D>, indexes: NdArrayTensor<i64, D> ) -> NdArrayTensor<E, D>

fn index_select_assign<const D: usize>( tensor: NdArrayTensor<E, D>, indexes: NdArrayTensor<i64, D>, value: NdArrayTensor<E, D> ) -> NdArrayTensor<E, D>

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

fn index_select_dim_assign<const D1: usize, const D2: usize>( tensor: NdArrayTensor<E, D1>, dim: usize, indexes: NdArrayTensor<i64, 1>, value: NdArrayTensor<E, D2> ) -> NdArrayTensor<E, D1>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<E: Copy> Copy for NdArrayBackend<E>