# Classes

The following classes are available globally.

• ``` SGDOptimizer ```

See more

#### Declaration

Swift

``public class SGDOptimizer: Optimizer``
• ``` SerranoTensorSymbol ```

Implementation of `TensorSymbol`

See more

#### Declaration

Swift

``public class SerranoTensorSymbol: SerranoGraphSymbol, TensorSymbol``
• ``` SerranoOperatorSymbol ```

Implementaion of `OperatorSymbol`

See more

#### Declaration

Swift

``public class SerranoOperatorSymbol: SerranoGraphSymbol, OperatorSymbol``
• ``` SerranoScalarSymbol ```

Implementation of `ScalarSymbol`

See more

#### Declaration

Swift

``public class SerranoScalarSymbol: SerranoGraphSymbol, ScalarSymbol``
• ``` SerranoGraphSymbol ```

Implementation of `GraphSymbol`

See more

#### Declaration

Swift

``public class SerranoGraphSymbol: GraphSymbol, Hashable``
• ``` ComputationGraph ```

## Intro

The implementation of `Graph`. A `ComputationGraph` just a set of symbols and connections between them. The graph computes the output tensors stage by stage.

A typical usage:

``````
let graph = ComputationGraph()

let a = graph.tensor("A", shape: TensorShape(dataType: .float, shape: [2,3]))
let b = graph.tensor("B", shape: TensorShape(dataType: .float, shape: [2,3]))
let (c, op) = graph.operation("", inputSymbols: [a, b], op: PowOperator()).first
``````

## ComputationGraph V.S. Model

`ComputationGraph` is low-level abstraction of machine learning models. It has two basic funtions:

• forward. Compute results from input to output
• backward. Compute and update data symbols that are differentiable use optimizer User needs to call `forward(:)` and `backward(:)` manually to do training and `ComputationGraph` is not aware of loss function. If you want to use loss function if a graph, you need add it into this graph as an operator symbol.

`Model` is a higher level abstraction inherited from `ComputationGraph`. It has all functions `ComputationGraph` has and beyond that:

• Loss function. `Model` could setup loss function to do the backward training. ‘ComputationGraph’
• High level training functions. `Model` could automatically repeat `forward(:)` and `backward(:)` util reaches conditions users setup like max number of epoch, early stop etc.
• High level prediction functions.
See more

#### Declaration

Swift

``public class ComputationGraph: Graph``
• ``` FullyconnectedOperator ```

The regular fully connected operator. Operator do the `1D_dot(inputTensor.flatten, weights) + bias` calculation on all input tensors.

## Weight tensor layout

The `weight` is a 2D tensor with shape: `[n, m]` where :

• `n`: the flattened dimension of `inputTensors`, i.e. same value as `count` of a input tensor.
• `m`: the number of hidden nodes, same value as `numUnits`;

Thus, each column stores the weights of corresponding hidden unit.

## Bias tensor layout

The `bias` is a 1D tensor with shape `[m]` where:

• `m`: the number of hidden nodes, same value as `numUnits`;

Thus, each value in the tensor is the bias value of corresponding hidden unit.

## Input tensors auto flatten

For input tensor with rank `>=2`, the operator will automatically flatten the tensor and then do calcualtion.

## Multiple input tensors

If `inputTensors` has more than 1 tensor object, the operator applies calculation on each input tensor independently and stores the results in corresponding tensor of `outputTensors`.

Note

All input tensor should have same `count`.

## Bias enable choice

Bias could be disabled by setting the `biasEnabled` to `false`.

## Batch calculation

This operator itself does not explicitly support batch calculation. But user can use slice tensor to do the same thing. Details can be found in Slice tensor and Batch calculation with operators

See more

#### Declaration

Swift

``public class FullyconnectedOperator: ComputableOperator``
• ``` BatchNormOperator ```

Batch normalization operator.

Normalize on input tensors by each tensor’s mean and variance.

## Currently, only support 2D tensor with channel information.

See more

#### Declaration

Swift

``public class BatchNormOperator: ComputableOperator``
• ``` Pooling2DOperator ```

This class is an abstract class for 2D pooling operators.

See more

#### Declaration

Swift

``public class Pooling2DOperator: ComputableOperator``
• ``` MaxPool2DOperator ```

Undocumented

See more

#### Declaration

Swift

``public class MaxPool2DOperator: Pooling2DOperator``
• ``` AvgPool2DOperator ```

