Struct MpsGraph 

pub struct MpsGraph;

Apple MPSGraph backend for Burn.

Trait Implementations

impl ActivationOps<MpsGraph> for MpsGraph

fn leaky_relu( tensor: <B as Backend>::FloatTensorPrimitive, negative_slope: Scalar, ) -> <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: Scalar, beta: Scalar, ) -> <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 Backend for MpsGraph

type Device = MpsGraphDevice

Device type.

type FloatTensorPrimitive = MpsGraphTensor

Tensor primitive to be used for all float operations.

type FloatElem = f32

Default float element type.

type IntTensorPrimitive = MpsGraphTensor

Tensor primitive to be used for all int operations.

type IntElem = i32

Int element type.

type BoolTensorPrimitive = MpsGraphTensor

Tensor primitive to be used for all bool operations.

type BoolElem = bool

Tensor primitive to be used for all bool operations.

type QuantizedTensorPrimitive = MpsGraphQTensor

Tensor primitive to be used for all quantized operations.

fn name(_device: &Self::Device) -> String

Name of the backend.

fn seed(_device: &Self::Device, seed: u64)

Seeds the backend on the specified device.

fn dtype_usage(_device: &Self::Device, dtype: DType) -> DTypeUsageSet

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

fn ad_enabled(_device: &Self::Device) -> bool

If autodiff is enabled.

fn memory_persistent_allocations<Output, Input, Func>( device: &Self::Device, input: Input, func: Func, ) -> Output

where Func: Fn(Input) -> Output,

Sets the current allocation mode to persistent.

fn memory_cleanup(device: &Self::Device)

Manually triggers a memory cleanup on the given device.

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

Sync the backend, ensure that all computation are finished.

fn staging<'a, Iter>(_data: Iter, _device: &Self::Device)

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

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

fn supports_dtype(device: &Self::Device, dtype: DType) -> bool

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

impl BoolTensorOps<MpsGraph> for MpsGraph

fn bool_empty(shape: Shape, device: &Device<MpsGraph>) -> BoolTensor<MpsGraph>

Creates a new bool tensor.

fn bool_zeros(shape: Shape, device: &Device<MpsGraph>) -> BoolTensor<MpsGraph>

Creates a new bool tensor filled false.

fn bool_ones(shape: Shape, device: &Device<MpsGraph>) -> BoolTensor<MpsGraph>

Creates a new bool tensor filled true.

fn bool_into_data( t: BoolTensor<MpsGraph>, ) -> impl Future<Output = Result<TensorData, ExecutionError>> + Send

Converts the tensor to a data structure.

fn bool_from_data( data: TensorData, device: &Device<MpsGraph>, ) -> BoolTensor<MpsGraph>

Creates a tensor from the data structure.

fn bool_into_int(t: BoolTensor<MpsGraph>) -> IntTensor<MpsGraph>

Converts bool tensor to int tensor.

