# Classes#

## Summary#

class |
class parent |
truncated documentation |
---|---|---|

Abs === Absolute takes one input data (Tensor<T>) and produces one output data (Tensor<T>) where the absolute is, y = … |
||

Acos ==== Calculates the arccosine (inverse of cosine) of the given input tensor, element-wise. |
||

Acosh ===== Calculates the hyperbolic arccosine of the given input tensor element-wise. |
||

Adagrad (ai.onnx.preview.training) ================================== Compute one iteration of ADAGRAD, a stochastic gradient … |
||

Adam (ai.onnx.preview.training) =============================== Compute one iteration of Adam, a stochastic gradient based … |
||

Add === Performs element-wise binary addition (with Numpy-style broadcasting support). This operator supports **multidirectional … |
||

Structure which contains the necessary information to display a graph using an adjacency matrix. |
||

And === Returns the tensor resulted from performing the and logical operation elementwise on the input tensors A and … |
||

ArgMax ====== Computes the indices of the max elements of the input tensor’s element along the provided axis. The resulting … |
||

ArgMax ====== Computes the indices of the max elements of the input tensor’s element along the provided axis. The resulting … |
||

ArgMin ====== Computes the indices of the min elements of the input tensor’s element along the provided axis. The resulting … |
||

ArgMin ====== Computes the indices of the min elements of the input tensor’s element along the provided axis. The resulting … |
||

ArrayFeatureExtractor (ai.onnx.ml) ================================== Select elements of the input tensor based on the … |
||

Mocks an array without changing the data it receives. Notebooks Time processing for every ONNX nodes in a graph illustrates the weaknesses … |
||

Asin ==== Calculates the arcsine (inverse of sine) of the given input tensor, element-wise. |
||

Asinh ===== Calculates the hyperbolic arcsine of the given input tensor element-wise. |
||

Atan ==== Calculates the arctangent (inverse of tangent) of the given input tensor, element-wise. |
||

Atanh ===== Calculates the hyperbolic arctangent of the given input tensor element-wise. |
||

Class wrapping a function to make it simple as a parameter. |
||

Extends the API to automatically look for exporters. |
||

Extends the API to automatically look for exporters. |
||

AveragePool =========== AveragePool consumes an input tensor X and applies average pooling across the tensor according … |
||

BatchNormalization ================== Carries out batch normalization as described in the paper https://arxiv.org/abs/1502.03167. … |
||

BatchNormalization ================== Carries out batch normalization as described in the paper https://arxiv.org/abs/1502.03167. … |
||

Bernoulli ========= Draws binary random numbers (0 or 1) from a Bernoulli distribution. The input tensor should be a tensor … |
||

BiGraph representation. |
||

Binarizer (ai.onnx.ml) ====================== Maps the values of the input tensor to either 0 or 1, element-wise, based … |
||

BitShift ======== Bitwise shift operator performs element-wise operation. For each input element, if the attribute “direction” … |
||

Returns … |
||

BroadcastGradientArgs (mlprodict) ================================= |
||

Defines a schema for operators added in this package such as |
||

CDist (mlprodict) ================= |
||

Defines a schema for operators added in this package such as |
||

Stores all the necessary information to cache the preprocessing of a an einsum equation. |
||

Cast ==== The operator casts the elements of a given input tensor to a data type specified by the ‘to’ argument and returns … |
||

CastLike ======== The operator casts the elements of a given input tensor (the first input) to the same data type as the … |
||

CategoryMapper (ai.onnx.ml) =========================== Converts strings to integers and vice versa. Two sequences of … |
||

Ceil ==== Ceil takes one input data (Tensor<T>) and produces one output data (Tensor<T>) where the ceil is, y = ceil(x), … |
||

Celu ==== Continuously Differentiable Exponential Linear Units: Perform the linear unit element-wise on the input tensor … |
||

Class hosting information about a graph. |
||

Registry. |
||

Clip ==== Clip operator limits the given input within an interval. The interval is specified by the inputs ‘min’ and ‘max’. … |
||

Clip ==== Clip operator limits the given input within an interval. The interval is specified by the inputs ‘min’ and ‘max’. … |
||

Defines a visitor which walks though the syntax tree of the code. |
||

Visits the code, implements verification rules. |
||

Class which converts a Python function into something else. It must implements methods |
||

Runtime for operator |
||

Raised when a compilation error was detected. |
||

ComplexAbs (mlprodict) ====================== |
||

Defines a schema for operators added in this package such as |
||

Compress ======== Selects slices from an input tensor along a given axis where condition evaluates to True for each axis … |
||

Concat ====== Concatenate a list of tensors into a single tensor. All input tensors must have the same shape, except for … |
||

ConcatFromSequence ================== Concatenate a sequence of tensors into a single tensor. All input tensors must have … |
||

ConstantOfShape =============== Generate a tensor with given value and shape. |
||