2D Average pooling.

## Input shape

Input data should be a tensor with 3D shape `[channel, height, width]` or `[height, width, channel]` according to the `channelPosition`.

See more

#### Declaration

Swift

``public class AvgPool2DOperator: Pooling2DOperator``
• ``` SumPool2DOperator ```

2D Sum Pooling.

## Input shape

Input data should be a tensor with 3D shape `[channel, height, width]` or `[height, width, channel]` according to the `channelPosition`.

See more

#### Declaration

Swift

``public class SumPool2DOperator: Pooling2DOperator``
• ``` FlatbufferIO ```

See more

#### Declaration

Swift

``public class FlatbufferIO``
• ``` ConvOperator2D ```

2D Convolution operator.

## Input tensors shapes

All tensors in `inputTensors` should have same shapes

## Shape specification

• inputTensors: each tensor: `[channel, height, width]` or `[height, width, channel]` according to `channelPosition`
• weight: `[num_filter，channel, kernelSize[0], kernelSize[1]]`,
• bias: `[num_filter]`,
• outputTensors: each tensor: `[out_height, out_width, num_filter]`, i.e., `TensorChannelOrder.Last`

## nil weight

At declaration, `weight` could be `nil`. However, if you add this operator through a graph’s `operation(_,inputs:,op:)` API (i.e. symbolic constructing graph). You must indicate the `inputShape` attribute so that the graph could estimate the input and output shape information.

## Batch process

This operator does not directly support batch data. However, user could use `TensorSlice` to do the batch processing. Details can be found in Slice tensor and Batch calculation with operators.

## Dilation

Currently, calculation with `dilation > 1` has not been implemented and supported.

See more

#### Declaration

Swift

``public class ConvOperator2D: ComputableOperator``
• ``` Img2ColOperator ```

Operator works like img2col in matlab. It converts any 3D tensor (`[H, W, C]` or `[C, H, W]`) into a 2D tensor (`[H*W, C*M*N]`) according to patchSize `[M, N]` and stride.

See more

#### Declaration

Swift

``public class Img2ColOperator: ComputableOperator``
• ``` ActivationOperator ```

The abstract class for all activation operator. An activation operator is actually a special kind of `UnaryOperator` doing a little bit more complex element-wise computation.

See more

#### Declaration

Swift

``public class ActivationOperator: UnaryOperator``
• ``` ReLUOperator ```

Rectified Linear Unit, `y=max(x,alpha=0.0)`

See more

#### Declaration

Swift

``public class ReLUOperator: ActivationOperator``
• ``` SigmoidOperator ```

Sigmoid.`y = 1 / (1 + exp(-x))`

See more

#### Declaration

Swift

``public class SigmoidOperator: ActivationOperator``
• ``` SoftplusOperator ```

Softplus.`y = log(exp(x) + 1)`

See more

#### Declaration

Swift

``public class SoftplusOperator: ActivationOperator``
• ``` SoftsignOperator ```

Softsign.`y = x / (1 + abs(x))`

See more

#### Declaration

Swift

``public class SoftsignOperator: ActivationOperator``
• ``` LinearOperator ```

Do nothing. Output identify tensor. `y = x`

See more

#### Declaration

Swift

``public class LinearOperator: ActivationOperator``
• ``` ELUOperator ```

Exponential Linear Units.

`y = x if x > 0, else y = alpha*(exp(x) - 1)`

## Reference

Fast and Accurate Deep Network Learning by Exponential Linear Units (ELUs)

See more

#### Declaration

Swift

``public class ELUOperator: ActivationOperator``
• ``` SELUOperator ```

Scaled Exponential Linear Unit.

`y = scale * elu(x)`

## alpha

default value is `1.673263`

## scale

default value is `1.050701`

## Reference

Self-Normalizing Neural Networks

See more

#### Declaration

Swift

``public class SELUOperator: ActivationOperator``
• ``` SoftmaxOperator ```

Softmax activations.

`y = exp(x) / reduce_sum(exp(x), dim)`

Default `dim` is the last dimension of input tensors.

Note

The operator assumens all input tensors have same rank. If not, it could not do the calculation.
See more

#### Declaration

Swift

``public class SoftmaxOperator: ActivationOperator``
• ``` LeakyReLUOperator ```

LeakyReLU activation operator.

``````y = alpha * x (x <   0)
y = x         (x >=  0)
``````

