.. _l-classes: Classes ======= .. contents:: :local: :depth: 1 Summary +++++++ +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | class | class parent | truncated documentation | +=====================================================================================================================================================+==============+=======================================================================================================================================================================================================================================================+ | :class:`Abs ` | | Abs === Absolute takes one input data (Tensor) and produces one output data (Tensor) where the absolute is, y = ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Acos ` | | Acos ==== Calculates the arccosine (inverse of cosine) of the given input tensor, element-wise. **Inputs** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Acosh ` | | Acosh ===== Calculates the hyperbolic arccosine of the given input tensor element-wise. **Inputs** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Adagrad ` | | Adagrad (ai.onnx.preview.training) ================================== Compute one iteration of ADAGRAD, a stochastic gradient ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Adam ` | | Adam (ai.onnx.preview.training) =============================== Compute one iteration of Adam, a stochastic gradient based ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Add ` | | Add === Performs element-wise binary addition (with Numpy-style broadcasting support). This operator supports **multidirectional ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`AdjacencyGraphDisplay ` | | Structure which contains the necessary information to display a graph using an adjacency matrix. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`And ` | | And === Returns the tensor resulted from performing the `and` logical operation elementwise on the input tensors `A` and ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ArgMax_11 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ArgMax_12 ` | | ArgMax ====== Computes the indices of the max elements of the input tensor's element along the provided axis. The resulting ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ArgMax_12 ` | | ArgMax ====== Computes the indices of the max elements of the input tensor's element along the provided axis. The resulting ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ArgMin_11 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ArgMin_12 ` | | ArgMin ====== Computes the indices of the min elements of the input tensor's element along the provided axis. The resulting ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ArgMin_12 ` | | ArgMin ====== Computes the indices of the min elements of the input tensor's element along the provided axis. The resulting ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ArrayFeatureExtractor ` | | ArrayFeatureExtractor (ai.onnx.ml) ================================== Select elements of the input tensor based on the ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ArrayZipMapDictionary ` | | Mocks an array without changing the data it receives. Notebooks :ref:`onnxnodetimerst` illustrates the weaknesses ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Asin ` | | Asin ==== Calculates the arcsine (inverse of sine) of the given input tensor, element-wise. **Inputs** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Asinh ` | | Asinh ===== Calculates the hyperbolic arcsine of the given input tensor element-wise. **Inputs** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Atan ` | | Atan ==== Calculates the arctangent (inverse of tangent) of the given input tensor, element-wise. **Inputs** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Atanh ` | | Atanh ===== Calculates the hyperbolic arctangent of the given input tensor element-wise. **Inputs** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`AttributeGraph ` | | Class wrapping a function to make it simple as a parameter. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`AutoAction ` | | Extends the API to automatically look for exporters. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`AutoType ` | | Extends the API to automatically look for exporters. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`AveragePool ` | | AveragePool =========== AveragePool consumes an input tensor X and applies average pooling across the tensor according ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`BatchNormalization_14 ` | | BatchNormalization ================== Carries out batch normalization as described in the paper https://arxiv.org/abs/1502.03167. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`BatchNormalization_14 ` | | BatchNormalization ================== Carries out batch normalization as described in the paper https://arxiv.org/abs/1502.03167. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`BatchNormalization_9 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Bernoulli ` | | Bernoulli ========= Draws binary random numbers (0 or 1) from a Bernoulli distribution. The input tensor should be a tensor ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`BiGraph ` | | BiGraph representation. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Binarizer ` | | Binarizer (ai.onnx.ml) ====================== Maps the values of the input tensor to either 0 or 1, element-wise, based ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`BitShift ` | | BitShift ======== Bitwise shift operator performs element-wise operation. For each input element, if the attribute "direction" ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`BlackmanWindow ` | | Returns :math:`\omega_n = 0.42 - 0.5 \cos \left( \frac{2\pi n}{N-1} \right) + 0.08 \cos \left( \frac{4\pi n}{N-1} \right)` ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`BroadcastGradientArgs ` | | BroadcastGradientArgs (mlprodict) ================================= **Version** *Onnx name:* `BroadcastGradientArgs `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`BroadcastGradientArgsSchema ` | | Defines a schema for operators added in this package such as :class:`BroadcastGradientArgs`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`CDist ` | | CDist (mlprodict) ================= **Version** *Onnx name:* `CDist `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`CDistSchema ` | | Defines a schema for operators added in this package such as :class:`TreeEnsembleClassifierDouble`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`CachedEinsum ` | | Stores all the necessary information to cache the preprocessing of a an einsum equation. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Cast ` | | Cast ==== The operator casts the elements of a given input tensor to a data type specified by the 'to' argument and returns ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`CastLike ` | | CastLike ======== The operator casts the elements of a given input tensor (the first input) to the same data type as the ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`CategoryMapper ` | | CategoryMapper (ai.onnx.ml) =========================== Converts strings to integers and vice versa. Two sequences of ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Ceil ` | | Ceil ==== Ceil takes one input data (Tensor) and produces one output data (Tensor) where the ceil is, y = ceil(x), ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Celu ` | | Celu ==== Continuously Differentiable Exponential Linear Units: Perform the linear unit element-wise on the input tensor ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`CheckerContext ` | | Class hosting information about a graph. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`CheckerContextDefaultRegistry ` | | Registry. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Clip_11 ` | | Clip ==== Clip operator limits the given input within an interval. The interval is specified by the inputs 'min' and 'max'. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Clip_11 ` | | Clip ==== Clip operator limits the given input within an interval. The interval is specified by the inputs 'min' and 'max'. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Clip_6 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`CodeNodeVisitor ` | | Defines a visitor which walks though the syntax tree of the code. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`CodeNodeVisitor ` | | Visits the code, implements verification rules. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`CodeTranslator ` | | Class which converts a Python function into something else. It must implements methods *visit* and *depart*. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`CommonExpand ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`CommonGRU ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`CommonLSTM ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`CommonRNN ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`CommonReshape ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`CommonSplit ` | | Runtime for operator *Split*. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`CompilationError ` | | Raised when a compilation error was detected. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ComplexAbs ` | | ComplexAbs (mlprodict) ====================== **Version** *Onnx name:* `ComplexAbs `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ComplexAbsSchema ` | | Defines a schema for operators added in this package such as :class:`ComplexAbs`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Compress ` | | Compress ======== Selects slices from an input tensor along a given axis where condition evaluates to True for each axis ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Concat ` | | Concat ====== Concatenate a list of tensors into a single tensor. All input tensors must have the same shape, except for ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ConcatFromSequence ` | | ConcatFromSequence ================== Concatenate a sequence of tensors into a single tensor. All input tensors must have ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ConstantOfShape ` | | ConstantOfShape =============== Generate a tensor with given value and shape. **Attributes** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Constant_11 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Constant_12 ` | | Constant ======== This operator produces a constant tensor. Exactly one of the provided attributes, either value, sparse_value, ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Constant_12 ` | | Constant ======== This operator produces a constant tensor. Exactly one of the provided attributes, either value, sparse_value, ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Constant_9 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Conv ` | | Conv ==== The convolution operator consumes an input tensor and a filter, and computes the output. **Attributes** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Conv ` | | C++ implementation of operator Conv for :epkg:`ReferenceEvaluator`. See following example. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ConvDouble ` | | Implements float runtime for operator Conv. The code is inspired from `conv.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ConvFloat ` | | Implements float runtime for operator Conv. The code is inspired from `conv.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ConvTranspose ` | | ConvTranspose ============= The convolution transpose operator consumes an input tensor and a filter, and computes the ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ConvTransposeDouble ` | | Implements float runtime for operator Conv. The code is inspired from `conv_transpose.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ConvTransposeFloat ` | | Implements float runtime for operator Conv. The code is inspired from `conv_transpose.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Cos ` | | Cos === Calculates the cosine of the given input tensor, element-wise. **Inputs** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Cosh ` | | Cosh ==== Calculates the hyperbolic cosine of the given input tensor element-wise. **Inputs** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`CumSum ` | | CumSum ====== Performs cumulative sum of the input elements along the given axis. By default, it will do the sum inclusively ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`CustomScorerTransform ` | | Wraps a scoring function into a transformer. Function @see fn register_scorers must be called to register the converter ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`DEBUG ` | | DEBUG (mlprodict) ================= **Version** *Onnx name:* `DEBUG `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`DEBUGSchema ` | | Defines a schema for operators added in this package such as :class:`Solve`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`DFT ` | | DFT === Computes the discrete Fourier transform of input. **Attributes** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`DefaultNone ` | | Default value for parameters when the parameter is not set but the operator has a default behaviour for it. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`DepthToSpace ` | | DepthToSpace ============ DepthToSpace rearranges (permutes) data from depth into blocks of spatial data. This is the reverse ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`DequantizeLinear ` | | DequantizeLinear ================ The linear dequantization operator. It consumes a quantized tensor, a scale, and a zero ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Det ` | | Det === Det calculates determinant of a square matrix or batches of square matrices. Det takes one input tensor of shape ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`DetectedVariable ` | | Wrapper around a :class:`Variable` to detect inputs and outputs of a graph. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`DictVectorizer ` | | DictVectorizer (ai.onnx.ml) =========================== Uses an index mapping to convert a dictionary to an array. Given ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Div ` | | Div === Performs element-wise binary division (with Numpy-style broadcasting support). This operator supports **multidirectional ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`DropoutBase ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Dropout_12 ` | | Dropout ======= Dropout takes an input floating-point tensor, an optional input ratio (floating-point scalar) and an optional ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Dropout_12 ` | | Dropout ======= Dropout takes an input floating-point tensor, an optional input ratio (floating-point scalar) and an optional ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Dropout_7 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`DynamicQuantizeLinear ` | | DynamicQuantizeLinear ===================== A Function to fuse calculation for Scale, Zero Point and FP32->8Bit convertion ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Einsum ` | | Einsum ====== An einsum of the form ``term1, term2 -> output-term`` produces an output tensor using the following equation ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`EinsumSubOp ` | | Defines a sub operation used in Einsum decomposition. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Elu ` | | Elu === Elu takes one input data (Tensor) and produces one output data (Tensor) where the function `f(x) = alpha * (exp(x) - 1.) for x < 0`, ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Equal ` | | Equal ===== Returns the tensor resulted from performing the `equal` logical operation elementwise on the input tensors ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Erf ` | | Erf === Computes the error function of the given input tensor element-wise. **Inputs** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ExistingVariable ` | | Temporary name. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Exp ` | | Exp === Calculates the exponential of the given input tensor, element-wise. **Inputs** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Expand_13 ` | | Expand ====== Broadcast the input tensor following the given shape and the broadcast rule. The broadcast rule is similar ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Expand_13 ` | | Expand ====== Broadcast the input tensor following the given shape and the broadcast rule. The broadcast rule is similar ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ExpectedAssertionError ` | | Expected failure. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Expression ` | | Expression (mlprodict) ====================== **Version** *Onnx name:* `Expression `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ExpressionSchema ` | | Defines a schema for operators added in this package such as :class:`ComplexAbs`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`EyeLike ` | | EyeLike ======= Generate a 2D tensor (matrix) with ones on the diagonal and zeros everywhere else. Only 2D tensors are ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`FFT ` | | FFT (mlprodict) =============== **Version** *Onnx name:* `FFT `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`FFT2D ` | | FFT2D (mlprodict) ================= **Version** *Onnx name:* `FFT2D `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`FFT2DSchema ` | | Defines a schema for operators added in this package such as :class:`FFT`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`FFTSchema ` | | Defines a schema for operators added in this package such as :class:`FFT`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`FctVersion ` | | Identifies a version of a function based on its arguments and its parameters. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`FeatureVectorizer ` | | Very similar to :class:`Concat`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Flatten ` | | Flatten ======= Flattens the input tensor into a 2D matrix. If input tensor has shape (d_0, d_1, . | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Float32InfError ` | | Raised when a float is out of range and cannot be converted into a float32. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Floor ` | | Floor ===== Floor takes one input data (Tensor) and produces one output data (Tensor) where the floor is, y = floor(x), ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`FusedMatMul ` | | FusedMatMul (mlprodict) ======================= **Version** *Onnx name:* `FusedMatMul `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`FusedMatMulSchema ` | | Defines a schema for operators added in this package such as :class:`FusedMatMul`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`GPT2TokenizerTransformer ` | | Wraps `GPT2Tokenizer `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`GRU ` | | GRU === Computes an one-layer GRU. This operator is usually supported via some custom implementation such as CuDNN. Notations: ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Gather ` | | Gather ====== Given `data` tensor of rank r >= 1, and `indices` tensor of rank q, gather entries of the axis dimension ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`GatherDouble ` | | Implements runtime for operator Gather. The code is inspired from `tfidfvectorizer.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`GatherElements ` | | GatherElements ============== GatherElements takes two inputs `data` and `indices` of the same rank r >= 1 and an optional ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`GatherFloat ` | | Implements runtime for operator Gather. The code is inspired from `tfidfvectorizer.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`GatherInt64 ` | | Implements runtime for operator Gather. The code is inspired from `tfidfvectorizer.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`GatherND ` | | Python runtime for function *SoftmaxCrossEntropyLoss*. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Gemm ` | | Gemm ==== General Matrix multiplication: https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms#Level_3 A' = transpose(A) ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`GlobalAveragePool ` | | GlobalAveragePool ================= GlobalAveragePool consumes an input tensor X and applies average pooling across the ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`GlobalMaxPool ` | | GlobalMaxPool ============= GlobalMaxPool consumes an input tensor X and applies max pooling across the values in the ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`GraphBuilder ` | | Helpers to build graph. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`GraphEinsumSubOp ` | | Class gathering all nodes produced to explicit einsum operators. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Greater ` | | Greater ======= Returns the tensor resulted from performing the `greater` logical operation elementwise on the input tensors ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`GreaterOrEqual ` | | GreaterOrEqual ============== Returns the tensor resulted from performing the `greater_equal` logical operation elementwise ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`GridSample ` | | GridSample ========== Given an input `X` and a flow-field `grid`, computes the output `Y` using `X` values and pixel locations ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`GridSampleDouble ` | | Implements float runtime for operator GridSample. The code is inspired from `pool.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`GridSampleFloat ` | | Implements float runtime for operator GridSample. The code is inspired from `pool.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`HammingWindow ` | | Returns :math:`\omega_n = \alpha - \beta \cos \left( \frac{\pi n}{N-1} \right)` where *N* is the window length. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`HannWindow ` | | Returns :math:`\omega_n = \sin^2\left( \frac{\pi n}{N-1} \right)` where *N* is the window length. See `hann_window `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`HardSigmoid ` | | HardSigmoid =========== HardSigmoid takes one input data (Tensor) and produces one output data (Tensor) where the ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Hardmax ` | | Hardmax ======= The operator computes the hardmax values for the given input: Hardmax(element in input, axis) = 1 if ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Identity ` | | Identity ======== Identity operator **Inputs** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`If ` | | If == If conditional **Attributes** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ImperfectPythonCode ` | | Raised if the code shows errors. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Imputer ` | | Imputer (ai.onnx.ml) ==================== Replaces inputs that equal one value with another, leaving all other elements ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`InferenceSession ` | | Wrappers around InferenceSession from :epkg:`onnxruntime`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`InferenceSession2 ` | | Overwrites class *InferenceSession* to capture the standard output and error. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`InputDetectedVariable ` | | Instance of :class:`DetectedVariable`. Only for inputs. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Inverse ` | | Inverse (mlprodict) =================== **Version** *Onnx name:* `Inverse `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`InverseSchema ` | | Defines a schema for operators added in this package such as :class:`Inverse`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`IsInf ` | | IsInf ===== Map infinity to true and other values to false. **Attributes** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`IsNaN ` | | IsNaN ===== Returns which elements of the input are NaN. **Inputs** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`LRN ` | | LRN === Local Response Normalization proposed in the [AlexNet paper](https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf). ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`LSTM ` | | LSTM ==== Computes an one-layer LSTM. This operator is usually supported via some custom implementation such as CuDNN. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`LabelEncoder ` | | LabelEncoder (ai.onnx.ml) ========================= Maps each element in the input tensor to another value. The mapping ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`LayerNormalization ` | | LayerNormalization ================== This is layer normalization defined in ONNX as function. The overall computation ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`LeakyRelu ` | | LeakyRelu ========= LeakyRelu takes input data (Tensor) and an argument alpha, and produces one output data (Tensor) ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Less ` | | Less ==== Returns the tensor resulted from performing the `less` logical operation elementwise on the input tensors `A` ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`LessOrEqual ` | | LessOrEqual =========== Returns the tensor resulted from performing the `less_equal` logical operation elementwise on ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`LexicalScopeContext ` | | 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. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`LinearClassifier ` | | LinearClassifier (ai.onnx.ml) ============================= Linear classifier **Attributes** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`LinearRegressor ` | | LinearRegressor (ai.onnx.ml) ============================ Generalized linear regression evaluation. If targets is set ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Log ` | | Log === Calculates the natural log of the given input tensor, element-wise. **Inputs** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`LogSoftmax ` | | LogSoftmax ========== The operator computes the log of softmax values for the given input: LogSoftmax(input, axis) = ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Loop ` | | Loop ==== Generic Looping construct. This loop has multiple termination conditions: 1) Trip count. Iteration count specified ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`LpNormalization ` | | LpNormalization =============== Given a matrix, apply Lp-normalization along the provided axis. **Attributes** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLAction ` | | Base class for every action. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLActionAdd ` | | Addition | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLActionBinary ` | | Any binary operation. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLActionCast ` | | Cast into another type. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLActionConcat ` | | Concatenate number of arrays into an array. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLActionCst ` | | Constant | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLActionFunction ` | | A function. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLActionFunctionCall ` | | Any function call. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLActionIfElse ` | | Addition | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLActionReturn ` | | Returns a results. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLActionSign ` | | Sign of an expression: 1=positive, 0=negative. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLActionTensorAdd ` | | Tensor addition. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLActionTensorDiv ` | | Tensor division. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLActionTensorDot ` | | Scalar product. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLActionTensorMul ` | | Tensor multiplication. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLActionTensorSub ` | | Tensor soustraction. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLActionTensorTake ` | | Extracts an element of the tensor. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLActionTensorVector ` | | Tensor operation. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLActionTestEqual ` | | Operator ``==``. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLActionTestInf ` | | Operator ``<``. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLActionUnary ` | | Any binary operation. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLActionVar ` | | Variable. The constant is only needed to guess the variable type. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLModel ` | | Base class for every machine learned model | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLNumType ` | | Base class for numerical types. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLNumTypeBool ` | | A numpy.bool. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLNumTypeFloat32 ` | | A numpy.float32. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLNumTypeFloat64 ` | | A numpy.float64. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLNumTypeInt32 ` | | A numpy.int32. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLNumTypeInt64 ` | | A numpy.int64. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLNumTypeSingle ` | | int32 or float32 | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLTensor ` | | Defines a tensor with a dimension and a single type for what it contains. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MLType ` | | Base class for every type. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MatMul ` | | MatMul ====== Matrix product that behaves like numpy.matmul: https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.matmul.html ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Max ` | | Max === Element-wise max of each of the input tensors (with Numpy-style broadcasting support). All inputs and outputs ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MaxPool ` | | MaxPool ======= MaxPool consumes an input tensor X and applies max pooling across the tensor according to kernel sizes, ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MaxPoolDouble ` | | Implements float runtime for operator Conv. The code is inspired from `pool.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MaxPoolFloat ` | | Implements float runtime for operator Conv. The code is inspired from `pool.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Mean ` | | Mean ==== Element-wise mean of each of the input tensors (with Numpy-style broadcasting support). All inputs and outputs ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Min ` | | Min === Element-wise min of each of the input tensors (with Numpy-style broadcasting support). All inputs and outputs ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MissingInputError ` | | Raised when an input is missing. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MissingOperatorError ` | | Missing operator. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MissingVariableError ` | | Raised when a variable is missing. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MockVariableName ` | | A string. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MockVariableNameShape ` | | A string and a shape. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MockVariableNameShapeType ` | | A string and a shape and a type. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MockWrappedLightGbmBoosterClassifier ` | | Mocked lightgbm. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Mod ` | | Mod === Performs element-wise binary modulus (with Numpy-style broadcasting support). The sign of the remainder is the ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Momentum ` | | Momentum (ai.onnx.preview.training) =================================== Compute one iteration of stochastic gradient update ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Mul ` | | Mul === Performs element-wise binary multiplication (with Numpy-style broadcasting support). This operator supports **multidirectional ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MultiOnnxVar ` | | Class used to return multiple :class:`OnnxVar` at the same time. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MurmurHash3 ` | | MurmurHash3 (mlprodict) ======================= **Version** *Onnx name:* `MurmurHash3 `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`MurmurHash3Schema ` | | Defines a schema for operators added in this package such as :class:`MurmurHash3`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`NDArray ` | | Used to annotation ONNX numpy functions. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`NDArraySameType ` | | Shortcut to simplify signature description. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`NDArraySameTypeSameShape ` | | Shortcut to simplify signature description. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`NDArrayType ` | | Shortcut to simplify signature description. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`NDArrayTypeSameShape ` | | Shortcut to simplify signature description. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Neg ` | | Neg === Neg takes one input data (Tensor) and produces one output data (Tensor) where each element flipped sign, ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`NegativeLogLikelihoodLoss ` | | Python runtime for function *NegativeLogLikelihoodLoss*. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`NewOperatorSchema ` | | Defines a schema for operators added in this package such as :class:`TreeEnsembleRegressorDouble`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`NodeResultName ` | | Defines a result name for a node. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`NonMaxSuppression ` | | NonMaxSuppression ================= Filter out boxes that have high intersection-over-union (IOU) overlap with previously ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`NonZero ` | | NonZero ======= Returns the indices of the elements that are non-zero (in row-major order - by dimension). NonZero behaves ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Normalizer ` | | Normalizer (ai.onnx.ml) ======================= Normalize the input. There are three normalization modes, which have ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Not ` | | Not === Returns the negation of the input tensor element-wise. **Inputs** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`NotImplementedShapeInferenceError ` | | Shape Inference can be implemented but is currently not. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`NumpyCode ` | | Converts an ONNX operators into :epkg:`numpy` code. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OneHot ` | | OneHot ====== Produces a one-hot tensor based on inputs. The locations represented by the index values in the 'indices' ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OneHotEncoder ` | | :epkg:`ONNX` specifications does not mention the possibility to change the output type, sparse, dense, float, double. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxBackendAssertionError ` | | Expected failure. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxBackendMissingNewOnnxOperatorException ` | | Raised when :epkg:`onnxruntime` or :epkg:`mlprodict` does not implement a new operator defined in the latest onnx. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxBackendTest ` | | Definition of a backend test. It starts with a folder, in this folder, one onnx file must be there, then a subfolder ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxBroadcastGradientArgs_1 ` | | Defines a custom operator for BroadcastGradientArgs. Returns the reduction axes for computing gradients of s0 op s1 ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxBroadcastGradientArgs_1 ` | | Defines a custom operator for BroadcastGradientArgs. Returns the reduction axes for computing gradients of s0 op s1 ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxCheckError ` | | Raised when a model fails check. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxComplexAbs_1 ` | | Defines a custom operator for ComplexAbs. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxComplexAbs_1 ` | | Defines a custom operator for ComplexAbs. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxExisting ` | | Wrapper around OnnxIdentity to specify this operator is not part of the subgraph it is used in. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxFFT2D_1 ` | | Defines a custom operator for FFT2D. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxFFT2D_1 ` | | Defines a custom operator for FFT2D. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxFFT_1 ` | | Defines a custom operator for FFT. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxFFT_1 ` | | Defines a custom operator for FFT. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxFusedMatMul_1 ` | | MatMul and Gemm without a C. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxFusedMatMul_1 ` | | MatMul and Gemm without a C. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxInference ` | | Loads an :epkg:`ONNX` file or object or stream. Computes the output of the :epkg:`ONNX` graph. Several runtimes ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxInference2 ` | | onnxruntime API | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxInferenceBackend ` | | ONNX backend following the pattern from `onnx/backend/base.py `_. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxInferenceBackendMicro ` | | Same backend as @see cl OnnxInferenceBackend but runtime is @see cl OnnxMicroRuntime. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxInferenceBackendOrt ` | | Same backend as @see cl OnnxInferenceBackend but runtime is `onnxruntime1`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxInferenceBackendPyC ` | | Same backend as @see cl OnnxInferenceBackend but runtime is `python_compiled`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxInferenceBackendPyEval ` | | Same backend as @see cl OnnxInferenceBackend but runtime is @see cl OnnxShapeInference. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxInferenceBackendRep ` | | Computes the prediction for an ONNX graph loaded with @see cl OnnxInference. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxInferenceBackendShape ` | | Same backend as @see cl OnnxInferenceBackend but runtime is @see cl OnnxShapeInference. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxInferenceExport ` | | Implements methods to export a instance of :class:`OnnxInference` into :epkg:`json`, :epkg:`dot`, *text*, *python*. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxInferenceNode ` | | A node to execute. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxKind ` | | Describes a result type. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxLoadFactory ` | | Automatically creating all operators from onnx packages takes time. That's why function :class:`loadop` only creates ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxMicroRuntime ` | | Implements a micro runtime for ONNX graphs. It does not implements all the operator types. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxNotebook ` | | Defines magic commands to help with notebooks | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxNumpyCompiler ` | | Implements a class which runs onnx graph. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxNumpyFunction ` | | Class wrapping a function build with :class:`OnnxNumpyCompiler`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxNumpyFunctionInferenceSession ` | | Overwrites :class:`OnnxNumpyFunction` to run an instance of `InferenceSession` from :epkg:`onnxruntime`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxNumpyFunctionOnnxInference ` | | Overwrites :class:`OnnxNumpyFunction` to run an instance of :class:`OnnxInference`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxOperator ` | | Ancestor to every *ONNX* operator exposed in :mod:`mlprodict.npy.xops` and :mod:`mlprodict.npy.xops_ml`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxOperatorBase ` | | Base class for :class:`OnnxOperator`, :class:`OnnxOperator`Item, :class:`OnnxOperatorTuple`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxOperatorFunction ` | | This operator is used to insert existing ONNX function into the ONNX graph being built. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxOperatorItem ` | | Accessor to one of the output returned by a :class:`OnnxOperator`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxOperatorTuple ` | | Class used to return multiple :class:`OnnxVar` at the same time. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxPipeline ` | | The pipeline overwrites method *fit*, it trains and converts every steps into ONNX before training the next step ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxRFFT_1 ` | | Defines a custom operator for FFT. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxRFFT_1 ` | | Defines a custom operator for FFT. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxRuntimeMissingNewOnnxOperatorException ` | | Raised when a new operator was added but cannot be found. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxShapeInference ` | | Implements a micro runtime for ONNX graphs. It does not implements all the operator types. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxSoftmaxGrad_13 ` | | Gradient of Softmax. SoftmaxGrad computes :math:`Y * ( dY - ReduceSum(Y * dY))`. ONNX does not have a dot product, ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxSoftmaxGrad_13 ` | | Gradient of Softmax. SoftmaxGrad computes :math:`Y * ( dY - ReduceSum(Y * dY))`. ONNX does not have a dot product, ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxSpeedupClassifier ` | | Trains with :epkg:`scikit-learn`, transform with :epkg:`ONNX`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxSpeedupCluster ` | | Trains with :epkg:`scikit-learn`, transform with :epkg:`ONNX`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxSpeedupRegressor ` | | Trains with :epkg:`scikit-learn`, transform with :epkg:`ONNX`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxSpeedupTransformer ` | | Trains with :epkg:`scikit-learn`, transform with :epkg:`ONNX`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxSubEstimator ` | | This operator is used to call the converter of a model to insert the node coming from the conversion into a bigger ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxSubOnnx ` | | This operator is used to insert existing ONNX into the ONNX graph being built. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxTokenizer_1 ` | | Defines a custom operator not defined by ONNX specifications but in onnxruntime. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxTokenizer_1 ` | | Defines a custom operator not defined by ONNX specifications but in onnxruntime. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxTransformer ` | | Calls :epkg:`onnxruntime` or the runtime implemented in this package to transform input based on a ONNX graph. It ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxTranslator ` | | Class which converts a Python function into an :epkg:`ONNX` function. It must implements methods *visit* and *depart*. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxVar ` | | Variables used into :epkg:`onnx` computation. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxVarGraph ` | | Overloads :class:`OnnxVar` to handle graph attribute. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxWholeSession ` | | Runs the prediction for a single :epkg:`ONNX`, it lets the runtime handle the graph logic as well. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxYieldOp_1 ` | | Defines a custom operator for YieldOp. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OnnxYieldOp_1 ` | | Defines a custom operator for YieldOp. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OpFunction ` | | Runs a custom function. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OpRun ` | | Ancestor to all operators in this subfolder. The runtime for every node can checked into `ONNX unit tests `_. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OpRunArg ` | | Ancestor to all unary operators in this subfolder and which produces position of extremas (ArgMax, ...). Checks ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OpRunBinary ` | | Ancestor to all binary operators in this subfolder. Checks that inputs type are the same. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OpRunBinaryComparison ` | | Ancestor to all binary operators in this subfolder comparing tensors. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OpRunBinaryNum ` | | Ancestor to all binary operators in this subfolder. Checks that inputs type are the same. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OpRunBinaryNumpy ` | | Implements the inplaces logic. *numpy_fct* is a binary numpy function which takes two matrices and has a argument ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OpRunClassifierProb ` | | Ancestor to all binary operators in this subfolder. Checks that inputs type are the same. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OpRunCustom ` | | Automates some methods for custom operators defined outside *mlprodict*. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OpRunExtended ` | | Base class to cache C++ implementation based on inputs. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OpRunOnnxEmpty ` | | Unique operator for an empty runtime. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OpRunOnnxRuntime ` | | Unique operator which calls :epkg:`onnxruntime` to compute predictions for one operator. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OpRunReduceNumpy ` | | Implements the reduce logic. It must have a parameter *axes*. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OpRunUnary ` | | Ancestor to all unary operators in this subfolder. Checks that inputs type are the same. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OpRunUnaryNum ` | | Ancestor to all unary and numerical operators in this subfolder. Checks that inputs type are the same. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OperatorSchema ` | | Defines a schema for operators added in this package such as :class:`TreeEnsembleRegressorDouble`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OptionalGetElement ` | | OptionalGetElement ================== If the input is a tensor or sequence type, it returns the input. If the input is ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OptionalHasElement ` | | OptionalHasElement ================== Returns true if (1) the input is an optional-type and contains an element, or, (2) ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Or ` | | Or == Returns the tensor resulted from performing the `or` logical operation elementwise on the input tensors `A` and ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`OutputDetectedVariable ` | | Instance of :class:`DetectedVariable`. Only for outputs. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`PRelu ` | | PRelu ===== PRelu takes input data (Tensor) and slope tensor as input, and produces one output data (Tensor) where ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Pad_1 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Pad_18 ` | | Pad === Given a tensor containing the data to be padded (`data`), a tensor containing the number of start and end pad ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Pad_18 ` | | Pad === Given a tensor containing the data to be padded (`data`), a tensor containing the number of start and end pad ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Pow ` | | Pow === Pow takes input data (Tensor) and exponent Tensor, and produces one output data (Tensor) where the function ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`QLinearConv ` | | QLinearConv =========== The convolution operator consumes a quantized input tensor, its scale and zero point, a quantized ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`QLinearConvInt8 ` | | Implements int8 runtime for operator QLinearConv. The code is inspired from `qlinearconv.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`QLinearConvUInt8 ` | | Implements uint8 runtime for operator QLinearConvUInt8. The code is inspired from `qlinearconv.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`QuantizeLinear ` | | QuantizeLinear ============== The linear quantization operator. It consumes a high precision tensor, a scale, and a zero ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`QuantizedBiasTensor ` | | Instantiates a quantized tensor (uint8) with bias from a float tensor. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`QuantizedTensor ` | | Instantiates a quantized tensor (uint8) from a float tensor. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RFFT ` | | RFFT (mlprodict) ================ **Version** *Onnx name:* `RFFT `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RFFTSchema ` | | Defines a schema for operators added in this package such as :class:`FFT`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RNN_14 ` | | RNN === Computes an one-layer simple RNN. This operator is usually supported via some custom implementation such as CuDNN. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RNN_14 ` | | RNN === Computes an one-layer simple RNN. This operator is usually supported via some custom implementation such as CuDNN. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RNN_7 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RandomNormal ` | | RandomNormal ============ Generate a tensor with random values drawn from a normal distribution. The shape of the tensor ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RandomNormalLike ` | | RandomNormalLike ================ Generate a tensor with random values drawn from a normal distribution. The shape of ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RandomUniform ` | | RandomUniform ============= Generate a tensor with random values drawn from a uniform distribution. The shape of the tensor ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RandomUniformLike ` | | RandomUniformLike ================= Generate a tensor with random values drawn from a uniform distribution. The shape ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Range ` | | Range ===== Generate a tensor containing a sequence of numbers that begin at `start` and extends by increments of `delta` ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Reciprocal ` | | Reciprocal ========== Reciprocal takes one input data (Tensor) and produces one output data (Tensor) where the reciprocal ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceL1_1 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceL1_18 ` | | ReduceL1 ======== Computes the L1 norm of the input tensor's element along the provided axes. The resulting tensor has ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceL1_18 ` | | ReduceL1 ======== Computes the L1 norm of the input tensor's element along the provided axes. The resulting tensor has ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceL2_1 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceL2_18 ` | | ReduceL2 ======== Computes the L2 norm of the input tensor's element along the provided axes. The resulting tensor has ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceL2_18 ` | | ReduceL2 ======== Computes the L2 norm of the input tensor's element along the provided axes. The resulting tensor has ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceLogSumExp_1 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceLogSumExp_18 ` | | ReduceLogSumExp =============== Computes the log sum exponent of the input tensor's element along the provided axes. The ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceLogSumExp_18 ` | | ReduceLogSumExp =============== Computes the log sum exponent of the input tensor's element along the provided axes. The ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceLogSum_1 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceLogSum_18 ` | | ReduceLogSum ============ Computes the log sum of the input tensor's element along the provided axes. The resulting tensor ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceLogSum_18 ` | | ReduceLogSum ============ Computes the log sum of the input tensor's element along the provided axes. The resulting tensor ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceMax_1 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceMax_18 ` | | ReduceMax ========= Computes the max of the input tensor's element along the provided axes. The resulting tensor has the ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceMax_18 ` | | ReduceMax ========= Computes the max of the input tensor's element along the provided axes. The resulting tensor has the ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceMean_1 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceMean_18 ` | | ReduceMean ========== Computes the mean of the input tensor's element along the provided axes. The resulting tensor has ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceMean_18 ` | | ReduceMean ========== Computes the mean of the input tensor's element along the provided axes. The resulting tensor has ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceMin_1 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceMin_18 ` | | ReduceMin ========= Computes the min of the input tensor's element along the provided axes. The resulting tensor has the ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceMin_18 ` | | ReduceMin ========= Computes the min of the input tensor's element along the provided axes. The resulting tensor has the ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceProd_1 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceProd_18 ` | | ReduceProd ========== Computes the product of the input tensor's element along the provided axes. The resulting tensor ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceProd_18 ` | | ReduceProd ========== Computes the product of the input tensor's element along the provided axes. The resulting tensor ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceSumSquare_1 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceSumSquare_18 ` | | ReduceSumSquare =============== Computes the sum square of the input tensor's element along the provided axes. The resulting ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceSumSquare_18 ` | | ReduceSumSquare =============== Computes the sum square of the input tensor's element along the provided axes. The resulting ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceSum_1 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceSum_11 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceSum_13 ` | | ReduceSum ========= Computes the sum of the input tensor's element along the provided axes. The resulting tensor has the ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ReduceSum_13 ` | | ReduceSum ========= Computes the sum of the input tensor's element along the provided axes. The resulting tensor has the ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RefAttrName ` | | Implements a link between a parameter of a function and an attribute in node. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Relu ` | | Relu ==== Relu takes one input data (Tensor) and produces one output data (Tensor) where the rectified linear function, ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Reshape_13 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Reshape_14 ` | | Reshape ======= Reshape the input tensor similar to numpy.reshape. First input is the data tensor, second input is a shape ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Reshape_14 ` | | Reshape ======= Reshape the input tensor similar to numpy.reshape. First input is the data tensor, second input is a shape ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Reshape_5 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Resize ` | | Resize ====== Resize the input tensor. In general, it calculates every value in the output tensor as a weighted average ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RoiAlign ` | | RoiAlign ======== Region of Interest (RoI) align operation described in the [Mask R-CNN paper](https://arxiv.org/abs/1703.06870). ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RoiAlignDouble ` | | Implements float runtime for operator RoiAlign. The code is inspired from `pool.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RoiAlignFloat ` | | Implements float runtime for operator RoiAlign. The code is inspired from `pool.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Round ` | | Round ===== Round takes one input Tensor and rounds the values, element-wise, meaning it finds the nearest integer for ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RuntimeBadResultsError ` | | Raised when the results are too different from :epkg:`scikit-learn`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RuntimeNonMaxSuppression ` | | Implements runtime for operator NonMaxSuppression. The code is inspired from `non_max_suppression.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RuntimeSVMClassifierDouble ` | | Implements runtime for operator SVMClassifierDouble. The code is inspired from `svm_classifier.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RuntimeSVMClassifierFloat ` | | Implements runtime for operator SVMClassifier. The code is inspired from `svm_classifier.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RuntimeSVMRegressorDouble ` | | Implements Double runtime for operator SVMRegressor. The code is inspired from `svm_regressor.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RuntimeSVMRegressorFloat ` | | Implements float runtime for operator SVMRegressor. The code is inspired from `svm_regressor.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RuntimeTfIdfVectorizer ` | | Implements runtime for operator TfIdfVectorizer. The code is inspired from `tfidfvectorizer.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RuntimeTreeEnsembleClassifierDouble ` | | Implements runtime for operator TreeEnsembleClassifier. The code is inspired from `tree_ensemble_classifier.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RuntimeTreeEnsembleClassifierFloat ` | | Implements runtime for operator TreeEnsembleClassifier. The code is inspired from `tree_ensemble_classifier.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RuntimeTreeEnsembleClassifierPDouble ` | | Implements double runtime for operator TreeEnsembleClassifier. The code is inspired from `tree_ensemble_Classifier.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RuntimeTreeEnsembleClassifierPFloat ` | | Implements float runtime for operator TreeEnsembleClassifier. The code is inspired from `tree_ensemble_Classifier.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RuntimeTreeEnsembleRegressorDouble ` | | Implements double runtime for operator TreeEnsembleRegressor. The code is inspired from `tree_ensemble_regressor.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RuntimeTreeEnsembleRegressorFloat ` | | Implements float runtime for operator TreeEnsembleRegressor. The code is inspired from `tree_ensemble_regressor.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RuntimeTreeEnsembleRegressorPDouble ` | | Implements double runtime for operator TreeEnsembleRegressor. The code is inspired from `tree_ensemble_regressor.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RuntimeTreeEnsembleRegressorPFloat ` | | Implements float runtime for operator TreeEnsembleRegressor. The code is inspired from `tree_ensemble_regressor.cc `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`RuntimeTypeError ` | | Raised when a type of a variable is unexpected. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`STFT ` | | STFT ==== Computes the Short-time Fourier Transform of the signal. **Attributes** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`SVMClassifier ` | | SVMClassifier (ai.onnx.ml) ========================== Support Vector Machine classifier **Attributes** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`SVMClassifierCommon ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`SVMClassifierDouble ` | | SVMClassifierDouble (mlprodict) =============================== **Version** *Onnx name:* `SVMClassifierDouble `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`SVMClassifierDoubleSchema ` | | Defines a schema for operators added in this package such as :class:`SVMClassifierDouble`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`SVMRegressor ` | | SVMRegressor (ai.onnx.ml) ========================= Support Vector Machine regression prediction and one-class SVM anomaly ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`SVMRegressorCommon ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`SVMRegressorDouble ` | | SVMRegressorDouble (mlprodict) ============================== **Version** *Onnx name:* `SVMRegressorDouble `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`SVMRegressorDoubleSchema ` | | Defines a schema for operators added in this package such as :class:`SVMRegressorDouble`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Scaler ` | | Scaler (ai.onnx.ml) =================== Rescale input data, for example to standardize features by removing the mean and ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Scan ` | | Scan ==== Scan can be used to iterate over one or more scan_input tensors, constructing zero or more scan_output tensors. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ScatterElements ` | | ScatterElements =============== ScatterElements takes three inputs `data`, `updates`, and `indices` of the same rank r ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ScatterND ` | | ScatterND ========= ScatterND takes three inputs `data` tensor of rank r >= 1, `indices` tensor of rank q >= 1, and `updates` ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Schema ` | | Wrapper around a schema. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Selu ` | | Selu ==== Selu takes one input data (Tensor) and produces one output data (Tensor) where the scaled exponential ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`SentencePieceTokenizerTransformer ` | | Wraps `SentencePieceTokenizer `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`SequenceAt ` | | SequenceAt ========== Outputs a tensor copy from the tensor at 'position' in 'input_sequence'. Accepted range for 'position' ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`SequenceConstruct ` | | SequenceConstruct ================= Construct a tensor sequence containing 'inputs' tensors. All tensors in 'inputs' must ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`SequenceEmpty ` | | SequenceEmpty ============= Construct an empty tensor sequence, with given data type. **Attributes** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`SequenceInsert ` | | SequenceInsert ============== Outputs a tensor sequence that inserts 'tensor' into 'input_sequence' at 'position'. 'tensor' ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ShapeConstraint ` | | One constraint. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ShapeConstraintList ` | | A list of ShapeConstraint. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ShapeContainer ` | | Stores all infered shapes as :class:`ShapeResult`. Attributes: | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ShapeInferenceDimensionError ` | | Raised when the shape cannot continue due to unknown dimension. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ShapeInferenceException ` | | Raised when shape inference fails. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ShapeInferenceMissing ` | | Raised when an operator is missing. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ShapeResult ` | | Contains information about shape and type of a result in an onnx graph. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Shape_1 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Shape_15 ` | | Shape ===== Takes a tensor as input and outputs an 1D int64 tensor containing the shape of the input tensor. Optional ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Shape_15 ` | | Shape ===== Takes a tensor as input and outputs an 1D int64 tensor containing the shape of the input tensor. Optional ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Shrink ` | | Shrink ====== Shrink takes one input data (Tensor) and produces one Tensor output, having same datatype and shape ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Sigmoid ` | | Sigmoid ======= Sigmoid takes one input data (Tensor) and produces one output data (Tensor) where the sigmoid function, ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Sign ` | | Sign ==== Calculate the sign of the given input tensor element-wise. If input > 0, output 1. if input < 0, output -1. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`SimplifiedOnnxInference ` | | Simple wrapper around InferenceSession which imitates :class:`OnnxInference`. It only enable *CPUExecutionProvider*. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Sin ` | | Sin === Calculates the sine of the given input tensor, element-wise. **Inputs** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Sinh ` | | Sinh ==== Calculates the hyperbolic sine of the given input tensor element-wise. **Inputs** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Size ` | | Size ==== Takes a tensor as input and outputs a int64 scalar that equals to the total number of elements of the input ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`SliceCommon ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Slice_1 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Slice_10 ` | | Slice ===== Produces a slice of the input tensor along multiple axes. Similar to numpy: https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Slice_10 ` | | Slice ===== Produces a slice of the input tensor along multiple axes. Similar to numpy: https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`SoftmaxCrossEntropyLoss ` | | Python runtime for function *SoftmaxCrossEntropyLoss*. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`SoftmaxGradSchema ` | | Defines a schema for operators added in this package such as :class:`SoftmaxGrad_13`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`SoftmaxGrad_13 ` | | SoftmaxGrad computes :math:`dX = Y * ( dY - ReduceSum(Y * dY))`. ONNX does not have a dot product, which can be ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`SoftmaxGrad_13 ` | | SoftmaxGrad computes :math:`dX = Y * ( dY - ReduceSum(Y * dY))`. ONNX does not have a dot product, which can be ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Softmax_1 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Softmax_13 ` | | Softmax ======= The operator computes the normalized exponential values for the given input: Softmax(input, axis) = ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Softmax_13 ` | | Softmax ======= The operator computes the normalized exponential values for the given input: Softmax(input, axis) = ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Softplus ` | | Softplus ======== Softplus takes one input data (Tensor) and produces one output data (Tensor) where the softplus ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Softsign ` | | Softsign ======== Calculates the softsign (x/(1+|x|)) of the given input tensor element-wise. **Inputs** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Solve ` | | Solve (mlprodict) ================= **Version** *Onnx name:* `Solve `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`SolveSchema ` | | Defines a schema for operators added in this package such as :class:`Solve`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`SpaceToDepth ` | | SpaceToDepth ============ SpaceToDepth rearranges blocks of spatial data into depth. More specifically, this op outputs ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Split_11 ` | | Runtime for operator *Split*. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Split_13 ` | | Runtime for operator *Split*. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Split_13 ` | | Runtime for operator *Split*. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Split_2 ` | | Runtime for operator *Split*. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Sqrt ` | | Sqrt ==== Square root takes one input data (Tensor) and produces one output data (Tensor) where the square root ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Squeeze_1 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Squeeze_11 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Squeeze_13 ` | | Squeeze ======= Remove single-dimensional entries from the shape of a tensor. Takes an input `axes` with a list of axes ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Squeeze_13 ` | | Squeeze ======= Remove single-dimensional entries from the shape of a tensor. Takes an input `axes` with a list of axes ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`StringNormalizer ` | | The operator is not really threadsafe as python cannot play with two locales at the same time. stop words should ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Sub ` | | Sub === Performs element-wise binary subtraction (with Numpy-style broadcasting support). This operator supports **multidirectional ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Sum ` | | Sum === Element-wise sum of each of the input tensors (with Numpy-style broadcasting support). All inputs and outputs ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Tan ` | | Tan === Calculates the tangent of the given input tensor, element-wise. **Inputs** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Tanh ` | | Tanh ==== Calculates the hyperbolic tangent of the given input tensor element-wise. **Inputs** | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TemplateBenchmarkClassifier ` | | :epkg:`asv` test for a classifier, Full template can be found in `common_asv_skl.py `_. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TemplateBenchmarkClassifierRawScore ` | | :epkg:`asv` test for a classifier, Full template can be found in `common_asv_skl.py `_. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TemplateBenchmarkClustering ` | | :epkg:`asv` example for a clustering algorithm, Full template can be found in `common_asv_skl.py `_. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TemplateBenchmarkMultiClassifier ` | | :epkg:`asv` example for a classifier, Full template can be found in `common_asv_skl.py `_. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TemplateBenchmarkOutlier ` | | :epkg:`asv` example for an outlier detector, Full template can be found in `common_asv_skl.py `_. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TemplateBenchmarkRegressor ` | | :epkg:`asv` example for a regressor, Full template can be found in `common_asv_skl.py `_. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TemplateBenchmarkTrainableTransform ` | | :epkg:`asv` example for a trainable transform, Full template can be found in `common_asv_skl.py `_. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TemplateBenchmarkTransform ` | | :epkg:`asv` example for a transform, Full template can be found in `common_asv_skl.py `_. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TemplateBenchmarkTransformPositive ` | | :epkg:`asv` example for a transform, Full template can be found in `common_asv_skl.py `_. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Tf2OnnxConvert ` | | Applies the converter on an ONNX graph. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TfIdfVectorizer ` | | TfIdfVectorizer =============== This transform extracts n-grams from the input sequence and save them as a vector. Input ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ThresholdedRelu ` | | ThresholdedRelu =============== ThresholdedRelu takes one input data (Tensor) and produces one output data (Tensor) ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Tokenizer ` | | See :epkg:`Tokenizer`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TokenizerSchema ` | | Defines a schema for operators added in this package such as :class:`TreeEnsembleClassifierDouble`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TokenizerTransformerBase ` | | Base class for :class:`SentencePieceTokenizerTransformer` and :class:`GPT2TokenizerTransformer`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TopK_1 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TopK_10 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TopK_11 ` | | TopK ==== Retrieve the top-K largest or smallest elements along a specified axis. Given an input tensor of shape [a_1, ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TopK_11 ` | | TopK ==== Retrieve the top-K largest or smallest elements along a specified axis. Given an input tensor of shape [a_1, ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Transpose ` | | Transpose ========= Transpose the input tensor similar to numpy.transpose. For example, when perm=(1, 0, 2), given an ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TreeEnsembleClassifierCommon ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TreeEnsembleClassifierDouble ` | | TreeEnsembleClassifierDouble (mlprodict) ======================================== **Version** *Onnx name:* `TreeEnsembleClassifierDouble `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TreeEnsembleClassifierDoubleSchema ` | | Defines a schema for operators added in this package such as :class:`TreeEnsembleClassifierDouble`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TreeEnsembleClassifier_1 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TreeEnsembleClassifier_3 ` | | TreeEnsembleClassifier (ai.onnx.ml) =================================== Tree Ensemble classifier. Returns the top class ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TreeEnsembleClassifier_3 ` | | TreeEnsembleClassifier (ai.onnx.ml) =================================== Tree Ensemble classifier. Returns the top class ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TreeEnsembleRegressorCommon ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TreeEnsembleRegressorDouble ` | | Runtime for the custom operator `TreeEnsembleRegressorDouble`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TreeEnsembleRegressorDoubleSchema ` | | Defines a schema for operators added in this package such as :class:`TreeEnsembleRegressorDouble`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TreeEnsembleRegressor_1 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TreeEnsembleRegressor_3 ` | | TreeEnsembleRegressor (ai.onnx.ml) ================================== Tree Ensemble regressor. Returns the regressed ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`TreeEnsembleRegressor_3 ` | | TreeEnsembleRegressor (ai.onnx.ml) ================================== Tree Ensemble regressor. Returns the regressed ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Trilu ` | | Trilu ===== Given a 2-D matrix or batches of 2-D matrices, returns the upper or lower triangular part of the tensor(s). ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`UndefinedSchema ` | | Undefined schema. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Unique ` | | Unique ====== Find the unique elements of a tensor. When an optional attribute 'axis' is provided, unique subtensors sliced ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Unsqueeze_1 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Unsqueeze_11 ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Unsqueeze_13 ` | | Unsqueeze ========= Insert single-dimensional entries to the shape of an input tensor (`data`). Takes one required input ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Unsqueeze_13 ` | | Unsqueeze ========= Insert single-dimensional entries to the shape of an input tensor (`data`). Takes one required input ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Variable ` | | An input or output to an ONNX graph. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Where ` | | 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) ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`WrappedLightGbmBooster ` | | A booster can be a classifier, a regressor. Trick to wrap it in a minimal function. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`WrappedLightGbmBoosterClassifier ` | | Trick to wrap a LGBMClassifier into a class. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`XGBClassifierConverter ` | | converter for XGBClassifier | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`XGBConverter ` | | common methods for converters | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`XGBRegressorConverter ` | | converter class | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`Xor ` | | Xor === Returns the tensor resulted from performing the `xor` logical operation elementwise on the input tensors `A` and ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`YieldOp ` | | YieldOp (mlprodict) =================== **Version** *Onnx name:* `YieldOp `_ ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`YieldOpSchema ` | | Defines a schema for operators added in this package such as :class:`ComplexAbs`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ZipMap ` | | The class does not output a dictionary as specified in :epkg:`ONNX` specifications but a :class:`ArrayZipMapDictionary` ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`ZipMapDictionary ` | | Custom dictionary class much faster for this runtime, it implements a subset of the same methods. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_ArgMax ` | | Base class for runtime for operator `ArgMax `_. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_ArgMin ` | | Base class for runtime for operator `ArgMin `_. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_ClassifierCommon ` | | Labels strings are not natively implemented in C++ runtime. The class stores the strings labels, replaces them by ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_CombineModels ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_CommonAsvSklBenchmark ` | | Common tests to all benchmarks testing converted :epkg:`scikit-learn` models. See `benchmark attributes `_. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_CommonAsvSklBenchmarkClassifier ` | | Common class for a classifier. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_CommonAsvSklBenchmarkClassifierRawScore ` | | Common class for a classifier. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_CommonAsvSklBenchmarkClustering ` | | Common class for a clustering algorithm. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_CommonAsvSklBenchmarkMultiClassifier ` | | Common class for a multi-classifier. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_CommonAsvSklBenchmarkOutlier ` | | Common class for outlier detection. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_CommonAsvSklBenchmarkRegressor ` | | Common class for a regressor. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_CommonAsvSklBenchmarkTrainableTransform ` | | Common class for a trainable transformer. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_CommonAsvSklBenchmarkTransform ` | | Common class for a transformer. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_CommonAsvSklBenchmarkTransformPositive ` | | Common class for a transformer for positive features. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_CommonQuantizeLinear ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_CommonRandom ` | | Common methods to all random operators. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_CommonTopK ` | | Ths class hides a parameter used as a threshold above which the parallelisation is started: ``th_para``. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_CommonWindow ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_CustomSchema ` | | For operators defined outside onnx. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_GraphBuilder ` | | Graph builder. It takes a graph structure made with instances of :class:`OnnxOperatorBase`. The main method is `to_onnx`. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_MyEncoder ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_NDArrayAlias ` | | Ancestor to custom signature. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_OnnxPipelineStepSpeedup ` | | Speeds up inference by replacing methods *transform* or *predict* by a runtime for :epkg:`ONNX`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_ParamEncoder ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_Softmax ` | | | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_StaticVariables ` | | Holds static variables. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_WrapperLogger ` | | Wrappers around class :class:`logging.Logger` to take indentation into account. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_WrapperPrint ` | | Wrappers around print to help debugging. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_created_classes ` | | Class to store all dynamic classes created by wrappers. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`_inline_mapping ` | | Overwrites class dictionary to debug more easily. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`if_then_else ` | | Overloads class :class:`OnnxVarGraph`. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`tf_op ` | | Decorator to register any new converter. | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`wrapper_onnxnumpy ` | | Intermediate wrapper to store a pointer on the compiler (type: :class:`OnnxNumpyCompiler`). | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :class:`wrapper_onnxnumpy_np ` | | Intermediate wrapper to store a pointer on the compiler (type: :class:`OnnxNumpyCompiler`) supporting multiple signatures. ... | +-----------------------------------------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+