Struct burn::backend::wgpu::JitBackend

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

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( tensor: <B as Backend>::FloatTensorPrimitive, negative_slope: <B as Backend>::FloatElem, ) -> <B as Backend>::FloatTensorPrimitive

Applies the LeakyReLU activation function.

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

Applies the ReLU activation function.

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

Applies the ReLU activation function backward.

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

Applies the Gelu activation function.

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

Applies the PReLu activation function.

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

Applies the Gelu activation function backward.

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

Applies the Sigmoid activation function.

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

Applies the Sigmoid activation function backward.

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

Applies the hard Sigmoid activation function.

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

Applies the LogSigmoid activation function.

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

Applies the LogSigmoid activation function backward.

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 = JitTensor<R, <JitBackend<R, F, I> as Backend>::FloatElem>

Tensor primitive to be used for all float operations.

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

Tensor primitive to be used for all int operations.

type BoolTensorPrimitive = JitTensor<R, u32>

Tensor primitive to be used for all bool operations.

type QuantizedTensorPrimitive = QJitTensor<R, <JitBackend<R, F, I> as Backend>::FloatElem, <JitBackend<R, F, I> as Backend>::IntElem>

Tensor primitive to be used for all quantized operations.

type QuantizedEncoding = u32

Quantized tensor encoding type.

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 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( tensor: <JitBackend<R, FOrigin, IOrigin> as Backend>::FloatTensorPrimitive, 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

Transfer the tensor to the target backend.

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

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( shape: Shape, device: &<JitBackend<R, F, I> as Backend>::Device, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive

Creates a new bool tensor.

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

Returns the shape of the tensor.

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

Converts the tensor to a data structure.

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

Creates a tensor from the data structure.

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

Converts bool tensor to int tensor.

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

Gets the device of the tensor.

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

Moves the tensor to the device.

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

Reshapes the tensor.

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

Gets the values from the tensor for the given ranges.

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

Sets the values in the tensor for the given ranges.

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

Equates the two tensors.

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

Inverses boolean values.

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

Converts bool tensor to float tensor.

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

Swaps two dimensions of a bool tensor.

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

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

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

Permutes the dimensions of a tensor.

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

Broadcasts the bool tensor to the given shape.

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

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

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

Concatenates the tensors along the given dimension.

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

Element-wise non-equality comparison.

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

Transposes a bool tensor.

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

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

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

Split the tensor along the given dimension into chunks.

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

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

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

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

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

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

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

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

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

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

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

Compute the indices of the elements that are non-zero.

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.

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

Performs copy-assignment from source.

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.

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.

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( data: TensorData, device: &<JitBackend<R, F, I> as Backend>::Device, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive

Creates a new tensor from the data structure.

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

Creates a new tensor with random values.

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

Gets the shape of the tensor.

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

Converts the tensor to a data structure.

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

Gets the device of the tensor.

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

Moves the tensor to the given device.

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

Creates an empty tensor with the given shape.

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

Adds two tensors together.

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

Adds a scalar to a tensor.

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

Creates a new tensor with zeros.

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

Creates a tensor filled with given value.

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

Creates a new tensor with ones.

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

Subtracts two tensors.

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

Subtracts a scalar from a tensor.

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

Multiplies two tensors together element-wise.

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

Multiplies a tensor by a scalar.

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

Divides two tensors element-wise.

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

Divides a tensor by a scalar.

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

Computes the modulus of a tensor given a scalar.

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

Multiplies two tensors together using matrix multiplication.

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

Swaps two dimensions of a tensor.

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

Reshapes a tensor.

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

Gather elements from a tensor.

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

Scatter elements into a tensor.

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

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

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

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

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

Select tensor elements corresponding for the given ranges.

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

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

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

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

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

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

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

Equal comparison of two tensors.

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

Equal comparison of a tensor and a scalar.

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

Greater than comparison of two tensors.

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

Greater than comparison of a tensor and a scalar.

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

Greater than or equal comparison of two tensors.

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

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

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

Less than comparison of two tensors.

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

Less than comparison of a tensor and a scalar.

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

Less than or equal comparison of two tensors.

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

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

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

Sum of all elements in a tensor.

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

Sum of all elements in a tensor along a dimension.

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

Mean of all elements in a tensor along a dimension.

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

Product of all elements in a tensor.

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

Product of all elements in a tensor along a dimension.

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

Returns a new tensor with exponential values.

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

Returns a new tensor with natural logarithm values.

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

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

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

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

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

Returns a new tensor with square root values.

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

Returns a new tensor with absolute values.

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

Returns a new tensor with cosine values.

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

Returns a new tensor with sine values.

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

Returns a new tensor with tangent values.

fn float_round( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive

Returns a new tensor with rounded values.

fn float_floor( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive

Returns a new tensor with floored values.

fn float_ceil( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive

Returns a new tensor with ceiled values.

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

Returns a new tensor with the error function values.

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

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

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

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

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

Converts float tensor to int tensor.

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

Clamps a tensor between a minimum and maximum value.

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

Calculates the reciprocals element-wise

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

Repeat the tensor along the given dimension.

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

Element-wise power with a FloatTensor.

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

Permutes the dimensions of a tensor.

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

Broadcasts the float tensor to the given shape.

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

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

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

Clamps a tensor under a minimum value.

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

Clamps a tensor over a maximum value.

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

Negates a tensor element-wise.

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

Transposes a tensor.

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

Element-wise non-equality comparison.

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

Element-wise non-equality comparison with a scalar.

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

Detaches a tensor from the computation graph.

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

Sets the require_grad flag of a tensor.

fn float_is_require_grad(_tensor: &<B as Backend>::FloatTensorPrimitive) -> bool

Returns the require_grad flag of a tensor.

fn float_mean( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::FloatTensorPrimitive

Mean of all elements in a tensor.

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

Converts a tensor to full precision.

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

Converts a tensor from full precision.

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

Element-wise power with an IntTensor.

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

raises a tensor to the power of an int scalar.

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

Concatenates tensors along a dimension.

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

Gets the maximum element of a tensor.

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

Gets the maximum elements of a tensor along an axis.

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

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

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

Gets the minimum element of a tensor.

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

Gets the minimum elements of a tensor along an axis.

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

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

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

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

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

Split the tensor along the given dimension into chunks.

fn float_any( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

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

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

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

fn float_all( tensor: <B as Backend>::FloatTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

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

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

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

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

Returns the signs of the float tensor.

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

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

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

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

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

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

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( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive, 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( shape: Shape, device: &<JitBackend<R, F, I> as Backend>::Device, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive

Creates a new int tensor.

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

Returns the shape of the tensor.

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

Converts the tensor to a data structure.

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

Creates a tensor from the data structure.

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

Gets the device of the tensor.

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

Moves the tensor to the given device.

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

Reshapes the tensor.

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

Gets the element at the given indices.

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

Sets the element at the given indices.

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

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

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

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

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

Gather elements from the tensor at the given indices.

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

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

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

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

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

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

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

Element-wise equality comparison.

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

Element-wise equality comparison with a scalar.

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

Element-wise greater than comparison.

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

Element-wise greater than comparison with a scalar.

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

Element-wise greater than or equal comparison.

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

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

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

Element-wise less than comparison.

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

Element-wise less than comparison with a scalar.

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

Element-wise less than or equal comparison.

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

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

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

Element-wise addition.

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

Element-wise addition with a scalar.

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

Element-wise subtraction.

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

Element-wise subtraction with a scalar.

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

Element-wise multiplication.

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

Element-wise multiplication with a scalar.

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

Element-wise division.

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

Element-wise division with a scalar.

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

Element-wise modulus with a scalar.

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

Creates a tensor of zeros.

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

Creates a tensor of ones.

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

Sums all elements in the tensor.

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

Sums all elements in the tensor along a dimension.

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

Computes the product of all elements in the tensor.

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

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

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

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

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

Gets the indices of the maximum elements along a dimension.

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

Gets the indices of the minimum elements along a dimension.

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

Clamps a tensor between a minimum and maximum value.

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

Returns a new tensor with absolute values.

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

Converts int tensor to float tensor.

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

Swaps two dimensions of an int tensor.

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

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

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

Creates a new int tensor with random values.

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

Permutes the dimensions of a tensor.

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

Broadcasts the int tensor to the given shape.

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

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

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

Concatenates the given tensors along the given dimension.

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

Element-wise non-equality comparison.

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

Element-wise non-equality comparison with a scalar.

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

Element-wise power with a IntTensor.

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

Element-wise power with a floatTensor.

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

Element-wise power with a scalar.

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

Element-wise power with a floatTensor.

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

Clamps a tensor under a minimum value.

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

Clamps a tensor over a maximum value.

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

Element-wise negation.

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

Creates a tensor filled with given value.

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

Computes the mean of all elements in the tensor.

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

Gets the maximum element in the tensor.

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

Gets the maximum element in the tensor along a dimension.

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

Gets the maximum elements and corresponding indices along a dimension.

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

Gets the minimum element in the tensor.

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

Gets the minimum elements in the tensor along a dimension.

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

Gets the minimum elements and corresponding indices along a dimension.

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

Transposes an int tensor.

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

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

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

Split the tensor along the given dimension into chunks.

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

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

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

Creates a new tensor with values from the given range.

fn int_any( tensor: <B as Backend>::IntTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

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

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

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

fn int_all( tensor: <B as Backend>::IntTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

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

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

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

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

Returns the signs of the int tensor.

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

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

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

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

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

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

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, weight: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive, bias: Option<<JitBackend<R, F, I> as Backend>::FloatTensorPrimitive>, options: ConvOptions<2>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive

Two dimensional convolution.

fn deform_conv2d( x: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive, offset: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive, weight: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive, mask: Option<<JitBackend<R, F, I> as Backend>::FloatTensorPrimitive>, bias: Option<<JitBackend<R, F, I> as Backend>::FloatTensorPrimitive>, options: DeformConvOptions<2>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive

Two dimensional deformable convolution.

fn deform_conv2d_backward( x: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive, offset: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive, weight: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive, mask: Option<<JitBackend<R, F, I> as Backend>::FloatTensorPrimitive>, bias: Option<<JitBackend<R, F, I> as Backend>::FloatTensorPrimitive>, output_grad: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive, options: DeformConvOptions<2>, ) -> DeformConv2dBackward<JitBackend<R, F, I>>

Backward pass for the deform_conv2d operation.

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

Three dimensional convolution.

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

Two dimensional transposed convolution.

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

Three dimensional transposed convolution.

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

Two dimensional avg pooling.

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

Backward pass for the avg pooling 2d operation.

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

Two dimensional max pooling.

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

Two dimensional max pooling with indices.

fn max_pool2d_with_indices_backward( x: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], dilation: [usize; 2], output_grad: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive, indices: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive, ) -> 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, output_size: [usize; 2], ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive

Two dimensional adaptive avg pooling.

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

Backward pass for the adaptive avg pooling 2d operation.

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

Down/up samples the input.

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

Backward pass for the interpolate operation.

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

Embedding operation.

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

Embedding backward operation.

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

One dimensional convolution.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

One dimensional transposed convolution.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Four-dimensional unfolding.

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

One dimensional avg pooling.

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

Backward pass for the avg pooling 1d operation.

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

One dimensional adaptive avg pooling.

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

Backward pass for the adaptive avg pooling 1d operation.

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

One dimensional max pooling.

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

One dimensional max pooling with indices.

fn max_pool1d_with_indices_backward( x: <B as Backend>::FloatTensorPrimitive, kernel_size: usize, stride: usize, padding: usize, dilation: usize, output_grad: <B as Backend>::FloatTensorPrimitive, indices: <B as Backend>::IntTensorPrimitive, ) -> 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( data: TensorData, device: &<JitBackend<R, F, I> as Backend>::Device, ) -> <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive

Creates a new tensor from the data structure.

fn quantize( tensor: <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive, scheme: &QuantizationScheme, qparams: QuantizationParametersPrimitive<JitBackend<R, F, I>>, ) -> <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive

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

fn dequantize( tensor: <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive

Convert the tensor back to a higher precision data type.

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

Gets the shape of the tensor.

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

Gets the device of the tensor.

fn q_to_device( tensor: <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive, device: &<JitBackend<R, F, I> as Backend>::Device, ) -> <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive

Moves the tensor to the given device.

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

Reshapes a tensor.

async fn q_into_data( tensor: <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive, ) -> TensorData

Converts the tensor to a data structure.

fn q_swap_dims( _tensor: <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive, _dim1: usize, _dim2: usize, ) -> <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive

Swaps two dimensions of a tensor.

fn q_permute( _tensor: <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive, _axes: &[usize], ) -> <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive

Permutes the dimensions of a tensor.

fn q_flip( _tensor: <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive, _axes: &[usize], ) -> <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive

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

fn q_gather( _dim: usize, _tensor: <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive, _indices: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive, ) -> <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive

Gather elements from a tensor.

fn q_select( _tensor: <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive, _dim: usize, _indices: <JitBackend<R, F, I> as Backend>::IntTensorPrimitive, ) -> <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive

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

fn q_slice( _tensor: <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive, _ranges: &[Range<usize>], ) -> <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive

Select tensor elements corresponding for the given ranges.

fn q_expand( _tensor: <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive, _shape: Shape, ) -> <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive

Broadcasts the tensor to the given shape.

fn quantize_dynamic( tensor: <B as Backend>::FloatTensorPrimitive, scheme: &QuantizationScheme, ) -> <B as Backend>::QuantizedTensorPrimitive

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

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

Detaches a tensor from the computation graph.

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

Sets the require_grad flag of a tensor.

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

Returns the require_grad flag of a tensor.

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

Repeat the tensor along the given dimension.

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

Adds two tensors together.

fn q_add_scalar( lhs: <B as Backend>::QuantizedTensorPrimitive, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::QuantizedTensorPrimitive

Adds a scalar to a tensor.

fn q_clamp_min( tensor: <B as Backend>::QuantizedTensorPrimitive, min: <B as Backend>::FloatElem, ) -> <B as Backend>::QuantizedTensorPrimitive

Clamps a tensor under a minimum value.

fn q_clamp_max( tensor: <B as Backend>::QuantizedTensorPrimitive, max: <B as Backend>::FloatElem, ) -> <B as Backend>::QuantizedTensorPrimitive

Clamps a tensor over a maximum value.

fn q_clamp( tensor: <B as Backend>::QuantizedTensorPrimitive, min: <B as Backend>::FloatElem, max: <B as Backend>::FloatElem, ) -> <B as Backend>::QuantizedTensorPrimitive

Clamps a tensor between a minimum and maximum value.

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

Subtracts two tensors.

fn q_sub_scalar( lhs: <B as Backend>::QuantizedTensorPrimitive, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::QuantizedTensorPrimitive

Subtracts a scalar from a tensor.

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

Multiplies two tensors together element-wise.

fn q_mul_scalar( lhs: <B as Backend>::QuantizedTensorPrimitive, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::QuantizedTensorPrimitive

Multiplies a tensor by a scalar.

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

Divides two tensors element-wise.

fn q_div_scalar( lhs: <B as Backend>::QuantizedTensorPrimitive, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::QuantizedTensorPrimitive

Divides a tensor by a scalar.

fn q_remainder_scalar( lhs: <B as Backend>::QuantizedTensorPrimitive, rhs: <B as Backend>::FloatElem, ) -> <B as Backend>::QuantizedTensorPrimitive

Computes the modulus of a tensor given a scalar.

fn q_matmul( lhs: <B as Backend>::QuantizedTensorPrimitive, rhs: <B as Backend>::QuantizedTensorPrimitive, ) -> <B as Backend>::QuantizedTensorPrimitive

Multiplies two tensors together using matrix multiplication.

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

Negates a tensor element-wise.

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

Calculates the reciprocals element-wise

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

Transposes a tensor.

fn q_scatter( dim: usize, tensor: <B as Backend>::QuantizedTensorPrimitive, indices: <B as Backend>::IntTensorPrimitive, value: <B as Backend>::QuantizedTensorPrimitive, ) -> <B as Backend>::QuantizedTensorPrimitive

Scatter elements into a tensor.

fn q_select_assign( tensor: <B as Backend>::QuantizedTensorPrimitive, dim: usize, indices: <B as Backend>::IntTensorPrimitive, value: <B as Backend>::QuantizedTensorPrimitive, ) -> <B as Backend>::QuantizedTensorPrimitive

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

fn q_slice_assign( tensor: <B as Backend>::QuantizedTensorPrimitive, ranges: &[Range<usize>], value: <B as Backend>::QuantizedTensorPrimitive, ) -> <B as Backend>::QuantizedTensorPrimitive

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

fn q_mask_where( tensor: <B as Backend>::QuantizedTensorPrimitive, mask: <B as Backend>::BoolTensorPrimitive, value: <B as Backend>::QuantizedTensorPrimitive, ) -> <B as Backend>::QuantizedTensorPrimitive

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

fn q_mask_fill( tensor: <B as Backend>::QuantizedTensorPrimitive, mask: <B as Backend>::BoolTensorPrimitive, value: <B as Backend>::FloatElem, ) -> <B as Backend>::QuantizedTensorPrimitive

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

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

Sum of all elements in a tensor.

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

Sum of all elements in a tensor along a dimension.

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

Product of all elements in a tensor.

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

Product of all elements in a tensor along a dimension.

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

Mean of all elements in a tensor.

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

Mean of all elements in a tensor along a dimension.

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

Returns a new tensor with exponential values.

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

Returns a new tensor with natural logarithm values.

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

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

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

Element-wise power with another tensor.

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

Element-wise power with an IntTensor.

fn q_powi_scalar( lhs: <B as Backend>::QuantizedTensorPrimitive, rhs: <B as Backend>::IntElem, ) -> <B as Backend>::QuantizedTensorPrimitive

Element-wise power with an int scalar.

fn q_powf_scalar( tensor: <B as Backend>::QuantizedTensorPrimitive, value: f32, ) -> <B as Backend>::QuantizedTensorPrimitive

Element-wise power with a float scalar.

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

Returns a new tensor with square root values.

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

Returns a new tensor with absolute values.

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

Returns a new tensor with cosine values.

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

Returns a new tensor with sine values.

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

Returns a new tensor with tangent values.

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

Returns a new tensor with the error function values.

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

Concatenates tensors along a dimension.

fn q_argmax( tensor: <B as Backend>::QuantizedTensorPrimitive, dim: usize, ) -> <B as Backend>::IntTensorPrimitive

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

fn q_argmin( tensor: <B as Backend>::QuantizedTensorPrimitive, dim: usize, ) -> <B as Backend>::IntTensorPrimitive

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

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

Gets the maximum element of a tensor.

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

Gets the maximum elements of a tensor along an axis.

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

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

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

Gets the minimum element of a tensor.

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

Gets the minimum elements of a tensor along an axis.

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

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

fn q_narrow( tensor: <B as Backend>::QuantizedTensorPrimitive, dim: usize, start: usize, length: usize, ) -> <B as Backend>::QuantizedTensorPrimitive

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

fn q_chunk( tensor: <B as Backend>::QuantizedTensorPrimitive, chunks: usize, dim: usize, ) -> Vec<<B as Backend>::QuantizedTensorPrimitive>

Split the tensor along the given dimension into chunks.

fn q_any( tensor: <B as Backend>::QuantizedTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

Tests if any element in the tensor evaluates to True.

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

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

fn q_all( tensor: <B as Backend>::QuantizedTensorPrimitive, ) -> <B as Backend>::BoolTensorPrimitive

Tests if all elements in the tensor evaluate to True.

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

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

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

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

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

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

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

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

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( handle: TensorHandle<<JitBackend<R, F, I> as ReprBackend>::Handle>, ) -> <JitBackend<R, F, I> as Backend>::FloatTensorPrimitive

Convert a handle to a float tensor.

fn int_tensor( handle: TensorHandle<<JitBackend<R, F, I> as ReprBackend>::Handle>, ) -> <JitBackend<R, F, I> as Backend>::IntTensorPrimitive

Convert a handle to an int tensor.

fn bool_tensor( handle: TensorHandle<<JitBackend<R, F, I> as ReprBackend>::Handle>, ) -> <JitBackend<R, F, I> as Backend>::BoolTensorPrimitive

Convert a handle to a bool tensor.

fn quantized_tensor( handles: QuantizedKind<TensorHandle<<JitBackend<R, F, I> as ReprBackend>::Handle>>, scheme: QuantizationScheme, ) -> <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive

Convert a handle to a quantized tensor.

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

Convert a float tensor to a handle.

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

Convert an int tensor to a handle.

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

Convert a bool tensor to a handle.

fn quantized_tensor_handle( tensor: <JitBackend<R, F, I> as Backend>::QuantizedTensorPrimitive, ) -> QuantizedKind<<JitBackend<R, F, I> as ReprBackend>::Handle>

Convert a quantized tensor to a handle. A quantized tensor has multiple handles for the tensor itself and the quantization parameters.