## scale factor alpha

Default value is `0.3`

## Reference

Rectifier Nonlinearities Improve Neural Network Acoustic Models

See more

#### Declaration

Swift

``public class LeakyReLUOperator: ELUOperator``
• ``` ThresholdedReLUOperator ```

Thresholded Rectified Linear Unit. `f(x) = x if x > alpha, else f(x) = 0`

## Threshold `alpha`

Default value is `1.0`

## Reference

Zero-Bias Autoencoders and the Benefits of Co-Adapting Features

See more

#### Declaration

Swift

``public class ThresholdedReLUOperator: ELUOperator``
• ``` ForwardGraph ```

`ForwardGraph` is a subclass of `ComputationGraph` that can only do forward computation. Thus, it has mooptimization during forward computation and the internal results are not accessable.

See more

#### Declaration

Swift

``public class ForwardGraph: ComputationGraph``
• ``` ReduceOperator ```

The abstract class for all reduce operators. Should not be used directly. A reduce operator do some aggregate calculation along given axes. An example given by TensorFlow is here.

See more

#### Declaration

Swift

``public class ReduceOperator: ComputableOperator``
• ``` ReduceSumOperator ```

Computes the sum of array elements over given axes.

See more

#### Declaration

Swift

``public class ReduceSumOperator: ReduceOperator``
• ``` ReduceProductOperator ```

Computes the product of array elements over given axes.

See more

#### Declaration

Swift

``public class ReduceProductOperator: ReduceOperator``
• ``` ReduceMaxOperator ```

Computes the max of array elements over given axes.

See more

#### Declaration

Swift

``public class ReduceMaxOperator: ReduceOperator``
• ``` ReduceMinOperator ```

Computes the min of array elements over given axes.

See more

#### Declaration

Swift

``public class ReduceMinOperator: ReduceOperator``
• ``` ReduceMeanOperator ```

Computes the mean of array elements over given axes.

See more

#### Declaration

Swift

``public class ReduceMeanOperator: ReduceOperator``
• ``` CopyOperator ```

Do copy operation on `inputTensors`.

See more

#### Declaration

Swift

``public class CopyOperator: ComputableOperator``
• ``` UnaryOperator ```

Abstract class define the standard unary operator working flow. This class should not be used directly. Any class inheritance this class is doing element-wise computation for input tensors.

See more

#### Declaration

Swift

``public class UnaryOperator: ComputableOperator``
• ``` SinOperator ```

Undocumented

See more

#### Declaration

Swift

``public class SinOperator: UnaryOperator``
• ``` TanOperator ```

Compute element-wise tangent on input tensors.

Note

This operator may output `NaN` or `Infinite` values and operator would not check these situations.
See more

#### Declaration

Swift

``public class TanOperator: UnaryOperator``
• ``` CosOperator ```

Compute element-wise cosine on input tensors.

Note

This operator may output `NaN` or `Infinite` values and operator would not check these situations.
See more

#### Declaration

Swift

``public class CosOperator: UnaryOperator``
• ``` ArcsinOperator ```

Compute element-wise arc sine on input tensors.

Note

This operator may output `NaN` or `Infinite` values and operator would not check these situations.
See more

#### Declaration

Swift

``public class ArcsinOperator: UnaryOperator``
• ``` ArccosOperator ```

Compute element-wise arc cosine on input tensors.

Note

This operator may output `NaN` or `Infinite` values and operator would not check these situations.
See more

#### Declaration

Swift

``public class ArccosOperator: UnaryOperator``
• ``` ArctanOperator ```

Compute element-wise arc tangent on input tensors.

Note

This operator may output `NaN` or `Infinite` values and operator would not check these situations.
See more

#### Declaration

Swift

``public class ArctanOperator: UnaryOperator``
• ``` DegreeOperator ```

Compute element-wise of input tensors radians to degrees.

See more

#### Declaration

Swift

``public class DegreeOperator: UnaryOperator``
• ``` AbsOperator ```

Compute element-wise abs values of input tensors.

See more

#### Declaration

Swift

``public class AbsOperator: UnaryOperator``
• ``` RadianOperator ```

Compute element-wise radien values of input tensors fro degrees.

See more

#### Declaration

Swift

``public class RadianOperator: UnaryOperator``
• ``` SinhOperator ```

Compute element-wise hyperbolic sine of input tensors.

