Struct Autodiff 

pub struct Autodiff<B, C = NoCheckpointing> { /* private fields */ }

Enable auto-differentiation on a backend.

This works as a backend decorator, extending the functionality of any backend with backpropagation.

Implementations

impl<Src, C> Autodiff<Src, C>

where Src: Backend, C: CheckpointStrategy,

pub fn to_backend<Dst, Adapter>( tensor: <Autodiff<Src, C> as BackendTypes>::FloatTensorPrimitive, device: &<Dst as BackendTypes>::Device, ) -> <Autodiff<Dst, C> as BackendTypes>::FloatTensorPrimitive

where Dst: Backend, Adapter: DifferentiableTransfer<Src, Dst>,

Transfers a tensor to another backend through the supplied adapter.

Tracked inputs remain connected to the graph; their outputs are non-leaf tensors and cannot retain their own gradients. Detach the output before requiring its gradient to start a new leaf on the destination, severing the source connection. Untracked inputs remain untracked. The checkpointing strategy is preserved. Transfers aren’t replayed during gradient checkpointing.

Distributed backward requires every distributed parameter to use the same backend as the loss. Incompatible graphs panic before synchronization or gradient computation begins.

Trait Implementations

impl<B, C> ActivationOps<Autodiff<B, C>> for Autodiff<B, C>

where B: Backend, C: CheckpointStrategy,