Constant ======== This operator produces a constant tensor. Exactly one of the provided attributes, either value, sparse_value, … |
||

Constant ======== This operator produces a constant tensor. Exactly one of the provided attributes, either value, sparse_value, … |
||

Conv ==== The convolution operator consumes an input tensor and a filter, and computes the output. |
||

C++ implementation of operator Conv for ReferenceEvaluator. See following example. |
||

Implements float runtime for operator Conv. The code is inspired from conv.cc … |
||

Implements float runtime for operator Conv. The code is inspired from conv.cc … |
||

ConvTranspose ============= The convolution transpose operator consumes an input tensor and a filter, and computes the … |
||

Implements float runtime for operator Conv. The code is inspired from conv_transpose.cc … |
||

Implements float runtime for operator Conv. The code is inspired from conv_transpose.cc … |
||

Cos === Calculates the cosine of the given input tensor, element-wise. |
||

Cosh ==== Calculates the hyperbolic cosine of the given input tensor element-wise. |
||

CumSum ====== Performs cumulative sum of the input elements along the given axis. By default, it will do the sum inclusively … |
||

Wraps a scoring function into a transformer. Function @see fn register_scorers must be called to register the converter … |
||

DEBUG (mlprodict) ================= |
||

Defines a schema for operators added in this package such as |
||

DFT === Computes the discrete Fourier transform of input. |
||

Default value for parameters when the parameter is not set but the operator has a default behaviour for it. |
||

DepthToSpace ============ DepthToSpace rearranges (permutes) data from depth into blocks of spatial data. This is the reverse … |
||

DequantizeLinear ================ The linear dequantization operator. It consumes a quantized tensor, a scale, and a zero … |
||

Det === Det calculates determinant of a square matrix or batches of square matrices. Det takes one input tensor of shape … |
||

Wrapper around a |
||

DictVectorizer (ai.onnx.ml) =========================== Uses an index mapping to convert a dictionary to an array. Given … |
||

Div === Performs element-wise binary division (with Numpy-style broadcasting support). This operator supports **multidirectional … |
||

Dropout ======= Dropout takes an input floating-point tensor, an optional input ratio (floating-point scalar) and an optional … |
||

Dropout ======= Dropout takes an input floating-point tensor, an optional input ratio (floating-point scalar) and an optional … |
||

DynamicQuantizeLinear ===================== A Function to fuse calculation for Scale, Zero Point and FP32->8Bit convertion … |
||

Einsum ====== An einsum of the form |
||

Defines a sub operation used in Einsum decomposition. |
||

Elu === Elu takes one input data (Tensor<T>) and produces one output data (Tensor<T>) where the function f(x) = alpha * (exp(x) - 1.) for x < 0, … |
||

Equal ===== Returns the tensor resulted from performing the equal logical operation elementwise on the input tensors … |
||

Erf === Computes the error function of the given input tensor element-wise. |
||

Temporary name. |
||

Exp === Calculates the exponential of the given input tensor, element-wise. |
||

Expand ====== Broadcast the input tensor following the given shape and the broadcast rule. The broadcast rule is similar … |
||

Expand ====== Broadcast the input tensor following the given shape and the broadcast rule. The broadcast rule is similar … |
||

Expected failure. |
||

Expression (mlprodict) ====================== |
||

Defines a schema for operators added in this package such as |
||

EyeLike ======= Generate a 2D tensor (matrix) with ones on the diagonal and zeros everywhere else. Only 2D tensors are … |
||

FFT (mlprodict) =============== |
||

FFT2D (mlprodict) ================= |
||

Defines a schema for operators added in this package such as |
||

Defines a schema for operators added in this package such as |
||

Identifies a version of a function based on its arguments and its parameters. |
||

Very similar to |
||