Note

This operator may output `NaN` or `Infinite` values and operator would not check these situations.
See more

#### Declaration

Swift

``public class SinhOperator: UnaryOperator``
• ``` CoshOperator ```

Compute element-wise hyperbolic cosine of input tensors.

Note

This operator may output `NaN` or `Infinite` values and operator would not check these situations.
See more

#### Declaration

Swift

``public class CoshOperator: UnaryOperator``
• ``` TanhOperator ```

Compute element-wise hyperbolic tangent of input tensors.

Note

This operator may output `NaN` or `Infinite` values and operator would not check these situations.
See more

#### Declaration

Swift

``public class TanhOperator: UnaryOperator``
• ``` ArctanhOperator ```

Compute element-wise inverse hyperbolic tangent on input tensors.

Note

This operator may output `NaN` or `Infinite` values and operator would not check these situations.
See more

#### Declaration

Swift

``public class ArctanhOperator: UnaryOperator``
• ``` ArccoshOperator ```

Compute element-wise inverse hyperbolic cosine on input tensors.

Note

This operator may output `NaN` or `Infinite` values and operator would not check these situations.
See more

#### Declaration

Swift

``public class ArccoshOperator: UnaryOperator``
• ``` ArcsinhOperator ```

Compute element-wise inverse hyperbolic cosine on input tensors.

Note

This operator may output `NaN` or `Infinite` values and operator would not check these situations.
See more

#### Declaration

Swift

``public class ArcsinhOperator: UnaryOperator``
• ``` FloorOperator ```

Operator computes element-wise floor of the input tensors and returen result tensors.

See more

#### Declaration

Swift

``public class FloorOperator: UnaryOperator``
• ``` CeilOperator ```

Operator computes element-wise floor of the input tensors and returen result tensors.

See more

#### Declaration

Swift

``public class CeilOperator: UnaryOperator``
• ``` RintOperator ```

Operator computes element-wise rounded value to the nearest integer of the input.

See more

#### Declaration

Swift

``public class RintOperator: UnaryOperator``
• ``` RoundOperator ```

Operator computes element-wise rounded value to the truncating integers of input values.

See more

#### Declaration

Swift

``public class RoundOperator: UnaryOperator``
• ``` SquareOperator ```

Compute element-wise square values of input tensors.

Note

This operator may output `NaN` or `Infinite` values and operator would not check these situations.
See more

#### Declaration

Swift

``public class SquareOperator: UnaryOperator``
• ``` RsqrtOperator ```

Compute element-wise reciprocal values of square-root of input tensors. `1 / sqrt(x)`

See more

#### Declaration

Swift

``public class RsqrtOperator: UnaryOperator``
• ``` SqrtOperator ```

Compute element-wise square-root values of input tensors.

See more

#### Declaration

Swift

``public class SqrtOperator: UnaryOperator``
• ``` Log1pOperator ```

Compute element-wise `log(1 + x)` values of input tensors. Base is `e`.

See more

#### Declaration

Swift

``public class Log1pOperator: UnaryOperator``
• ``` Log2Operator ```

Compute element-wise `log2(x)` values of input tensors.

See more

#### Declaration

Swift

``public class Log2Operator: UnaryOperator``
• ``` Log10Operator ```

Compute element-wise `log10(x)` values of input tensors.

See more

#### Declaration

Swift

``public class Log10Operator: UnaryOperator``
• ``` LogOperator ```

Compute element-wise `log(x)` values of input tensors. Base is `e`.

See more

#### Declaration

Swift

``public class LogOperator: UnaryOperator``
• ``` Expm1Operator ```

Compute element-wise `e^x - 1` values of input tensors.

Note

This operator may output `NaN` or `Infinite` values and operator would not check these situations.
See more

#### Declaration

Swift

``public class Expm1Operator: UnaryOperator``
• ``` ExpOperator ```

Compute element-wise `exp(x)` values of input tensors.

Note

This operator may output `NaN` or `Infinite` values and operator would not check these situations.
See more

#### Declaration

Swift

``public class ExpOperator: UnaryOperator``
• ``` BroadcastOperator ```

Doing broadcasting on input tensors and store result in output tensors. Serrano follows the broadcasting rule of Scipy.

See more

#### Declaration

Swift

``public class BroadcastOperator: ComputableOperator``
• ``` TransposeOperator ```

