Struct burn::backend::wgpu::JitBackend

pub struct JitBackend<R, F, I>
where
    R: JitRuntime,
    F: FloatElement,
    I: IntElement,
{ /* private fields */ }
Expand description

Generic tensor backend that can be compiled just-in-time to any shader runtime

Implementations§

§

impl<R, F, I> JitBackend<R, F, I>
where R: JitRuntime, F: FloatElement, I: IntElement,

pub fn new() -> JitBackend<R, F, I>

Constructs a new JitBackend.

Trait Implementations§

§

impl<R, F, I> ActivationOps<JitBackend<R, F, I>> for JitBackend<R, F, I>
where R: JitRuntime, F: FloatElement, I: IntElement,

§

fn leaky_relu<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, negative_slope: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive<D>

Applies the LeakyReLU activation function. Read more
§

fn relu<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

Applies the ReLU activation function. Read more
§

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

Applies the ReLU activation function backward. Read more
§

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

Applies the Gelu activation function. Read more
§

fn prelu<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, alpha: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

Applies the PReLu activation function. Read more
§

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

Applies the Gelu activation function backward. Read more
§

fn sigmoid<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

Applies the Sigmoid activation function. Read more
§

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

Applies the Sigmoid activation function backward. Read more
§

fn hard_sigmoid<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, alpha: <B as Backend>::FloatElem, beta: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive<D>

Applies the hard Sigmoid activation function. Read more
§

fn log_sigmoid<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

Applies the LogSigmoid activation function. Read more
§

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

Applies the LogSigmoid activation function backward. Read more
§

impl<R, F, I> Backend for JitBackend<R, F, I>
where R: JitRuntime, <R as Runtime>::Server: ComputeServer, <R as Runtime>::Device: DeviceOps, F: FloatElement, I: IntElement,

§

type Device = <R as Runtime>::Device

Device type.
§

type FullPrecisionBridge = PrecisionBridge<R, f32, i32>

A bridge that can cast tensors to full precision.
§

type FloatElem = F

Float element type.
§

type IntElem = I

Int element type.
§

type FloatTensorPrimitive<const D: usize> = JitTensor<R, <JitBackend<R, F, I> as Backend>::FloatElem, D>

Tensor primitive to be used for all float operations.
§

type IntTensorPrimitive<const D: usize> = JitTensor<R, <JitBackend<R, F, I> as Backend>::IntElem, D>

Tensor primitive to be used for all int operations.
§

type BoolTensorPrimitive<const D: usize> = JitTensor<R, u32, D>

Tensor primitive to be used for all bool operations.
§

type QuantizedTensorPrimitive<const D: usize> = QJitTensor<R, D>

Tensor primitive to be used for all quantized operations.
§

fn name() -> String

Name of the backend.
§

fn seed(seed: u64)

Seed the backend.
§

fn ad_enabled() -> bool

If autodiff is enabled.
§

fn sync(device: &<JitBackend<R, F, I> as Backend>::Device, sync_type: SyncType)

Sync the backend, ensure that all computation are finished.
§

impl<R, FOrigin, IOrigin, FTarget, ITarget> BackendBridge<JitBackend<R, FOrigin, IOrigin>> for PrecisionBridge<R, FTarget, ITarget>
where R: JitRuntime, FOrigin: FloatElement, IOrigin: IntElement, FTarget: FloatElement, ITarget: IntElement,

§

type Target = JitBackend<R, FTarget, ITarget>

The target backend
§

fn into_target<const D: usize>( tensor: <JitBackend<R, FOrigin, IOrigin> as Backend>::FloatTensorPrimitive<D>, device: Option<<<PrecisionBridge<R, FTarget, ITarget> as BackendBridge<JitBackend<R, FOrigin, IOrigin>>>::Target as Backend>::Device>, ) -> <<PrecisionBridge<R, FTarget, ITarget> as BackendBridge<JitBackend<R, FOrigin, IOrigin>>>::Target as Backend>::FloatTensorPrimitive<D>

Transfer the tensor to the target backend.
§

fn from_target<const D: usize>( tensor: <<PrecisionBridge<R, FTarget, ITarget> as BackendBridge<JitBackend<R, FOrigin, IOrigin>>>::Target as Backend>::FloatTensorPrimitive<D>, device: Option<<JitBackend<R, FOrigin, IOrigin> as Backend>::Device>, ) -> <JitBackend<R, FOrigin, IOrigin> as Backend>::FloatTensorPrimitive<D>

Transfer the tensor from the target backend.
§

impl<R, F, I> BoolTensorOps<JitBackend<R, F, I>> for JitBackend<R, F, I>
where R: JitRuntime, F: FloatElement, I: IntElement,

§