Flatten ======= Flattens the input tensor into a 2D matrix. If input tensor has shape (d_0, d_1, . |
||

Raised when a float is out of range and cannot be converted into a float32. |
||

Floor ===== Floor takes one input data (Tensor<T>) and produces one output data (Tensor<T>) where the floor is, y = floor(x), … |
||

FusedMatMul (mlprodict) ======================= |
||

Defines a schema for operators added in this package such as |
||

Wraps GPT2Tokenizer … |
||

GRU === Computes an one-layer GRU. This operator is usually supported via some custom implementation such as CuDNN. Notations: … |
||

Gather ====== Given data tensor of rank r >= 1, and indices tensor of rank q, gather entries of the axis dimension … |
||

Implements runtime for operator Gather. The code is inspired from tfidfvectorizer.cc … |
||

GatherElements ============== GatherElements takes two inputs data and indices of the same rank r >= 1 and an optional … |
||

Implements runtime for operator Gather. The code is inspired from tfidfvectorizer.cc … |
||

Implements runtime for operator Gather. The code is inspired from tfidfvectorizer.cc … |
||

Python runtime for function |
||

Gemm ==== General Matrix multiplication: https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms#Level_3 A’ = transpose(A) … |
||

GlobalAveragePool ================= GlobalAveragePool consumes an input tensor X and applies average pooling across the … |
||

GlobalMaxPool ============= GlobalMaxPool consumes an input tensor X and applies max pooling across the values in the … |
||

Helpers to build graph. |
||

Class gathering all nodes produced to explicit einsum operators. |
||

Greater ======= Returns the tensor resulted from performing the greater logical operation elementwise on the input tensors … |
||

GreaterOrEqual ============== Returns the tensor resulted from performing the greater_equal logical operation elementwise … |
||

GridSample ========== Given an input X and a flow-field grid, computes the output Y using X values and pixel locations … |
||

Implements float runtime for operator GridSample. The code is inspired from pool.cc … |
||

Implements float runtime for operator GridSample. The code is inspired from pool.cc … |
||

Returns where |
||

Returns where |
||

HardSigmoid =========== HardSigmoid takes one input data (Tensor<T>) and produces one output data (Tensor<T>) where the … |
||

Hardmax ======= The operator computes the hardmax values for the given input: Hardmax(element in input, axis) = 1 if … |
||

Identity ======== Identity operator |
||

If == If conditional |
||

Raised if the code shows errors. |
||

Imputer (ai.onnx.ml) ==================== Replaces inputs that equal one value with another, leaving all other elements … |
||

Wrappers around InferenceSession from onnxruntime. |
||

Overwrites class |
||

Instance of |
||

Inverse (mlprodict) =================== |
||

Defines a schema for operators added in this package such as |
||

IsInf ===== Map infinity to true and other values to false. |
||

IsNaN ===== Returns which elements of the input are NaN. |
||

LRN === Local Response Normalization proposed in the [AlexNet paper](https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf). … |
||

LSTM ==== Computes an one-layer LSTM. This operator is usually supported via some custom implementation such as CuDNN. … |
||

LabelEncoder (ai.onnx.ml) ========================= Maps each element in the input tensor to another value. The mapping … |
||

LayerNormalization ================== This is layer normalization defined in ONNX as function. The overall computation … |
||

LeakyRelu ========= LeakyRelu takes input data (Tensor<T>) and an argument alpha, and produces one output data (Tensor<T>) … |
||

Less ==== Returns the tensor resulted from performing the less logical operation elementwise on the input tensors A … |
||

LessOrEqual =========== Returns the tensor resulted from performing the less_equal logical operation elementwise on … |
||

Construct an instance with the lexical scope from the parent graph to allow lookup of names from that scope via this_or_ancestor_graph_has. … |
||

LinearClassifier (ai.onnx.ml) ============================= Linear classifier |
||

LinearRegressor (ai.onnx.ml) ============================ Generalized linear regression evaluation. If targets is set … |
||

Log === Calculates the natural log of the given input tensor, element-wise. |
||

LogSoftmax ========== The operator computes the log of softmax values for the given input: LogSoftmax(input, axis) = … |
||

Loop ==== Generic Looping construct. This loop has multiple termination conditions: 1) Trip count. Iteration count specified … |
||

LpNormalization =============== Given a matrix, apply Lp-normalization along the provided axis. |
||

Base class for every action. |
||

Addition |
||

Any binary operation. |
||

Cast into another type. |
||

Concatenate number of arrays into an array. |
||

Constant |
||

A function. |
||

Any function call. |
||

Addition |
||

Returns a results. |
||

Sign of an expression: 1=positive, 0=negative. |
||

Tensor addition. |
||

Tensor division. |
||

Scalar product. |
||

Tensor multiplication. |
||

Tensor soustraction. |
||

Extracts an element of the tensor. |
||

Tensor operation. |
||

Operator |
||

Operator |
||

Any binary operation. |
||

Variable. The constant is only needed to guess the variable type. |
||

Base class for every machine learned model |
||

Base class for numerical types. |
||

A numpy.bool. |
||

A numpy.float32. |
||

A numpy.float64. |
||

A numpy.int32. |
||

A numpy.int64. |
||

int32 or float32 |
||

Defines a tensor with a dimension and a single type for what it contains. |
||

Base class for every type. |
||

MatMul ====== Matrix product that behaves like numpy.matmul: https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.matmul.html … |
||

Max === Element-wise max of each of the input tensors (with Numpy-style broadcasting support). All inputs and outputs … |
||

MaxPool ======= MaxPool consumes an input tensor X and applies max pooling across the tensor according to kernel sizes, … |
||

Implements float runtime for operator Conv. The code is inspired from pool.cc … |
||

Implements float runtime for operator Conv. The code is inspired from pool.cc … |
||

Mean ==== Element-wise mean of each of the input tensors (with Numpy-style broadcasting support). All inputs and outputs … |
||

