Class GPUCommandBufferBackend

Represents a GPUCompute backend ops.

Inheritance
object
CPUBackend
GPUCommandBufferBackend
Implements
Inherited Members
Namespace: Unity.Sentis
Assembly: solution.dll
Syntax
public class GPUCommandBufferBackend : CPUBackend, IBackend, IDisposable

Constructors

Name Description
GPUCommandBufferBackend(ITensorAllocator)

Initializes and returns an instance of GPUComputeOps.
GPUCommandBufferBackend(CommandBuffer, ITensorAllocator)

Initializes and returns an instance of GPUComputeOps.

Fields

Name Description
cb

The command buffer to use for scheduling.

Properties

Name Description
deviceType

Returns the DeviceType for the ops.

Methods

Name Description
Abs(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Abs math function: f(x) = f(x) = |x|.
Abs(TensorInt, TensorInt)

Computes an output tensor by applying the element-wise Abs math function: f(x) = f(x) = |x|.
Acos(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Acos trigonometric function: f(x) = acos(x).
Acosh(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Acosh trigonometric function: f(x) = acosh(x).
Add(TensorFloat, TensorFloat, TensorFloat)

Performs an element-wise Add math operation: f(a, b) = a + b.

This supports numpy-style broadcasting of input tensors.
Add(TensorInt, TensorInt, TensorInt)

Performs an element-wise Add math operation: f(a, b) = a + b.

This supports numpy-style broadcasting of input tensors.
And(TensorInt, TensorInt, TensorInt)

Performs an element-wise And logical operation: f(a, b) = a & b.

This supports numpy-style broadcasting of input tensors.
ArgMax(TensorFloat, TensorInt, int, bool, bool)

Computes the indices of the maximum elements of the input tensor along a given axis.
ArgMax(TensorInt, TensorInt, int, bool, bool)

Computes the indices of the maximum elements of the input tensor along a given axis.
ArgMin(TensorFloat, TensorInt, int, bool, bool)

Computes the indices of the minimum elements of the input tensor along a given axis.
ArgMin(TensorInt, TensorInt, int, bool, bool)

Computes the indices of the minimum elements of the input tensor along a given axis.
Asin(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Asin trigonometric function: f(x) = asin(x).
Asinh(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Asinh trigonometric function: f(x) = asinh(x).
Atan(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Atan trigonometric function: f(x) = atan(x).
Atanh(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Atanh trigonometric function: f(x) = atanh(x).
AveragePool(TensorFloat, TensorFloat, int[], int[], int[])

Calculates an output tensor by pooling the mean values of the input tensor across its spatial dimensions according to the given pool and stride values.
BatchNormalization(TensorFloat, TensorFloat, TensorFloat, TensorFloat, TensorFloat, TensorFloat, float)

Computes the mean variance on the last dimension of the input tensor and normalizes it according to scale and bias tensors.
Bernoulli(TensorFloat, Tensor, float?)

Generates an output tensor with values 0 or 1 from a Bernoulli distribution. The input tensor contains the probabilities to use for generating the output values.
Cast(Tensor, Tensor)

Computes the output tensor using an element-wise Cast function: f(x) = (float)x or f(x) = (int)x depending on the value of toType.
Ceil(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Ceil math function: f(x) = ceil(x).
Celu(TensorFloat, TensorFloat, float)

Computes an output tensor by applying the element-wise Celu activation function: f(x) = max(0, x) + min(0, alpha * (exp(x / alpha) - 1)).
Clip(TensorFloat, TensorFloat, float, float)

Computes an output tensor by applying the element-wise Clip math function: f(x) = clamp(x, min, max).
Clip(TensorInt, TensorInt, int, int)

Computes an output tensor by applying the element-wise Clip math function: f(x) = clamp(x, min, max).
CompressWithIndices(Tensor, TensorInt, Tensor, int, int)

Computes the output tensor by selecting slices from an input tensor according to the 'indices' tensor along an 'axis'.
Concat(Tensor[], Tensor, int)

Calculates an output tensor by concatenating the input tensors along a given axis.
Conv(TensorFloat, TensorFloat, TensorFloat, TensorFloat, int, Span<int>, Span<int>, Span<int>, FusableActivation)

Applies a convolution filter to an input tensor.
ConvTranspose(TensorFloat, TensorFloat, TensorFloat, TensorFloat, Span<int>, Span<int>, Span<int>, FusableActivation)

Applies a transpose convolution filter to an input tensor.
Cos(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Cos trigonometric function: f(x) = cos(x).
Cosh(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Cosh trigonometric function: f(x) = cosh(x).
CumSum(TensorFloat, TensorFloat, int, bool, bool)

Performs the cumulative sum along a given axis.
CumSum(TensorInt, TensorInt, int, bool, bool)

Performs the cumulative sum along a given axis.
Dense(TensorFloat, TensorFloat, TensorFloat, TensorFloat, FusableActivation)

Performs a matrix multiplication operation: f(x, w, b) = X x W + B.

This supports numpy-style broadcasting of input tensors.
DepthToSpace(TensorFloat, TensorFloat, int, DepthToSpaceMode)

Computes the output tensor by permuting data from depth into blocks of spatial data.
Div(TensorFloat, TensorFloat, TensorFloat)

Performs an element-wise Div math operation: f(a, b) = a / b.

This supports numpy-style broadcasting of input tensors.
Div(TensorInt, TensorInt, TensorInt)

Performs an element-wise Div math operation: f(a, b) = a / b.

This supports numpy-style broadcasting of input tensors.
Einsum(TensorFloat[], TensorFloat, TensorIndex[], TensorIndex, TensorIndex, TensorShape)

Performs an Einsum math operation.
Elu(TensorFloat, TensorFloat, float)

Computes an output tensor by applying the element-wise Elu activation function: f(x) = x if x >= 0, otherwise f(x) = alpha * (e^x - 1).
Equal(TensorFloat, TensorFloat, TensorInt)

Performs an element-wise Equal logical comparison operation: f(a, b) = 1 if a == b, otherwise f(x) = 0.

This supports numpy-style broadcasting of input tensors.
Equal(TensorInt, TensorInt, TensorInt)

Performs an element-wise Equal logical comparison operation: f(a, b) = 1 if a == b, otherwise f(x) = 0.

This supports numpy-style broadcasting of input tensors.
Erf(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Erf activation function: f(x) = erf(x).
Exp(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Exp math function: f(x) = exp(x).
Expand(Tensor, Tensor)

Calculates an output tensor by broadcasting the input tensor into a given shape.
FMod(TensorFloat, TensorFloat, TensorFloat)

Performs an element-wise Mod math operation: f(a, b) = a % b.

The sign of the remainder is the same as the sign of the dividend, as in C#.

This supports numpy-style broadcasting of input tensors.
FMod(TensorInt, TensorInt, TensorInt)

Performs an element-wise Mod math operation: f(a, b) = a % b.

The sign of the remainder is the same as the sign of the dividend, as in C#.

This supports numpy-style broadcasting of input tensors.
Floor(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Floor math function: f(x) = floor(x).
Gather(Tensor, TensorInt, Tensor, int)

Takes values from the input tensor indexed by the indices tensor along a given axis and concatenates them.
GatherElements(Tensor, TensorInt, Tensor, int)

Takes values from the input tensor indexed by the indices tensor along a given axis and concatenates them.
GatherND(Tensor, TensorInt, Tensor, int)

Takes slices of values from the batched input tensor indexed by the indices tensor.
Gelu(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Gelu activation function: f(x) = x / 2 * (1 + erf(x / sqrt(2))).
GlobalAveragePool(TensorFloat, TensorFloat)

Calculates an output tensor by pooling the mean values of the input tensor across all of its spatial dimensions. The spatial dimensions of the output are size 1.
GlobalAverageVariancePool(TensorFloat, TensorFloat, int)

Calculates an output tensor by pooling the mean and variance values of the input tensor across the spatial dimensions from a given axis. The spatial dimensions of the output are size 1.
GlobalMaxPool(TensorFloat, TensorFloat)

Calculates an output tensor by pooling the maximum values of the input tensor across all of its spatial dimensions. The spatial dimensions of the output are size 1.
Greater(TensorFloat, TensorFloat, TensorInt)

Performs an element-wise Greater logical comparison operation: f(a, b) = 1 if a > b, otherwise f(x) = 0.

This supports numpy-style broadcasting of input tensors.
Greater(TensorInt, TensorInt, TensorInt)

Performs an element-wise Greater logical comparison operation: f(a, b) = 1 if a > b, otherwise f(x) = 0.

This supports numpy-style broadcasting of input tensors.
GreaterOrEqual(TensorFloat, TensorFloat, TensorInt)

Performs an element-wise GreaterOrEqual logical comparison operation: f(a, b) = 1 if a >= b, otherwise f(x) = 0.

This supports numpy-style broadcasting of input tensors.
GreaterOrEqual(TensorInt, TensorInt, TensorInt)

Performs an element-wise GreaterOrEqual logical comparison operation: f(a, b) = 1 if a >= b, otherwise f(x) = 0.

This supports numpy-style broadcasting of input tensors.
HardSigmoid(TensorFloat, TensorFloat, float, float)

Computes an output tensor by applying the element-wise HardSigmoid activation function: f(x) = clamp(alpha * x + beta, 0, 1).
HardSwish(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise HardSwish activation function: f(x) = x * max(0, min(1, 1/6 * x + 0.5)).
Hardmax(TensorFloat, TensorFloat, int)

Computes an output tensor by applying the Hardmax activation function along an axis: f(x, axis) = 1 if x is the first maximum value along the specified axis, otherwise f(x) = 0.
InstanceNormalization(TensorFloat, TensorFloat, TensorFloat, TensorFloat, float)

Computes the mean variance on the spatial dimensions of the input tensor and normalizes them according to scale and bias tensors.
IsInf(TensorFloat, TensorInt, bool, bool)

Performs an element-wise IsInf logical operation: f(x) = 1 elementwise if x is +Inf and detectPositive is true, or x is -Inf and detectNegative is true. Otherwise f(x) = 0.
IsNaN(TensorFloat, TensorInt)

Performs an element-wise IsNaN logical operation: f(x) = 1 if x is NaN, otherwise f(x) = 0.
LSTM(TensorFloat, TensorFloat, TensorFloat, TensorFloat, TensorInt, TensorFloat, TensorFloat, TensorFloat, TensorFloat, TensorFloat, TensorFloat, RnnDirection, RnnActivation[], float[], float[], bool, float, RnnLayout)

Generates an output tensor by computing a one-layer long short-term memory (LSTM) on an input tensor.
LayerNormalization(TensorFloat, TensorFloat, TensorFloat, TensorFloat, float)

Computes the mean variance on the last dimension of the input tensor and normalizes it according to scale and bias tensors.
LeakyRelu(TensorFloat, TensorFloat, float)

Computes an output tensor by applying the element-wise LeakyRelu activation function: f(x) = x if x >= 0, otherwise f(x) = alpha * x.
Less(TensorFloat, TensorFloat, TensorInt)

Performs an element-wise Less logical comparison operation: f(a, b) = 1 if a < b, otherwise f(x) = 0.

This supports numpy-style broadcasting of input tensors.
Less(TensorInt, TensorInt, TensorInt)

Performs an element-wise Less logical comparison operation: f(a, b) = 1 if a < b, otherwise f(x) = 0.

This supports numpy-style broadcasting of input tensors.
LessOrEqual(TensorFloat, TensorFloat, TensorInt)

Performs an element-wise LessOrEqual logical comparison operation: f(a, b) = 1 if a <= b, otherwise f(x) = 0.

This supports numpy-style broadcasting of input tensors.
LessOrEqual(TensorInt, TensorInt, TensorInt)

Performs an element-wise LessOrEqual logical comparison operation: f(a, b) = 1 if a <= b, otherwise f(x) = 0.

This supports numpy-style broadcasting of input tensors.
Log(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Log math function: f(x) = log(x).
LogSoftmax(TensorFloat, TensorFloat, int)

Computes an output tensor by applying the LogSoftmax activation function along an axis: f(x, axis) = log(Softmax(x, axis)).
MatMul(TensorFloat, TensorFloat, TensorFloat)

Performs a multi-dimensional matrix multiplication operation: f(a, b) = a x b.
MatMul2D(TensorFloat, TensorFloat, TensorFloat, bool, bool)

Performs a matrix multiplication operation with optional transposes: f(a, b) = a' x b'.
Max(TensorFloat[], TensorFloat)

Performs an element-wise Max math operation: f(x1, x2 ... xn) = max(x1, x2 ... xn).

This supports numpy-style broadcasting of input tensors.
Max(TensorInt[], TensorInt)

Performs an element-wise Max math operation: f(x1, x2 ... xn) = max(x1, x2 ... xn).

This supports numpy-style broadcasting of input tensors.
MaxPool(TensorFloat, TensorFloat, int[], int[], int[])

Calculates an output tensor by pooling the maximum values of the input tensor across its spatial dimensions according to the given pool and stride values.
Mean(TensorFloat[], TensorFloat)

Performs an element-wise Mean math operation: f(x1, x2 ... xn) = (x1 + x2 ... xn) / n.

This supports numpy-style broadcasting of input tensors.
MemClear(Tensor)

Sets the entries of a tensor to 0.
MemCopy(Tensor, Tensor)

Creates a copy of a given input tensor with the same shape and values.
MemCopyStride(Tensor, Tensor, int, int, int, int, int, int)

Copy blocks of values from X to O, we copy 'count' blocks each of length 'length' values with initial offsets given by 'offsetX', 'offsetO' and with strides given by 'strideX', 'strideO'
MemSet(TensorFloat, float)

Sets the entries of a tensor to a given fill value.
MemSet(TensorInt, int)

Sets the entries of a tensor to a given fill value.
Min(TensorFloat[], TensorFloat)

Performs an element-wise Min math operation: f(x1, x2 ... xn) = min(x1, x2 ... xn).

This supports numpy-style broadcasting of input tensors.
Min(TensorInt[], TensorInt)

Performs an element-wise Min math operation: f(x1, x2 ... xn) = min(x1, x2 ... xn).

This supports numpy-style broadcasting of input tensors.
Mod(TensorInt, TensorInt, TensorInt)

Performs an element-wise Mod math operation: f(a, b) = a % b.

The sign of the remainder is the same as the sign of the divisor, as in Python.

This supports numpy-style broadcasting of input tensors.
Mul(TensorFloat, TensorFloat, TensorFloat)

Performs an element-wise Mul math operation: f(a, b) = a * b.

This supports numpy-style broadcasting of input tensors.
Mul(TensorInt, TensorInt, TensorInt)

Performs an element-wise Mul math operation: f(a, b) = a * b.

This supports numpy-style broadcasting of input tensors.
Neg(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Neg math function: f(x) = -x.
Neg(TensorInt, TensorInt)

Computes an output tensor by applying the element-wise Neg math function: f(x) = -x.
NewTensor(TensorShape, DataType, AllocScope)

Allocates a new tensor with the internal allocator.
Not(TensorInt, TensorInt)

Performs an element-wise Not logical operation: f(x) = ~x.
OneHot(TensorInt, TensorFloat, int, int, float, float)

Generates a one-hot tensor with a given depth, indices and on and off values.
OneHot(TensorInt, TensorInt, int, int, int, int)

Generates a one-hot tensor with a given depth, indices and on and off values.
Or(TensorInt, TensorInt, TensorInt)

Performs an element-wise Or logical operation: f(a, b) = a | b.

This supports numpy-style broadcasting of input tensors.
PRelu(TensorFloat, TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise PRelu activation function: f(x) = x if x >= 0, otherwise f(x) = slope * x.
Pad(TensorFloat, TensorFloat, ReadOnlySpan<int>, PadMode, float)

Calculates the output tensor by adding padding to the input tensor according to the given padding values and mode.
PinToDevice(Tensor, bool)

Prepares Tensor for use with CPU backend.
Pow(TensorFloat, TensorFloat, TensorFloat)

Performs an element-wise Pow math operation: f(a, b) = pow(a, b).

This supports numpy-style broadcasting of input tensors.
Pow(TensorFloat, TensorInt, TensorFloat)

Performs an element-wise Pow math operation: f(a, b) = pow(a, b).

This supports numpy-style broadcasting of input tensors.
RandomNormal(TensorFloat, float, float, float?)

Generates an output tensor of a given shape with random values in a normal distribution with given mean and scale, and an optional seed value.
RandomUniform(TensorFloat, float, float, float?)

Generates an output tensor of a given shape with random values in a uniform distribution between a given low and high, and an optional seed value.
Range(TensorFloat, float, float)

Generates a 1D output tensor where the values form an arithmetic progression defined by the start and delta values.
Range(TensorInt, int, int)

Generates a 1D output tensor where the values form an arithmetic progression defined by the start and delta values.
Reciprocal(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Reciprocal math function: f(x) = 1 / x.
ReduceL1(TensorFloat, TensorFloat, ReadOnlySpan<int>, bool)

Reduces an input tensor along the given axes using the ReduceL1 operation: f(x1, x2 ... xn) = |x1| + |x2| + ... + |xn|.
ReduceL1(TensorInt, TensorInt, ReadOnlySpan<int>, bool)

Reduces an input tensor along the given axes using the ReduceL1 operation: f(x1, x2 ... xn) = |x1| + |x2| + ... + |xn|.
ReduceL2(TensorFloat, TensorFloat, ReadOnlySpan<int>, bool)

Reduces an input tensor along the given axes using the ReduceL2 operation: f(x1, x2 ... xn) = sqrt(x1² + x2² + ... + xn²).
ReduceLogSum(TensorFloat, TensorFloat, ReadOnlySpan<int>, bool)

Reduces an input tensor along the given axes using the ReduceLogSum operation: f(x1, x2 ... xn) = log(x1 + x2 + ... + xn).
ReduceLogSumExp(TensorFloat, TensorFloat, ReadOnlySpan<int>, bool)

Reduces an input tensor along the given axes using the ReduceLogSumExp operation: f(x1, x2 ... xn) = log(e^x1 + e^x2 + ... + e^xn).
ReduceMax(TensorFloat, TensorFloat, ReadOnlySpan<int>, bool)

Reduces an input tensor along the given axes using the ReduceMax operation: f(x1, x2 ... xn) = max(x1, x2, ... , xn).
ReduceMax(TensorInt, TensorInt, ReadOnlySpan<int>, bool)

Reduces an input tensor along the given axes using the ReduceMean operation: f(x1, x2 ... xn) = max(x1, x2, ... , xn).
ReduceMean(TensorFloat, TensorFloat, ReadOnlySpan<int>, bool)

Reduces an input tensor along the given axes using the ReduceMean operation: f(x1, x2 ... xn) = (x1 + x2 + ... + xn) / n.
ReduceMin(TensorFloat, TensorFloat, ReadOnlySpan<int>, bool)

Reduces an input tensor along the given axes using the ReduceMin operation: f(x1, x2 ... xn) = min(x1, x2, ... , xn).
ReduceMin(TensorInt, TensorInt, ReadOnlySpan<int>, bool)

Reduces an input tensor along the given axes using the ReduceMin operation: f(x1, x2 ... xn) = min(x1, x2, ... , xn).
ReduceProd(TensorFloat, TensorFloat, ReadOnlySpan<int>, bool)

Reduces an input tensor along the given axes using the ReduceProd operation: f(x1, x2 ... xn) = x1 * x2 * ... * xn.
ReduceProd(TensorInt, TensorInt, ReadOnlySpan<int>, bool)

Reduces an input tensor along the given axes using the ReduceProd operation: f(x1, x2 ... xn) = x1 * x2 * ... * xn.
ReduceSum(TensorFloat, TensorFloat, ReadOnlySpan<int>, bool)

Reduces an input tensor along the given axes using the ReduceSum operation: f(x1, x2 ... xn) = x1 + x2 + ... + xn.
ReduceSum(TensorInt, TensorInt, ReadOnlySpan<int>, bool)

Reduces an input tensor along the given axes using the ReduceSum operation: f(x1, x2 ... xn) = x1 + x2 + ... + xn.
ReduceSumExp(TensorFloat, TensorFloat, ReadOnlySpan<int>, bool)
ReduceSumSquare(TensorFloat, TensorFloat, ReadOnlySpan<int>, bool)

Reduces an input tensor along the given axes using the ReduceSumSquare operation: f(x1, x2 ... xn) = x1² + x2² + ... + xn².
ReduceSumSquare(TensorInt, TensorInt, ReadOnlySpan<int>, bool)

Reduces an input tensor along the given axes using the ReduceSumSquare operation: f(x1, x2 ... xn) = x1² + x2² + ... + xn².
Relu(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Relu activation function: f(x) = max(0, x).
Relu6(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Relu6 activation function: f(x) = clamp(x, 0, 6).
Reshape(Tensor, Tensor)

Calculates an output tensor by copying the data from the input tensor and using a given shape. The data from the input tensor is unchanged.
Resize(TensorFloat, TensorFloat, ReadOnlySpan<float>, InterpolationMode, NearestMode, CoordTransformMode)

Calculates an output tensor by resampling the input tensor along the spatial dimensions with given scales.
RoiAlign(TensorFloat, TensorFloat, TensorInt, TensorFloat, RoiPoolingMode, int, int, int, float)

Calculates an output tensor by pooling the input tensor across each region of interest given by the rois tensor.
Round(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Round math function: f(x) = round(x).

If the fractional part is equal to 0.5, rounds to the nearest even integer.
ScalarMad(TensorFloat, TensorFloat, float, float)

Performs an element-wise Mad math operation: multiplies and adds bias to a tensor: f(T, s, b) = s * T + b.
ScaleBias(TensorFloat, TensorFloat, TensorFloat, TensorFloat)

Computes the output tensor with an element-wise ScaleBias function: f(x, s, b) = x * s + b.
ScatterElements(Tensor, TensorInt, Tensor, Tensor, int, ScatterReductionMode)

Copies the input tensor and updates values at indexes specified by the indices tensor with values specified by the updates tensor along a given axis.

ScatterElements updates the values depending on the reduction mode used.
ScatterND(TensorFloat, TensorInt, TensorFloat, TensorFloat, ScatterReductionMode)

Copies the input tensor and updates values at indexes specified by the indices tensor with values specified by the updates tensor.

ScatterND updates the values depending on the reduction mode used.
ScatterND(TensorInt, TensorInt, TensorInt, TensorInt, ScatterReductionMode)

Copies the input tensor and updates values at indexes specified by the indices tensor with values specified by the updates tensor.

ScatterND updates the values depending on the reduction mode used.
Selu(TensorFloat, TensorFloat, float, float)

Computes an output tensor by applying the element-wise Selu activation function: f(x) = gamma * x if x >= 0, otherwise f(x) = (alpha * e^x - alpha).
Shrink(TensorFloat, TensorFloat, float, float)

Computes an output tensor by applying the element-wise Shrink activation function: f(x) = x + bias if x < lambd. f(x) = x - bias if x > lambd. Otherwise f(x) = 0.
Sigmoid(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Sigmoid activation function: f(x) = 1/(1 + e^(-x)).
Sign(TensorFloat, TensorFloat)

Performs an element-wise Sign math operation: f(x) = 1 if x > 0. f(x) = -1 if x < 0. Otherwise f(x) = 0.
Sign(TensorInt, TensorInt)

Performs an element-wise Sign math operation: f(x) = 1 if x > 0. f(x) = -1 if x < 0. Otherwise f(x) = 0.
Sin(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Sin trigonometric function: f(x) = sin(x).
SinglePassLSTM(TensorFloat, TensorFloat, TensorFloat, TensorFloat, TensorInt, TensorFloat, TensorFloat, TensorFloat, TensorFloat, RnnActivation[], float[], float[], bool, float, bool, int, RnnLayout)

Computes a single pass LSTM either forward or reverse dirIndex and layout are used to calculate where to index the various tensors in bidirectional and batch first layout passes X has given layout W, R are cropped to single direction P, B are full number of directions Y has given layout and full number of directions (matches output of Layer) Y_h, Y_c are SequenceFirst layout and cropped to single direction HtxRT and XsixWT are temp vectors of the correct dimension for the intermediate results of the matmuls activations, activationAlpha and activationBeta have full number of dimensions
Sinh(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Sinh trigonometric function: f(x) = sinh(x).
Slice(Tensor, Tensor, ReadOnlySpan<int>, ReadOnlySpan<int>, ReadOnlySpan<int>)

Calculates an output tensor by slicing the input tensor along given axes with given starts, ends, and steps.
Softmax(TensorFloat, TensorFloat, int)

Computes an output tensor by applying the Softmax activation function along an axis: f(x, axis) = exp(X) / ReduceSum(exp(X), axis).
Softplus(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Softplus activation function: f(x) = ln(e^x + 1).
Softsign(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Softsign activation function: f(x) = x/(|x| + 1).
SpaceToDepth(TensorFloat, TensorFloat, int)

Computes the output tensor by permuting data from blocks of spatial data into depth.
Split(Tensor, Tensor, int, int)

Calculates an output tensor by splitting the input tensor along a given axis between start and end.
Sqrt(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Sqrt math function: f(x) = sqrt(x).
Square(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Square math function: f(x) = x * x.
Sub(TensorFloat, TensorFloat, TensorFloat)

Performs an element-wise Sub math operation: f(a, b) = a - b.

This supports numpy-style broadcasting of input tensors.
Sub(TensorInt, TensorInt, TensorInt)

Performs an element-wise Sub math operation: f(a, b) = a - b.

This supports numpy-style broadcasting of input tensors.
Sum(TensorFloat[], TensorFloat)

Performs an element-wise Sum math operation: f(x1, x2 ... xn) = x1 + x2 ... xn.

This supports numpy-style broadcasting of input tensors.
Swish(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Swish activation function: f(x) = sigmoid(x) * x = x / (1 + e^{-x}).
Tan(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Tan trigonometric function: f(x) = tan(x).
Tanh(TensorFloat, TensorFloat)

Computes an output tensor by applying the element-wise Tanh activation function: f(x) = tanh(x).
ThresholdedRelu(TensorFloat, TensorFloat, float)

Computes an output tensor by applying the element-wise ThresholdedRelu activation function: f(x) = x if x > alpha, otherwise f(x) = 0.
Tile(Tensor, Tensor, ReadOnlySpan<int>)

Calculates an output tensor by repeating the input layer a given number of times along each axis.
TopK(TensorFloat, TensorFloat, TensorInt, int, int, bool)

Calculates the top-K largest or smallest elements of an input tensor along a given axis.
Transpose(Tensor, Tensor)

Calculates an output tensor by reversing the dimensions of the input tensor.
Transpose(Tensor, Tensor, int[])

Calculates an output tensor by permuting the axes and data of the input tensor according to the given permutations.
Tril(Tensor, Tensor, int)

Computes the output tensor by retaining the lower triangular values from an input matrix or matrix batch and setting the other values to zero.
Triu(Tensor, Tensor, int)

Computes the output tensor by retaining the upper triangular values from an input matrix or matrix batch and setting the other values to zero.
Where(TensorInt, Tensor, Tensor, Tensor)

Performs an element-wise Where logical operation: f(condition, a, b) = a if condition is true, otherwise f(condition, a, b) = b.
Xor(TensorInt, TensorInt, TensorInt)

Performs an element-wise Xor logical operation: f(a) = a ^ b.