fn gelu( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Applies the Gelu activation function.

fn relu( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Applies the ReLU activation function.

fn sigmoid( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Applies the Sigmoid activation function.

fn log_sigmoid( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Applies the LogSigmoid activation function.

fn leaky_relu( tensor: <B as BackendTypes>::FloatTensorPrimitive, negative_slope: Scalar, ) -> <B as BackendTypes>::FloatTensorPrimitive

Applies the LeakyReLU activation function.

fn relu_backward( output: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Applies the ReLU activation function backward.

fn prelu( tensor: <B as BackendTypes>::FloatTensorPrimitive, alpha: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Applies the PReLu activation function.

fn gelu_backward( x: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Applies the Gelu activation function backward.

fn sigmoid_backward( output: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Applies the Sigmoid activation function backward.

fn hard_sigmoid( tensor: <B as BackendTypes>::FloatTensorPrimitive, alpha: Scalar, beta: Scalar, ) -> <B as BackendTypes>::FloatTensorPrimitive

Applies the hard Sigmoid activation function.

fn softmax( tensor: <B as BackendTypes>::FloatTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::FloatTensorPrimitive

Applies the softmax function along the given dimension.

fn log_softmax( tensor: <B as BackendTypes>::FloatTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::FloatTensorPrimitive

Applies the log-softmax function along the given dimension.

fn softmin( tensor: <B as BackendTypes>::FloatTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::FloatTensorPrimitive

Applies the softmin function along the given dimension.

fn log_sigmoid_backward( x: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Applies the LogSigmoid activation function backward.

impl<B, C> AutodiffBackend for Autodiff<B, C>

where B: Backend, C: CheckpointStrategy,

type InnerBackend = B

The inner backend type.

type Gradients = Gradients

Gradients type.

fn backward(tensor: AutodiffTensor<B>) -> Gradients

Backward pass.

fn grad( tensor: &AutodiffTensor<B>, grads: &Gradients, ) -> Option<<B as BackendTypes>::FloatTensorPrimitive>

Returns the gradients of a tensor.

fn grad_remove( tensor: &AutodiffTensor<B>, grads: &mut Gradients, ) -> Option<<B as BackendTypes>::FloatTensorPrimitive>

Pops the gradients of a tensor and returns them.

fn inner(tensor: AutodiffTensor<B>) -> <B as BackendTypes>::FloatTensorPrimitive

Returns the tensor with inner backend type.

fn from_inner( tensor: <B as BackendTypes>::FloatTensorPrimitive, ) -> AutodiffTensor<B>

Converts the inner backend tensor to the autodiff backend tensor.

fn grad_replace( tensor: &AutodiffTensor<B>, grads: &mut <Autodiff<B, C> as AutodiffBackend>::Gradients, grad: <B as BackendTypes>::FloatTensorPrimitive, )

Replace the gradients of a tensor with the one provided.

fn int_inner( tensor: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, ) -> <<Autodiff<B, C> as AutodiffBackend>::InnerBackend as BackendTypes>::IntTensorPrimitive

Returns the tensor with inner backend type.

fn bool_inner( tensor: <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive, ) -> <<Autodiff<B, C> as AutodiffBackend>::InnerBackend as BackendTypes>::BoolTensorPrimitive

Returns the tensor with inner backend type.

fn int_from_inner( tensor: <<Autodiff<B, C> as AutodiffBackend>::InnerBackend as BackendTypes>::IntTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

Converts the inner backend tensor to the autodiff backend tensor.

fn bool_from_inner( tensor: <<Autodiff<B, C> as AutodiffBackend>::InnerBackend as BackendTypes>::BoolTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive

Converts the inner backend tensor to the autodiff backend tensor.

fn q_inner( tensor: <Autodiff<B, C> as BackendTypes>::QuantizedTensorPrimitive, ) -> <<Autodiff<B, C> as AutodiffBackend>::InnerBackend as BackendTypes>::QuantizedTensorPrimitive

Returns the tensor with inner backend type.

fn q_from_inner( tensor: <<Autodiff<B, C> as AutodiffBackend>::InnerBackend as BackendTypes>::QuantizedTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::QuantizedTensorPrimitive

Converts the inner backend tensor to the autodiff backend tensor.

fn set_distributed_params( tensor: AutodiffTensor<B>, param_id: ParamId, ) -> AutodiffTensor<B>

Mark the tensor as distributed across multiple devices. The gradients will be aggregated during the backward pass.

fn distributed_params(tensor: &AutodiffTensor<B>) -> Option<DistributedParams>

Returns the distributed parameters if the tensor was marked as distributed.

fn is_distributed(tensor: &AutodiffTensor<B>) -> bool

Returns true if the tensor was marked as distributed.

impl<B, C> Backend for Autodiff<B, C>

where B: Backend, C: CheckpointStrategy,

fn ad_enabled(_device: &<Autodiff<B, C> as BackendTypes>::Device) -> bool

If autodiff is enabled.

fn name(device: &<Autodiff<B, C> as BackendTypes>::Device) -> String

Name of the backend.

fn seed(device: &<B as BackendTypes>::Device, seed: u64)

Seeds the backend on the specified device.

fn sync(device: &<B as BackendTypes>::Device) -> Result<(), ExecutionError>

Sync the backend, ensure that all computation are finished.

fn profile<O>( device: &<Autodiff<B, C> as BackendTypes>::Device, options: ProfileOptions, func: impl FnOnce() -> O + Send, ) -> Result<(O, ProfileDuration), ExecutionError>

where O: Send + 'static,

Measure how long the device spends on the work func puts on the calling stream, in device time.

fn profile_start( device: &<Autodiff<B, C> as BackendTypes>::Device, ) -> Result<Option<ProfileToken>, ExecutionError>

Open a profiling window at the calling stream’s current position, to be closed with profile_end from the same stream.

fn profile_end( device: &<Autodiff<B, C> as BackendTypes>::Device, token: ProfileToken, options: ProfileOptions, ) -> Result<ProfileDuration, ExecutionError>

Close the window token at the calling stream’s current position.

fn profile_abandon( device: &<Autodiff<B, C> as BackendTypes>::Device, token: ProfileToken, )

Drop the window token opened without measuring it, for a caller that will never reach profile_end.

fn memory_persistent_allocations<Output, Input, Func>( device: &<Autodiff<B, C> as BackendTypes>::Device, input: Input, func: Func, ) -> Output

where Output: Send, Input: Send, Func: Fn(Input) -> Output + Send,

Sets the current allocation mode to persistent.

fn memory_cleanup(device: &<Autodiff<B, C> as BackendTypes>::Device)

Manually triggers a memory cleanup on the given device.

fn memory_pool_report( device: &<Autodiff<B, C> as BackendTypes>::Device, ) -> Option<Vec<SlicedPoolReport>>

The dynamic pools’ measured state, in the order allocations are routed through them. None on a backend that does not report one, or whose stream has failed.

fn memory_pool_usage( device: &<Autodiff<B, C> as BackendTypes>::Device, ) -> Option<MemoryPoolUsage>

The device allocator’s current state. None on a backend that does not report one, or whose stream has failed.

fn staging<'a, Iter>( data: Iter, device: &<Autodiff<B, C> as BackendTypes>::Device, )

where Iter: Iterator<Item = &'a mut TensorData>,

Marks the given data as being used as a staging buffer for transfer between CPU and accelerators like GPUs.

fn supports_dtype( device: &<Autodiff<B, C> as BackendTypes>::Device, dtype: DType, ) -> bool

Whether the type is fully supported by the specified device for general operations.

fn dtype_usage( device: &<Autodiff<B, C> as BackendTypes>::Device, dtype: DType, ) -> EnumSet<DTypeUsage>

Returns the DTypeUsageSet for the given DType on the specified device.

fn device_count(type_id: u16) -> usize

Returns the number of devices available on this backend. device is a reference device used to determine the underlying backend that should be queried. A CUDA device will return all devices available to CUDA, a Vulkan device will return all devices available to Vulkan, etc.

fn flush( device: &<Autodiff<B, C> as BackendTypes>::Device, ) -> Result<(), ExecutionError>

Flush any pending operation of the backend.

fn graph_prepare(_device: &Self::Device) -> Result<(), ExecutionError>

Prepare device for an upcoming graph capture: route allocations into a stable pool so every buffer allocated before graph_stop_capture can be pinned. Call before the warmup run. No-op by default.

fn graph_start_capture(_device: &Self::Device) -> Result<(), ExecutionError>

Begin recording launches on device into a graph (see graph_stop_capture). Errors on backends without hardware graph support, so callers fall back to re-running.

fn graph_stop_capture( _device: &Self::Device, ) -> Result<Self::GraphPrimitive, ExecutionError>

Stop recording and return the captured graph, ready to graph_replay.

unsafe fn graph_replay( _device: &Self::Device, _graph: &Self::GraphPrimitive, ) -> Result<(), ExecutionError>

Replay a captured graph — one dispatch re-running the recorded launches against their original buffers.

impl<B, C> BackendTypes for Autodiff<B, C>

where B: BackendTypes, C: CheckpointStrategy,

type Device = <B as BackendTypes>::Device

Device type.

type FloatTensorPrimitive = AutodiffTensor<B>

Tensor primitive to be used for all float operations.

type IntTensorPrimitive = <B as BackendTypes>::IntTensorPrimitive

Tensor primitive to be used for all int operations.

type BoolTensorPrimitive = <B as BackendTypes>::BoolTensorPrimitive

Tensor primitive to be used for all bool operations.

type QuantizedTensorPrimitive = <B as BackendTypes>::QuantizedTensorPrimitive

Tensor primitive to be used for all quantized operations.

type GraphPrimitive = GraphUnsupported

Captured graph primitive returned by Backend::graph_stop_capture and consumed by Backend::graph_replay: a backend-owned recording of a launch sequence that replays as a single dispatch.

impl<B, C> BoolTensorOps<Autodiff<B, C>> for Autodiff<B, C>

where B: Backend, C: CheckpointStrategy,

fn bool_from_data( data: TensorData, device: &<B as BackendTypes>::Device, ) -> <B as BackendTypes>::BoolTensorPrimitive

Creates a tensor from the data structure.

async fn bool_into_data( tensor: <B as BackendTypes>::BoolTensorPrimitive, ) -> Result<TensorData, ExecutionError>

Converts the tensor to a data structure.

fn bool_into_int( tensor: <B as BackendTypes>::BoolTensorPrimitive, out_dtype: IntDType, ) -> <B as BackendTypes>::IntTensorPrimitive

Converts bool tensor to int tensor.

fn bool_to_device( tensor: <B as BackendTypes>::BoolTensorPrimitive, device: &<B as BackendTypes>::Device, ) -> <B as BackendTypes>::BoolTensorPrimitive

Moves the tensor to the device.

fn bool_reshape( tensor: <B as BackendTypes>::BoolTensorPrimitive, shape: Shape, ) -> <B as BackendTypes>::BoolTensorPrimitive

Reshapes the tensor.

fn bool_slice( tensor: <B as BackendTypes>::BoolTensorPrimitive, slices: &[Slice], ) -> <B as BackendTypes>::BoolTensorPrimitive

Gets the values from the tensor for the given ranges.

fn bool_empty( shape: Shape, device: &<B as BackendTypes>::Device, dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Creates a new bool tensor.

fn bool_zeros( shape: Shape, device: &<B as BackendTypes>::Device, dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Creates a new bool tensor filled false.

fn bool_ones( shape: Shape, device: &<B as BackendTypes>::Device, dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Creates a new bool tensor filled true.

fn bool_slice_assign( tensor: <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive, slices: &[Slice], value: <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive

Sets the values in the tensor for the given ranges.

fn bool_cat( tensors: Vec<<B as BackendTypes>::BoolTensorPrimitive>, dim: usize, ) -> <B as BackendTypes>::BoolTensorPrimitive

Concatenates the tensors along the given dimension.

fn bool_equal( lhs: <B as BackendTypes>::BoolTensorPrimitive, rhs: <B as BackendTypes>::BoolTensorPrimitive, ) -> <B as BackendTypes>::BoolTensorPrimitive

Equates the two tensors.

fn bool_not( tensor: <B as BackendTypes>::BoolTensorPrimitive, ) -> <B as BackendTypes>::BoolTensorPrimitive

Inverses boolean values.

fn bool_and( lhs: <B as BackendTypes>::BoolTensorPrimitive, rhs: <B as BackendTypes>::BoolTensorPrimitive, ) -> <B as BackendTypes>::BoolTensorPrimitive

Executes the logical and (&&) operation on two boolean tensors.

fn bool_or( lhs: <B as BackendTypes>::BoolTensorPrimitive, rhs: <B as BackendTypes>::BoolTensorPrimitive, ) -> <B as BackendTypes>::BoolTensorPrimitive

Executes the logical or (||) operation on two boolean tensors.

fn bool_xor( lhs: <B as BackendTypes>::BoolTensorPrimitive, rhs: <B as BackendTypes>::BoolTensorPrimitive, ) -> <B as BackendTypes>::BoolTensorPrimitive

Element-wise exclusive or.

fn bool_into_float( tensor: <B as BackendTypes>::BoolTensorPrimitive, out_dtype: FloatDType, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Converts bool tensor to float tensor.

fn bool_swap_dims( tensor: <B as BackendTypes>::BoolTensorPrimitive, dim1: usize, dim2: usize, ) -> <B as BackendTypes>::BoolTensorPrimitive

Swaps two dimensions of a bool tensor.

fn bool_permute( tensor: <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive, axes: &[usize], ) -> <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive

Permutes the dimensions of a tensor.

fn bool_flip( tensor: <B as BackendTypes>::BoolTensorPrimitive, axes: &[usize], ) -> <B as BackendTypes>::BoolTensorPrimitive

Reverse the order of elements in a tensor along the given axes.

async fn bool_argwhere( tensor: <B as BackendTypes>::BoolTensorPrimitive, out_dtype: IntDType, ) -> <B as BackendTypes>::IntTensorPrimitive

Compute the indices of the elements that are non-zero, grouped by element.

fn bool_expand( tensor: <B as BackendTypes>::BoolTensorPrimitive, shape: Shape, ) -> <B as BackendTypes>::BoolTensorPrimitive

Broadcasts the bool tensor to the given shape.

fn bool_repeat_dim( tensor: <B as BackendTypes>::BoolTensorPrimitive, dim: usize, times: usize, ) -> <B as BackendTypes>::BoolTensorPrimitive

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

fn bool_unfold( tensor: <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive, dim: usize, size: usize, step: usize, ) -> <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive

Unfold windows along a dimension.

fn bool_mask_where( tensor: <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive, mask: <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive, source: <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive

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

fn bool_mask_fill( tensor: <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive, mask: <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive, value: Scalar, ) -> <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive

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

async fn bool_mask_select( tensor: <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive, mask: <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive

Selects the elements of the tensor where the mask is true, returned as a 1D tensor.

fn bool_gather( dim: usize, tensor: <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive, indices: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive

Gather elements from the tensor at the given indices.

fn bool_scatter_or( dim: usize, tensor: <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive, indices: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, value: <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive

Scatter a given value to the tensor at the given indices using boolean or reduction.

fn bool_equal_elem( lhs: <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive, rhs: Scalar, ) -> <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive

Element-wise equality comparison with a scalar.

fn bool_select( tensor: <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive, dim: usize, indices: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive

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

fn bool_select_or( tensor: <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive, dim: usize, indices: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, value: <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive

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

fn bool_not_equal( lhs: <B as BackendTypes>::BoolTensorPrimitive, rhs: <B as BackendTypes>::BoolTensorPrimitive, ) -> <B as BackendTypes>::BoolTensorPrimitive

Element-wise non-equality comparison.

fn bool_not_equal_elem( lhs: <B as BackendTypes>::BoolTensorPrimitive, rhs: Scalar, ) -> <B as BackendTypes>::BoolTensorPrimitive

Element-wise non-equality comparison with a scalar.

fn bool_transpose( tensor: <B as BackendTypes>::BoolTensorPrimitive, ) -> <B as BackendTypes>::BoolTensorPrimitive

Transposes a bool tensor.

fn bool_any( tensor: <B as BackendTypes>::BoolTensorPrimitive, ) -> <B as BackendTypes>::BoolTensorPrimitive

Tests if any element in the boolean tensor evaluates to True.

fn bool_any_dim( tensor: <B as BackendTypes>::BoolTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::BoolTensorPrimitive

Tests if any element in the boolean tensor evaluates to True along a given dimension dim.

fn bool_all( tensor: <B as BackendTypes>::BoolTensorPrimitive, ) -> <B as BackendTypes>::BoolTensorPrimitive

Tests if all elements in the boolean tensor evaluate to True.

fn bool_all_dim( tensor: <B as BackendTypes>::BoolTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::BoolTensorPrimitive

Tests if all elements in the boolean tensor evaluate to True along a given dimension dim.

impl<B, C> Clone for Autodiff<B, C>

where B: Clone, C: Clone,

fn clone(&self) -> Autodiff<B, C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B, C> Copy for Autodiff<B, C>

where B: Copy, C: Copy,

impl<B, C> Debug for Autodiff<B, C>

where B: Debug, C: Debug,

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

Formats the value using the given formatter.

impl<B, C> Default for Autodiff<B, C>

where B: Default, C: Default,

fn default() -> Autodiff<B, C>

Returns the “default value” for a type.

impl<C> DispatchKindConversion<Autodiff<Flex, C>> for DispatchTensor

where C: CheckpointStrategy + IntoGradientCheckpointingStrategy,

Available on crate features autodiff and flex only.

fn try_into_backend( tensor: DispatchTensor, ) -> Result<BackendTensor<Autodiff<Flex, C>>, String>

Attempts to extract a backend-specific BackendTensor wrapper from a generic, dynamically-routed DispatchTensor.

fn from_backend(tensor: BackendTensor<Autodiff<Flex, C>>) -> DispatchTensor

Encapsulates a backend-specific tensor variant back into a globally routing DispatchTensor.

impl<B, C> DistributedOps<Autodiff<B, C>> for Autodiff<B, C>

where B: Backend, C: CheckpointStrategy,

fn start_communication_server( devices: &[<B as BackendTypes>::Device], config: DistributedConfig, )

Start the communication server used to orchestrate tensor syncing between devices.

fn close_communication_server(device: &<B as BackendTypes>::Device)

Close the communication server used to orchestrate syncing between devices.

fn register_sync_parameters( device: &<B as BackendTypes>::Device, distributed_params: Vec<DistributedParams>, )

Register the parameters that will require gradient synchronization for the upcoming backward pass.

fn submit_sync_collective(device: &<B as BackendTypes>::Device)

Tell the gradient sync server that this device has submitted all its sync operations and is ready to be synchronized.

fn submit_gradient_sync( tensor: TensorRef<Autodiff<B, C>>, distributed_params: DistributedParams, )

Submit a gradient tensor for synchronization across all devices.

fn all_reduce( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, op: ReduceOperation, device_ids: Vec<DeviceId>, ) -> CollectiveTensor<Autodiff<B, C>>

all_reduce operation.

fn sync_collective(device: &<B as BackendTypes>::Device)

Sync the collective operations.

unsafe fn comm_device(tensor: &TensorRef<B>) -> <B as BackendTypes>::Device

Get the device of the tensor reference.

unsafe fn float_from_ref( tensor: &TensorRef<B>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Returns a clone of the float tensor from the tensor reference.

impl<B, C> FloatTensorOps<Autodiff<B, C>> for Autodiff<B, C>

where B: Backend, C: CheckpointStrategy,

fn float_from_data( data: TensorData, device: &<Autodiff<B, C> as BackendTypes>::Device, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Creates a new tensor from the data structure.

fn float_random( shape: Shape, distribution: Distribution, device: &<Autodiff<B, C> as BackendTypes>::Device, dtype: FloatDType, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Creates a new tensor with random values.

fn float_zeros( shape: Shape, device: &<Autodiff<B, C> as BackendTypes>::Device, dtype: FloatDType, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Creates a new tensor with zeros.

fn float_ones( shape: Shape, device: &<Autodiff<B, C> as BackendTypes>::Device, dtype: FloatDType, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Creates a new tensor with ones.

async fn float_into_data( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> Result<TensorData, ExecutionError>

Converts the tensor to a data structure.

fn float_to_device( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, device: &<Autodiff<B, C> as BackendTypes>::Device, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Moves the tensor to the given device.

fn float_empty( shape: Shape, device: &<Autodiff<B, C> as BackendTypes>::Device, dtype: FloatDType, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Creates an empty tensor with the given shape.

fn float_add( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Adds two tensors together.

fn float_add_scalar( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: Scalar, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Adds a scalar to a tensor.

fn float_sub( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Subtracts two tensors.

fn float_sub_scalar( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: Scalar, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Subtracts a scalar from a tensor.

fn float_mul( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Multiplies two tensors together element-wise.

fn float_mul_scalar( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: Scalar, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Multiplies a tensor by a scalar.

fn float_div( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Divides two tensors element-wise.

fn float_div_scalar( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: Scalar, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Divides a tensor by a scalar.

fn float_remainder( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Computes the remainder of division between two tensors element-wise.

fn float_remainder_scalar( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: Scalar, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Computes the modulus of a tensor given a scalar.

fn float_matmul( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Multiplies two tensors together using matrix multiplication.

fn float_cross( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Computes the cross product of two tensors along a given dimension.

fn float_neg( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Negates a tensor element-wise.

fn float_recip( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Calculates the reciprocals element-wise

fn float_swap_dims( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim1: usize, dim2: usize, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Swaps two dimensions of a tensor.

fn float_permute( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, axes: &[usize], ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Permutes the dimensions of a tensor.

fn float_flip( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, axes: &[usize], ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Reverse the order of elements in a tensor along the given axes.

fn float_reshape( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, shape: Shape, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Reshapes a tensor.

fn float_gather( dim: usize, tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, indices: <B as BackendTypes>::IntTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Gather elements from a tensor.

fn float_scatter( dim: usize, tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, indices: <B as BackendTypes>::IntTensorPrimitive, value: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, update: IndexingUpdateOp, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Scatter elements into a tensor using the specified update operation.

fn float_scatter_nd( data: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, indices: <B as BackendTypes>::IntTensorPrimitive, values: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, reduction: IndexingUpdateOp, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Multi-dimensional scatter: update data at locations specified by indices with values.

fn float_gather_nd( data: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, indices: <B as BackendTypes>::IntTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Multi-dimensional gather: collect slices from data at locations specified by indices.

fn float_select( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, indices: <B as BackendTypes>::IntTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

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

fn float_select_assign( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, indices: <B as BackendTypes>::IntTensorPrimitive, value: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, update: IndexingUpdateOp, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Assign selected elements along a dimension using the specified update operation.

fn float_slice( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, slices: &[Slice], ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Select tensor elements corresponding to the given slices.

fn float_slice_assign( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, slices: &[Slice], value: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Assign the selected elements corresponding to the given slices to the given value.

fn float_mask_where( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, mask: <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive, source: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

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

fn float_mask_fill( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, mask: <B as BackendTypes>::BoolTensorPrimitive, value: Scalar, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

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

fn float_equal( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Equal comparison of two tensors.

fn float_equal_elem( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: Scalar, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Equal comparison of a tensor and a scalar.

fn float_greater( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Greater than comparison of two tensors.

fn float_greater_elem( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: Scalar, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Greater than comparison of a tensor and a scalar.

fn float_greater_equal( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Greater than or equal comparison of two tensors.

fn float_greater_equal_elem( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: Scalar, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

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

fn float_lower( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Less than comparison of two tensors.

fn float_lower_elem( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: Scalar, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Less than comparison of a tensor and a scalar.

fn float_lower_equal( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Less than or equal comparison of two tensors.

fn float_lower_equal_elem( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: Scalar, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

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

fn float_is_nan( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, out_dtype: BoolStore, ) -> <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive

Returns a new tensor with boolean elements indicating whether each element of the input is NaN.

fn float_is_inf( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, out_dtype: BoolStore, ) -> <Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive

Returns a new tensor with boolean elements indicating whether each element of the input is infinite (either +INF or -INF).

fn float_detach( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Detaches a tensor from the computation graph.

fn float_set_require_grad( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, require_grad: bool, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Sets the require_grad flag of a tensor.

fn float_is_require_grad( tensor: &<Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> bool

Returns the require_grad flag of a tensor.

fn float_mean( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Mean of all elements in a tensor.

fn float_sum( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Sum of all elements in a tensor.

fn float_mean_dim( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Mean of all elements in a tensor along a dimension.

fn float_sum_dim( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Sum of all elements in a tensor along a dimension.

fn float_prod( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Product of all elements in a tensor.

fn float_prod_dim( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Product of all elements in a tensor along a dimension.

fn float_cumsum( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Computes the cumulative sum of elements along a dimension.

fn float_cumprod( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Computes the cumulative product of elements along a dimension.

fn float_cummin( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Computes the cumulative minimum of elements along a dimension.

fn float_cummax( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Computes the cumulative maximum of elements along a dimension.

fn float_argmax( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, out_dtype: IntDType, ) -> <B as BackendTypes>::IntTensorPrimitive

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

fn float_argtopk( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, k: usize, out_dtype: IntDType, ) -> <B as BackendTypes>::IntTensorPrimitive

Gets the indices of the k maximum elements of a tensor along an axis. if two elements are equals, it will be ordered by lowest indices

fn float_topk( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, k: usize, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Gets the values of the k maximum elements of a tensor along an axis.

fn float_argmin( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, out_dtype: IntDType, ) -> <B as BackendTypes>::IntTensorPrimitive

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

fn float_exp( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a new tensor with exponential values.

fn float_log( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a new tensor with natural logarithm values.

fn float_log1p( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

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

fn float_powi_scalar( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: Scalar, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Raises a tensor to the power of an int scalar.

fn float_powf_scalar_impl( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, value: Scalar, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

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

fn float_sqrt( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a new tensor with square root values.

fn float_abs( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a new tensor with absolute values.

fn float_cos( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a new tensor with cosine values.

fn float_sin( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a new tensor with sine values.

fn float_tanh( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a new tensor with hyperbolic tangent values.

fn float_cosh( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a new tensor with hyperbolic cosine values.

fn float_sinh( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a new tensor with hyperbolic sine values.

fn float_tan( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a new tensor with tangent values.

fn float_asin( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a new tensor with inverse sine values.

fn float_acos( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a new tensor with inverse cosine values.

fn float_atan( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a new tensor with the inverse tangent values.

fn float_asinh( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a new tensor with inverse hyperbolic sine values.

fn float_acosh( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a new tensor with inverse hyperbolic cosine values.

fn float_atanh( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a new tensor with the inverse hyperbolic tangent values.

fn float_atan2( y: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, x: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a tensor with the four-quadrant inverse tangent values of y and x.

fn float_round( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a new tensor with rounded values.

fn float_floor( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a new tensor with floored values.

fn float_ceil( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a new tensor with ceiled values.

fn float_trunc( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a new tensor with truncated values.

fn float_erf( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a new tensor with the error function values.

fn float_cat( tensors: Vec<<Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive>, dim: usize, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Concatenates tensors along a dimension.

fn float_max_dim( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Gets the maximum elements of a tensor along an axis.

fn float_max_dim_with_indices( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, indices_dtype: IntDType, ) -> (<Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, <B as BackendTypes>::IntTensorPrimitive)

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

fn float_min_dim( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Gets the minimum elements of a tensor along an axis.

fn float_min_dim_with_indices( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, indices_dtype: IntDType, ) -> (<Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, <B as BackendTypes>::IntTensorPrimitive)

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

fn float_into_int( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, out_dtype: IntDType, ) -> <B as BackendTypes>::IntTensorPrimitive

Converts float tensor to int tensor.

fn float_powf( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Element-wise power with a FloatTensor.

fn float_hypot( lhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, rhs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns a new tensor with the Euclidean distance values.

fn float_sign( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Returns the signs of the float tensor.

fn float_expand( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, shape: Shape, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Broadcasts the float tensor to the given shape.

fn float_sort( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, descending: bool, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Sort the elements of the input tensor by value in along a given dimension.

fn float_sort_with_indices( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, descending: bool, indices_dtype: IntDType, ) -> (<Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, <B as BackendTypes>::IntTensorPrimitive)

Sort the elements of the input tensor by value in along a given dimension.

fn float_argsort( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, descending: bool, out_dtype: IntDType, ) -> <B as BackendTypes>::IntTensorPrimitive

Returns the indices that sort the elements of the input tensor by value along a given dimension.

fn float_repeat_dim( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, times: usize, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Repeat the tensor along the given dimension.

fn float_cast( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dtype: FloatDType, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Converts a tensor to another floating point data type.

fn float_unfold( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, size: usize, step: usize, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Unfold windows along a dimension.

fn float_full( shape: Shape, fill_value: Scalar, device: &<B as BackendTypes>::Device, dtype: FloatDType, ) -> <B as BackendTypes>::FloatTensorPrimitive

Creates a tensor filled with given value.

fn float_clamp_min( tensor: <B as BackendTypes>::FloatTensorPrimitive, min: Scalar, ) -> <B as BackendTypes>::FloatTensorPrimitive

Clamps a tensor under a minimum value.

fn float_clamp_max( tensor: <B as BackendTypes>::FloatTensorPrimitive, max: Scalar, ) -> <B as BackendTypes>::FloatTensorPrimitive

Clamps a tensor over a maximum value.

fn float_clamp( tensor: <B as BackendTypes>::FloatTensorPrimitive, min: Scalar, max: Scalar, ) -> <B as BackendTypes>::FloatTensorPrimitive

Clamps a tensor between a minimum and maximum value.

fn float_transpose( tensor: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Transposes a tensor.

fn float_mask_select( tensor: <B as BackendTypes>::FloatTensorPrimitive, mask: <B as BackendTypes>::BoolTensorPrimitive, ) -> impl Future<Output = <B as BackendTypes>::FloatTensorPrimitive> + Send + 'static

Selects the elements of the tensor where the mask is true, returned as a 1D tensor.

fn float_not_equal( lhs: <B as BackendTypes>::FloatTensorPrimitive, rhs: <B as BackendTypes>::FloatTensorPrimitive, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Element-wise non-equality comparison.

fn float_not_equal_elem( lhs: <B as BackendTypes>::FloatTensorPrimitive, rhs: Scalar, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Element-wise non-equality comparison with a scalar.

fn float_sum_dims( tensor: <B as BackendTypes>::FloatTensorPrimitive, dims: &[usize], ) -> <B as BackendTypes>::FloatTensorPrimitive

Sum the tensor along several dimensions at once, keeping each of them with length one.

fn float_powi( lhs: <B as BackendTypes>::FloatTensorPrimitive, rhs: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Element-wise power with an IntTensor.

fn float_powi_scalar_impl( lhs: <B as BackendTypes>::FloatTensorPrimitive, rhs: Scalar, ) -> <B as BackendTypes>::FloatTensorPrimitive

Raises a tensor to the power of an int scalar.

fn float_powf_scalar( tensor: <B as BackendTypes>::FloatTensorPrimitive, value: Scalar, ) -> <B as BackendTypes>::FloatTensorPrimitive

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

fn float_topk_with_indices( tensor: <B as BackendTypes>::FloatTensorPrimitive, dim: usize, k: usize, out_dtype: IntDType, ) -> (<B as BackendTypes>::FloatTensorPrimitive, <B as BackendTypes>::IntTensorPrimitive)

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

fn float_max( tensor: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Gets the maximum element of a tensor.

fn float_min( tensor: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Gets the minimum element of a tensor.

fn float_max_abs( tensor: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Gets the maximum absolute element of a tensor.

fn float_max_abs_dim( tensor: <B as BackendTypes>::FloatTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::FloatTensorPrimitive

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

fn float_any( tensor: <B as BackendTypes>::FloatTensorPrimitive, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Tests if any element in the float tensor evaluates to True.

fn float_any_dim( tensor: <B as BackendTypes>::FloatTensorPrimitive, dim: usize, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Tests if any element in the float tensor evaluates to True along a given dimension dim.

fn float_all( tensor: <B as BackendTypes>::FloatTensorPrimitive, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Tests if all elements in the float tensor evaluate to True.

fn float_all_dim( tensor: <B as BackendTypes>::FloatTensorPrimitive, dim: usize, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Tests if all elements in the float tensor evaluate to True along a given dimension dim.

fn float_grid_sample_2d( tensor: <B as BackendTypes>::FloatTensorPrimitive, grid: <B as BackendTypes>::FloatTensorPrimitive, options: GridSampleOptions, ) -> <B as BackendTypes>::FloatTensorPrimitive

Samples tensor as a two-dimensional spatial grid of (possibly multi-channel) values, using the given locations in [-1, 1].

fn float_pad( tensor: <B as BackendTypes>::FloatTensorPrimitive, padding: &[(usize, usize)], mode: PadMode, ) -> <B as BackendTypes>::FloatTensorPrimitive

Pads a tensor with one (before, after) pair per dimension.

impl<B, C> IntTensorOps<Autodiff<B, C>> for Autodiff<B, C>

where B: Backend, C: CheckpointStrategy,

fn int_from_data( data: TensorData, device: &<Autodiff<B, C> as BackendTypes>::Device, ) -> <B as BackendTypes>::IntTensorPrimitive

Creates a tensor from the data structure.

async fn int_into_data( tensor: <B as BackendTypes>::IntTensorPrimitive, ) -> Result<TensorData, ExecutionError>

Converts the tensor to a data structure.

fn int_to_device( tensor: <B as BackendTypes>::IntTensorPrimitive, device: &<Autodiff<B, C> as BackendTypes>::Device, ) -> <B as BackendTypes>::IntTensorPrimitive

Moves the tensor to the given device.

fn int_reshape( tensor: <B as BackendTypes>::IntTensorPrimitive, shape: Shape, ) -> <B as BackendTypes>::IntTensorPrimitive

Reshapes the tensor.

fn int_slice( tensor: <B as BackendTypes>::IntTensorPrimitive, slices: &[Slice], ) -> <B as BackendTypes>::IntTensorPrimitive

Gets the element at the given indices.

fn int_empty( shape: Shape, device: &<Autodiff<B, C> as BackendTypes>::Device, dtype: IntDType, ) -> <B as BackendTypes>::IntTensorPrimitive

Creates a new int tensor.

fn int_slice_assign( tensor: <B as BackendTypes>::IntTensorPrimitive, slices: &[Slice], value: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::IntTensorPrimitive

Sets the values in the tensor for the given ranges.

fn int_cat( tensors: Vec<<B as BackendTypes>::IntTensorPrimitive>, dim: usize, ) -> <B as BackendTypes>::IntTensorPrimitive

Concatenates the given tensors along the given dimension.

fn int_equal( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: <B as BackendTypes>::IntTensorPrimitive, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Element-wise equality comparison.

fn int_equal_elem( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: Scalar, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Element-wise equality comparison with a scalar.

fn int_add( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::IntTensorPrimitive

Element-wise addition.

fn int_add_scalar( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: Scalar, ) -> <B as BackendTypes>::IntTensorPrimitive

Element-wise addition with a scalar.

fn int_clamp_min( tensor: <B as BackendTypes>::IntTensorPrimitive, min: Scalar, ) -> <B as BackendTypes>::IntTensorPrimitive

Clamps a tensor under a minimum value.

fn int_clamp_max( tensor: <B as BackendTypes>::IntTensorPrimitive, max: Scalar, ) -> <B as BackendTypes>::IntTensorPrimitive

Clamps a tensor over a maximum value.

fn int_clamp( tensor: <B as BackendTypes>::IntTensorPrimitive, min: Scalar, max: Scalar, ) -> <B as BackendTypes>::IntTensorPrimitive

Clamps a tensor between a minimum and maximum value.

fn int_sub( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::IntTensorPrimitive

Element-wise subtraction.

fn int_sub_scalar( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: Scalar, ) -> <B as BackendTypes>::IntTensorPrimitive

Element-wise subtraction with a scalar.

fn int_mul( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::IntTensorPrimitive

Element-wise multiplication.

fn int_mul_scalar( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: Scalar, ) -> <B as BackendTypes>::IntTensorPrimitive

Element-wise multiplication with a scalar.

fn int_div( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::IntTensorPrimitive

Element-wise division.

fn int_div_scalar( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: Scalar, ) -> <B as BackendTypes>::IntTensorPrimitive

Element-wise division with a scalar.

fn int_remainder( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::IntTensorPrimitive

Element-wise floor modulo.

fn int_remainder_scalar( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: Scalar, ) -> <B as BackendTypes>::IntTensorPrimitive

Element-wise floor modulo with a scalar.

fn int_matmul( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::IntTensorPrimitive

Multiplies two tensors together using matrix multiplication.

fn int_neg( tensor: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::IntTensorPrimitive

Element-wise negation.

fn int_zeros( shape: Shape, device: &<Autodiff<B, C> as BackendTypes>::Device, dtype: IntDType, ) -> <B as BackendTypes>::IntTensorPrimitive

Creates a tensor of zeros.

fn int_ones( shape: Shape, device: &<Autodiff<B, C> as BackendTypes>::Device, dtype: IntDType, ) -> <B as BackendTypes>::IntTensorPrimitive

Creates a tensor of ones.

fn int_full( shape: Shape, fill_value: Scalar, device: &<Autodiff<B, C> as BackendTypes>::Device, dtype: IntDType, ) -> <B as BackendTypes>::IntTensorPrimitive

Creates a tensor filled with given value.

fn int_sum( tensor: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::IntTensorPrimitive

Sums all elements in the tensor.

fn int_sum_dim( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::IntTensorPrimitive

Sums all elements in the tensor along a dimension.

fn int_mean( tensor: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::IntTensorPrimitive

Computes the mean of all elements in the tensor.

fn int_mean_dim( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::IntTensorPrimitive

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

fn int_cumsum( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::IntTensorPrimitive

Computes the cumulative sum of elements along a dimension.

fn int_cumprod( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::IntTensorPrimitive

Computes the cumulative product of elements along a dimension.

fn int_cummin( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::IntTensorPrimitive

Computes the cumulative minimum of elements along a dimension.

fn int_cummax( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::IntTensorPrimitive

Computes the cumulative maximum of elements along a dimension.

fn int_repeat_dim( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, times: usize, ) -> <B as BackendTypes>::IntTensorPrimitive

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

fn int_greater( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: <B as BackendTypes>::IntTensorPrimitive, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Element-wise greater than comparison.

fn int_greater_elem( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: Scalar, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Element-wise greater than comparison with a scalar.

fn int_greater_equal( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: <B as BackendTypes>::IntTensorPrimitive, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Element-wise greater than or equal comparison.

fn int_greater_equal_elem( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: Scalar, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Element-wise greater than or equal comparison with a scalar.

fn int_lower( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: <B as BackendTypes>::IntTensorPrimitive, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Element-wise less than comparison.

fn int_lower_elem( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: Scalar, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Element-wise less than comparison with a scalar.

fn int_lower_equal( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: <B as BackendTypes>::IntTensorPrimitive, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Element-wise less than or equal comparison.

fn int_lower_equal_elem( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: Scalar, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Element-wise less than or equal comparison with a scalar.

fn int_gather( dim: usize, tensor: <B as BackendTypes>::IntTensorPrimitive, indices: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::IntTensorPrimitive

Gather elements from the tensor at the given indices.

fn int_scatter( dim: usize, tensor: <B as BackendTypes>::IntTensorPrimitive, indices: <B as BackendTypes>::IntTensorPrimitive, value: <B as BackendTypes>::IntTensorPrimitive, update: IndexingUpdateOp, ) -> <B as BackendTypes>::IntTensorPrimitive

Scatter elements into a tensor using the specified update operation.

fn int_scatter_nd( data: <B as BackendTypes>::IntTensorPrimitive, indices: <B as BackendTypes>::IntTensorPrimitive, values: <B as BackendTypes>::IntTensorPrimitive, reduction: IndexingUpdateOp, ) -> <B as BackendTypes>::IntTensorPrimitive

Multi-dimensional scatter for int tensors.

fn int_select( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, indices: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::IntTensorPrimitive

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

fn int_select_assign( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, indices: <B as BackendTypes>::IntTensorPrimitive, value: <B as BackendTypes>::IntTensorPrimitive, update: IndexingUpdateOp, ) -> <B as BackendTypes>::IntTensorPrimitive

Assign selected elements along a dimension using the specified update operation.

fn int_mask_where( tensor: <B as BackendTypes>::IntTensorPrimitive, mask: <B as BackendTypes>::BoolTensorPrimitive, value: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::IntTensorPrimitive

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

fn int_mask_fill( tensor: <B as BackendTypes>::IntTensorPrimitive, mask: <B as BackendTypes>::BoolTensorPrimitive, value: Scalar, ) -> <B as BackendTypes>::IntTensorPrimitive

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

async fn int_mask_select( tensor: <B as BackendTypes>::IntTensorPrimitive, mask: <B as BackendTypes>::BoolTensorPrimitive, ) -> <B as BackendTypes>::IntTensorPrimitive

Selects the elements of the tensor where the mask is true, returned as a 1D tensor.

fn int_argmax( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::IntTensorPrimitive

Gets the indices of the maximum elements along a dimension.

fn int_argtopk( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, k: usize, ) -> <B as BackendTypes>::IntTensorPrimitive

Gets the indices of the k maximum elements along a dimension. If two elements share the same value, it will be ordered by the lowest coordinate

fn int_argmin( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::IntTensorPrimitive

Gets the indices of the minimum elements along a dimension.

fn int_max( tensor: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::IntTensorPrimitive

Gets the maximum element in the tensor.

fn int_max_dim( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::IntTensorPrimitive

Gets the maximum element in the tensor along a dimension.

fn int_topk( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, k: usize, ) -> <B as BackendTypes>::IntTensorPrimitive

Gets the values of the k maximum elements along a dimension.

fn int_max_dim_with_indices( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, ) -> (<B as BackendTypes>::IntTensorPrimitive, <B as BackendTypes>::IntTensorPrimitive)

Gets the maximum elements and corresponding indices along a dimension.

fn int_min( tensor: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::IntTensorPrimitive

Gets the minimum element in the tensor.

fn int_min_dim( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::IntTensorPrimitive

Gets the minimum elements in the tensor along a dimension.

fn int_min_dim_with_indices( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, ) -> (<B as BackendTypes>::IntTensorPrimitive, <B as BackendTypes>::IntTensorPrimitive)

Gets the minimum elements and corresponding indices along a dimension.

fn int_abs( tensor: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::IntTensorPrimitive

Returns a new tensor with absolute values.

fn int_into_float( tensor: <B as BackendTypes>::IntTensorPrimitive, out_dtype: FloatDType, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Converts int tensor to float tensor.

fn int_swap_dims( tensor: <B as BackendTypes>::IntTensorPrimitive, dim1: usize, dim2: usize, ) -> <B as BackendTypes>::IntTensorPrimitive

Swaps two dimensions of an int tensor.

fn int_random( shape: Shape, distribution: Distribution, device: &<Autodiff<B, C> as BackendTypes>::Device, dtype: IntDType, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

Creates a new int tensor with random values.

fn int_arange( range: Range<i64>, device: &<Autodiff<B, C> as BackendTypes>::Device, dtype: IntDType, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

Creates a new tensor with values from the given range.

fn int_permute( tensor: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, axes: &[usize], ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

Permutes the dimensions of a tensor.

fn int_flip( tensor: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, axes: &[usize], ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

Reverse the order of elements in a tensor along the given axes.

fn int_sign( tensor: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

Returns the signs of the int tensor.

fn int_prod( tensor: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

Computes the product of all elements in the tensor.

fn int_prod_dim( tensor: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, dim: usize, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

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

fn int_expand( tensor: <B as BackendTypes>::IntTensorPrimitive, shape: Shape, ) -> <B as BackendTypes>::IntTensorPrimitive

Broadcasts the int tensor to the given shape.

fn int_sort( tensor: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, dim: usize, descending: bool, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

Sort the elements of the input tensor by value along a given dimension.

fn int_sort_with_indices( tensor: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, dim: usize, descending: bool, ) -> (<Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive)

Sort the elements of the input tensor by value along a given dimension.

fn int_argsort( tensor: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, dim: usize, descending: bool, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

Returns the indices that sort the elements of the input tensor by value along a given dimension.

fn bitwise_and( lhs: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, rhs: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

Bitwise AND operation for Int Tensors

fn bitwise_and_scalar( lhs: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, rhs: Scalar, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

Bitwise AND operation for Int Tensors with a scalar

fn bitwise_or( lhs: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, rhs: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

Bitwise OR operation for Int Tensors

fn bitwise_or_scalar( lhs: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, rhs: Scalar, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

Bitwise OR operation for Int Tensors with a scalar

fn bitwise_xor( lhs: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, rhs: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

Bitwise XOR operation for Int Tensors

fn bitwise_xor_scalar( lhs: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, rhs: Scalar, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

Bitwise XOR operation for Int Tensors with a scalar

fn bitwise_not( tensor: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

Bitwise NOT operation for Int Tensors

fn bitwise_left_shift( lhs: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, rhs: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

Bitwise left shift operation for Int Tensors

fn bitwise_left_shift_scalar( lhs: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, rhs: Scalar, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

Bitwise left shift operation for Int Tensors with a scalar

fn bitwise_right_shift( lhs: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, rhs: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

Bitwise right shift operation for Int Tensors

fn bitwise_right_shift_scalar( lhs: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, rhs: Scalar, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

Bitwise right shift operation for Int Tensors with a scalar

fn int_cast( tensor: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, dtype: IntDType, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

Converts a tensor to another integer data type.

fn int_unfold( tensor: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, dim: usize, size: usize, step: usize, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

Unfold windows along a dimension.

fn int_gather_nd( _data: <B as BackendTypes>::IntTensorPrimitive, _indices: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::IntTensorPrimitive

Multi-dimensional gather for int tensors.

fn int_not_equal( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: <B as BackendTypes>::IntTensorPrimitive, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Element-wise non-equality comparison.

fn int_not_equal_elem( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: Scalar, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Element-wise non-equality comparison with a scalar.

fn int_square( tensor: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::IntTensorPrimitive

Element-wise square with a IntTensor.

fn int_powi( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::IntTensorPrimitive

Element-wise power with a IntTensor.

fn int_powi_scalar( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: Scalar, ) -> <B as BackendTypes>::IntTensorPrimitive

Element-wise power with a scalar.

fn int_powi_scalar_impl( lhs: <B as BackendTypes>::IntTensorPrimitive, rhs: Scalar, ) -> <B as BackendTypes>::IntTensorPrimitive

Element-wise power with a scalar.

fn int_topk_with_indices( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, k: usize, ) -> (<B as BackendTypes>::IntTensorPrimitive, <B as BackendTypes>::IntTensorPrimitive)

Gets the values of the k maximum elements along a dimension, and their indices.

fn int_max_abs( tensor: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::IntTensorPrimitive

Gets the maximum absolute element in the tensor.

fn int_max_abs_dim( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::IntTensorPrimitive

Gets the maximum absolute element in the tensor along a dimension.

fn int_transpose( tensor: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::IntTensorPrimitive

Transposes an int tensor.

fn int_arange_step( range: Range<i64>, step: usize, device: &<B as BackendTypes>::Device, dtype: IntDType, ) -> <B as BackendTypes>::IntTensorPrimitive

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

fn int_any( tensor: <B as BackendTypes>::IntTensorPrimitive, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Tests if any element in the int tensor evaluates to True.

fn int_any_dim( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Tests if any element in the int tensor evaluates to True along a given dimension dim.

fn int_all( tensor: <B as BackendTypes>::IntTensorPrimitive, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Tests if all elements in the int tensor evaluate to True.

fn int_all_dim( tensor: <B as BackendTypes>::IntTensorPrimitive, dim: usize, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Tests if all elements in the int tensor evaluate to True along a given dimension dim.

fn int_pad( tensor: <B as BackendTypes>::IntTensorPrimitive, padding: &[(usize, usize)], mode: PadMode, ) -> <B as BackendTypes>::IntTensorPrimitive

Pads a tensor with one (before, after) pair per dimension.

impl<B, C> ModuleOps<Autodiff<B, C>> for Autodiff<B, C>

where B: Backend, C: CheckpointStrategy,

fn batch_norm_train( x: AutodiffTensor<B>, gamma: AutodiffTensor<B>, beta: AutodiffTensor<B>, epsilon: f64, ) -> BatchNormTrain<Autodiff<B, C>>

Applies batch normalization with the statistics of the batch itself, and returns them.

fn batch_norm_train_backward( _x: AutodiffTensor<B>, _gamma: AutodiffTensor<B>, _mean: AutodiffTensor<B>, _variance: AutodiffTensor<B>, _epsilon: f64, _output_grad: AutodiffTensor<B>, ) -> BatchNormTrainBackward<Autodiff<B, C>>

Gradients of batch_norm_train with respect to its input, gamma and beta, given the gradient of its output. mean and variance are the statistics it returned.

fn embedding( weights: AutodiffTensor<B>, indices: <B as BackendTypes>::IntTensorPrimitive, ) -> AutodiffTensor<B>

Embedding operation.

fn embedding_backward( _weights: AutodiffTensor<B>, _output: AutodiffTensor<B>, _indices: <B as BackendTypes>::IntTensorPrimitive, ) -> AutodiffTensor<B>

Embedding backward operation.

fn linear( x: AutodiffTensor<B>, weight: AutodiffTensor<B>, bias: Option<AutodiffTensor<B>>, ) -> AutodiffTensor<B>

Linear transformation.

fn linear_x_backward( _weight: AutodiffTensor<B>, _output_grad: AutodiffTensor<B>, ) -> AutodiffTensor<B>

Backward pass for linear, returning the gradient for x.

fn linear_weight_backward( _x: AutodiffTensor<B>, _output_grad: AutodiffTensor<B>, ) -> AutodiffTensor<B>

Backward pass for linear, returning the gradient for weight.

fn linear_bias_backward(_output_grad: AutodiffTensor<B>) -> AutodiffTensor<B>

Backward pass for linear, returning the gradient for bias.

fn conv1d( x: AutodiffTensor<B>, weight: AutodiffTensor<B>, bias: Option<AutodiffTensor<B>>, options: ConvOptions<1>, ) -> AutodiffTensor<B>

One dimensional convolution.

fn conv_transpose1d( x: AutodiffTensor<B>, weight: AutodiffTensor<B>, bias: Option<AutodiffTensor<B>>, options: ConvTransposeOptions<1>, ) -> AutodiffTensor<B>

One dimensional transposed convolution.

fn conv2d( x: AutodiffTensor<B>, weight: AutodiffTensor<B>, bias: Option<AutodiffTensor<B>>, options: ConvOptions<2>, ) -> AutodiffTensor<B>

Two dimensional convolution.

fn deform_conv2d( x: AutodiffTensor<B>, offset: AutodiffTensor<B>, weight: AutodiffTensor<B>, mask: Option<AutodiffTensor<B>>, bias: Option<AutodiffTensor<B>>, options: DeformConvOptions<2>, ) -> AutodiffTensor<B>

Two dimensional deformable convolution.

fn deform_conv2d_backward( _x: AutodiffTensor<B>, _offset: AutodiffTensor<B>, _weight: AutodiffTensor<B>, _mask: Option<AutodiffTensor<B>>, _bias: Option<AutodiffTensor<B>>, _output_grad: AutodiffTensor<B>, _options: DeformConvOptions<2>, ) -> DeformConv2dBackward<Autodiff<B, C>>

Backward pass for the deform_conv2d operation.

fn conv_transpose2d( x: AutodiffTensor<B>, weight: AutodiffTensor<B>, bias: Option<AutodiffTensor<B>>, options: ConvTransposeOptions<2>, ) -> AutodiffTensor<B>

Two dimensional transposed convolution.

fn conv3d( x: AutodiffTensor<B>, weight: AutodiffTensor<B>, bias: Option<AutodiffTensor<B>>, options: ConvOptions<3>, ) -> AutodiffTensor<B>

Three dimensional convolution.

fn conv_transpose3d( x: AutodiffTensor<B>, weight: AutodiffTensor<B>, bias: Option<AutodiffTensor<B>>, options: ConvTransposeOptions<3>, ) -> AutodiffTensor<B>

Three dimensional transposed convolution.

fn avg_pool1d( x: AutodiffTensor<B>, kernel_size: usize, stride: usize, padding: usize, count_include_pad: bool, ceil_mode: bool, ) -> AutodiffTensor<B>

One dimensional avg pooling.

fn avg_pool2d( x: AutodiffTensor<B>, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], count_include_pad: bool, ceil_mode: bool, ) -> AutodiffTensor<B>

Two dimensional avg pooling.

fn avg_pool2d_backward( _x: AutodiffTensor<B>, _grad: AutodiffTensor<B>, _kernel_size: [usize; 2], _stride: [usize; 2], _padding: [usize; 2], _count_include_pad: bool, _ceil_mode: bool, ) -> AutodiffTensor<B>

Backward pass for the avg pooling 2d operation.

fn max_pool1d( x: AutodiffTensor<B>, kernel_size: usize, stride: usize, padding: usize, dilation: usize, ceil_mode: bool, ) -> AutodiffTensor<B>

One dimensional max pooling.

fn max_pool1d_with_indices( x: AutodiffTensor<B>, kernel_size: usize, stride: usize, padding: usize, dilation: usize, ceil_mode: bool, int_dtype: IntDType, ) -> MaxPool1dWithIndices<Autodiff<B, C>>

One dimensional max pooling with indices.

fn max_pool1d_with_indices_backward( x: AutodiffTensor<B>, kernel_size: usize, stride: usize, padding: usize, dilation: usize, ceil_mode: bool, output_grad: AutodiffTensor<B>, indices: <B as BackendTypes>::IntTensorPrimitive, ) -> MaxPool1dBackward<Autodiff<B, C>>

Backward pass for the max pooling 1d operation.

fn max_pool2d( x: AutodiffTensor<B>, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], dilation: [usize; 2], ceil_mode: bool, ) -> AutodiffTensor<B>

Two dimensional max pooling.

fn max_pool2d_with_indices( x: AutodiffTensor<B>, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], dilation: [usize; 2], ceil_mode: bool, int_dtype: IntDType, ) -> MaxPool2dWithIndices<Autodiff<B, C>>

Two dimensional max pooling with indices.

fn max_pool2d_with_indices_backward( _x: AutodiffTensor<B>, _kernel_size: [usize; 2], _stride: [usize; 2], _padding: [usize; 2], _dilation: [usize; 2], _ceil_mode: bool, _output_grad: AutodiffTensor<B>, _indices: <B as BackendTypes>::IntTensorPrimitive, ) -> MaxPool2dBackward<Autodiff<B, C>>

Backward pass for the max pooling 2d operation.

fn adaptive_avg_pool1d( x: AutodiffTensor<B>, output_size: usize, ) -> AutodiffTensor<B>

One dimensional adaptive avg pooling.

fn adaptive_avg_pool2d( x: AutodiffTensor<B>, output_size: [usize; 2], ) -> AutodiffTensor<B>

Two dimensional adaptive avg pooling.

fn adaptive_avg_pool2d_backward( _x: AutodiffTensor<B>, _grad: AutodiffTensor<B>, ) -> AutodiffTensor<B>

Backward pass for the adaptive avg pooling 2d operation.

fn adaptive_avg_pool3d( x: AutodiffTensor<B>, output_size: [usize; 3], ) -> AutodiffTensor<B>

Three dimensional adaptive avg pooling.

fn adaptive_avg_pool3d_backward( _x: AutodiffTensor<B>, _grad: AutodiffTensor<B>, ) -> AutodiffTensor<B>

Backward pass for the adaptive avg pooling 3d operation.

fn interpolate( x: AutodiffTensor<B>, output_size: [usize; 2], options: InterpolateOptions, ) -> AutodiffTensor<B>

Down/up samples the input.

fn interpolate_backward( _x: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, _grad: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, _output_size: [usize; 2], _options: InterpolateOptions, ) -> AutodiffTensor<B>

Backward pass for the interpolate operation.

fn attention( query: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, key: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, value: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, mask: Option<<Autodiff<B, C> as BackendTypes>::BoolTensorPrimitive>, attn_bias: Option<<Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive>, options: AttentionModuleOptions, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Computes scaled dot-product attention: softmax(QKᵗ * scale) · V, where scale defaults to 1/sqrt(head_dim). Optionally applies masking, additive bias, causal masking, and softcap to the attention scores.

fn ctc_loss( log_probs: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, targets: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, input_lengths: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, target_lengths: <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive, blank: usize, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Computes the Connectionist Temporal Classification (CTC) loss.

fn batch_norm( x: <B as BackendTypes>::FloatTensorPrimitive, gamma: <B as BackendTypes>::FloatTensorPrimitive, beta: <B as BackendTypes>::FloatTensorPrimitive, mean: <B as BackendTypes>::FloatTensorPrimitive, variance: <B as BackendTypes>::FloatTensorPrimitive, epsilon: f64, ) -> <B as BackendTypes>::FloatTensorPrimitive

Applies batch normalization using explicitly supplied channel statistics.

fn conv1d_x_backward( x: <B as BackendTypes>::FloatTensorPrimitive, weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvOptions<1>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv1d operation, returning the gradient for x.

fn conv1d_weight_backward( x: <B as BackendTypes>::FloatTensorPrimitive, weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvOptions<1>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv1d operation, returning the gradient for weight.

fn conv1d_bias_backward( x: <B as BackendTypes>::FloatTensorPrimitive, bias: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv1d operation, returning the gradient for bias.

fn conv2d_x_backward( x: <B as BackendTypes>::FloatTensorPrimitive, weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvOptions<2>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv2d operation, returning the gradient for x.

fn conv2d_weight_backward( x: <B as BackendTypes>::FloatTensorPrimitive, weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvOptions<2>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv2d operation, returning the gradient for weight.

fn conv2d_bias_backward( x: <B as BackendTypes>::FloatTensorPrimitive, bias: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv2d operation, returning the gradient for bias.

fn conv3d_x_backward( x: <B as BackendTypes>::FloatTensorPrimitive, weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvOptions<3>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv3d operation, returning the gradient for x.

fn conv3d_weight_backward( x: <B as BackendTypes>::FloatTensorPrimitive, weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvOptions<3>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv3d operation, returning the gradient for weight.

fn conv3d_bias_backward( x: <B as BackendTypes>::FloatTensorPrimitive, bias: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv3d operation, returning the gradient for bias.

fn conv_transpose1d_x_backward( weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvTransposeOptions<1>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv transpose 1d operation, returning the gradient for x.

fn conv_transpose1d_weight_backward( x: <B as BackendTypes>::FloatTensorPrimitive, weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvTransposeOptions<1>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv transpose 1d operation, returning the gradient for weight.

fn conv_transpose1d_bias_backward( x: <B as BackendTypes>::FloatTensorPrimitive, bias: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv transpose 1d operation, returning the gradient for bias.

fn conv_transpose2d_x_backward( weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvTransposeOptions<2>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv transpose 2d operation, returning the gradient for x.

fn conv_transpose2d_weight_backward( x: <B as BackendTypes>::FloatTensorPrimitive, weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvTransposeOptions<2>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv transpose 2d operation, returning the gradient for weight.

fn conv_transpose2d_bias_backward( x: <B as BackendTypes>::FloatTensorPrimitive, bias: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv transpose 2d operation, returning the gradient for bias.

fn conv_transpose3d_x_backward( weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvTransposeOptions<3>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv transpose 3d operation, returning the gradient for x.

fn conv_transpose3d_weight_backward( x: <B as BackendTypes>::FloatTensorPrimitive, weight: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, options: ConvTransposeOptions<3>, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv transpose 3d operation, returning the gradient for weight.

fn conv_transpose3d_bias_backward( x: <B as BackendTypes>::FloatTensorPrimitive, bias: <B as BackendTypes>::FloatTensorPrimitive, output_grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the conv transpose 3d operation, returning the gradient for bias.

fn unfold4d( x: <B as BackendTypes>::FloatTensorPrimitive, kernel_size: [usize; 2], options: UnfoldOptions, ) -> <B as BackendTypes>::FloatTensorPrimitive

Four-dimensional unfolding.

fn fold4d( x: <B as BackendTypes>::FloatTensorPrimitive, output_size: [usize; 2], kernel_size: [usize; 2], options: UnfoldOptions, ) -> <B as BackendTypes>::FloatTensorPrimitive

Four dimensional fold (col2im), the adjoint of unfold4d.

fn avg_pool1d_backward( x: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, kernel_size: usize, stride: usize, padding: usize, count_include_pad: bool, ceil_mode: bool, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the avg pooling 1d operation.

fn adaptive_avg_pool1d_backward( x: <B as BackendTypes>::FloatTensorPrimitive, grad: <B as BackendTypes>::FloatTensorPrimitive, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for the adaptive avg pooling 1d operation.

fn layer_norm( tensor: <B as BackendTypes>::FloatTensorPrimitive, gamma: <B as BackendTypes>::FloatTensorPrimitive, beta: Option<<B as BackendTypes>::FloatTensorPrimitive>, epsilon: f64, ) -> <B as BackendTypes>::FloatTensorPrimitive

Applies Layer Normalization over the last dimension of the input tensor.

fn has_ctc_loss_backward() -> bool

Returns true if this backend implements ctc_loss_backward natively.

fn ctc_loss_backward( _log_probs: <B as BackendTypes>::FloatTensorPrimitive, _targets: <B as BackendTypes>::IntTensorPrimitive, _input_lengths: <B as BackendTypes>::IntTensorPrimitive, _target_lengths: <B as BackendTypes>::IntTensorPrimitive, _grad_loss: <B as BackendTypes>::FloatTensorPrimitive, _blank: usize, ) -> <B as BackendTypes>::FloatTensorPrimitive

Backward pass for ctc_loss: gradient w.r.t. log_probs.

impl<B, C> QTensorOps<Autodiff<B, C>> for Autodiff<B, C>

where B: Backend, C: CheckpointStrategy,

fn q_from_data( data: TensorData, device: &<Autodiff<B, C> as BackendTypes>::Device, ) -> <Autodiff<B, C> as BackendTypes>::QuantizedTensorPrimitive

Creates a new tensor from the data structure.

fn quantize( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, scheme: &QuantScheme, qparams: QuantizationParametersPrimitive<Autodiff<B, C>>, ) -> <Autodiff<B, C> as BackendTypes>::QuantizedTensorPrimitive

Convert the tensor to a lower precision data type based on the quantization scheme and parameters.

fn quantize_dynamic( tensor: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, scheme: &QuantScheme, ) -> <Autodiff<B, C> as BackendTypes>::QuantizedTensorPrimitive

Dynamically convert the tensor to a lower precision data type based on the quantization scheme.

fn dequantize( tensor: <Autodiff<B, C> as BackendTypes>::QuantizedTensorPrimitive, dtype: FloatDType, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Convert the tensor back to a higher precision data type.

fn q_to_device( tensor: <Autodiff<B, C> as BackendTypes>::QuantizedTensorPrimitive, device: &<Autodiff<B, C> as BackendTypes>::Device, ) -> <Autodiff<B, C> as BackendTypes>::QuantizedTensorPrimitive

Moves the tensor to the given device.

fn q_reshape( tensor: <Autodiff<B, C> as BackendTypes>::QuantizedTensorPrimitive, shape: Shape, ) -> <Autodiff<B, C> as BackendTypes>::QuantizedTensorPrimitive

Reshapes a tensor.

async fn q_into_data( tensor: <Autodiff<B, C> as BackendTypes>::QuantizedTensorPrimitive, ) -> Result<TensorData, ExecutionError>

Converts the tensor to a data structure.

fn q_swap_dims( tensor: <Autodiff<B, C> as BackendTypes>::QuantizedTensorPrimitive, dim1: usize, dim2: usize, ) -> <Autodiff<B, C> as BackendTypes>::QuantizedTensorPrimitive

Swaps two dimensions of a tensor.

fn q_permute( tensor: <Autodiff<B, C> as BackendTypes>::QuantizedTensorPrimitive, axes: &[usize], ) -> <Autodiff<B, C> as BackendTypes>::QuantizedTensorPrimitive

Permutes the dimensions of a tensor.

fn q_flip( tensor: <Autodiff<B, C> as BackendTypes>::QuantizedTensorPrimitive, axes: &[usize], ) -> <Autodiff<B, C> as BackendTypes>::QuantizedTensorPrimitive

Reverse the order of elements in a tensor along the given axes.

fn q_argmax( tensor: <Autodiff<B, C> as BackendTypes>::QuantizedTensorPrimitive, dim: usize, out_dtype: IntDType, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

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

fn q_argmin( tensor: <Autodiff<B, C> as BackendTypes>::QuantizedTensorPrimitive, dim: usize, out_dtype: IntDType, ) -> <Autodiff<B, C> as BackendTypes>::IntTensorPrimitive

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

fn q_detach( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Detaches a tensor from the computation graph.

fn q_set_require_grad( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, _require_grad: bool, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Sets the require_grad flag of a tensor.

fn q_is_require_grad( _tensor: &<B as BackendTypes>::QuantizedTensorPrimitive, ) -> bool

Returns the require_grad flag of a tensor.

fn q_expand( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, shape: Shape, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Broadcasts the tensor to the given shape.

fn q_transpose( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Transposes a tensor.

fn q_select( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, indices: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

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

fn q_slice( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, slices: &[Slice], ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Select tensor elements corresponding to the given slices.

fn q_gather( dim: usize, tensor: <B as BackendTypes>::QuantizedTensorPrimitive, indices: <B as BackendTypes>::IntTensorPrimitive, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Gather elements from a tensor.

fn q_repeat_dim( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, times: usize, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Repeat the tensor along the given dimension.

fn q_add( lhs: <B as BackendTypes>::QuantizedTensorPrimitive, rhs: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Adds two tensors together.

fn q_add_scalar( lhs: <B as BackendTypes>::QuantizedTensorPrimitive, rhs: Scalar, ) -> TensorPrimitive<B>

Adds a scalar to a tensor.

fn q_clamp_min( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, min: Scalar, ) -> TensorPrimitive<B>

Clamps a tensor under a minimum value.

fn q_clamp_max( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, max: Scalar, ) -> TensorPrimitive<B>

Clamps a tensor over a maximum value.

fn q_clamp( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, min: Scalar, max: Scalar, ) -> TensorPrimitive<B>

Clamps a tensor between a minimum and maximum value.

fn q_sub( lhs: <B as BackendTypes>::QuantizedTensorPrimitive, rhs: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Subtracts two tensors.

fn q_sub_scalar( lhs: <B as BackendTypes>::QuantizedTensorPrimitive, rhs: Scalar, ) -> TensorPrimitive<B>

Subtracts a scalar from a tensor.

fn q_mul( lhs: <B as BackendTypes>::QuantizedTensorPrimitive, rhs: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Multiplies two tensors together element-wise.

fn q_mul_scalar( lhs: <B as BackendTypes>::QuantizedTensorPrimitive, rhs: Scalar, ) -> TensorPrimitive<B>

Multiplies a tensor by a scalar.

fn q_div( lhs: <B as BackendTypes>::QuantizedTensorPrimitive, rhs: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Divides two tensors element-wise.

fn q_div_scalar( lhs: <B as BackendTypes>::QuantizedTensorPrimitive, rhs: Scalar, ) -> TensorPrimitive<B>

Divides a tensor by a scalar.

fn q_matmul( lhs: TensorPrimitive<B>, rhs: TensorPrimitive<B>, ) -> TensorPrimitive<B>

Multiplies two tensors together using matrix multiplication.

fn q_neg( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Negates a tensor element-wise.

fn q_recip( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Calculates the reciprocals element-wise

fn q_sum( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Sum of all elements in a tensor.

fn q_sum_dim( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, ) -> TensorPrimitive<B>

Sum of all elements in a tensor along a dimension.

fn q_prod( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Product of all elements in a tensor.

fn q_prod_dim( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, ) -> TensorPrimitive<B>

Product of all elements in a tensor along a dimension.

fn q_mean( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Mean of all elements in a tensor.

fn q_mean_dim( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, ) -> TensorPrimitive<B>

Mean of all elements in a tensor along a dimension.

fn q_cumsum( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, ) -> TensorPrimitive<B>

Computes the cumulative sum of elements along a dimension.

fn q_cumprod( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, ) -> TensorPrimitive<B>

Computes the cumulative product of elements along a dimension.

fn q_cummin( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, ) -> TensorPrimitive<B>

Computes the cumulative minimum of elements along a dimension.

fn q_cummax( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, ) -> TensorPrimitive<B>

Computes the cumulative maximum of elements along a dimension.

fn q_exp( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Returns a new tensor with exponential values.

fn q_log( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Returns a new tensor with natural logarithm values.

fn q_log1p( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

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

fn q_powf( lhs: <B as BackendTypes>::QuantizedTensorPrimitive, rhs: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Element-wise power with another tensor.

fn q_powi( lhs: <B as BackendTypes>::QuantizedTensorPrimitive, rhs: <B as BackendTypes>::IntTensorPrimitive, ) -> TensorPrimitive<B>

Element-wise power with an IntTensor.

fn q_powi_scalar( lhs: <B as BackendTypes>::QuantizedTensorPrimitive, rhs: Scalar, ) -> TensorPrimitive<B>

Element-wise power with an int scalar.

fn q_powf_scalar( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, value: Scalar, ) -> TensorPrimitive<B>

Element-wise power with a float scalar.

fn q_sqrt( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Returns a new tensor with square root values.

fn q_abs( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Returns a new tensor with absolute values.

fn q_cos( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Returns a new tensor with cosine values.

fn q_sin( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Returns a new tensor with sine values.

fn q_tan( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Returns a new tensor with tangent values.

fn q_cosh( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Returns a new tensor with hyperbolic cosine values.

fn q_sinh( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Returns a new tensor with hyperbolic sine values.

fn q_tanh( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Returns a new tensor with hyperbolic tangent values.

fn q_erf( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> TensorPrimitive<B>

Returns a new tensor with the error function values.

fn q_cat( tensors: Vec<<B as BackendTypes>::QuantizedTensorPrimitive>, dim: usize, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Concatenates tensors along a dimension.

fn q_argtopk( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, k: usize, out_dtype: IntDType, ) -> <B as BackendTypes>::IntTensorPrimitive

Gets the indices of the k maximum elements of a tensor along an axis. If two elements are equals, order them by the lowest indices

fn q_topk( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, k: usize, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Gets the values of the k maximum elements of a tensor along an axis.

fn q_topk_with_indices( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, k: usize, out_dtype: IntDType, ) -> (<B as BackendTypes>::QuantizedTensorPrimitive, <B as BackendTypes>::IntTensorPrimitive)

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

fn q_max( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Gets the maximum element of a tensor.

fn q_max_dim( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Gets the maximum elements of a tensor along an axis.

fn q_max_dim_with_indices( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, out_dtype: IntDType, ) -> (<B as BackendTypes>::QuantizedTensorPrimitive, <B as BackendTypes>::IntTensorPrimitive)

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

fn q_min( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Gets the minimum element of a tensor.

fn q_min_dim( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Gets the minimum elements of a tensor along an axis.

fn q_min_dim_with_indices( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, out_dtype: IntDType, ) -> (<B as BackendTypes>::QuantizedTensorPrimitive, <B as BackendTypes>::IntTensorPrimitive)

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

fn q_max_abs( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Gets the maximum element of a tensor.

fn q_max_abs_dim( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Gets the maximum elements of a tensor along an axis.

fn q_any( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Tests if any element in the tensor evaluates to True.

fn q_any_dim( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Tests if any element in the float tensor evaluates to True along a given dimension dim.

fn q_all( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Tests if all elements in the tensor evaluate to True.

fn q_all_dim( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, out_dtype: BoolStore, ) -> <B as BackendTypes>::BoolTensorPrimitive

Tests if all elements in the tensor evaluate to True along a given dimension dim.

fn q_sort( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, descending: bool, ) -> <B as BackendTypes>::QuantizedTensorPrimitive

Sort the elements of the input tensor by value in along a given dimension.

fn q_sort_with_indices( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, descending: bool, out_dtype: IntDType, ) -> (<B as BackendTypes>::QuantizedTensorPrimitive, <B as BackendTypes>::IntTensorPrimitive)

Sort the elements of the input tensor by value in along a given dimension.

fn q_argsort( tensor: <B as BackendTypes>::QuantizedTensorPrimitive, dim: usize, descending: bool, out_dtype: IntDType, ) -> <B as BackendTypes>::IntTensorPrimitive

Returns the indices that sort the elements of the input tensor by value along a given dimension.

impl<B, C> SignalOps for Autodiff<B, C>

where B: Backend + SignalOps, C: CheckpointStrategy,

fn rfft( signal: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, n: Option<usize>, ) -> (<Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive)

Real FFT along dim, truncating or padding to n when supplied. Returns the real and imaginary components of the one-sided spectrum.

fn irfft( spectrum_re: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, spectrum_im: <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive, dim: usize, n: Option<usize>, ) -> <Autodiff<B, C> as BackendTypes>::FloatTensorPrimitive

Inverse real FFT along dim, with optional output length n.

impl<B, C> TransactionOps<Autodiff<B, C>> for Autodiff<B, C>

where B: Backend, C: CheckpointStrategy,

async fn tr_execute( transaction: TransactionPrimitive<Autodiff<B, C>>, ) -> Result<TransactionPrimitiveData, ExecutionError>

Executes a transaction and return its data.