Min === Element-wise min of each of the input tensors (with Numpy-style broadcasting support). All inputs and outputs … |
||

Raised when an input is missing. |
||

Missing operator. |
||

Raised when a variable is missing. |
||

A string. |
||

A string and a shape. |
||

A string and a shape and a type. |
||

Mocked lightgbm. |
||

Mod === Performs element-wise binary modulus (with Numpy-style broadcasting support). The sign of the remainder is the … |
||

Momentum (ai.onnx.preview.training) =================================== Compute one iteration of stochastic gradient update … |
||

Mul === Performs element-wise binary multiplication (with Numpy-style broadcasting support). This operator supports **multidirectional … |
||

Class used to return multiple |
||

MurmurHash3 (mlprodict) ======================= |
||

Defines a schema for operators added in this package such as |
||

Used to annotation ONNX numpy functions. |
||

Shortcut to simplify signature description. |
||

Shortcut to simplify signature description. |
||

Shortcut to simplify signature description. |
||

Shortcut to simplify signature description. |
||

Neg === Neg takes one input data (Tensor<T>) and produces one output data (Tensor<T>) where each element flipped sign, … |
||

Python runtime for function |
||

Defines a schema for operators added in this package such as |
||

Defines a result name for a node. |
||

NonMaxSuppression ================= Filter out boxes that have high intersection-over-union (IOU) overlap with previously … |
||

NonZero ======= Returns the indices of the elements that are non-zero (in row-major order - by dimension). NonZero behaves … |
||

Normalizer (ai.onnx.ml) ======================= Normalize the input. There are three normalization modes, which have … |
||

Not === Returns the negation of the input tensor element-wise. |
||

Shape Inference can be implemented but is currently not. |
||

Converts an ONNX operators into numpy code. |
||

OneHot ====== Produces a one-hot tensor based on inputs. The locations represented by the index values in the ‘indices’ … |
||

ONNX specifications does not mention the possibility to change the output type, sparse, dense, float, double. … |
||

Expected failure. |
||

Raised when onnxruntime or mlprodict does not implement a new operator defined in the latest onnx. … |
||

Definition of a backend test. It starts with a folder, in this folder, one onnx file must be there, then a subfolder … |
||

Defines a custom operator for BroadcastGradientArgs. Returns the reduction axes for computing gradients of s0 op s1 … |
||

Defines a custom operator for BroadcastGradientArgs. Returns the reduction axes for computing gradients of s0 op s1 … |
||

Raised when a model fails check. |
||

Defines a custom operator for ComplexAbs. |
||

Defines a custom operator for ComplexAbs. |
||

Wrapper around OnnxIdentity to specify this operator is not part of the subgraph it is used in. |
||

Defines a custom operator for FFT2D. |
||

Defines a custom operator for FFT2D. |
||

Defines a custom operator for FFT. |
||

Defines a custom operator for FFT. |
||

MatMul and Gemm without a C. |
||

MatMul and Gemm without a C. |
||

Loads an ONNX file or object or stream. Computes the output of the ONNX graph. Several runtimes … |
||

onnxruntime API |
||

ONNX backend following the pattern from onnx/backend/base.py. … |
||

Same backend as @see cl OnnxInferenceBackend but runtime is @see cl OnnxMicroRuntime. |
||

Same backend as @see cl OnnxInferenceBackend but runtime is onnxruntime1. |
||

Same backend as @see cl OnnxInferenceBackend but runtime is python_compiled. |
||

Same backend as @see cl OnnxInferenceBackend but runtime is @see cl OnnxShapeInference. |
||

Computes the prediction for an ONNX graph loaded with @see cl OnnxInference. |
||

Same backend as @see cl OnnxInferenceBackend but runtime is @see cl OnnxShapeInference. |
||

Implements methods to export a instance of |
||

A node to execute. |
||

Describes a result type. |
||

Automatically creating all operators from onnx packages takes time. That’s why function |
||

Implements a micro runtime for ONNX graphs. It does not implements all the operator types. |
||

Defines magic commands to help with notebooks |
||

Implements a class which runs onnx graph. |
||

Class wrapping a function build with |
||

Overwrites |
||

Overwrites |
||

Ancestor to every |
||

Base class for |
||

This operator is used to insert existing ONNX function into the ONNX graph being built. |
||

Accessor to one of the output returned by a |
||

Class used to return multiple |
||

The pipeline overwrites method |
||

Defines a custom operator for FFT. |
||

Defines a custom operator for FFT. |
||

Raised when a new operator was added but cannot be found. |
||

Implements a micro runtime for ONNX graphs. It does not implements all the operator types. |
||

Gradient of Softmax. SoftmaxGrad computes . ONNX does not have a dot product, … |
||

Gradient of Softmax. SoftmaxGrad computes . ONNX does not have a dot product, … |
||