Transpose 2D matrix on all `inputTensors` and put transposed values in `outputTensors`.

See more

#### Declaration

Swift

``public class TransposeOperator: ComputableOperator``
• ``` OperatorFuncs ```

Convenient function APIs of operators.

See more

#### Declaration

Swift

``public class OperatorFuncs``
• ``` BroadcastArithmeticOperator ```

The abstract parent class for all broadcast arithmetic oeprators. Any child class of this operator support element-wise calculation between two `Tensor` objects with broadcasting support.

See more

#### Declaration

Swift

``public class BroadcastArithmeticOperator: ComputableOperator``
• ``` BroadcastAddOperator ```

Note

The `inputTensors` of this operator should just have exactly 2 tensors and the `outputTensors` should just have 1 tensor.
See more

#### Declaration

Swift

``public class BroadcastAddOperator: BroadcastArithmeticOperator``
• ``` BroadcastSubOperator ```

Note

The `inputTensors` of this operator should just have exactly 2 tensors and the `outputTensors` should just have 1 tensor.
See more

#### Declaration

Swift

``public class BroadcastSubOperator: BroadcastArithmeticOperator``
• ``` BroadcastMultOperator ```

Note

The `inputTensors` of this operator should just have exactly 2 tensors and the `outputTensors` should just have 1 tensor.
See more

#### Declaration

Swift

``public class BroadcastMultOperator: BroadcastArithmeticOperator``
• ``` BroadcastDivOperator ```

Note

The `inputTensors` of this operator should just have exactly 2 tensors and the `outputTensors` should just have 1 tensor.
See more

#### Declaration

Swift

``public class BroadcastDivOperator: BroadcastArithmeticOperator``
• ``` BinaryOperator ```

Abstract class define the standard binary operator working flow. This class should not be used directly. Any class inheritance this class is doing computation on exactly two input tensors in element-wise way and return one result tensor, i.e. `x + y ->>> z` This `BinaryOperator` does not support broadcasting

See more

#### Declaration

Swift

``public class BinaryOperator: ComputableOperator``
• ``` AddOperator ```

Do `a+b`. Not support broadcasting.

See more

#### Declaration

Swift

``public class AddOperator: BinaryOperator``
• ``` SubOperator ```

Do `a-b`. Not support broadcasting.

See more

#### Declaration

Swift

``public class SubOperator: BinaryOperator``
• ``` MultOperator ```

Do `a*b` in element-wise way. Not support broadcasting.

See more

#### Declaration

Swift

``public class MultOperator: BinaryOperator``
• ``` DivOperator ```

Do `a/b` in element-wise way. Not support broadcasting.

See more

#### Declaration

Swift

``public class DivOperator: BinaryOperator``
• ``` RDivOperator ```

Do `b/a` in element-wise way. Not support broadcasting.

See more

#### Declaration

Swift

``public class RDivOperator: BinaryOperator``
• ``` PowOperator ```

Do `a^b` in element-wise way. Not support broadcasting.

Note

This operator may output `NaN` or `Infinite` values and operator would not check these situations.
See more

#### Declaration

Swift

``public class PowOperator: BinaryOperator``
• ``` MatrixMultOperator ```

matrix multiplication.

## Transpose input tensors

Opertor’s attributes `transposeA` and `transposeB` indicating if tranposing input tensors before doing calculation. And if any or both of them are set to `true`, all caulcation and input/output validation will be doing after transposing.

By default, operator tries to use MPSMatrixMultiplication in `MetalPerformanceShaders`. But on some devices which do not support `MetalPerformanceShaders`, we use self kernel.

## Multiple input

This operator could takein multiple input. Currently, it support multiple input `A` and single input `B`. If `inputTensors` contains more than 2 elements, operator will view last element as input `B` and all previous element as input `A`s.

See more

#### Declaration

Swift

``public class MatrixMultOperator: ComputableOperator``
• ``` RandomValueGenerator ```

Undocumented

See more

#### Declaration

Swift

``public class RandomValueGenerator``
• ``` WeakRef ```

Weak reference object. Used in container of weak reference

See more

#### Declaration

Swift

``public class WeakRef<T: AnyObject>``
• ``` SerranoLogging ```

Undocumented

See more

#### Declaration

Swift

``public class SerranoLogging``
• ``` Tensor ```

A `Tensor` object is a n-dimension page-aligned data container with fixed-size memory space. The attribute `shape` specifying the dimension information of a `Tensor` object.

