Struct dfdx::tensor::Tensor

impl<S: Shape, E, D: Storage<E>, T> Tensor<S, E, D, T>

pub fn ghost(&self) -> GhostTensor<S, E, D>

Creates a ghost tensor that doesn’t hold a reference to the tensor’s data.

impl<S: Shape, E: Dtype + NumpyDtype, D: CopySlice<E>, T> Tensor<S, E, D, T>

pub fn write_to_npz<W: Write + Seek>( &self, w: &mut ZipWriter<W>, filename: String ) -> ZipResult<()>

Writes data to a new file in a zip archive named filename.

pub fn read_from_npz<R: Read + Seek>( &mut self, r: &mut ZipArchive<R>, filename: String ) -> Result<(), NpzError>

Reads data from a file already in a zip archive named filename.

pub fn load_from_npy<P: AsRef<Path>>(&mut self, path: P) -> Result<(), NpyError>

Attemps to load the data from a .npy file at path

pub fn save_to_npy<P: AsRef<Path>>(&self, path: P) -> Result<()>

Saves the tensor to a .npy file located at path

impl<S: Shape, E: Dtype + SafeDtype, D: CopySlice<E>, T> Tensor<S, E, D, T>

pub fn load_safetensor( &mut self, tensors: &SafeTensors<'_>, key: &str ) -> Result<(), Error>

Loads data from the SafeTensors Storage with the given key

impl<S: Shape, E, D: CopySlice<E>, T> Tensor<S, E, D, T>

pub fn copy_from(&mut self, src: &[E])

Copy physical data from a slice - panics if there are not enough elements in the slice.

let data = [1.0, 2.0, 3.0, 4.0];
let mut t: Tensor<Rank2<2, 2>, f32, _> = dev.zeros();
t.copy_from(&data);
assert_eq!(t.array(), [[1.0, 2.0], [3.0, 4.0]]);

pub fn copy_into(&self, dst: &mut [E])

Copy physical data into a slice - panics if there are not enough elements in the tensor.

let t: Tensor<Rank2<2, 2>, f32, _> = dev.tensor([[1.0, 2.0], [3.0, 4.0]]);
let mut data = [0.0; 4];
t.copy_into(&mut data);
assert_eq!(data, [1.0, 2.0, 3.0, 4.0]);

pub fn try_fast_gelu(self) -> Result<Self, D::Err>

See fast_gelu

pub fn gelu(self) -> Self

👎Deprecated since 0.12.0: Use Tensor::fast_gelu instead

Use Tensor::fast_gelu instead

pub fn try_gelu(self) -> Result<Self, D::Err>

pub fn try_nans_to(self, value: impl Into<f64>) -> Result<Self, D::Err>

See nans_to

impl<S: Shape, E: Dtype, D: UnaryKernel<NegateKernelOp, E>, T: Tape<E, D>> Tensor<S, E, D, T>

pub fn negate(self) -> Self

See tanh

pub fn lower_tri(self, diagonal: impl Into<Option<isize>>) -> Self

See lower_tri

pub fn try_upper_tri( self, diagonal: impl Into<Option<isize>> ) -> Result<Self, <Self as HasErr>::Err>

See upper_tri

pub fn upper_tri(self, diagonal: impl Into<Option<isize>>) -> Self

See upper_tri

Trait Implementations§

impl<S: Shape, E: Dtype, D: Storage<E>, LhsTape: Tape<E, D>, Rhs> Add<Rhs> for Tensor<S, E, D, LhsTape>where Self: TryAdd<Rhs>,

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

See add

type Output = Tensor<S, E, D, LhsTape>

The resulting type after applying the + operator.

fn broadcast<Dst: ConstShape, Ax: Axes>(self) -> Self::WithShape<Dst>where Self::Shape: BroadcastShapeTo<Dst, Ax>,

Broadcast into shape Dst along axes Ax.

fn try_broadcast<Dst: ConstShape, Ax: Axes>( self ) -> Result<Self::WithShape<Dst>, Self::Err>where Self::Shape: BroadcastShapeTo<Dst, Ax>,

Fallible version of BroadcastTo::broadcast

fn broadcast_like<Dst: HasShape, Ax: Axes>( self, dst: &Dst ) -> Self::WithShape<Dst::Shape>where Self::Shape: BroadcastShapeTo<Dst::Shape, Ax>,

Same as BroadcastTo::broadcast, but the target shape is given

impl<S: Shape, E: Dtype, D: ChooseKernel<E>, LhsTape: Tape<E, D> + Merge<RhsTape>, RhsTape: Tape<E, D>> ChooseFrom<Tensor<S, E, D, LhsTape>, Tensor<S, E, D, RhsTape>> for Tensor<S, bool, D>

type Output = Tensor<S, E, D, LhsTape>

fn try_choose( self, lhs: Tensor<S, E, D, LhsTape>, rhs: Tensor<S, E, D, RhsTape> ) -> Result<Self::Output, Self::Err>

Fallible version of choose

fn choose(self, lhs: Lhs, rhs: Rhs) -> Self::Output

Construct a new tensor, where the output tensor contains the elements of lhs where self is true, and rhs where self is false.

impl<S: Clone + Shape, E: Clone, D: Clone + Storage<E>, T: Clone> Clone for Tensor<S, E, D, T>where D::Vec: Clone, S::Concrete: Clone,

fn clone(&self) -> Tensor<S, E, D, T>

Returns a copy of the value. Read more

The resulting type after applying the / operator.

impl<Src: Shape, E: Dtype, D: ReplaceDimKernel<E>, T: Tape<E, D>> GatherTo<E, D> for Tensor<Src, E, D, T>

fn try_gather<Dst: Shape, Idx: Shape>( self, idx: Tensor<Idx, usize, D> ) -> Result<Self::WithShape<Dst>, Self::Err>where Self::Shape: ReplaceDimTo<Dst, Idx>,

fn gather<Dst: Shape, Idx: Shape>( self, idx: Tensor<Idx, usize, D> ) -> Self::WithShape<Dst>where Self::Shape: ReplaceDimTo<Dst, Idx>,

The returned type after indexing.

fn forward(&self, input: Input) -> Self::Output

Forward Input through the module and produce Module::Output. Read more

impl<B: Dim, C: Dim, H: Dim, W: Dim, E: Dtype, D: Device<E>, T: Tape<E, D>> Module<Tensor<(B, C, H, W), E, D, T>> for AvgPoolGlobal

type Output = Tensor<(B, C), E, D, T>

The type that this unit produces given Input.

fn forward(&self, input: Input) -> Self::Output

Forward Input through the module and produce Module::Output. Read more

impl<B: Dim, C: Dim, H: Dim, W: Dim, E: Dtype, D: Device<E>, T: Tape<E, D>> Module<Tensor<(B, C, H, W), E, D, T>> for MinPoolGlobal

type Output = Tensor<(B, C), E, D, T>

The type that this unit produces given Input.

fn forward(&self, input: Input) -> Self::Output

Forward Input through the module and produce Module::Output. Read more

impl<E: Dtype, D: Device<E>, T: Tape<E, D> + Merge<NoneTape>, B: ConstDim, C: ConstDim, M: ConstDim, N: ConstDim> Module<Tensor<(B, C, M, N), E, D, T>> for PReLU1D<C, E, D>where (B, C, M, N): ReduceShapeTo<(C,), Axes3<0, 2, 3>>, Tensor<(B, C, M, N), E, D, T>: TryPReLU<Tensor<(B, C, M, N), E, D, NoneTape>>,

type Output = Tensor<(B, C, M, N), E, D, T>

The type that this unit produces given Input.

fn forward(&self, input: Input) -> Self::Output

Forward Input through the module and produce Module::Output. Read more

impl<B: Dim, const C: usize, E: Dtype, D: Device<E>> Module<Tensor<(B, Const<C>), E, D, NoneTape>> for BatchNorm1D<C, E, D>

fn try_forward( &self, x: Tensor<(B, Const<C>), E, D, NoneTape> ) -> Result<Self::Output, D::Err>

Inference 1d forward - does not update Self::running_mean and Self::running_var

fn try_forward( &self, input: Tensor<(B, Const<C>, Const<H>, Const<W>), E, D, T> ) -> Result<Self::Output, D::Err>

fn forward(&self, input: Input) -> Self::Output

Forward Input through the module and produce Module::Output. Read more

impl<B: Dim, const C: usize, H: Dim, W: Dim, E: Dtype, D: Device<E>> Module<Tensor<(B, Const<C>, H, W), E, D, NoneTape>> for BatchNorm2D<C, E, D>

fn try_forward( &self, x: Tensor<(B, Const<C>, H, W), E, D, NoneTape> ) -> Result<Self::Output, D::Err>

Inference 4d forward - does not update Self::running_mean and Self::running_var

fn try_forward( &self, input: Tensor<(B, Const<C>, H, W), E, D, T> ) -> Result<Self::Output, D::Err>

fn forward(&self, input: Input) -> Self::Output

Forward Input through the module and produce Module::Output. Read more

impl<B: Dim, const C: usize, L: Dim, E: Dtype, D: Device<E>> Module<Tensor<(B, Const<C>, L), E, D, NoneTape>> for BatchNorm1D<C, E, D>

fn try_forward( &self, x: Tensor<(B, Const<C>, L), E, D, NoneTape> ) -> Result<Self::Output, D::Err>

Inference 2d forward - does not update Self::running_mean and Self::running_var

type Output = Tensor<(B, Const<C>, L), E, D, NoneTape>

Forward Input through the module and produce Module::Output. Read more

impl<const V: usize, const M: usize, SEQ: Dim, E: Dtype, D: Device<E>, T: Tape<E, D>> Module<Tensor<(SEQ,), usize, D, T>> for Embedding<V, M, E, D>

type Output = Tensor<(SEQ, Const<M>), E, D, T>

The type that this unit produces given Input.

type Error = <D as HasErr>::Err

fn try_forward( &self, input: Tensor<(SEQ,), usize, D, T> ) -> Result<Self::Output, D::Err>

fn forward(&self, input: Input) -> Self::Output

Forward Input through the module and produce Module::Output. Read more

impl<S: Shape, E: Dtype, D: Device<E>> Module<Tensor<S, E, D, NoneTape>> for Dropout

fn try_forward( &self, input: Tensor<S, E, D, NoneTape> ) -> Result<Self::Output, D::Err>

Does nothing.

type Error = <D as HasErr>::Err

fn forward_mut(&mut self, input: Input) -> Self::Output

Forward Input through the module and produce ModuleMut::Output. Read more

impl<B: Dim, const C: usize, L: Dim, E: Dtype, D: Device<E>> ModuleMut<Tensor<(B, Const<C>, L), E, D, OwnedTape<E, D>>> for BatchNorm1D<C, E, D>

fn try_forward_mut( &mut self, x: Tensor<(B, Const<C>, L), E, D, OwnedTape<E, D>> ) -> Result<Self::Output, D::Err>

Training 1d forward - updates Self::running_mean and Self::running_var

type Error = <D as HasErr>::Err

fn forward_mut(&mut self, input: Input) -> Self::Output

Forward Input through the module and produce ModuleMut::Output. Read more

impl<const N: usize, S: Shape, E: Dtype, D: Device<E>> ModuleMut<Tensor<S, E, D, OwnedTape<E, D>>> for DropoutOneIn<N>

fn try_forward_mut( &mut self, input: Tensor<S, E, D, OwnedTape<E, D>> ) -> Result<Self::Output, D::Err>

Calls dropout() with p=1/N using self.rng.

type Output = Tensor<S, E, D, OwnedTape<E, D>>

The type that this unit produces given Input.

fn put_tape(self, tape: T) -> Self::Output

impl<S: Shape, E, D: Storage<E>, T: Tape<E, D>> RealizeTo for Tensor<S, E, D, T>

fn try_realize<Dst: Shape<Concrete = S::Concrete>>( self ) -> Result<Self::WithShape<Dst>, Self>where Self::Shape: RealizeShapeTo<Dst>,

Realizes the concrete shape of the tensor as another compatable shape, or returns the original tensor if the new shape’s dimensions are incompatable.

impl<S: Shape, E: Dtype, D: ReshapeKernel<E>, T: Tape<E, D>> ReshapeTo for Tensor<S, E, D, T>

fn try_reshape_like<Dst: Shape>( self, dst: &Dst ) -> Result<Self::WithShape<Dst>, Self::Err>

Reshapes a tensor to a different runtime shape.

fn reshape_like<Dst: Shape>(self, dst: &Dst) -> Self::WithShape<Dst>

type Traced = Tensor<S, F, D, OwnedTape<E, D>>

fn leaky_traced(self) -> Self::Traced

Start tracking gradients. The gradients will never free temporary gradients - See Gradients::leaky() for more info. Read more

fn traced(self, gradients: Gradients<E, D>) -> Self::Traced

Accumulates gradients into gradients. Use crate::nn::ZeroGrads::alloc_grads() to create gradients.

fn leaky_trace(&self) -> Self::Traced

Start tracking gradients, clones self. The gradients will never free temporary gradients - See Gradients::leaky() for more info. Read more

👎Deprecated: Use TryConcatAlong::try_concat_along instead

Fallible version of TryConcat::concat.

fn concat(self, rhs: Rhs) -> Self::Output

fn lt(&self, rhs: Rhs) -> Self::Output

See lt

impl<B: Dim, M: Dim, K: Dim, N: Dim, E: Dtype, D, T, R> TryMatMul<Tensor<(B, K, N), E, D, R>> for Tensor<(B, M, K), E, D, T>where D: MatMatBatch3Kernel<E>, T: Tape<E, D> + Merge<R>, R: Tape<E, D>,

fn try_matmul( self, rhs: Tensor<(B, K, N), E, D, R> ) -> Result<Self::Output, Self::Err>

let x: Tensor<Rank3<1, 3, 2>, f32, _> = dev.zeros();
let y: Tensor<Rank3<1, 3, 4>, f32, _> = dev.zeros();
let _: Tensor<Rank3<1, 3, 4>, f32, _> = x.try_matmul(y);

type Output = Tensor<(B, M, N), E, D, T>

fn matmul(self, rhs: Rhs) -> Self::Output

impl<B: Dim, S: Dim, M: Dim, K: Dim, N: Dim, E: Dtype, D, T, R> TryMatMul<Tensor<(B, S, K, N), E, D, R>> for Tensor<(B, S, M, K), E, D, T>where D: MatMatBatch4Kernel<E>, T: Tape<E, D> + Merge<R>, R: Tape<E, D>,

fn try_matmul( self, rhs: Tensor<(B, S, K, N), E, D, R> ) -> Result<Self::Output, Self::Err>

let x: Tensor<Rank4<1, 5, 3, 2>, f32, _> = dev.zeros();
let y: Tensor<Rank4<1, 5, 3, 4>, f32, _> = dev.zeros();
let _: Tensor<Rank3<1, 5, 3, 4>, f32, _> = x.try_matmul(y);

let x: Tensor<Rank3<1, 3, 2>, f32, _> = dev.zeros();
let y: Tensor<Rank2<3, 4>, f32, _> = dev.zeros();
let _: Tensor<Rank3<1, 3, 4>, f32, _> = x.try_matmul(y);

let x: Tensor<Rank2<3, 2>, f32, _> = dev.zeros();
let y: Tensor<Rank2<3, 4>, f32, _> = dev.zeros();
let _: Tensor<Rank2<3, 4>, f32, _> = x.try_matmul(y);

fn try_prelu(self, rhs: Tensor<S, E, D, R>) -> Result<Self, Self::Err>

See prelu

fn try_upscale2d<const OH: usize, const OW: usize, M: UpscaleMethod>( self, method: M ) -> Result<<Self as GenericUpscale2D<M>>::Output<Const<OH>, Const<OW>>, Self::Err>where Self: GenericUpscale2D<M>,

Fallibly upscale to compile time known dimensions.

fn upscale2d_like<OH: Dim, OW: Dim, M: UpscaleMethod>( self, method: M, height: OH, width: OW ) -> <Self as GenericUpscale2D<M>>::Output<OH, OW>where Self: GenericUpscale2D<M>,

Upscale to runtime known dimensions.

fn try_upscale2d_like<OH: Dim, OW: Dim, M: UpscaleMethod>( self, method: M, height: OH, width: OW ) -> Result<<Self as GenericUpscale2D<M>>::Output<OH, OW>, Self::Err>where Self: GenericUpscale2D<M>,

Fallibly upscale to runtime known dimensions.

impl<S: Shape, E: Dtype, D: Device<E>, T: Tape<E, D>> VarTo for Tensor<S, E, D, T>

fn try_var<Dst: Shape, Ax: Axes>( self ) -> Result<Self::WithShape<Dst>, Self::Err>where Self::Shape: HasAxes<Ax> + ReduceShapeTo<Dst, Ax>,

Fallible version of VarTo::var

fn var<Dst: Shape, Ax: Axes>(self) -> Self::WithShape<Dst>where Self::Shape: HasAxes<Ax> + ReduceShapeTo<Dst, Ax>,

Result Tensor has smaller number of dimensions. Read more

Construct it on the device

fn try_build(device: &D) -> Result<Self, D::Err>

Fallible version of BuildModule::build

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<E, D, M> NumParams<E, D> for Mwhere E: Dtype, D: Device<E>, M: TensorCollection<E, D>,

fn num_trainable_params(&self) -> usize

Returns the number of trainable params in any model.

Drops the object pointed to by the given pointer. Read more

impl<E, D, M> ResetParams<E, D> for Mwhere E: Dtype, D: Device<E>, M: TensorCollection<E, D>,

fn reset_params(&mut self)

Reset all a model’s parameters.

fn try_reset_params(&mut self) -> Result<(), D::Err>

Reset all a model’s parameters.

impl<E, D, T> SaveToNpz<E, D> for Twhere E: Dtype + NumpyDtype, D: Device<E>, T: TensorCollection<E, D>,

fn save<P: AsRef<Path>>(&self, path: P) -> ZipResult<()>

Save this object into the .npz file determined located at path. Read more

Copy self from D1 to D2

impl<E1, D, T> ToDtype<E1, D> for Twhere E1: Dtype, D: Device<E1>, T: TensorCollection<E1, D>,

fn try_to_dtype<E2: Dtype>(&self) -> Result<Self::To<E2, D>, D::Err>where D: Device<E2> + ToDtypeKernel<E1, E2>,

Fallible version of ToDtype::to_dtype

fn to_dtype<E2: Dtype>(&self) -> Self::To<E2, D>where D: Device<E2> + ToDtypeKernel<E1, E2>,

Create a copy of self with dtype E2

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom for Twhere U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

fn alloc_grads(&self) -> Gradients<E, D>

Allocates gradients for this tensor collection. This marks all other gradients as temporary, so they are dropped after .backward()

fn try_alloc_grads(&self) -> Result<Gradients<E, D>, D::Err>

Allocates gradients for this tensor collection. This marks all other gradients as temporary, so they are dropped after .backward()

fn zero_grads(&self, gradients: &mut Gradients<E, D>)

Zero’s any gradients associated with self.