Trains with scikit-learn, transform with ONNX. |
||

Trains with scikit-learn, transform with ONNX. |
||

Trains with scikit-learn, transform with ONNX. |
||

Trains with scikit-learn, transform with ONNX. |
||

This operator is used to call the converter of a model to insert the node coming from the conversion into a bigger … |
||

This operator is used to insert existing ONNX into the ONNX graph being built. |
||

Defines a custom operator not defined by ONNX specifications but in onnxruntime. |
||

Defines a custom operator not defined by ONNX specifications but in onnxruntime. |
||

Calls onnxruntime or the runtime implemented in this package to transform input based on a ONNX graph. It … |
||

Class which converts a Python function into an ONNX function. It must implements methods |
||

Variables used into onnx computation. |
||

Overloads |
||

Runs the prediction for a single ONNX, it lets the runtime handle the graph logic as well. |
||

Defines a custom operator for YieldOp. |
||

Defines a custom operator for YieldOp. |
||

Runs a custom function. |
||

Ancestor to all operators in this subfolder. The runtime for every node can checked into ONNX unit tests. … |
||

Ancestor to all unary operators in this subfolder and which produces position of extremas (ArgMax, …). Checks … |
||

Ancestor to all binary operators in this subfolder. Checks that inputs type are the same. |
||

Ancestor to all binary operators in this subfolder comparing tensors. |
||

Ancestor to all binary operators in this subfolder. Checks that inputs type are the same. |
||

Implements the inplaces logic. |
||

Ancestor to all binary operators in this subfolder. Checks that inputs type are the same. |
||

Automates some methods for custom operators defined outside |
||

Base class to cache C++ implementation based on inputs. |
||

Unique operator for an empty runtime. |
||

Unique operator which calls onnxruntime to compute predictions for one operator. |
||

Implements the reduce logic. It must have a parameter |
||

Ancestor to all unary operators in this subfolder. Checks that inputs type are the same. |
||

Ancestor to all unary and numerical operators in this subfolder. Checks that inputs type are the same. |
||

Defines a schema for operators added in this package such as |
||

OptionalGetElement ================== If the input is a tensor or sequence type, it returns the input. If the input is … |
||

OptionalHasElement ================== Returns true if (1) the input is an optional-type and contains an element, or, (2) … |
||

Or == Returns the tensor resulted from performing the or logical operation elementwise on the input tensors A and … |
||

Instance of |
||

PRelu ===== PRelu takes input data (Tensor<T>) and slope tensor as input, and produces one output data (Tensor<T>) where … |
||

Pad === Given a tensor containing the data to be padded (data), a tensor containing the number of start and end pad … |
||

Pad === Given a tensor containing the data to be padded (data), a tensor containing the number of start and end pad … |
||

Pow === Pow takes input data (Tensor<T>) and exponent Tensor, and produces one output data (Tensor<T>) where the function … |
||

QLinearConv =========== The convolution operator consumes a quantized input tensor, its scale and zero point, a quantized … |
||

Implements int8 runtime for operator QLinearConv. The code is inspired from qlinearconv.cc … |
||

Implements uint8 runtime for operator QLinearConvUInt8. The code is inspired from qlinearconv.cc … |
||

QuantizeLinear ============== The linear quantization operator. It consumes a high precision tensor, a scale, and a zero … |
||

Instantiates a quantized tensor (uint8) with bias from a float tensor. |
||

Instantiates a quantized tensor (uint8) from a float tensor. |
||

RFFT (mlprodict) ================ |
||

Defines a schema for operators added in this package such as |
||

RNN === Computes an one-layer simple RNN. This operator is usually supported via some custom implementation such as CuDNN. … |
||

RNN === Computes an one-layer simple RNN. This operator is usually supported via some custom implementation such as CuDNN. … |
||

RandomNormal ============ Generate a tensor with random values drawn from a normal distribution. The shape of the tensor … |
||

RandomNormalLike ================ Generate a tensor with random values drawn from a normal distribution. The shape of … |
||

RandomUniform ============= Generate a tensor with random values drawn from a uniform distribution. The shape of the tensor … |
||

RandomUniformLike ================= Generate a tensor with random values drawn from a uniform distribution. The shape … |
||

Range ===== Generate a tensor containing a sequence of numbers that begin at start and extends by increments of delta … |
||

Reciprocal ========== Reciprocal takes one input data (Tensor<T>) and produces one output data (Tensor<T>) where the reciprocal … |
||

ReduceL1 ======== Computes the L1 norm of the input tensor’s element along the provided axes. The resulting tensor has … |
||

ReduceL1 ======== Computes the L1 norm of the input tensor’s element along the provided axes. The resulting tensor has … |
||

ReduceL2 ======== Computes the L2 norm of the input tensor’s element along the provided axes. The resulting tensor has … |
||