## All elements stored as `Float` values

No matter what type of array user passing in: `Double` or `Float` or `Int`, inside a `Tensor` object values will be converted and stored as `Float` (32-bit signle precision). `Serrano` chose this because 32-bit `Float` is the maximum precise floating data type `Metal` could support (v1.2).

## Inside Memory Layout

Inside a `Tensor` object, it maintains a virtual 1-d array as a contiguous memory space manually allocated. Elements are stored following `row-major` order. Details can be found in `TensorShape` docs.

## Tensor-Tensor arithmetic operators

Besides Operators which contains many math and NN operations, `Tensor` object itself implements/overloads common arithmetic operators. Tensor object support element-wise arithmetic operation with or without broadcasting. Also it supports in-place operation choice.

• `+` Addition without broadcasting
• `-` Substraction without broadcasting
• `*` Multiplication without broadcasting
• `/` Division without broadcasting

### Element-wise in-place operation:

• `&+` Addition without broadcasting
• `&-` Substraction without broadcasting
• `&*` Multiplication without broadcasting
• `&/` Division without broadcasting

• `.+` Addition without broadcasting
• `.-` Substraction without broadcasting
• `.*` Multiplication without broadcasting
• `./` Division without broadcasting

### Element-wise in-place operation with broadcasting:

• `.&+` Addition without broadcasting
• `.&-` Substraction without broadcasting
• `.&*` Multiplication without broadcasting
• `.&/` Division without broadcasting

Example usage:

``````/// Element wise addition without broadcasting
let tensorA = Tensor(repeatingValue: 1.0,
tensorShape: TensorShape(dataType:.float, shape: [2, 5]))
let tensorB = Tensor(repeatingValue: 2.0,
tensorShape: TensorShape(dataType:.float, shape: [2, 5]))
let result1 = tensorA + tensorB

let result2 = tensorA &+ tensorB
print(result2 == tensorA) // true

let tensorD = Tensor(repeatingValue: 2.0,
tensorShape: TensorShape(dataType:.float, shape: [1, 5]))
let result3 = tensorA .+ tensorD

let resunt4 = tensorA .&+ tensorD
print(result4 == tensorA) // true
``````

## Directly used as TensorSymbol

`Tensor` conforms to `TensorSymbol` protocol. So a tensor object could be used as a symbol participating in graph computation.

See more

#### Declaration

Swift

``public class Tensor: Hashable, Equatable, TensorSymbol``
• ``` MetalHardwareChecker ```

This util class contains APIs that check the device’s hardware capabilities and limits accroding to Apple’s official docs.

Note

The limits values of each type of hardware device should be checked and updated with Apple’s doc frequently. If you find any mismatching with Apple’s official doc, please make a PR at github.
See more

#### Declaration

Swift

``public class MetalHardwareChecker``
• ``` SerranoEngine ```

This class is supposed be initialized and configured at the very beggining of your app. It is responsible for setting up computation envirionment involving with iOS’s GPU device. It will initialize serveral instances which will involve with heavy GPU evaluation and are reconmmended reusing by Apple documentation.

The `configuredEngine` is a singleton instance and should be used everywhere you need to access `GPUDevice` (an instance of `MTLDevice`),\ `serranoCommandQueue` (an instance of `MTLCommandQueue`).

Initial and configure a GPU engine:

``````   let configuredEngine = SerranoEngine.configuredEngine
let (success, message) = configuredEngine.configureEngine(computationMode: .GPU, serranoCommandQueue: nil, serranoMTLLibrary: nil, systemDefaultGPUDevice: nil)
if !success {
// Failed to congiure GPU device
print(message)
}
``````

Initial and configure a CPU engine:

``````    let configuredEngine = SerranoEngine.configuredEngine
configuredEngine.configureEngine(computationMode: .CPU, serranoCommandQueue: nil, serranoMTLLibrary: nil, systemDefaultGPUDevice: nil)
``````
See more

#### Declaration

Swift

``public class SerranoEngine``
• ``` TensorUtils ```

Undocumented

See more

#### Declaration

Swift

``public class TensorUtils``
• ``` OperatorUtils ```

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

See more

#### Declaration

Swift

``public class OperatorUtils``
• ``` SerranoResourceManager ```

This is a framework level class

See more

#### Declaration

Swift

``public class SerranoResourceManager``