fn bool_empty<const D: usize>( shape: Shape<D>, device: &<JitBackend<R, F, I> as Backend>::Device, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Creates a new bool tensor. Read more
§

fn bool_shape<const D: usize>( tensor: &<JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>, ) -> Shape<D>

Returns the shape of the tensor. Read more
§

async fn bool_into_data<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>, ) -> TensorData

Converts the tensor to a data structure. Read more
§

fn bool_from_data<const D: usize>( data: TensorData, device: &<JitBackend<R, F, I> as Backend>::Device, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Creates a tensor from the data structure. Read more
§

fn bool_into_int<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Converts bool tensor to int tensor. Read more
§

fn bool_device<const D: usize>( tensor: &<JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::Device

Gets the device of the tensor. Read more
§

fn bool_to_device<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>, device: &<JitBackend<R, F, I> as Backend>::Device, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Moves the tensor to the device.
§

fn bool_reshape<const D1: usize, const D2: usize>( tensor: <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D1>, shape: Shape<D2>, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D2>

Reshapes the tensor. Read more
§

fn bool_slice<const D1: usize, const D2: usize>( tensor: <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D1>, ranges: [Range<usize>; D2], ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D1>

Gets the values from the tensor for the given ranges. Read more
§

fn bool_slice_assign<const D1: usize, const D2: usize>( tensor: <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D1>, ranges: [Range<usize>; D2], value: <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D1>, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D1>

Sets the values in the tensor for the given ranges. Read more
§

fn bool_equal<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Equates the two tensors. Read more
§

fn bool_not<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Inverses boolean values. Read more
§

fn bool_into_float<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Converts bool tensor to float tensor. Read more
§

fn bool_swap_dims<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>, dim1: usize, dim2: usize, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Swaps two dimensions of a bool tensor. Read more
§

fn bool_repeat_dim<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>, dim: usize, times: usize, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

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

fn bool_permute<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>, axes: [usize; D], ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Permutes the dimensions of a tensor. Read more
§

fn bool_expand<const D1: usize, const D2: usize>( tensor: <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D1>, shape: Shape<D2>, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D2>

Broadcasts the bool tensor to the given shape.
§

fn bool_flip<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>, axes: &[usize], ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

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

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

Concatenates the tensors along the given dimension. Read more
§

fn bool_not_equal<const D: usize>( lhs: <B as Backend>::BoolTensorPrimitive<D>, rhs: <B as Backend>::BoolTensorPrimitive<D>, ) -> <B as Backend>::BoolTensorPrimitive<D>

Element-wise non-equality comparison. Read more
§

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

Transposes a bool tensor. Read more
§

fn bool_narrow<const D: usize>( tensor: <B as Backend>::BoolTensorPrimitive<D>, dim: usize, start: usize, length: usize, ) -> <B as Backend>::BoolTensorPrimitive<D>

Returns a new tensor with the given dimension narrowed to the given range. Read more
§

fn bool_chunk<const D: usize>( tensor: <B as Backend>::BoolTensorPrimitive<D>, chunks: usize, dim: usize, ) -> Vec<<B as Backend>::BoolTensorPrimitive<D>>

Split the tensor along the given dimension into chunks. Read more
§

fn bool_any<const D: usize>( tensor: <B as Backend>::BoolTensorPrimitive<D>, ) -> <B as Backend>::BoolTensorPrimitive<1>

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

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

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

fn bool_all<const D: usize>( tensor: <B as Backend>::BoolTensorPrimitive<D>, ) -> <B as Backend>::BoolTensorPrimitive<1>

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

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

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

fn bool_argwhere<const D: usize>( tensor: <B as Backend>::BoolTensorPrimitive<D>, ) -> impl Future<Output = <B as Backend>::IntTensorPrimitive<2>> + Send

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

fn bool_nonzero<const D: usize>( tensor: <B as Backend>::BoolTensorPrimitive<D>, ) -> impl Future<Output = Vec<<B as Backend>::IntTensorPrimitive<1>>> + Send

Compute the indices of the elements that are non-zero. Read more
§

impl<R, F, I> Clone for JitBackend<R, F, I>
where R: JitRuntime, F: FloatElement, I: IntElement,

§

fn clone(&self) -> JitBackend<R, F, I>

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
§

impl<R, F, I> Debug for JitBackend<R, F, I>
where R: JitRuntime, F: FloatElement, I: IntElement,

§

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

Formats the value using the given formatter. Read more
§

impl<R, F, I> Default for JitBackend<R, F, I>
where R: JitRuntime, F: FloatElement, I: IntElement,

§

fn default() -> JitBackend<R, F, I>

Returns the “default value” for a type. Read more
§

impl<R, F, I> FloatTensorOps<JitBackend<R, F, I>> for JitBackend<R, F, I>
where R: JitRuntime, F: FloatElement, I: IntElement,

§

fn float_from_data<const D: usize>( data: TensorData, device: &<JitBackend<R, F, I> as Backend>::Device, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Creates a new tensor from the data structure. Read more
§

fn float_random<const D: usize>( shape: Shape<D>, distribution: Distribution, device: &<JitBackend<R, F, I> as Backend>::Device, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Creates a new tensor with random values. Read more
§

fn float_shape<const D: usize>( tensor: &<JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> Shape<D>

Gets the shape of the tensor. Read more
§

async fn float_into_data<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> TensorData

Converts the tensor to a data structure. Read more
§

fn float_device<const D: usize>( tensor: &<JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::Device

Gets the device of the tensor. Read more
§

fn float_to_device<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, device: &<JitBackend<R, F, I> as Backend>::Device, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Moves the tensor to the given device. Read more
§

fn float_empty<const D: usize>( shape: Shape<D>, device: &<JitBackend<R, F, I> as Backend>::Device, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Creates an empty tensor with the given shape. Read more
§

fn float_add<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Adds two tensors together. Read more
§

fn float_add_scalar<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::FloatElem, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Adds a scalar to a tensor. Read more
§

fn float_zeros<const D: usize>( shape: Shape<D>, device: &<JitBackend<R, F, I> as Backend>::Device, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Creates a new tensor with zeros. Read more
§

fn float_full<const D: usize>( shape: Shape<D>, fill_value: <JitBackend<R, F, I> as Backend>::FloatElem, device: &<R as Runtime>::Device, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Creates a tensor filled with given value. Read more
§

fn float_ones<const D: usize>( shape: Shape<D>, device: &<JitBackend<R, F, I> as Backend>::Device, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Creates a new tensor with ones. Read more
§

fn float_sub<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Subtracts two tensors. Read more
§

fn float_sub_scalar<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::FloatElem, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Subtracts a scalar from a tensor. Read more
§

fn float_mul<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Multiplies two tensors together element-wise.
§

fn float_mul_scalar<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::FloatElem, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Multiplies a tensor by a scalar. Read more
§

fn float_div<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Divides two tensors element-wise. Read more
§

fn float_div_scalar<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::FloatElem, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Divides a tensor by a scalar. Read more
§

fn float_remainder_scalar<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::FloatElem, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Computes the modulus of a tensor given a scalar. Read more
§

fn float_matmul<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Multiplies two tensors together using matrix multiplication. Read more
§

fn float_swap_dims<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, dim1: usize, dim2: usize, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Swaps two dimensions of a tensor. Read more
§

fn float_reshape<const D1: usize, const D2: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D1>, shape: Shape<D2>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D2>

Reshapes a tensor. Read more
§

fn float_gather<const D: usize>( dim: usize, tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, indices: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Gather elements from a tensor. Read more
§

fn float_scatter<const D: usize>( dim: usize, tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, indices: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, value: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Scatter elements into a tensor. Read more
§

fn float_select<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, dim: usize, indices: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<1>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Select tensor elements along the given dimension corresponding for the given indices. Read more
§

fn float_select_assign<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, dim: usize, indices: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<1>, value: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

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

fn float_slice<const D1: usize, const D2: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D1>, ranges: [Range<usize>; D2], ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D1>

Select tensor elements corresponding for the given ranges. Read more
§

fn float_slice_assign<const D1: usize, const D2: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D1>, ranges: [Range<usize>; D2], value: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D1>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D1>

Assign the selected elements corresponding for the given ranges to the given value. Read more
§

fn float_mask_where<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, mask: <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>, value: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Update the given tensor with the value tensor where the mask is true. Read more
§

fn float_mask_fill<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, mask: <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>, value: <JitBackend<R, F, I> as Backend>::FloatElem, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Update the given tensor with the value where the mask is true. Read more
§

fn float_equal<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Equal comparison of two tensors. Read more
§

fn float_equal_elem<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::FloatElem, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Equal comparison of a tensor and a scalar. Read more
§

fn float_greater<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Greater than comparison of two tensors. Read more
§

fn float_greater_elem<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::FloatElem, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Greater than comparison of a tensor and a scalar. Read more
§

fn float_greater_equal<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Greater than or equal comparison of two tensors. Read more
§

fn float_greater_equal_elem<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::FloatElem, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Greater than or equal comparison of a tensor and a scalar. Read more
§

fn float_lower<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Less than comparison of two tensors. Read more
§

fn float_lower_elem<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::FloatElem, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Less than comparison of a tensor and a scalar. Read more
§

fn float_lower_equal<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Less than or equal comparison of two tensors. Read more
§

fn float_lower_equal_elem<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::FloatElem, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Less than or equal comparison of a tensor and a scalar. Read more
§

fn float_sum<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<1>

Sum of all elements in a tensor. Read more
§

fn float_sum_dim<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, dim: usize, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Sum of all elements in a tensor along a dimension. Read more
§

fn float_mean_dim<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, dim: usize, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Mean of all elements in a tensor along a dimension. Read more
§

fn float_prod<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<1>

Product of all elements in a tensor. Read more
§

fn float_prod_dim<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, dim: usize, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Product of all elements in a tensor along a dimension. Read more
§

fn float_exp<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Returns a new tensor with exponential values. Read more
§

fn float_log<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Returns a new tensor with natural logarithm values. Read more
§

fn float_log1p<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

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

fn float_powf_scalar<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, rhs: f32, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

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

fn float_sqrt<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Returns a new tensor with square root values. Read more
§

fn float_abs<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Returns a new tensor with absolute values. Read more
§

fn float_cos<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Returns a new tensor with cosine values. Read more
§

fn float_sin<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Returns a new tensor with sine values. Read more
§

fn float_tanh<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Returns a new tensor with tangent values. Read more
§

fn float_erf<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Returns a new tensor with the error function values. Read more
§

fn float_argmax<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, dim: usize, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

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

fn float_argmin<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, dim: usize, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

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

fn float_into_int<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Converts float tensor to int tensor. Read more
§

fn float_clamp<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, min: <JitBackend<R, F, I> as Backend>::FloatElem, max: <JitBackend<R, F, I> as Backend>::FloatElem, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Clamps a tensor between a minimum and maximum value. Read more
§

fn float_recip<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Calculates the reciprocals element-wise
§

fn float_repeat_dim<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, dim: usize, times: usize, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Repeat the tensor along the given dimension. Read more
§

fn float_powf<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Element-wise power with a FloatTensor. Read more
§

fn float_permute<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, axes: [usize; D], ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Permutes the dimensions of a tensor. Read more
§

fn float_expand<const D1: usize, const D2: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D1>, shape: Shape<D2>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D2>

Broadcasts the float tensor to the given shape.
§

fn float_flip<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, axes: &[usize], ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

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

fn float_clamp_min<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, min: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive<D>

Clamps a tensor under a minimum value. Read more
§

fn float_clamp_max<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, max: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive<D>

Clamps a tensor over a maximum value. Read more
§

fn float_neg<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

Negates a tensor element-wise.
§

fn float_transpose<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

Transposes a tensor. Read more
§

fn float_not_equal<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::BoolTensorPrimitive<D>

Element-wise non-equality comparison. Read more
§

fn float_not_equal_elem<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::BoolTensorPrimitive<D>

Element-wise non-equality comparison with a scalar. Read more
§

fn float_detach<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

Detaches a tensor from the computation graph.
§

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

Sets the require_grad flag of a tensor.
§

fn float_is_require_grad<const D: usize>( _tensor: &<B as Backend>::FloatTensorPrimitive<D>, ) -> bool

Returns the require_grad flag of a tensor.
§

fn float_mean<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<1>

Mean of all elements in a tensor. Read more
§

fn float_into_full_precision<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <<<B as Backend>::FullPrecisionBridge as BackendBridge<B>>::Target as Backend>::FloatTensorPrimitive<D>

Converts a tensor to full precision. Read more
§

fn float_from_full_precision<const D: usize>( tensor: <<<B as Backend>::FullPrecisionBridge as BackendBridge<B>>::Target as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

Converts a tensor from full precision. Read more
§

fn float_powi<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::IntTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

Element-wise power with an IntTensor. Read more
§

fn float_powi_scalar<const D: usize>( lhs: <B as Backend>::FloatTensorPrimitive<D>, rhs: <B as Backend>::IntElem, ) -> <B as Backend>::FloatTensorPrimitive<D>

raises a tensor to the power of an int scalar. Read more
§

fn float_cat<const D: usize>( tensors: Vec<<B as Backend>::FloatTensorPrimitive<D>>, dim: usize, ) -> <B as Backend>::FloatTensorPrimitive<D>

Concatenates tensors along a dimension. Read more
§

fn float_max<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<1>

Gets the maximum element of a tensor. Read more
§

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

Gets the maximum elements of a tensor along an axis. Read more
§

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

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

fn float_min<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<1>

Gets the minimum element of a tensor. Read more
§

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

Gets the minimum elements of a tensor along an axis. Read more
§

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

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

fn float_narrow<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, dim: usize, start: usize, length: usize, ) -> <B as Backend>::FloatTensorPrimitive<D>

Returns a new tensor with the given dimension narrowed to the given range. Read more
§

fn float_chunk<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, chunks: usize, dim: usize, ) -> Vec<<B as Backend>::FloatTensorPrimitive<D>>

Split the tensor along the given dimension into chunks. Read more
§

fn float_any<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::BoolTensorPrimitive<1>

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

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

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

fn float_all<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::BoolTensorPrimitive<1>

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

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

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

fn float_sign<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::FloatTensorPrimitive<D>

Returns the signs of the float tensor. Read more
§

fn float_sort<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, dim: usize, descending: bool, ) -> <B as Backend>::FloatTensorPrimitive<D>

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

fn float_sort_with_indices<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, dim: usize, descending: bool, ) -> (<B as Backend>::FloatTensorPrimitive<D>, <B as Backend>::IntTensorPrimitive<D>)

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

fn float_argsort<const D: usize>( tensor: <B as Backend>::FloatTensorPrimitive<D>, dim: usize, descending: bool, ) -> <B as Backend>::IntTensorPrimitive<D>

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

impl<R, F, I> FusionBackend for JitBackend<R, F, I>
where R: JitRuntime, F: FloatElement, I: IntElement,

§

type FusionRuntime = FusionJitRuntime<R>

The runtime used for this backend.
§

type FullPrecisionBackend = JitBackend<R, f32, i32>

Pointer to the full precision fusion backend.
§

fn cast_float<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, dtype: DType, ) -> <JitBackend<R, F, I> as ReprBackend>::Handle

Cast a float tensor and returns the resulting handle.
§

impl<R, F, I> IntTensorOps<JitBackend<R, F, I>> for JitBackend<R, F, I>
where R: JitRuntime, F: FloatElement, I: IntElement,

§

fn int_empty<const D: usize>( shape: Shape<D>, device: &<JitBackend<R, F, I> as Backend>::Device, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Creates a new int tensor. Read more
§

fn int_shape<const D: usize>( tensor: &<JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, ) -> Shape<D>

Returns the shape of the tensor. Read more
§

async fn int_into_data<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, ) -> TensorData

Converts the tensor to a data structure. Read more
§

fn int_from_data<const D: usize>( data: TensorData, device: &<JitBackend<R, F, I> as Backend>::Device, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Creates a tensor from the data structure. Read more
§

fn int_device<const D: usize>( tensor: &<JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::Device

Gets the device of the tensor. Read more
§

fn int_to_device<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, device: &<JitBackend<R, F, I> as Backend>::Device, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Moves the tensor to the given device.
§

fn int_reshape<const D1: usize, const D2: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D1>, shape: Shape<D2>, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D2>

Reshapes the tensor. Read more
§

fn int_slice<const D1: usize, const D2: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D1>, ranges: [Range<usize>; D2], ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D1>

Gets the element at the given indices. Read more
§

fn int_slice_assign<const D1: usize, const D2: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D1>, ranges: [Range<usize>; D2], value: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D1>, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D1>

Sets the element at the given indices. Read more
§

fn int_mask_where<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, mask: <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>, value: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

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

fn int_mask_fill<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, mask: <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>, value: <JitBackend<R, F, I> as Backend>::IntElem, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

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

fn int_gather<const D: usize>( dim: usize, tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, indices: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Gather elements from the tensor at the given indices. Read more
§

fn int_scatter<const D: usize>( dim: usize, tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, indices: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, value: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Scatter a given value to the tensor at the given indices. Read more
§

fn int_select<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, dim: usize, indices: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<1>, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Select tensor elements along the given dimension corresponding to the given indices. Read more
§

fn int_select_assign<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, dim: usize, indices: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<1>, value: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

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

fn int_equal<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Element-wise equality comparison. Read more
§

fn int_equal_elem<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::IntElem, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Element-wise equality comparison with a scalar. Read more
§

fn int_greater<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Element-wise greater than comparison. Read more
§

fn int_greater_elem<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::IntElem, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Element-wise greater than comparison with a scalar. Read more
§

fn int_greater_equal<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Element-wise greater than or equal comparison. Read more
§

fn int_greater_equal_elem<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::IntElem, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

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

fn int_lower<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Element-wise less than comparison. Read more
§

fn int_lower_elem<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::IntElem, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Element-wise less than comparison with a scalar. Read more
§

fn int_lower_equal<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Element-wise less than or equal comparison. Read more
§

fn int_lower_equal_elem<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::IntElem, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

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

fn int_add<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Element-wise addition. Read more
§

fn int_add_scalar<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::IntElem, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Element-wise addition with a scalar. Read more
§

fn int_sub<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Element-wise subtraction. Read more
§

fn int_sub_scalar<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::IntElem, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Element-wise subtraction with a scalar. Read more
§

fn int_mul<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Element-wise multiplication. Read more
§

fn int_mul_scalar<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::IntElem, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Element-wise multiplication with a scalar. Read more
§

fn int_div<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Element-wise division. Read more
§

fn int_div_scalar<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::IntElem, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Element-wise division with a scalar. Read more
§

fn int_remainder_scalar<const D: usize>( lhs: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, rhs: <JitBackend<R, F, I> as Backend>::IntElem, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Element-wise modulus with a scalar. Read more
§

fn int_zeros<const D: usize>( shape: Shape<D>, device: &<JitBackend<R, F, I> as Backend>::Device, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Creates a tensor of zeros. Read more
§

fn int_ones<const D: usize>( shape: Shape<D>, device: &<JitBackend<R, F, I> as Backend>::Device, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Creates a tensor of ones. Read more
§

fn int_sum<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<1>

Sums all elements in the tensor. Read more
§

fn int_sum_dim<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, dim: usize, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Sums all elements in the tensor along a dimension. Read more
§

fn int_prod<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<1>

Computes the product of all elements in the tensor. Read more
§

fn int_prod_dim<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, dim: usize, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

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

fn int_mean_dim<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, dim: usize, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

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

fn int_argmax<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, dim: usize, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Gets the indices of the maximum elements along a dimension. Read more
§

fn int_argmin<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, dim: usize, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Gets the indices of the minimum elements along a dimension. Read more
§

fn int_clamp<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, min: <JitBackend<R, F, I> as Backend>::IntElem, max: <JitBackend<R, F, I> as Backend>::IntElem, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Clamps a tensor between a minimum and maximum value. Read more
§

fn int_abs<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Returns a new tensor with absolute values. Read more
§

fn int_into_float<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Converts int tensor to float tensor. Read more
§

fn int_swap_dims<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, dim1: usize, dim2: usize, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Swaps two dimensions of an int tensor. Read more
§

fn int_repeat_dim<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, dim: usize, times: usize, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Repeats the tensor along the given dimension the given number of times. Read more
§

fn int_random<const D: usize>( shape: Shape<D>, distribution: Distribution, device: &<JitBackend<R, F, I> as Backend>::Device, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Creates a new int tensor with random values. Read more
§

fn int_permute<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, axes: [usize; D], ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Permutes the dimensions of a tensor. Read more
§

fn int_expand<const D1: usize, const D2: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D1>, shape: Shape<D2>, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D2>

Broadcasts the int tensor to the given shape.
§

fn int_flip<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, axes: &[usize], ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

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

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

Concatenates the given tensors along the given dimension. Read more
§

fn int_not_equal<const D: usize>( lhs: <B as Backend>::IntTensorPrimitive<D>, rhs: <B as Backend>::IntTensorPrimitive<D>, ) -> <B as Backend>::BoolTensorPrimitive<D>

Element-wise non-equality comparison. Read more
§

fn int_not_equal_elem<const D: usize>( lhs: <B as Backend>::IntTensorPrimitive<D>, rhs: <B as Backend>::IntElem, ) -> <B as Backend>::BoolTensorPrimitive<D>

Element-wise non-equality comparison with a scalar. Read more
§

fn int_powi<const D: usize>( lhs: <B as Backend>::IntTensorPrimitive<D>, rhs: <B as Backend>::IntTensorPrimitive<D>, ) -> <B as Backend>::IntTensorPrimitive<D>

Element-wise power with a IntTensor. Read more
§

fn int_powf<const D: usize>( lhs: <B as Backend>::IntTensorPrimitive<D>, rhs: <B as Backend>::FloatTensorPrimitive<D>, ) -> <B as Backend>::IntTensorPrimitive<D>

Element-wise power with a floatTensor. Read more
§

fn int_powi_scalar<const D: usize>( lhs: <B as Backend>::IntTensorPrimitive<D>, rhs: <B as Backend>::IntElem, ) -> <B as Backend>::IntTensorPrimitive<D>

Element-wise power with a scalar. Read more
§

fn int_powf_scalar<const D: usize>( lhs: <B as Backend>::IntTensorPrimitive<D>, rhs: f32, ) -> <B as Backend>::IntTensorPrimitive<D>

Element-wise power with a floatTensor. Read more
§

fn int_clamp_min<const D: usize>( tensor: <B as Backend>::IntTensorPrimitive<D>, min: <B as Backend>::IntElem, ) -> <B as Backend>::IntTensorPrimitive<D>

Clamps a tensor under a minimum value. Read more
§

fn int_clamp_max<const D: usize>( tensor: <B as Backend>::IntTensorPrimitive<D>, max: <B as Backend>::IntElem, ) -> <B as Backend>::IntTensorPrimitive<D>

Clamps a tensor over a maximum value. Read more
§

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

Element-wise negation. Read more
§

fn int_full<const D: usize>( shape: Shape<D>, fill_value: <B as Backend>::IntElem, device: &<B as Backend>::Device, ) -> <B as Backend>::IntTensorPrimitive<D>

Creates a tensor filled with given value. Read more
§

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

Computes the mean of all elements in the tensor. Read more
§

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

Gets the maximum element in the tensor. Read more
§

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

Gets the maximum element in the tensor along a dimension. Read more
§

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

Gets the maximum elements and corresponding indices along a dimension. Read more
§

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

Gets the minimum element in the tensor. Read more
§

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

Gets the minimum elements in the tensor along a dimension. Read more
§

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

Gets the minimum elements and corresponding indices along a dimension. Read more
§

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

Transposes an int tensor. Read more
§

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

Returns a new tensor with the given dimension narrowed to the given range. Read more
§

fn int_cartesian_grid<S, const D: usize, const D2: usize>( shape: S, device: &<B as Backend>::Device, ) -> <B as Backend>::IntTensorPrimitive<D2>
where S: Into<Shape<D>>,

Generates a cartesian grid for the given tensor shape on the specified device. The generated tensor is of dimension D2 = D + 1, where each element at dimension D contains the cartesian grid coordinates for that element. Read more
§

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

Split the tensor along the given dimension into chunks. Read more
§

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

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

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

Creates a new tensor with values from the given range. Read more
§

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

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

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

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

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

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

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

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

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

Returns the signs of the int tensor. Read more
§

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

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

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

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

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

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

impl<R, F, I> ModuleOps<JitBackend<R, F, I>> for JitBackend<R, F, I>
where R: JitRuntime, F: FloatElement, I: IntElement,

§

fn conv2d( x: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>, weight: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>, bias: Option<<JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<1>>, options: ConvOptions<2>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>

Two dimensional convolution. Read more
§

fn conv3d( x: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<5>, weight: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<5>, bias: Option<<JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<1>>, options: ConvOptions<3>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<5>

Three dimensional convolution. Read more
§

fn conv_transpose2d( x: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>, weight: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>, bias: Option<<JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<1>>, options: ConvTransposeOptions<2>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>

Two dimensional transposed convolution. Read more
§

fn conv_transpose3d( x: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<5>, weight: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<5>, bias: Option<<JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<1>>, options: ConvTransposeOptions<3>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<5>

Three dimensional transposed convolution. Read more
§

fn avg_pool2d( x: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], count_include_pad: bool, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>

Two dimensional avg pooling. Read more
§

fn avg_pool2d_backward( x: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>, grad: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], count_include_pad: bool, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>

Backward pass for the avg pooling 2d operation.
§

fn max_pool2d( x: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], dilation: [usize; 2], ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>

Two dimensional max pooling. Read more
§

fn max_pool2d_with_indices( x: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], dilation: [usize; 2], ) -> MaxPool2dWithIndices<JitBackend<R, F, I>>

Two dimensional max pooling with indices. Read more
§

fn max_pool2d_with_indices_backward( x: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], dilation: [usize; 2], output_grad: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>, indices: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<4>, ) -> MaxPool2dBackward<JitBackend<R, F, I>>

Backward pass for the max pooling 2d operation.
§

fn adaptive_avg_pool2d( x: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>, output_size: [usize; 2], ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>

Two dimensional adaptive avg pooling. Read more
§

fn adaptive_avg_pool2d_backward( x: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>, grad: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>

Backward pass for the adaptive avg pooling 2d operation.
§

fn interpolate( x: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>, output_size: [usize; 2], options: InterpolateOptions, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>

Down/up samples the input. Read more
§

fn interpolate_backward( x: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>, grad: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>, output_size: [usize; 2], options: InterpolateOptions, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<4>

Backward pass for the interpolate operation.
§

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

Embedding operation. Read more
§

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

Embedding backward operation. Read more
§

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

One dimensional convolution. Read more
§

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

Backward pass for the conv1d operation.
§

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

Backward pass for the conv2d operation.
§

fn conv3d_backward( x: <B as Backend>::FloatTensorPrimitive<5>, weight: <B as Backend>::FloatTensorPrimitive<5>, bias: Option<<B as Backend>::FloatTensorPrimitive<1>>, output_grad: <B as Backend>::FloatTensorPrimitive<5>, options: ConvOptions<3>, ) -> Conv3dBackward<B>

Backward pass for the conv3d operation.
§

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

One dimensional transposed convolution. Read more
§

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

Backward pass for the conv transpose 1d operation.
§

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

Backward pass for the conv transpose 2d operation.
§

fn conv_transpose3d_backward( x: <B as Backend>::FloatTensorPrimitive<5>, weight: <B as Backend>::FloatTensorPrimitive<5>, bias: Option<<B as Backend>::FloatTensorPrimitive<1>>, output_grad: <B as Backend>::FloatTensorPrimitive<5>, options: ConvTransposeOptions<3>, ) -> Conv3dBackward<B>

Backward pass for the conv transpose 3d operation.
§

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

Four-dimensional unfolding. Read more
§

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

One dimensional avg pooling. Read more
§

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

Backward pass for the avg pooling 1d operation.
§

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

One dimensional adaptive avg pooling. Read more
§

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

Backward pass for the adaptive avg pooling 1d operation.
§

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

One dimensional max pooling. Read more
§

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

One dimensional max pooling with indices. Read more
§

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

Backward pass for the max pooling 1d operation.
§

impl<R, F, I> QTensorOps<JitBackend<R, F, I>> for JitBackend<R, F, I>
where R: JitRuntime, F: FloatElement, I: IntElement,

§

fn q_from_data<const D: usize>( _data: TensorData, _device: &<JitBackend<R, F, I> as Backend>::Device, ) -> <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive<D>

Creates a new tensor from the data structure. Read more
§

fn quantize<const D: usize>( _tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, _scheme: &QuantizationScheme, _qparams: QuantizationParametersPrimitive<JitBackend<R, F, I>>, ) -> <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive<D>

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

fn dequantize<const D: usize>( _tensor: <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Convert the tensor back to a higher precision data type.
§

fn q_shape<const D: usize>( tensor: &<JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive<D>, ) -> Shape<D>

Gets the shape of the tensor. Read more
§

fn q_device<const D: usize>( tensor: &<JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as Backend>::Device

Gets the device of the tensor. Read more
§

fn q_reshape<const D1: usize, const D2: usize>( tensor: <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive<D1>, shape: Shape<D2>, ) -> <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive<D2>

Reshapes a tensor. Read more
§

async fn q_into_data<const D: usize>( _tensor: <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive<D>, ) -> TensorData

Converts the tensor to a data structure. Read more
§

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

Sets the require_grad flag of a tensor.
§

fn q_is_require_grad<const D: usize>( _tensor: &<B as Backend>::QuantizedTensorPrimitive<D>, ) -> bool

Returns the require_grad flag of a tensor.
§

impl<R, F, I> ReprBackend for JitBackend<R, F, I>
where R: JitRuntime, F: FloatElement, I: IntElement,

§

type Handle = JitFusionHandle<R>

The type that can be used to point to a tensor of any kind.
§

fn float_tensor<const D: usize>( handle: <JitBackend<R, F, I> as ReprBackend>::Handle, shape: Shape<D>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>

Convert a handle to a float tensor.
§

fn int_tensor<const D: usize>( handle: <JitBackend<R, F, I> as ReprBackend>::Handle, shape: Shape<D>, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>

Convert a handle to an int tensor.
§

fn bool_tensor<const D: usize>( handle: <JitBackend<R, F, I> as ReprBackend>::Handle, shape: Shape<D>, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>

Convert a handle to a bool tensor.
§

fn float_tensor_handle<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as ReprBackend>::Handle

Convert a float tensor to a handle.
§

fn int_tensor_handle<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as ReprBackend>::Handle

Convert an int tensor to a handle.
§

fn bool_tensor_handle<const D: usize>( tensor: <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive<D>, ) -> <JitBackend<R, F, I> as ReprBackend>::Handle

Convert a bool tensor to a handle.

Auto Trait Implementations§

§

impl<R, F, I> Freeze for JitBackend<R, F, I>

§

impl<R, F, I> RefUnwindSafe for JitBackend<R, F, I>
where R: RefUnwindSafe, F: RefUnwindSafe, I: RefUnwindSafe,

§

impl<R, F, I> Send for JitBackend<R, F, I>

§

impl<R, F, I> Sync for JitBackend<R, F, I>

§

impl<R, F, I> Unpin for JitBackend<R, F, I>
where R: Unpin, F: Unpin, I: Unpin,

§

impl<R, F, I> UnwindSafe for JitBackend<R, F, I>
where R: UnwindSafe, F: UnwindSafe, I: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where T: Clone,

source§

default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

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

impl<R, P> ReadPrimitive<R> for P
where R: Read + ReadEndian<P>, P: Default,

source§

fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_little_endian().
source§

fn read_from_big_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_big_endian().
source§

fn read_from_native_endian(read: &mut R) -> Result<Self, Error>

Read this value from the supplied reader. Same as ReadEndian::read_from_native_endian().
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

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

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

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

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

impl<T> ErasedDestructor for T
where T: 'static,

§

impl<T> WasmNotSend for T
where T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where T: Sync,