ReduceL2 ======== Computes the L2 norm of the input tensor’s element along the provided axes. The resulting tensor has … |
||

ReduceLogSumExp =============== Computes the log sum exponent of the input tensor’s element along the provided axes. The … |
||

ReduceLogSumExp =============== Computes the log sum exponent of the input tensor’s element along the provided axes. The … |
||

ReduceLogSum ============ Computes the log sum of the input tensor’s element along the provided axes. The resulting tensor … |
||

ReduceLogSum ============ Computes the log sum of the input tensor’s element along the provided axes. The resulting tensor … |
||

ReduceMax ========= Computes the max of the input tensor’s element along the provided axes. The resulting tensor has the … |
||

ReduceMax ========= Computes the max of the input tensor’s element along the provided axes. The resulting tensor has the … |
||

ReduceMean ========== Computes the mean of the input tensor’s element along the provided axes. The resulting tensor has … |
||

ReduceMean ========== Computes the mean of the input tensor’s element along the provided axes. The resulting tensor has … |
||

ReduceMin ========= Computes the min of the input tensor’s element along the provided axes. The resulting tensor has the … |
||

ReduceMin ========= Computes the min of the input tensor’s element along the provided axes. The resulting tensor has the … |
||

ReduceProd ========== Computes the product of the input tensor’s element along the provided axes. The resulting tensor … |
||

ReduceProd ========== Computes the product of the input tensor’s element along the provided axes. The resulting tensor … |
||

ReduceSumSquare =============== Computes the sum square of the input tensor’s element along the provided axes. The resulting … |
||

ReduceSumSquare =============== Computes the sum square of the input tensor’s element along the provided axes. The resulting … |
||

ReduceSum ========= Computes the sum of the input tensor’s element along the provided axes. The resulting tensor has the … |
||

ReduceSum ========= Computes the sum of the input tensor’s element along the provided axes. The resulting tensor has the … |
||

Implements a link between a parameter of a function and an attribute in node. |
||

Relu ==== Relu takes one input data (Tensor<T>) and produces one output data (Tensor<T>) where the rectified linear function, … |
||

Reshape ======= Reshape the input tensor similar to numpy.reshape. First input is the data tensor, second input is a shape … |
||

Reshape ======= Reshape the input tensor similar to numpy.reshape. First input is the data tensor, second input is a shape … |
||

Resize ====== Resize the input tensor. In general, it calculates every value in the output tensor as a weighted average … |
||