fn bool_into_float(t: BoolTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Converts bool tensor to float tensor.

fn bool_device(t: &BoolTensor<MpsGraph>) -> Device<MpsGraph>

Gets the device of the tensor.

fn bool_to_device( t: BoolTensor<MpsGraph>, d: &Device<MpsGraph>, ) -> BoolTensor<MpsGraph>

Moves the tensor to the device.

fn bool_reshape(t: BoolTensor<MpsGraph>, shape: Shape) -> BoolTensor<MpsGraph>

Reshapes the tensor.

fn bool_slice(t: BoolTensor<MpsGraph>, slices: &[Slice]) -> BoolTensor<MpsGraph>

Gets the values from the tensor for the given ranges.

fn bool_slice_assign( t: BoolTensor<MpsGraph>, slices: &[Slice], v: BoolTensor<MpsGraph>, ) -> BoolTensor<MpsGraph>

Sets the values in the tensor for the given ranges.

fn bool_mask_where( t: BoolTensor<MpsGraph>, m: BoolTensor<MpsGraph>, v: BoolTensor<MpsGraph>, ) -> BoolTensor<MpsGraph>

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

fn bool_mask_fill( t: BoolTensor<MpsGraph>, m: BoolTensor<MpsGraph>, v: Scalar, ) -> BoolTensor<MpsGraph>

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

fn bool_gather( dim: usize, t: BoolTensor<MpsGraph>, idx: IntTensor<MpsGraph>, ) -> BoolTensor<MpsGraph>

Gather elements from the tensor at the given indices.

fn bool_scatter_or( dim: usize, t: BoolTensor<MpsGraph>, idx: IntTensor<MpsGraph>, v: BoolTensor<MpsGraph>, ) -> BoolTensor<MpsGraph>

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

fn bool_equal( a: BoolTensor<MpsGraph>, b: BoolTensor<MpsGraph>, ) -> BoolTensor<MpsGraph>

Equates the two tensors.

fn bool_equal_elem(t: BoolTensor<MpsGraph>, v: Scalar) -> BoolTensor<MpsGraph>

Element-wise equality comparison with a scalar.

fn bool_not(t: BoolTensor<MpsGraph>) -> BoolTensor<MpsGraph>

Inverses boolean values.

fn bool_and( a: BoolTensor<MpsGraph>, b: BoolTensor<MpsGraph>, ) -> BoolTensor<MpsGraph>

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

fn bool_or( a: BoolTensor<MpsGraph>, b: BoolTensor<MpsGraph>, ) -> BoolTensor<MpsGraph>

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

fn bool_swap_dims( t: BoolTensor<MpsGraph>, d1: usize, d2: usize, ) -> BoolTensor<MpsGraph>

Swaps two dimensions of a bool tensor.

fn bool_permute(t: BoolTensor<MpsGraph>, axes: &[usize]) -> BoolTensor<MpsGraph>

Permutes the dimensions of a tensor.

fn bool_flip(t: BoolTensor<MpsGraph>, axes: &[usize]) -> BoolTensor<MpsGraph>

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

fn bool_expand(t: BoolTensor<MpsGraph>, shape: Shape) -> BoolTensor<MpsGraph>

Broadcasts the bool tensor to the given shape.

fn bool_cat( tensors: Vec<BoolTensor<MpsGraph>>, dim: usize, ) -> BoolTensor<MpsGraph>

Concatenates the tensors along the given dimension.

fn bool_unfold( t: BoolTensor<MpsGraph>, dim: usize, size: usize, step: usize, ) -> BoolTensor<MpsGraph>

Unfold windows along a dimension.

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

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

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

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

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

Repeats one dimension of the tensor a given number of times along that 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_not_equal_elem( lhs: <B as Backend>::BoolTensorPrimitive, rhs: Scalar, ) -> <B as Backend>::BoolTensorPrimitive

Element-wise non-equality comparison with a scalar.

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

Element-wise exclusive or.

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

Transposes a bool tensor.

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 + 'static

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

impl Clone for MpsGraph

fn clone(&self) -> MpsGraph

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MpsGraph

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

Formats the value using the given formatter.

impl Default for MpsGraph

fn default() -> MpsGraph

Returns the “default value” for a type.

impl FloatTensorOps<MpsGraph> for MpsGraph

fn float_from_data( data: TensorData, device: &Device<MpsGraph>, ) -> FloatTensor<MpsGraph>

Creates a new tensor from the data structure.

fn float_random( shape: Shape, distribution: Distribution, device: &Device<MpsGraph>, ) -> FloatTensor<MpsGraph>

Creates a new tensor with random values.

fn float_into_data( t: FloatTensor<MpsGraph>, ) -> impl Future<Output = Result<TensorData, ExecutionError>> + Send

Converts the tensor to a data structure.

fn float_device(t: &FloatTensor<MpsGraph>) -> Device<MpsGraph>

Gets the device of the tensor.

fn float_to_device( t: FloatTensor<MpsGraph>, device: &Device<MpsGraph>, ) -> FloatTensor<MpsGraph>

Moves the tensor to the given device.

fn float_into_int(t: FloatTensor<MpsGraph>) -> IntTensor<MpsGraph>

Converts float tensor to int tensor.

fn float_empty( shape: Shape, device: &Device<MpsGraph>, dtype: FloatDType, ) -> FloatTensor<MpsGraph>

Creates an empty tensor with the given shape.

fn float_add( lhs: FloatTensor<MpsGraph>, rhs: FloatTensor<MpsGraph>, ) -> FloatTensor<MpsGraph>

Adds two tensors together.

fn float_add_scalar( lhs: FloatTensor<MpsGraph>, rhs: Scalar, ) -> FloatTensor<MpsGraph>

Adds a scalar to a tensor.

fn float_sub( lhs: FloatTensor<MpsGraph>, rhs: FloatTensor<MpsGraph>, ) -> FloatTensor<MpsGraph>

Subtracts two tensors.

fn float_sub_scalar( lhs: FloatTensor<MpsGraph>, rhs: Scalar, ) -> FloatTensor<MpsGraph>

Subtracts a scalar from a tensor.

fn float_mul( lhs: FloatTensor<MpsGraph>, rhs: FloatTensor<MpsGraph>, ) -> FloatTensor<MpsGraph>

Multiplies two tensors together element-wise.

fn float_mul_scalar( lhs: FloatTensor<MpsGraph>, rhs: Scalar, ) -> FloatTensor<MpsGraph>

Multiplies a tensor by a scalar.

fn float_div( lhs: FloatTensor<MpsGraph>, rhs: FloatTensor<MpsGraph>, ) -> FloatTensor<MpsGraph>

Divides two tensors element-wise.

fn float_div_scalar( lhs: FloatTensor<MpsGraph>, rhs: Scalar, ) -> FloatTensor<MpsGraph>

Divides a tensor by a scalar.

fn float_remainder( lhs: FloatTensor<MpsGraph>, rhs: FloatTensor<MpsGraph>, ) -> FloatTensor<MpsGraph>

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

fn float_remainder_scalar( lhs: FloatTensor<MpsGraph>, rhs: Scalar, ) -> FloatTensor<MpsGraph>

Computes the modulus of a tensor given a scalar.

fn float_powf( lhs: FloatTensor<MpsGraph>, rhs: FloatTensor<MpsGraph>, ) -> FloatTensor<MpsGraph>

Element-wise power with a FloatTensor.

fn float_powf_scalar_impl( t: FloatTensor<MpsGraph>, v: Scalar, ) -> FloatTensor<MpsGraph>

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

fn float_matmul( a: FloatTensor<MpsGraph>, b: FloatTensor<MpsGraph>, ) -> FloatTensor<MpsGraph>

Multiplies two tensors together using matrix multiplication.

fn float_recip(t: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Calculates the reciprocals element-wise

fn float_cross( lhs: FloatTensor<MpsGraph>, rhs: FloatTensor<MpsGraph>, dim: usize, ) -> FloatTensor<MpsGraph>

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

fn float_equal( lhs: FloatTensor<MpsGraph>, rhs: FloatTensor<MpsGraph>, ) -> BoolTensor<MpsGraph>

Equal comparison of two tensors.

fn float_equal_elem( lhs: FloatTensor<MpsGraph>, rhs: Scalar, ) -> BoolTensor<MpsGraph>

Equal comparison of a tensor and a scalar.

fn float_greater( lhs: FloatTensor<MpsGraph>, rhs: FloatTensor<MpsGraph>, ) -> BoolTensor<MpsGraph>

Greater than comparison of two tensors.

fn float_greater_elem( lhs: FloatTensor<MpsGraph>, rhs: Scalar, ) -> BoolTensor<MpsGraph>

Greater than comparison of a tensor and a scalar.

fn float_greater_equal( lhs: FloatTensor<MpsGraph>, rhs: FloatTensor<MpsGraph>, ) -> BoolTensor<MpsGraph>

Greater than or equal comparison of two tensors.

fn float_greater_equal_elem( lhs: FloatTensor<MpsGraph>, rhs: Scalar, ) -> BoolTensor<MpsGraph>

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

fn float_lower( lhs: FloatTensor<MpsGraph>, rhs: FloatTensor<MpsGraph>, ) -> BoolTensor<MpsGraph>

Less than comparison of two tensors.

fn float_lower_elem( lhs: FloatTensor<MpsGraph>, rhs: Scalar, ) -> BoolTensor<MpsGraph>

Less than comparison of a tensor and a scalar.

fn float_lower_equal( lhs: FloatTensor<MpsGraph>, rhs: FloatTensor<MpsGraph>, ) -> BoolTensor<MpsGraph>

Less than or equal comparison of two tensors.

fn float_lower_equal_elem( lhs: FloatTensor<MpsGraph>, rhs: Scalar, ) -> BoolTensor<MpsGraph>

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

fn float_exp(tensor: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Returns a new tensor with exponential values.

fn float_log(tensor: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Returns a new tensor with natural logarithm values.

fn float_sqrt(tensor: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Returns a new tensor with square root values.

fn float_abs(tensor: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Returns a new tensor with absolute values.

fn float_cos(tensor: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Returns a new tensor with cosine values.

fn float_sin(tensor: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Returns a new tensor with sine values.

fn float_tan(tensor: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Returns a new tensor with tangent values.

fn float_cosh(tensor: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Returns a new tensor with hyperbolic cosine values.

fn float_sinh(tensor: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Returns a new tensor with hyperbolic sine values.

fn float_tanh(tensor: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Returns a new tensor with hyperbolic tangent values.

fn float_acos(tensor: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Returns a new tensor with inverse cosine values.

fn float_acosh(tensor: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Returns a new tensor with inverse hyperbolic cosine values.

fn float_asin(tensor: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Returns a new tensor with inverse sine values.

fn float_asinh(tensor: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Returns a new tensor with inverse hyperbolic sine values.

fn float_atan(tensor: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Returns a new tensor with the inverse tangent values.

fn float_atanh(tensor: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Returns a new tensor with the inverse hyperbolic tangent values.

fn float_erf(tensor: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Returns a new tensor with the error function values.

fn float_floor(tensor: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Returns a new tensor with floored values.

fn float_ceil(tensor: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Returns a new tensor with ceiled values.

fn float_round(tensor: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Returns a new tensor with rounded values.

fn float_atan2( lhs: FloatTensor<MpsGraph>, rhs: FloatTensor<MpsGraph>, ) -> FloatTensor<MpsGraph>

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

fn float_log1p(t: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

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

fn float_trunc(t: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Returns a new tensor with truncated values.

fn float_swap_dims( t: FloatTensor<MpsGraph>, d1: usize, d2: usize, ) -> FloatTensor<MpsGraph>

Swaps two dimensions of a tensor.

fn float_permute( t: FloatTensor<MpsGraph>, axes: &[usize], ) -> FloatTensor<MpsGraph>

Permutes the dimensions of a tensor.

fn float_flip(t: FloatTensor<MpsGraph>, axes: &[usize]) -> FloatTensor<MpsGraph>

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

fn float_reshape( t: FloatTensor<MpsGraph>, shape: Shape, ) -> FloatTensor<MpsGraph>

Reshapes a tensor.

fn float_expand(t: FloatTensor<MpsGraph>, shape: Shape) -> FloatTensor<MpsGraph>

Broadcasts the float tensor to the given shape.

fn float_slice( t: FloatTensor<MpsGraph>, slices: &[Slice], ) -> FloatTensor<MpsGraph>

Select tensor elements corresponding to the given slices.

fn float_slice_assign( t: FloatTensor<MpsGraph>, slices: &[Slice], value: FloatTensor<MpsGraph>, ) -> FloatTensor<MpsGraph>

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

fn float_cat( tensors: Vec<FloatTensor<MpsGraph>>, dim: usize, ) -> FloatTensor<MpsGraph>

Concatenates tensors along a dimension.

fn float_gather( dim: usize, t: FloatTensor<MpsGraph>, idx: IntTensor<MpsGraph>, ) -> FloatTensor<MpsGraph>

Gather elements from a tensor.

fn float_scatter_add( dim: usize, t: FloatTensor<MpsGraph>, idx: IntTensor<MpsGraph>, val: FloatTensor<MpsGraph>, ) -> FloatTensor<MpsGraph>

Scatter elements into a tensor using sum reduction.

fn float_select( t: FloatTensor<MpsGraph>, dim: usize, idx: IntTensor<MpsGraph>, ) -> FloatTensor<MpsGraph>

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

fn float_select_add( t: FloatTensor<MpsGraph>, dim: usize, idx: IntTensor<MpsGraph>, val: FloatTensor<MpsGraph>, ) -> FloatTensor<MpsGraph>

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

fn float_mask_where( t: FloatTensor<MpsGraph>, mask: BoolTensor<MpsGraph>, val: FloatTensor<MpsGraph>, ) -> FloatTensor<MpsGraph>

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

fn float_mask_fill( t: FloatTensor<MpsGraph>, mask: BoolTensor<MpsGraph>, val: Scalar, ) -> FloatTensor<MpsGraph>

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

fn float_sum(t: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Sum of all elements in a tensor.

fn float_sum_dim(t: FloatTensor<MpsGraph>, dim: usize) -> FloatTensor<MpsGraph>

Sum of all elements in a tensor along a dimension.

fn float_mean_dim(t: FloatTensor<MpsGraph>, dim: usize) -> FloatTensor<MpsGraph>

Mean of all elements in a tensor along a dimension.

fn float_argmax(t: FloatTensor<MpsGraph>, dim: usize) -> IntTensor<MpsGraph>

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

fn float_argmin(t: FloatTensor<MpsGraph>, dim: usize) -> IntTensor<MpsGraph>

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

fn float_cumsum(t: FloatTensor<MpsGraph>, dim: usize) -> FloatTensor<MpsGraph>

Computes the cumulative sum of elements along a dimension.

fn float_cumprod(t: FloatTensor<MpsGraph>, dim: usize) -> FloatTensor<MpsGraph>

Computes the cumulative product of elements along a dimension.

fn float_cummin(t: FloatTensor<MpsGraph>, dim: usize) -> FloatTensor<MpsGraph>

Computes the cumulative minimum of elements along a dimension.

fn float_cummax(t: FloatTensor<MpsGraph>, dim: usize) -> FloatTensor<MpsGraph>

Computes the cumulative maximum of elements along a dimension.

fn float_sort( t: FloatTensor<MpsGraph>, dim: usize, desc: bool, ) -> FloatTensor<MpsGraph>

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

fn float_argsort( t: FloatTensor<MpsGraph>, dim: usize, desc: bool, ) -> IntTensor<MpsGraph>

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

fn float_cast( t: FloatTensor<MpsGraph>, dtype: FloatDType, ) -> FloatTensor<MpsGraph>

Converts a tensor to another floating point data type.

fn float_prod(t: FloatTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Product of all elements in a tensor.

fn float_prod_dim(t: FloatTensor<MpsGraph>, dim: usize) -> FloatTensor<MpsGraph>

Product of all elements in a tensor along a dimension.

fn float_max_dim(t: FloatTensor<MpsGraph>, dim: usize) -> FloatTensor<MpsGraph>

Gets the maximum elements of a tensor along an axis.

fn float_min_dim(t: FloatTensor<MpsGraph>, dim: usize) -> FloatTensor<MpsGraph>

Gets the minimum elements of a tensor along an axis.

fn float_unfold( t: FloatTensor<MpsGraph>, dim: usize, size: usize, step: usize, ) -> FloatTensor<MpsGraph>

Unfold windows along a dimension.

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

Creates a new tensor with zeros.

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

Creates a new tensor with ones.

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

Creates a tensor filled with given value.

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

Repeat the tensor along the given dimension.

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

Clamps a tensor under a minimum value.

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

Clamps a tensor over a maximum value.

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

Clamps a tensor between a minimum and 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: Scalar, ) -> <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_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: Scalar, ) -> <B as Backend>::FloatTensorPrimitive

Raises a tensor to the power of an int scalar.

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

Raises a tensor to the power of an int scalar.

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

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

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

Gets the maximum element of a tensor.

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

Gets the maximum absolute element of a tensor.

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

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

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_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_grid_sample_2d( tensor: <B as Backend>::FloatTensorPrimitive, grid: <B as Backend>::FloatTensorPrimitive, options: GridSampleOptions, ) -> <B as Backend>::FloatTensorPrimitive

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

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

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

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

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

impl IntTensorOps<MpsGraph> for MpsGraph

fn int_empty( shape: Shape, device: &Device<MpsGraph>, dtype: IntDType, ) -> IntTensor<MpsGraph>

Creates a new int tensor.

fn int_into_data( t: IntTensor<MpsGraph>, ) -> impl Future<Output = Result<TensorData, ExecutionError>> + Send

Converts the tensor to a data structure.

fn int_from_data( data: TensorData, device: &Device<MpsGraph>, ) -> IntTensor<MpsGraph>

Creates a tensor from the data structure.

fn int_device(t: &IntTensor<MpsGraph>) -> Device<MpsGraph>

Gets the device of the tensor.

fn int_to_device( t: IntTensor<MpsGraph>, d: &Device<MpsGraph>, ) -> IntTensor<MpsGraph>

Moves the tensor to the given device.

fn int_reshape(t: IntTensor<MpsGraph>, shape: Shape) -> IntTensor<MpsGraph>

Reshapes the tensor.

fn int_slice(t: IntTensor<MpsGraph>, slices: &[Slice]) -> IntTensor<MpsGraph>

Gets the element at the given indices.

fn int_slice_assign( t: IntTensor<MpsGraph>, slices: &[Slice], v: IntTensor<MpsGraph>, ) -> IntTensor<MpsGraph>

Sets the values in the tensor for the given ranges.

fn int_into_float(t: IntTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Converts int tensor to float tensor.

fn int_mask_where( t: IntTensor<MpsGraph>, m: BoolTensor<MpsGraph>, v: IntTensor<MpsGraph>, ) -> IntTensor<MpsGraph>

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

fn int_mask_fill( t: IntTensor<MpsGraph>, m: BoolTensor<MpsGraph>, v: Scalar, ) -> IntTensor<MpsGraph>

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

fn int_gather( dim: usize, t: IntTensor<MpsGraph>, idx: IntTensor<MpsGraph>, ) -> IntTensor<MpsGraph>

Gather elements from the tensor at the given indices.

fn int_scatter_add( dim: usize, t: IntTensor<MpsGraph>, idx: IntTensor<MpsGraph>, v: IntTensor<MpsGraph>, ) -> IntTensor<MpsGraph>

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

fn int_select( t: IntTensor<MpsGraph>, dim: usize, idx: IntTensor<MpsGraph>, ) -> IntTensor<MpsGraph>

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

fn int_select_add( t: IntTensor<MpsGraph>, dim: usize, idx: IntTensor<MpsGraph>, v: IntTensor<MpsGraph>, ) -> IntTensor<MpsGraph>

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

fn int_equal( a: IntTensor<MpsGraph>, b: IntTensor<MpsGraph>, ) -> BoolTensor<MpsGraph>

Element-wise equality comparison.

fn int_equal_elem(a: IntTensor<MpsGraph>, b: Scalar) -> BoolTensor<MpsGraph>

Element-wise equality comparison with a scalar.

fn int_greater( a: IntTensor<MpsGraph>, b: IntTensor<MpsGraph>, ) -> BoolTensor<MpsGraph>

Element-wise greater than comparison.

fn int_greater_elem(a: IntTensor<MpsGraph>, b: Scalar) -> BoolTensor<MpsGraph>

Element-wise greater than comparison with a scalar.

fn int_greater_equal( a: IntTensor<MpsGraph>, b: IntTensor<MpsGraph>, ) -> BoolTensor<MpsGraph>

Element-wise greater than or equal comparison.

fn int_greater_equal_elem( a: IntTensor<MpsGraph>, b: Scalar, ) -> BoolTensor<MpsGraph>

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

fn int_lower( a: IntTensor<MpsGraph>, b: IntTensor<MpsGraph>, ) -> BoolTensor<MpsGraph>

Element-wise less than comparison.

fn int_lower_elem(a: IntTensor<MpsGraph>, b: Scalar) -> BoolTensor<MpsGraph>

Element-wise less than comparison with a scalar.

fn int_lower_equal( a: IntTensor<MpsGraph>, b: IntTensor<MpsGraph>, ) -> BoolTensor<MpsGraph>

Element-wise less than or equal comparison.

fn int_lower_equal_elem( a: IntTensor<MpsGraph>, b: Scalar, ) -> BoolTensor<MpsGraph>

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

fn int_add( a: IntTensor<MpsGraph>, b: IntTensor<MpsGraph>, ) -> IntTensor<MpsGraph>

Element-wise addition.

fn int_add_scalar(a: IntTensor<MpsGraph>, b: Scalar) -> IntTensor<MpsGraph>

Element-wise addition with a scalar.

fn int_sub( a: IntTensor<MpsGraph>, b: IntTensor<MpsGraph>, ) -> IntTensor<MpsGraph>

Element-wise subtraction.

fn int_sub_scalar(a: IntTensor<MpsGraph>, b: Scalar) -> IntTensor<MpsGraph>

Element-wise subtraction with a scalar.

fn int_mul( a: IntTensor<MpsGraph>, b: IntTensor<MpsGraph>, ) -> IntTensor<MpsGraph>

Element-wise multiplication.

fn int_mul_scalar(a: IntTensor<MpsGraph>, b: Scalar) -> IntTensor<MpsGraph>

Element-wise multiplication with a scalar.

fn int_div( a: IntTensor<MpsGraph>, b: IntTensor<MpsGraph>, ) -> IntTensor<MpsGraph>

Element-wise division.

fn int_div_scalar(a: IntTensor<MpsGraph>, b: Scalar) -> IntTensor<MpsGraph>

Element-wise division with a scalar.

fn int_remainder( a: IntTensor<MpsGraph>, b: IntTensor<MpsGraph>, ) -> IntTensor<MpsGraph>

Element-wise modulus.

fn int_remainder_scalar( a: IntTensor<MpsGraph>, b: Scalar, ) -> IntTensor<MpsGraph>

Element-wise modulus with a scalar.

fn int_matmul( a: IntTensor<MpsGraph>, b: IntTensor<MpsGraph>, ) -> IntTensor<MpsGraph>

Multiplies two tensors together using matrix multiplication.

fn int_neg(t: IntTensor<MpsGraph>) -> IntTensor<MpsGraph>

Element-wise negation.

fn int_abs(t: IntTensor<MpsGraph>) -> IntTensor<MpsGraph>

Returns a new tensor with absolute values.

fn int_swap_dims( t: IntTensor<MpsGraph>, d1: usize, d2: usize, ) -> IntTensor<MpsGraph>

Swaps two dimensions of an int tensor.

fn int_permute(t: IntTensor<MpsGraph>, axes: &[usize]) -> IntTensor<MpsGraph>

Permutes the dimensions of a tensor.

fn int_flip(t: IntTensor<MpsGraph>, axes: &[usize]) -> IntTensor<MpsGraph>

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

fn int_expand(t: IntTensor<MpsGraph>, shape: Shape) -> IntTensor<MpsGraph>

Broadcasts the int tensor to the given shape.

fn int_sum(t: IntTensor<MpsGraph>) -> IntTensor<MpsGraph>

Sums all elements in the tensor.

fn int_sum_dim(t: IntTensor<MpsGraph>, dim: usize) -> IntTensor<MpsGraph>

Sums all elements in the tensor along a dimension.

fn int_prod(t: IntTensor<MpsGraph>) -> IntTensor<MpsGraph>

Computes the product of all elements in the tensor.

fn int_prod_dim(t: IntTensor<MpsGraph>, dim: usize) -> IntTensor<MpsGraph>

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

fn int_mean_dim(t: IntTensor<MpsGraph>, dim: usize) -> IntTensor<MpsGraph>

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

fn int_cumsum(t: IntTensor<MpsGraph>, d: usize) -> IntTensor<MpsGraph>

Computes the cumulative sum of elements along a dimension.

fn int_cumprod(t: IntTensor<MpsGraph>, d: usize) -> IntTensor<MpsGraph>

Computes the cumulative product of elements along a dimension.

fn int_cummin(t: IntTensor<MpsGraph>, d: usize) -> IntTensor<MpsGraph>

Computes the cumulative minimum of elements along a dimension.

fn int_cummax(t: IntTensor<MpsGraph>, d: usize) -> IntTensor<MpsGraph>

Computes the cumulative maximum of elements along a dimension.

fn int_argmax(t: IntTensor<MpsGraph>, dim: usize) -> IntTensor<MpsGraph>

Gets the indices of the maximum elements along a dimension.

fn int_argmin(t: IntTensor<MpsGraph>, dim: usize) -> IntTensor<MpsGraph>

Gets the indices of the minimum elements along a dimension.

fn int_random( shape: Shape, dist: Distribution, device: &Device<MpsGraph>, ) -> IntTensor<MpsGraph>

Creates a new int tensor with random values.

fn int_sort( t: IntTensor<MpsGraph>, dim: usize, desc: bool, ) -> IntTensor<MpsGraph>

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

fn int_argsort( t: IntTensor<MpsGraph>, dim: usize, desc: bool, ) -> IntTensor<MpsGraph>

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

fn bitwise_and( a: IntTensor<MpsGraph>, b: IntTensor<MpsGraph>, ) -> IntTensor<MpsGraph>

Bitwise AND operation for Int Tensors

fn bitwise_and_scalar(a: IntTensor<MpsGraph>, b: Scalar) -> IntTensor<MpsGraph>

Bitwise AND operation for Int Tensors with a scalar

fn bitwise_or( a: IntTensor<MpsGraph>, b: IntTensor<MpsGraph>, ) -> IntTensor<MpsGraph>

Bitwise OR operation for Int Tensors

fn bitwise_or_scalar(a: IntTensor<MpsGraph>, b: Scalar) -> IntTensor<MpsGraph>

Bitwise OR operation for Int Tensors with a scalar

fn bitwise_xor( a: IntTensor<MpsGraph>, b: IntTensor<MpsGraph>, ) -> IntTensor<MpsGraph>

Bitwise XOR operation for Int Tensors

fn bitwise_xor_scalar(a: IntTensor<MpsGraph>, b: Scalar) -> IntTensor<MpsGraph>

Bitwise XOR operation for Int Tensors with a scalar

fn bitwise_not(t: IntTensor<MpsGraph>) -> IntTensor<MpsGraph>

Bitwise NOT operation for Int Tensors

fn bitwise_left_shift( a: IntTensor<MpsGraph>, b: IntTensor<MpsGraph>, ) -> IntTensor<MpsGraph>

Bitwise left shift operation for Int Tensors

fn bitwise_left_shift_scalar( a: IntTensor<MpsGraph>, b: Scalar, ) -> IntTensor<MpsGraph>

Bitwise left shift operation for Int Tensors with a scalar

fn bitwise_right_shift( a: IntTensor<MpsGraph>, b: IntTensor<MpsGraph>, ) -> IntTensor<MpsGraph>

Bitwise right shift operation for Int Tensors

fn bitwise_right_shift_scalar( a: IntTensor<MpsGraph>, b: Scalar, ) -> IntTensor<MpsGraph>

Bitwise right shift operation for Int Tensors with a scalar

fn int_unfold( t: IntTensor<MpsGraph>, dim: usize, size: usize, step: usize, ) -> IntTensor<MpsGraph>

Unfold windows along a dimension.

fn int_cat(tensors: Vec<IntTensor<MpsGraph>>, dim: usize) -> IntTensor<MpsGraph>

Concatenates the given tensors along the given dimension.

fn int_cast(t: IntTensor<MpsGraph>, dtype: IntDType) -> IntTensor<MpsGraph>

Converts a tensor to another integer data type.

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

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

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: Scalar, ) -> <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: Scalar, ) -> <B as Backend>::IntTensorPrimitive

Element-wise power with a scalar.

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

Element-wise power with a scalar.

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

Element-wise power with a floatTensor.

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

Element-wise power with a floatTensor.

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

Clamps a tensor under a minimum value.

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

Clamps a tensor over a maximum value.

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

Clamps a tensor between a minimum and maximum value.

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

Creates a tensor of zeros.

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

Creates a tensor of ones.

fn int_full( shape: Shape, fill_value: Scalar, device: &<B as Backend>::Device, dtype: IntDType, ) -> <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_max_abs( tensor: <B as Backend>::IntTensorPrimitive, ) -> <B as Backend>::IntTensorPrimitive

Gets the maximum absolute element in the tensor.

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

Gets the maximum absolute element in the tensor 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_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_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.

impl ModuleOps<MpsGraph> for MpsGraph

fn embedding( w: FloatTensor<MpsGraph>, idx: IntTensor<MpsGraph>, ) -> FloatTensor<MpsGraph>

Embedding operation.

fn embedding_backward( w: FloatTensor<MpsGraph>, grad: FloatTensor<MpsGraph>, idx: IntTensor<MpsGraph>, ) -> FloatTensor<MpsGraph>

Embedding backward operation.

fn conv1d( x: FloatTensor<MpsGraph>, w: FloatTensor<MpsGraph>, b: Option<FloatTensor<MpsGraph>>, o: ConvOptions<1>, ) -> FloatTensor<MpsGraph>

One dimensional convolution.

fn conv2d( x: FloatTensor<MpsGraph>, w: FloatTensor<MpsGraph>, b: Option<FloatTensor<MpsGraph>>, o: ConvOptions<2>, ) -> FloatTensor<MpsGraph>

Two dimensional convolution.

fn conv3d( x: FloatTensor<MpsGraph>, w: FloatTensor<MpsGraph>, b: Option<FloatTensor<MpsGraph>>, o: ConvOptions<3>, ) -> FloatTensor<MpsGraph>

Three dimensional convolution.

fn deform_conv2d( x: FloatTensor<MpsGraph>, offset: FloatTensor<MpsGraph>, weight: FloatTensor<MpsGraph>, mask: Option<FloatTensor<MpsGraph>>, bias: Option<FloatTensor<MpsGraph>>, o: DeformConvOptions<2>, ) -> FloatTensor<MpsGraph>

Two dimensional deformable convolution.

fn deform_conv2d_backward( x: FloatTensor<MpsGraph>, offset: FloatTensor<MpsGraph>, weight: FloatTensor<MpsGraph>, mask: Option<FloatTensor<MpsGraph>>, bias: Option<FloatTensor<MpsGraph>>, output_grad: FloatTensor<MpsGraph>, _o: DeformConvOptions<2>, ) -> DeformConv2dBackward<MpsGraph>

Backward pass for the deform_conv2d operation.

fn conv_transpose1d( x: FloatTensor<MpsGraph>, w: FloatTensor<MpsGraph>, b: Option<FloatTensor<MpsGraph>>, o: ConvTransposeOptions<1>, ) -> FloatTensor<MpsGraph>

One dimensional transposed convolution.

fn conv_transpose2d( x: FloatTensor<MpsGraph>, w: FloatTensor<MpsGraph>, b: Option<FloatTensor<MpsGraph>>, o: ConvTransposeOptions<2>, ) -> FloatTensor<MpsGraph>

Two dimensional transposed convolution.

fn conv_transpose3d( x: FloatTensor<MpsGraph>, w: FloatTensor<MpsGraph>, b: Option<FloatTensor<MpsGraph>>, o: ConvTransposeOptions<3>, ) -> FloatTensor<MpsGraph>

Three dimensional transposed convolution.

fn avg_pool2d( x: FloatTensor<MpsGraph>, ks: [usize; 2], stride: [usize; 2], pad: [usize; 2], count_include_pad: bool, _ceil: bool, ) -> FloatTensor<MpsGraph>

Two dimensional avg pooling.

fn avg_pool2d_backward( x: FloatTensor<MpsGraph>, grad: FloatTensor<MpsGraph>, ks: [usize; 2], stride: [usize; 2], pad: [usize; 2], count_include_pad: bool, _ceil: bool, ) -> FloatTensor<MpsGraph>

Backward pass for the avg pooling 2d operation.

fn adaptive_avg_pool2d( x: FloatTensor<MpsGraph>, out: [usize; 2], ) -> FloatTensor<MpsGraph>

Two dimensional adaptive avg pooling.

fn adaptive_avg_pool2d_backward( x: FloatTensor<MpsGraph>, grad: FloatTensor<MpsGraph>, ) -> FloatTensor<MpsGraph>

Backward pass for the adaptive avg pooling 2d operation.

fn max_pool2d( x: FloatTensor<MpsGraph>, ks: [usize; 2], stride: [usize; 2], pad: [usize; 2], dil: [usize; 2], _ceil: bool, ) -> FloatTensor<MpsGraph>

Two dimensional max pooling.

fn max_pool2d_with_indices( x: FloatTensor<MpsGraph>, ks: [usize; 2], stride: [usize; 2], pad: [usize; 2], dil: [usize; 2], _ceil: bool, ) -> MaxPool2dWithIndices<MpsGraph>

Two dimensional max pooling with indices.

fn max_pool2d_with_indices_backward( x: FloatTensor<MpsGraph>, ks: [usize; 2], stride: [usize; 2], pad: [usize; 2], dil: [usize; 2], _ceil: bool, grad: FloatTensor<MpsGraph>, idx: IntTensor<MpsGraph>, ) -> MaxPool2dBackward<MpsGraph>

Backward pass for the max pooling 2d operation.

fn interpolate( x: FloatTensor<MpsGraph>, out_size: [usize; 2], opts: InterpolateOptions, ) -> FloatTensor<MpsGraph>

Down/up samples the input.

fn interpolate_backward( x: FloatTensor<MpsGraph>, grad: FloatTensor<MpsGraph>, _out_size: [usize; 2], opts: InterpolateOptions, ) -> FloatTensor<MpsGraph>

Backward pass for the interpolate operation.

fn attention( q: FloatTensor<MpsGraph>, k: FloatTensor<MpsGraph>, v: FloatTensor<MpsGraph>, mask: Option<BoolTensor<MpsGraph>>, _bias: Option<FloatTensor<MpsGraph>>, _opts: AttentionModuleOptions, ) -> FloatTensor<MpsGraph>

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

fn 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, 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, 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_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, ceil_mode: 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, ceil_mode: 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, ceil_mode: bool, ) -> <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, ceil_mode: bool, ) -> 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, ceil_mode: bool, output_grad: <B as Backend>::FloatTensorPrimitive, indices: <B as Backend>::IntTensorPrimitive, ) -> MaxPool1dBackward<B>

Backward pass for the max pooling 1d operation.

impl QTensorOps<MpsGraph> for MpsGraph

fn q_from_data( data: TensorData, device: &Device<MpsGraph>, ) -> QuantizedTensor<MpsGraph>

Creates a new tensor from the data structure.

fn quantize( tensor: FloatTensor<MpsGraph>, scheme: &QuantScheme, qparams: QuantizationParametersPrimitive<MpsGraph>, ) -> QuantizedTensor<MpsGraph>

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

fn dequantize(tensor: QuantizedTensor<MpsGraph>) -> FloatTensor<MpsGraph>

Convert the tensor back to a higher precision data type.

fn q_device(t: &QuantizedTensor<MpsGraph>) -> Device<MpsGraph>

Gets the device of the tensor.

fn q_to_device( t: QuantizedTensor<MpsGraph>, d: &Device<MpsGraph>, ) -> QuantizedTensor<MpsGraph>

Moves the tensor to the given device.

fn q_reshape( t: QuantizedTensor<MpsGraph>, shape: Shape, ) -> QuantizedTensor<MpsGraph>

Reshapes a tensor.

fn q_into_data( t: QuantizedTensor<MpsGraph>, ) -> impl Future<Output = Result<TensorData, ExecutionError>> + Send

Converts the tensor to a data structure.

fn q_swap_dims( t: QuantizedTensor<MpsGraph>, d1: usize, d2: usize, ) -> QuantizedTensor<MpsGraph>

Swaps two dimensions of a tensor.

fn q_permute( t: QuantizedTensor<MpsGraph>, axes: &[usize], ) -> QuantizedTensor<MpsGraph>

Permutes the dimensions of a tensor.

fn q_flip( t: QuantizedTensor<MpsGraph>, axes: &[usize], ) -> QuantizedTensor<MpsGraph>

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

fn q_select( t: QuantizedTensor<MpsGraph>, dim: usize, idx: IntTensor<MpsGraph>, ) -> QuantizedTensor<MpsGraph>

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

fn q_slice( t: QuantizedTensor<MpsGraph>, slices: &[Slice], ) -> QuantizedTensor<MpsGraph>

Select tensor elements corresponding to the given slices.

fn q_expand( t: QuantizedTensor<MpsGraph>, shape: Shape, ) -> QuantizedTensor<MpsGraph>

Broadcasts the tensor to the given shape.

fn quantize_dynamic( tensor: <B as Backend>::FloatTensorPrimitive, scheme: &QuantScheme, ) -> <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_transpose( tensor: <B as Backend>::QuantizedTensorPrimitive, ) -> <B as Backend>::QuantizedTensorPrimitive

Transposes a tensor.

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

Gather elements from 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, ) -> TensorPrimitive<B>

Adds two tensors together.

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

Adds a scalar to a tensor.

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

Clamps a tensor under a minimum value.

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

Clamps a tensor over a maximum value.

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

Clamps a tensor between a minimum and maximum value.

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

Subtracts two tensors.

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

Subtracts a scalar from a tensor.

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

Multiplies two tensors together element-wise.

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

Multiplies a tensor by a scalar.

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

Divides two tensors element-wise.

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

Divides a tensor by a scalar.

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

Multiplies two tensors together using matrix multiplication.

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

Negates a tensor element-wise.

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

Calculates the reciprocals element-wise

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

Sum of all elements in a tensor.

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

Sum of all elements in a tensor along a dimension.

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

Product of all elements in a tensor.

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

Product of all elements in a tensor along a dimension.

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

Mean of all elements in a tensor.

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

Mean of all elements in a tensor along a dimension.

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

Computes the cumulative sum of elements along a dimension.

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

Computes the cumulative product of elements along a dimension.

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

Computes the cumulative minimum of elements along a dimension.

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

Computes the cumulative maximum of elements along a dimension.

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

Returns a new tensor with exponential values.

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

Returns a new tensor with natural logarithm values.

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

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

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

Element-wise power with another tensor.

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

Element-wise power with an IntTensor.

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

Element-wise power with an int scalar.

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

Element-wise power with a float scalar.

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

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) -> TensorPrimitive<B>

Returns a new tensor with cosine values.

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

Returns a new tensor with sine values.

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

Returns a new tensor with tangent values.

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

Returns a new tensor with hyperbolic cosine values.

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

Returns a new tensor with hyperbolic sine values.

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

Returns a new tensor with hyperbolic tangent values.

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

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_max_abs( tensor: <B as Backend>::QuantizedTensorPrimitive, ) -> <B as Backend>::QuantizedTensorPrimitive

Gets the maximum element of a tensor.

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

Gets the maximum elements of a tensor along an axis.

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 TransactionOps<MpsGraph> for MpsGraph

fn tr_execute( transaction: TransactionPrimitive<B>, ) -> impl Future<Output = Result<TransactionPrimitiveData, ExecutionError>> + Send

Executes a transaction and return its data.

impl Copy for MpsGraph