RoiAlign ======== Region of Interest (RoI) align operation described in the [Mask R-CNN paper](https://arxiv.org/abs/1703.06870). … |
||

Implements float runtime for operator RoiAlign. The code is inspired from pool.cc … |
||

Implements float runtime for operator RoiAlign. The code is inspired from pool.cc … |
||

Round ===== Round takes one input Tensor and rounds the values, element-wise, meaning it finds the nearest integer for … |
||

Raised when the results are too different from scikit-learn. |
||

Implements runtime for operator NonMaxSuppression. The code is inspired from non_max_suppression.cc … |
||

Implements runtime for operator SVMClassifierDouble. The code is inspired from svm_classifier.cc … |
||

Implements runtime for operator SVMClassifier. The code is inspired from svm_classifier.cc … |
||

Implements Double runtime for operator SVMRegressor. The code is inspired from svm_regressor.cc … |
||

Implements float runtime for operator SVMRegressor. The code is inspired from svm_regressor.cc … |
||

Implements runtime for operator TfIdfVectorizer. The code is inspired from tfidfvectorizer.cc … |
||

Implements runtime for operator TreeEnsembleClassifier. The code is inspired from tree_ensemble_classifier.cc … |
||

Implements runtime for operator TreeEnsembleClassifier. The code is inspired from tree_ensemble_classifier.cc … |
||

Implements double runtime for operator TreeEnsembleClassifier. The code is inspired from tree_ensemble_Classifier.cc … |
||

Implements float runtime for operator TreeEnsembleClassifier. The code is inspired from tree_ensemble_Classifier.cc … |
||

Implements double runtime for operator TreeEnsembleRegressor. The code is inspired from tree_ensemble_regressor.cc … |
||

Implements float runtime for operator TreeEnsembleRegressor. The code is inspired from tree_ensemble_regressor.cc … |
||

Implements double runtime for operator TreeEnsembleRegressor. The code is inspired from tree_ensemble_regressor.cc … |
||

Implements float runtime for operator TreeEnsembleRegressor. The code is inspired from tree_ensemble_regressor.cc … |
||

Raised when a type of a variable is unexpected. |
||

STFT ==== Computes the Short-time Fourier Transform of the signal. |
||

SVMClassifier (ai.onnx.ml) ========================== Support Vector Machine classifier |
||

SVMClassifierDouble (mlprodict) =============================== |
||

Defines a schema for operators added in this package such as |
||

SVMRegressor (ai.onnx.ml) ========================= Support Vector Machine regression prediction and one-class SVM anomaly … |
||

SVMRegressorDouble (mlprodict) ============================== |
||

Defines a schema for operators added in this package such as |
||

Scaler (ai.onnx.ml) =================== Rescale input data, for example to standardize features by removing the mean and … |
||

Scan ==== Scan can be used to iterate over one or more scan_input tensors, constructing zero or more scan_output tensors. … |
||

ScatterElements =============== ScatterElements takes three inputs data, updates, and indices of the same rank r … |
||

ScatterND ========= ScatterND takes three inputs data tensor of rank r >= 1, indices tensor of rank q >= 1, and updates … |
||

Wrapper around a schema. |
||

Selu ==== Selu takes one input data (Tensor<T>) and produces one output data (Tensor<T>) where the scaled exponential … |
||

Wraps SentencePieceTokenizer … |
||

SequenceAt ========== Outputs a tensor copy from the tensor at ‘position’ in ‘input_sequence’. Accepted range for ‘position’ … |
||

SequenceConstruct ================= Construct a tensor sequence containing ‘inputs’ tensors. All tensors in ‘inputs’ must … |
||

SequenceEmpty ============= Construct an empty tensor sequence, with given data type. |
||

SequenceInsert ============== Outputs a tensor sequence that inserts ‘tensor’ into ‘input_sequence’ at ‘position’. ‘tensor’ … |
||

One constraint. |
||

A list of ShapeConstraint. |
||

Stores all infered shapes as |
||

Raised when the shape cannot continue due to unknown dimension. |
||

Raised when shape inference fails. |
||

Raised when an operator is missing. |
||

Contains information about shape and type of a result in an onnx graph. |
||

Shape ===== Takes a tensor as input and outputs an 1D int64 tensor containing the shape of the input tensor. Optional … |
||

Shape ===== Takes a tensor as input and outputs an 1D int64 tensor containing the shape of the input tensor. Optional … |
||

Shrink ====== Shrink takes one input data (Tensor<numeric>) and produces one Tensor output, having same datatype and shape … |
||

Sigmoid ======= Sigmoid takes one input data (Tensor<T>) and produces one output data (Tensor<T>) where the sigmoid function, … |
||

Sign ==== Calculate the sign of the given input tensor element-wise. If input > 0, output 1. if input < 0, output -1. … |
||

Simple wrapper around InferenceSession which imitates |
||

Sin === Calculates the sine of the given input tensor, element-wise. |
||

Sinh ==== Calculates the hyperbolic sine of the given input tensor element-wise. |
||

Size ==== Takes a tensor as input and outputs a int64 scalar that equals to the total number of elements of the input … |
||

Slice ===== Produces a slice of the input tensor along multiple axes. Similar to numpy: https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html … |
||

Slice ===== Produces a slice of the input tensor along multiple axes. Similar to numpy: https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html … |
||

Python runtime for function |
||

Defines a schema for operators added in this package such as |
||

SoftmaxGrad computes . ONNX does not have a dot product, which can be … |
||

SoftmaxGrad computes . ONNX does not have a dot product, which can be … |
||

Softmax ======= The operator computes the normalized exponential values for the given input: Softmax(input, axis) = … |
||

Softmax ======= The operator computes the normalized exponential values for the given input: Softmax(input, axis) = … |
||

Softplus ======== Softplus takes one input data (Tensor<T>) and produces one output data (Tensor<T>) where the softplus … |
||

Softsign ======== Calculates the softsign (x/(1+|x|)) of the given input tensor element-wise. |
||

Solve (mlprodict) ================= |
||

Defines a schema for operators added in this package such as |
||

SpaceToDepth ============ SpaceToDepth rearranges blocks of spatial data into depth. More specifically, this op outputs … |
||

Runtime for operator |
||

Runtime for operator |
||

Runtime for operator |
||

Runtime for operator |
||

Sqrt ==== Square root takes one input data (Tensor<T>) and produces one output data (Tensor<T>) where the square root … |
||

Squeeze ======= Remove single-dimensional entries from the shape of a tensor. Takes an input axes with a list of axes … |
||

Squeeze ======= Remove single-dimensional entries from the shape of a tensor. Takes an input axes with a list of axes … |
||

The operator is not really threadsafe as python cannot play with two locales at the same time. stop words should … |
||

Sub === Performs element-wise binary subtraction (with Numpy-style broadcasting support). This operator supports **multidirectional … |
||

Sum === Element-wise sum of each of the input tensors (with Numpy-style broadcasting support). All inputs and outputs … |
||

Tan === Calculates the tangent of the given input tensor, element-wise. |
||

Tanh ==== Calculates the hyperbolic tangent of the given input tensor element-wise. |
||

asv test for a classifier, Full template can be found in common_asv_skl.py. … |
||

asv test for a classifier, Full template can be found in common_asv_skl.py. … |
||

asv example for a clustering algorithm, Full template can be found in common_asv_skl.py. … |
||

asv example for a classifier, Full template can be found in common_asv_skl.py. … |
||

asv example for an outlier detector, Full template can be found in common_asv_skl.py. … |
||

asv example for a regressor, Full template can be found in common_asv_skl.py. … |
||

asv example for a trainable transform, Full template can be found in common_asv_skl.py. … |
||

asv example for a transform, Full template can be found in common_asv_skl.py. … |
||

asv example for a transform, Full template can be found in common_asv_skl.py. … |
||

Applies the converter on an ONNX graph. |
||

TfIdfVectorizer =============== This transform extracts n-grams from the input sequence and save them as a vector. Input … |
||

ThresholdedRelu =============== ThresholdedRelu takes one input data (Tensor<T>) and produces one output data (Tensor<T>) … |
||

See Tokenizer. |
||

Defines a schema for operators added in this package such as |
||

Base class for |
||

TopK ==== Retrieve the top-K largest or smallest elements along a specified axis. Given an input tensor of shape [a_1, … |
||

TopK ==== Retrieve the top-K largest or smallest elements along a specified axis. Given an input tensor of shape [a_1, … |
||

Transpose ========= Transpose the input tensor similar to numpy.transpose. For example, when perm=(1, 0, 2), given an … |
||

TreeEnsembleClassifierDouble (mlprodict) ======================================== |
||

Defines a schema for operators added in this package such as |
||

TreeEnsembleClassifier (ai.onnx.ml) =================================== Tree Ensemble classifier. Returns the top class … |
||

TreeEnsembleClassifier (ai.onnx.ml) =================================== Tree Ensemble classifier. Returns the top class … |
||

Runtime for the custom operator TreeEnsembleRegressorDouble. |
||

Defines a schema for operators added in this package such as |
||

TreeEnsembleRegressor (ai.onnx.ml) ================================== Tree Ensemble regressor. Returns the regressed … |
||

TreeEnsembleRegressor (ai.onnx.ml) ================================== Tree Ensemble regressor. Returns the regressed … |
||

Trilu ===== Given a 2-D matrix or batches of 2-D matrices, returns the upper or lower triangular part of the tensor(s). … |
||

Undefined schema. |
||

Unique ====== Find the unique elements of a tensor. When an optional attribute ‘axis’ is provided, unique subtensors sliced … |
||

Unsqueeze ========= Insert single-dimensional entries to the shape of an input tensor (data). Takes one required input … |
||

Unsqueeze ========= Insert single-dimensional entries to the shape of an input tensor (data). Takes one required input … |
||

An input or output to an ONNX graph. |
||

Where ===== Return elements, either from X or Y, depending on condition. Where behaves like [numpy.where](https://docs.scipy.org/doc/numpy/reference/generated/numpy.where.html) … |
||

A booster can be a classifier, a regressor. Trick to wrap it in a minimal function. |
||

Trick to wrap a LGBMClassifier into a class. |
||

converter for XGBClassifier |
||

common methods for converters |
||

converter class |
||

Xor === Returns the tensor resulted from performing the xor logical operation elementwise on the input tensors A and … |
||

YieldOp (mlprodict) =================== |
||

Defines a schema for operators added in this package such as |
||

The class does not output a dictionary as specified in ONNX specifications but a |
||

Custom dictionary class much faster for this runtime, it implements a subset of the same methods. |
||

Base class for runtime for operator ArgMax. … |
||

Base class for runtime for operator ArgMin. … |
||

Labels strings are not natively implemented in C++ runtime. The class stores the strings labels, replaces them by … |
||

Common tests to all benchmarks testing converted scikit-learn models. See benchmark attributes. … |
||

Common class for a classifier. |
||

Common class for a classifier. |
||

Common class for a clustering algorithm. |
||

Common class for a multi-classifier. |
||

Common class for outlier detection. |
||

Common class for a regressor. |
||

Common class for a trainable transformer. |
||

Common class for a transformer. |
||

Common class for a transformer for positive features. |
||

Common methods to all random operators. |
||

Ths class hides a parameter used as a threshold above which the parallelisation is started: |
||

For operators defined outside onnx. |
||

Graph builder. It takes a graph structure made with instances of |
||

Ancestor to custom signature. |
||

Speeds up inference by replacing methods |
||

Holds static variables. |
||

Wrappers around class |
||

Wrappers around print to help debugging. |
||

Class to store all dynamic classes created by wrappers. |
||

Overwrites class dictionary to debug more easily. |
||

Overloads class |
||

Decorator to register any new converter. |
||

Intermediate wrapper to store a pointer on the compiler (type: |
||

Intermediate wrapper to store a pointer on the compiler (type: |