diff --git a/CMakeLists.txt b/CMakeLists.txt index 29aa571..28e552c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -34,14 +34,6 @@ add_subdirectory(third_party/rapidcheck) set(CMAKE_CXX_STANDARD 14) -if ($ENV{EXCLUDE_ONNX_ML}) - set(INCLUDE_ONNX_ML FALSE) -else() - set(INCLUDE_ONNX_ML TRUE) -endif() - -message(STATUS "INCLUDE_ONNX_ML Dialect " ${INCLUDE_ONNX_ML}) - add_subdirectory(utils) add_subdirectory(src) add_subdirectory(docs) diff --git a/docs/Dialects/mlonnx.md b/docs/Dialects/mlonnx.md deleted file mode 100644 index 88f41f6..0000000 --- a/docs/Dialects/mlonnx.md +++ /dev/null @@ -1,597 +0,0 @@ - -### `mlonnx.ArrayFeatureExtractor` (MLONNXArrayFeatureExtractorOp) - -ONNX ArrayFeatureExtractor operation - -"Select elements of the input tensor based on the indices passed.
" -" The indices are applied to the last axes of the tensor." - -#### Operands: - -| Operand | Description | -| :-----: | ----------- | -`X` | memref of any type values or tensor of any type values -`Y` | memref of any type values or tensor of any type values - -#### Results: - -| Result | Description | -| :----: | ----------- | -`Z` | memref of any type values or tensor of any type values - -### `mlonnx.Binarizer` (MLONNXBinarizerOp) - -ONNX Binarizer operation - -"Maps the values of the input tensor to either 0 or 1, element-wise, based on the outcome of a comparison against a threshold value." - -#### Attributes: - -| Attribute | MLIR Type | Description | -| :-------: | :-------: | ----------- | -`threshold` | FloatAttr | 32-bit float attribute - -#### Operands: - -| Operand | Description | -| :-----: | ----------- | -`X` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values - -#### Results: - -| Result | Description | -| :----: | ----------- | -`Y` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values - -### `mlonnx.CastMap` (MLONNXCastMapOp) - -ONNX CastMap operation - -"Converts a map to a tensor.
The map key must be an int64 and the values will be ordered" -" in ascending order based on this key.
The operator supports dense packing or sparse packing." -" If using sparse packing, the key cannot exceed the max_map-1 value." - -#### Attributes: - -| Attribute | MLIR Type | Description | -| :-------: | :-------: | ----------- | -`cast_to` | StringAttr | string attribute -`map_form` | StringAttr | string attribute -`max_map` | IntegerAttr | 64-bit signless integer attribute - -#### Operands: - -| Operand | Description | -| :-----: | ----------- | -`X` | tuple with any combination of tensor of 64-bit signless integer values values or memref of 64-bit signless integer values - -#### Results: - -| Result | Description | -| :----: | ----------- | -`Y` | memref of any type values or tensor of any type values - -### `mlonnx.CategoryMapper` (MLONNXCategoryMapperOp) - -ONNX CategoryMapper operation - -"Converts strings to integers and vice versa.
" -" Two sequences of equal length are used to map between integers and strings," -" with strings and integers at the same index detailing the mapping.
" -" Each operator converts either integers to strings or strings to integers, depending " -" on which default value attribute is provided. Only one default value attribute" -" should be defined.
" -" If the string default value is set, it will convert integers to strings." -" If the int default value is set, it will convert strings to integers." - -#### Attributes: - -| Attribute | MLIR Type | Description | -| :-------: | :-------: | ----------- | -`cats_int64s` | ArrayAttr | 64-bit integer array attribute -`cats_strings` | ArrayAttr | string array attribute -`default_int64` | IntegerAttr | 64-bit signless integer attribute -`default_string` | StringAttr | string attribute - -#### Operands: - -| Operand | Description | -| :-----: | ----------- | -`X` | memref of any type values or tensor of any type values - -#### Results: - -| Result | Description | -| :----: | ----------- | -`Y` | memref of any type values or tensor of any type values - -### `mlonnx.DictVectorizer` (MLONNXDictVectorizerOp) - -ONNX DictVectorizer operation - -"Uses an index mapping to convert a dictionary to an array.
" -" Given a dictionary, each key is looked up in the vocabulary attribute corresponding to" -" the key type. The index into the vocabulary array at which the key is found is then" -" used to index the output 1-D tensor 'Y' and insert into it the value found in the dictionary 'X'.
" -" The key type of the input map must correspond to the element type of the defined vocabulary attribute." -" Therefore, the output array will be equal in length to the index mapping vector parameter." -" All keys in the input dictionary must be present in the index mapping vector." -" For each item in the input dictionary, insert its value in the output array." -" Any keys not present in the input dictionary, will be zero in the output array.
" -" For example: if the ``string_vocabulary`` parameter is set to ``[\"a\", \"c\", \"b\", \"z\"]``," -" then an input of ``{\"a\": 4, \"c\": 8}`` will produce an output of ``[4, 8, 0, 0]``." -" " - -#### Attributes: - -| Attribute | MLIR Type | Description | -| :-------: | :-------: | ----------- | -`int64_vocabulary` | ArrayAttr | 64-bit integer array attribute -`string_vocabulary` | ArrayAttr | string array attribute - -#### Operands: - -| Operand | Description | -| :-----: | ----------- | -`X` | tuple with any combination of tensor of 64-bit signless integer or 32-bit float or 64-bit float values values or memref of 64-bit signless integer or 32-bit float or 64-bit float values - -#### Results: - -| Result | Description | -| :----: | ----------- | -`Y` | memref of any type values or tensor of any type values - -### `mlonnx.FeatureVectorizer` (MLONNXFeatureVectorizerOp) - -ONNX FeatureVectorizer operation - -"Concatenates input tensors into one continuous output.
" -" All input shapes are 2-D and are concatenated along the second dimention. 1-D tensors are treated as [1,C]." -" Inputs are copied to the output maintaining the order of the input arguments.
" -" All inputs must be integers or floats, while the output will be all floating point values." - -#### Attributes: - -| Attribute | MLIR Type | Description | -| :-------: | :-------: | ----------- | -`inputdimensions` | ArrayAttr | 64-bit integer array attribute - -#### Operands: - -| Operand | Description | -| :-----: | ----------- | -`X` | tensor of 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float values or memref of 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float values - -#### Results: - -| Result | Description | -| :----: | ----------- | -`Y` | memref of any type values or tensor of any type values - -### `mlonnx.Imputer` (MLONNXImputerOp) - -ONNX Imputer operation - -"Replaces inputs that equal one value with another, leaving all other elements alone.
" -" This operator is typically used to replace missing values in situations where they have a canonical" -" representation, such as -1, 0, NaN, or some extreme value.
" -" One and only one of imputed_value_floats or imputed_value_int64s should be defined -- floats if the input tensor" -" holds floats, integers if the input tensor holds integers. The imputed values must all fit within the" -" width of the tensor element type. One and only one of the replaced_value_float or replaced_value_int64 should be defined," -" which one depends on whether floats or integers are being processed.
" -" The imputed_value attribute length can be 1 element, or it can have one element per input feature.
In other words, if the input tensor has the shape [*,F], then the length of the attribute array may be 1 or F. If it is 1, then it is broadcast along the last dimension and applied to each feature." - -#### Attributes: - -| Attribute | MLIR Type | Description | -| :-------: | :-------: | ----------- | -`imputed_value_floats` | ArrayAttr | 32-bit float array attribute -`imputed_value_int64s` | ArrayAttr | 64-bit integer array attribute -`replaced_value_float` | FloatAttr | 32-bit float attribute -`replaced_value_int64` | IntegerAttr | 64-bit signless integer attribute - -#### Operands: - -| Operand | Description | -| :-----: | ----------- | -`X` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values - -#### Results: - -| Result | Description | -| :----: | ----------- | -`Y` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values - -### `mlonnx.LabelEncoder` (MLONNXLabelEncoderOp) - -ONNX LabelEncoder operation - -"Maps each element in the input tensor to another value.
" -" The mapping is determined by the two parallel attributes, 'keys_*' and" -" 'values_*' attribute. The i-th value in the specified 'keys_*' attribute" -" would be mapped to the i-th value in the specified 'values_*' attribute. It" -" implies that input's element type and the element type of the specified" -" 'keys_*' should be identical while the output type is identical to the" -" specified 'values_*' attribute. If an input element can not be found in the" -" specified 'keys_*' attribute, the 'default_*' that matches the specified" -" 'values_*' attribute may be used as its output value.
" -" Let's consider an example which maps a string tensor to an integer tensor." -" Assume and 'keys_strings' is [\"Amy\", \"Sally\"], 'values_int64s' is [5, 6]," -" and 'default_int64' is '-1'. The input [\"Dori\", \"Amy\", \"Amy\", \"Sally\"," -" \"Sally\"] would be mapped to [-1, 5, 5, 6, 6].
" -" Since this operator is an one-to-one mapping, its input and output shapes" -" are the same. Notice that only one of 'keys_*'/'values_*' can be set.
" -" For key look-up, bit-wise comparison is used so even a float NaN can be" -" mapped to a value in 'values_*' attribute.
" - -#### Attributes: - -| Attribute | MLIR Type | Description | -| :-------: | :-------: | ----------- | -`default_float` | FloatAttr | 32-bit float attribute -`default_int64` | IntegerAttr | 64-bit signless integer attribute -`default_string` | StringAttr | string attribute -`keys_floats` | ArrayAttr | 32-bit float array attribute -`keys_int64s` | ArrayAttr | 64-bit integer array attribute -`keys_strings` | ArrayAttr | string array attribute -`values_floats` | ArrayAttr | 32-bit float array attribute -`values_int64s` | ArrayAttr | 64-bit integer array attribute -`values_strings` | ArrayAttr | string array attribute - -#### Operands: - -| Operand | Description | -| :-----: | ----------- | -`X` | memref of any type values or tensor of any type values - -#### Results: - -| Result | Description | -| :----: | ----------- | -`Y` | memref of any type values or tensor of any type values - -### `mlonnx.LinearClassifier` (MLONNXLinearClassifierOp) - -ONNX LinearClassifier operation - -"Linear classifier" - -#### Attributes: - -| Attribute | MLIR Type | Description | -| :-------: | :-------: | ----------- | -`classlabels_ints` | ArrayAttr | 64-bit integer array attribute -`classlabels_strings` | ArrayAttr | string array attribute -`coefficients` | ArrayAttr | 32-bit float array attribute -`intercepts` | ArrayAttr | 32-bit float array attribute -`multi_class` | IntegerAttr | 64-bit signless integer attribute -`post_transform` | StringAttr | string attribute - -#### Operands: - -| Operand | Description | -| :-----: | ----------- | -`X` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values - -#### Results: - -| Result | Description | -| :----: | ----------- | -`Y` | memref of any type values or tensor of any type values -`Z` | memref of any type values or tensor of any type values - -### `mlonnx.LinearRegressor` (MLONNXLinearRegressorOp) - -ONNX LinearRegressor operation - -"Generalized linear regression evaluation.
" -" If targets is set to 1 (default) then univariate regression is performed.
" -" If targets is set to M then M sets of coefficients must be passed in as a sequence" -" and M results will be output for each input n in N.
" -" The coefficients array is of length n, and the coefficients for each target are contiguous." -" Intercepts are optional but if provided must match the number of targets." - -#### Attributes: - -| Attribute | MLIR Type | Description | -| :-------: | :-------: | ----------- | -`coefficients` | ArrayAttr | 32-bit float array attribute -`intercepts` | ArrayAttr | 32-bit float array attribute -`post_transform` | StringAttr | string attribute -`targets` | IntegerAttr | 64-bit signless integer attribute - -#### Operands: - -| Operand | Description | -| :-----: | ----------- | -`X` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values - -#### Results: - -| Result | Description | -| :----: | ----------- | -`Y` | memref of any type values or tensor of any type values - -### `mlonnx.Normalizer` (MLONNXNormalizerOp) - -ONNX Normalizer operation - -"Normalize the input. There are three normalization modes, which have the corresponding formulas," -" defined using element-wise infix operators '/' and '^' and tensor-wide functions 'max' and 'sum':
" -"
" -" Max: Y = X / max(X)
" -" L1: Y = X / sum(X)
" -" L2: Y = sqrt(X^2 / sum(X^2)}
" -" In all modes, if the divisor is zero, Y == X." -"
" -" For batches, that is, [N,C] tensors, normalization is done along the C axis. In other words, each row" -" of the batch is normalized independently." - -#### Attributes: - -| Attribute | MLIR Type | Description | -| :-------: | :-------: | ----------- | -`norm` | StringAttr | string attribute - -#### Operands: - -| Operand | Description | -| :-----: | ----------- | -`X` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values - -#### Results: - -| Result | Description | -| :----: | ----------- | -`Y` | memref of any type values or tensor of any type values - -### `mlonnx.OneHotEncoder` (MLONNXOneHotEncoderOp) - -ONNX OneHotEncoder operation - -"Replace each input element with an array of ones and zeros, where a single" -" one is placed at the index of the category that was passed in. The total category count " -" will determine the size of the extra dimension of the output array Y.
" -" For example, if we pass a tensor with a single value of 4, and a category count of 8, " -" the output will be a tensor with ``[0,0,0,0,1,0,0,0]``.
" -" This operator assumes every input feature is from the same set of categories.
" -" If the input is a tensor of float, int32, or double, the data will be cast" -" to integers and the cats_int64s category list will be used for the lookups." - -#### Attributes: - -| Attribute | MLIR Type | Description | -| :-------: | :-------: | ----------- | -`cats_int64s` | ArrayAttr | 64-bit integer array attribute -`cats_strings` | ArrayAttr | string array attribute -`zeros` | IntegerAttr | 64-bit signless integer attribute - -#### Operands: - -| Operand | Description | -| :-----: | ----------- | -`X` | memref of any type values or tensor of any type values - -#### Results: - -| Result | Description | -| :----: | ----------- | -`Y` | memref of any type values or tensor of any type values - -### `mlonnx.SVMClassifier` (MLONNXSVMClassifierOp) - -ONNX SVMClassifier operation - -"Support Vector Machine classifier" - -#### Attributes: - -| Attribute | MLIR Type | Description | -| :-------: | :-------: | ----------- | -`classlabels_ints` | ArrayAttr | 64-bit integer array attribute -`classlabels_strings` | ArrayAttr | string array attribute -`coefficients` | ArrayAttr | 32-bit float array attribute -`kernel_params` | ArrayAttr | 32-bit float array attribute -`kernel_type` | StringAttr | string attribute -`post_transform` | StringAttr | string attribute -`prob_a` | ArrayAttr | 32-bit float array attribute -`prob_b` | ArrayAttr | 32-bit float array attribute -`rho` | ArrayAttr | 32-bit float array attribute -`support_vectors` | ArrayAttr | 32-bit float array attribute -`vectors_per_class` | ArrayAttr | 64-bit integer array attribute - -#### Operands: - -| Operand | Description | -| :-----: | ----------- | -`X` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values - -#### Results: - -| Result | Description | -| :----: | ----------- | -`Y` | memref of any type values or tensor of any type values -`Z` | memref of any type values or tensor of any type values - -### `mlonnx.SVMRegressor` (MLONNXSVMRegressorOp) - -ONNX SVMRegressor operation - -"Support Vector Machine regression prediction and one-class SVM anomaly detection." - -#### Attributes: - -| Attribute | MLIR Type | Description | -| :-------: | :-------: | ----------- | -`coefficients` | ArrayAttr | 32-bit float array attribute -`kernel_params` | ArrayAttr | 32-bit float array attribute -`kernel_type` | StringAttr | string attribute -`n_supports` | IntegerAttr | 64-bit signless integer attribute -`one_class` | IntegerAttr | 64-bit signless integer attribute -`post_transform` | StringAttr | string attribute -`rho` | ArrayAttr | 32-bit float array attribute -`support_vectors` | ArrayAttr | 32-bit float array attribute - -#### Operands: - -| Operand | Description | -| :-----: | ----------- | -`X` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values - -#### Results: - -| Result | Description | -| :----: | ----------- | -`Y` | memref of any type values or tensor of any type values - -### `mlonnx.Scaler` (MLONNXScalerOp) - -ONNX Scaler operation - -"Rescale input data, for example to standardize features by removing the mean and scaling to unit variance." - -#### Attributes: - -| Attribute | MLIR Type | Description | -| :-------: | :-------: | ----------- | -`offset` | ArrayAttr | 32-bit float array attribute -`scale` | ArrayAttr | 32-bit float array attribute - -#### Operands: - -| Operand | Description | -| :-----: | ----------- | -`X` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values - -#### Results: - -| Result | Description | -| :----: | ----------- | -`Y` | memref of any type values or tensor of any type values - -### `mlonnx.TreeEnsembleClassifier` (MLONNXTreeEnsembleClassifierOp) - -ONNX TreeEnsembleClassifier operation - -"Tree Ensemble classifier. Returns the top class for each of N inputs.
" -" The attributes named 'nodes_X' form a sequence of tuples, associated by " -" index into the sequences, which must all be of equal length. These tuples" -" define the nodes.
" -" Similarly, all fields prefixed with 'class_' are tuples of votes at the leaves." -" A leaf may have multiple votes, where each vote is weighted by" -" the associated class_weights index.
" -" One and only one of classlabels_strings or classlabels_int64s" -" will be defined. The class_ids are indices into this list." - -#### Attributes: - -| Attribute | MLIR Type | Description | -| :-------: | :-------: | ----------- | -`base_values` | ArrayAttr | 32-bit float array attribute -`class_ids` | ArrayAttr | 64-bit integer array attribute -`class_nodeids` | ArrayAttr | 64-bit integer array attribute -`class_treeids` | ArrayAttr | 64-bit integer array attribute -`class_weights` | ArrayAttr | 32-bit float array attribute -`classlabels_int64s` | ArrayAttr | 64-bit integer array attribute -`classlabels_strings` | ArrayAttr | string array attribute -`nodes_falsenodeids` | ArrayAttr | 64-bit integer array attribute -`nodes_featureids` | ArrayAttr | 64-bit integer array attribute -`nodes_hitrates` | ArrayAttr | 32-bit float array attribute -`nodes_missing_value_tracks_true` | ArrayAttr | 64-bit integer array attribute -`nodes_modes` | ArrayAttr | string array attribute -`nodes_nodeids` | ArrayAttr | 64-bit integer array attribute -`nodes_treeids` | ArrayAttr | 64-bit integer array attribute -`nodes_truenodeids` | ArrayAttr | 64-bit integer array attribute -`nodes_values` | ArrayAttr | 32-bit float array attribute -`post_transform` | StringAttr | string attribute - -#### Operands: - -| Operand | Description | -| :-----: | ----------- | -`X` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values - -#### Results: - -| Result | Description | -| :----: | ----------- | -`Y` | memref of any type values or tensor of any type values -`Z` | memref of any type values or tensor of any type values - -### `mlonnx.TreeEnsembleRegressor` (MLONNXTreeEnsembleRegressorOp) - -ONNX TreeEnsembleRegressor operation - -"Tree Ensemble regressor. Returns the regressed values for each input in N.
" -" All args with nodes_ are fields of a tuple of tree nodes, and" -" it is assumed they are the same length, and an index i will decode the" -" tuple across these inputs. Each node id can appear only once" -" for each tree id.
" -" All fields prefixed with target_ are tuples of votes at the leaves.
" -" A leaf may have multiple votes, where each vote is weighted by" -" the associated target_weights index.
" -" All trees must have their node ids start at 0 and increment by 1.
" -" Mode enum is BRANCH_LEQ, BRANCH_LT, BRANCH_GTE, BRANCH_GT, BRANCH_EQ, BRANCH_NEQ, LEAF" - -#### Attributes: - -| Attribute | MLIR Type | Description | -| :-------: | :-------: | ----------- | -`aggregate_function` | StringAttr | string attribute -`base_values` | ArrayAttr | 32-bit float array attribute -`n_targets` | IntegerAttr | 64-bit signless integer attribute -`nodes_falsenodeids` | ArrayAttr | 64-bit integer array attribute -`nodes_featureids` | ArrayAttr | 64-bit integer array attribute -`nodes_hitrates` | ArrayAttr | 32-bit float array attribute -`nodes_missing_value_tracks_true` | ArrayAttr | 64-bit integer array attribute -`nodes_modes` | ArrayAttr | string array attribute -`nodes_nodeids` | ArrayAttr | 64-bit integer array attribute -`nodes_treeids` | ArrayAttr | 64-bit integer array attribute -`nodes_truenodeids` | ArrayAttr | 64-bit integer array attribute -`nodes_values` | ArrayAttr | 32-bit float array attribute -`post_transform` | StringAttr | string attribute -`target_ids` | ArrayAttr | 64-bit integer array attribute -`target_nodeids` | ArrayAttr | 64-bit integer array attribute -`target_treeids` | ArrayAttr | 64-bit integer array attribute -`target_weights` | ArrayAttr | 32-bit float array attribute - -#### Operands: - -| Operand | Description | -| :-----: | ----------- | -`X` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values - -#### Results: - -| Result | Description | -| :----: | ----------- | -`Y` | memref of any type values or tensor of any type values - -### `mlonnx.ZipMap` (MLONNXZipMapOp) - -ONNX ZipMap operation - -"Creates a map from the input and the attributes.
" -" The values are provided by the input tensor, while the keys are specified by the attributes." -" Must provide keys in either classlabels_strings or classlabels_int64s (but not both).
" -" The columns of the tensor correspond one-by-one to the keys specified by the attributes. There must be as many columns as keys.
" - -#### Attributes: - -| Attribute | MLIR Type | Description | -| :-------: | :-------: | ----------- | -`classlabels_int64s` | ArrayAttr | 64-bit integer array attribute -`classlabels_strings` | ArrayAttr | string array attribute - -#### Operands: - -| Operand | Description | -| :-----: | ----------- | -`X` | memref of any type values or tensor of any type values - -#### Results: - -| Result | Description | -| :----: | ----------- | -`Z` | tensor of tensor of 32-bit float or 64-bit signless integer values values or memref of 32-bit float or 64-bit signless integer values - diff --git a/docs/Dialects/onnx.md b/docs/Dialects/onnx.md index 9e34f23..3191d3f 100644 --- a/docs/Dialects/onnx.md +++ b/docs/Dialects/onnx.md @@ -154,6 +154,26 @@ ONNX ArgMin operation | :----: | ----------- | `reduced` | memref of any type values or tensor of any type values +### `onnx.ArrayFeatureExtractor` (ONNXArrayFeatureExtractorOp) + +ONNX ArrayFeatureExtractor operation + +"Select elements of the input tensor based on the indices passed.
" +" The indices are applied to the last axes of the tensor." + +#### Operands: + +| Operand | Description | +| :-----: | ----------- | +`X` | memref of any type values or tensor of any type values +`Y` | memref of any type values or tensor of any type values + +#### Results: + +| Result | Description | +| :----: | ----------- | +`Z` | memref of any type values or tensor of any type values + ### `onnx.Asin` (ONNXAsinOp) ONNX Asin operation @@ -363,6 +383,30 @@ ONNX BatchNormalization operation in test mode | :----: | ----------- | `o_Y` | memref of any type values or tensor of any type values +### `onnx.Binarizer` (ONNXBinarizerOp) + +ONNX Binarizer operation + +"Maps the values of the input tensor to either 0 or 1, element-wise, based on the outcome of a comparison against a threshold value." + +#### Attributes: + +| Attribute | MLIR Type | Description | +| :-------: | :-------: | ----------- | +`threshold` | FloatAttr | 32-bit float attribute + +#### Operands: + +| Operand | Description | +| :-----: | ----------- | +`X` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values + +#### Results: + +| Result | Description | +| :----: | ----------- | +`Y` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values + ### `onnx.BitShift` (ONNXBitShiftOp) ONNX BitShift operation @@ -399,6 +443,34 @@ ONNX BitShift operation | :----: | ----------- | `Z` | tensor of 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values or memref of 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer values +### `onnx.CastMap` (ONNXCastMapOp) + +ONNX CastMap operation + +"Converts a map to a tensor.
The map key must be an int64 and the values will be ordered" +" in ascending order based on this key.
The operator supports dense packing or sparse packing." +" If using sparse packing, the key cannot exceed the max_map-1 value." + +#### Attributes: + +| Attribute | MLIR Type | Description | +| :-------: | :-------: | ----------- | +`cast_to` | StringAttr | string attribute +`map_form` | StringAttr | string attribute +`max_map` | IntegerAttr | 64-bit signless integer attribute + +#### Operands: + +| Operand | Description | +| :-----: | ----------- | +`X` | tuple with any combination of tensor of 64-bit signless integer values values or memref of 64-bit signless integer values + +#### Results: + +| Result | Description | +| :----: | ----------- | +`Y` | memref of any type values or tensor of any type values + ### `onnx.Cast` (ONNXCastOp) ONNX Cast operation @@ -441,6 +513,40 @@ ONNX Cast operation | :----: | ----------- | `output` | memref of any type values or tensor of any type values +### `onnx.CategoryMapper` (ONNXCategoryMapperOp) + +ONNX CategoryMapper operation + +"Converts strings to integers and vice versa.
" +" Two sequences of equal length are used to map between integers and strings," +" with strings and integers at the same index detailing the mapping.
" +" Each operator converts either integers to strings or strings to integers, depending " +" on which default value attribute is provided. Only one default value attribute" +" should be defined.
" +" If the string default value is set, it will convert integers to strings." +" If the int default value is set, it will convert strings to integers." + +#### Attributes: + +| Attribute | MLIR Type | Description | +| :-------: | :-------: | ----------- | +`cats_int64s` | ArrayAttr | 64-bit integer array attribute +`cats_strings` | ArrayAttr | string array attribute +`default_int64` | IntegerAttr | 64-bit signless integer attribute +`default_string` | StringAttr | string attribute + +#### Operands: + +| Operand | Description | +| :-----: | ----------- | +`X` | memref of any type values or tensor of any type values + +#### Results: + +| Result | Description | +| :----: | ----------- | +`Y` | memref of any type values or tensor of any type values + ### `onnx.Ceil` (ONNXCeilOp) ONNX Ceil operation @@ -895,6 +1001,42 @@ ONNX Det operation | :----: | ----------- | `Y` | tensor of 16-bit float or 32-bit float or 64-bit float values or memref of 16-bit float or 32-bit float or 64-bit float values +### `onnx.DictVectorizer` (ONNXDictVectorizerOp) + +ONNX DictVectorizer operation + +"Uses an index mapping to convert a dictionary to an array.
" +" Given a dictionary, each key is looked up in the vocabulary attribute corresponding to" +" the key type. The index into the vocabulary array at which the key is found is then" +" used to index the output 1-D tensor 'Y' and insert into it the value found in the dictionary 'X'.
" +" The key type of the input map must correspond to the element type of the defined vocabulary attribute." +" Therefore, the output array will be equal in length to the index mapping vector parameter." +" All keys in the input dictionary must be present in the index mapping vector." +" For each item in the input dictionary, insert its value in the output array." +" Any keys not present in the input dictionary, will be zero in the output array.
" +" For example: if the ``string_vocabulary`` parameter is set to ``[\"a\", \"c\", \"b\", \"z\"]``," +" then an input of ``{\"a\": 4, \"c\": 8}`` will produce an output of ``[4, 8, 0, 0]``." +" " + +#### Attributes: + +| Attribute | MLIR Type | Description | +| :-------: | :-------: | ----------- | +`int64_vocabulary` | ArrayAttr | 64-bit integer array attribute +`string_vocabulary` | ArrayAttr | string array attribute + +#### Operands: + +| Operand | Description | +| :-----: | ----------- | +`X` | tuple with any combination of tensor of 64-bit signless integer or 32-bit float or 64-bit float values values or memref of 64-bit signless integer or 32-bit float or 64-bit float values + +#### Results: + +| Result | Description | +| :----: | ----------- | +`Y` | memref of any type values or tensor of any type values + ### `onnx.Div` (ONNXDivOp) ONNX Div operation @@ -1135,6 +1277,33 @@ ONNX EyeLike operation | :----: | ----------- | `output` | tensor of 16-bit float or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer or 1-bit signless integer values or memref of 16-bit float or 32-bit float or 64-bit float or 8-bit signless integer or 16-bit signless integer or 32-bit signless integer or 64-bit signless integer or 1-bit signless integer values +### `onnx.FeatureVectorizer` (ONNXFeatureVectorizerOp) + +ONNX FeatureVectorizer operation + +"Concatenates input tensors into one continuous output.
" +" All input shapes are 2-D and are concatenated along the second dimention. 1-D tensors are treated as [1,C]." +" Inputs are copied to the output maintaining the order of the input arguments.
" +" All inputs must be integers or floats, while the output will be all floating point values." + +#### Attributes: + +| Attribute | MLIR Type | Description | +| :-------: | :-------: | ----------- | +`inputdimensions` | ArrayAttr | 64-bit integer array attribute + +#### Operands: + +| Operand | Description | +| :-----: | ----------- | +`X` | tensor of 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float values or memref of 32-bit signless integer or 64-bit signless integer or 32-bit float or 64-bit float values + +#### Results: + +| Result | Description | +| :----: | ----------- | +`Y` | memref of any type values or tensor of any type values + ### `onnx.Flatten` (ONNXFlattenOp) ONNX Flatten operation @@ -1768,6 +1937,40 @@ ONNX If operation | :----: | ----------- | `outputs` | memref of any type values or tensor of any type values +### `onnx.Imputer` (ONNXImputerOp) + +ONNX Imputer operation + +"Replaces inputs that equal one value with another, leaving all other elements alone.
" +" This operator is typically used to replace missing values in situations where they have a canonical" +" representation, such as -1, 0, NaN, or some extreme value.
" +" One and only one of imputed_value_floats or imputed_value_int64s should be defined -- floats if the input tensor" +" holds floats, integers if the input tensor holds integers. The imputed values must all fit within the" +" width of the tensor element type. One and only one of the replaced_value_float or replaced_value_int64 should be defined," +" which one depends on whether floats or integers are being processed.
" +" The imputed_value attribute length can be 1 element, or it can have one element per input feature.
In other words, if the input tensor has the shape [*,F], then the length of the attribute array may be 1 or F. If it is 1, then it is broadcast along the last dimension and applied to each feature." + +#### Attributes: + +| Attribute | MLIR Type | Description | +| :-------: | :-------: | ----------- | +`imputed_value_floats` | ArrayAttr | 32-bit float array attribute +`imputed_value_int64s` | ArrayAttr | 64-bit integer array attribute +`replaced_value_float` | FloatAttr | 32-bit float attribute +`replaced_value_int64` | IntegerAttr | 64-bit signless integer attribute + +#### Operands: + +| Operand | Description | +| :-----: | ----------- | +`X` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values + +#### Results: + +| Result | Description | +| :----: | ----------- | +`Y` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values + ### `onnx.InstanceNormalization` (ONNXInstanceNormalizationOp) ONNX InstanceNormalization operation @@ -1997,6 +2200,54 @@ ONNX LSTM operation `Y_h` | tensor of 16-bit float or 32-bit float or 64-bit float values or memref of 16-bit float or 32-bit float or 64-bit float values or none type `Y_c` | tensor of 16-bit float or 32-bit float or 64-bit float values or memref of 16-bit float or 32-bit float or 64-bit float values or none type +### `onnx.LabelEncoder` (ONNXLabelEncoderOp) + +ONNX LabelEncoder operation + +"Maps each element in the input tensor to another value.
" +" The mapping is determined by the two parallel attributes, 'keys_*' and" +" 'values_*' attribute. The i-th value in the specified 'keys_*' attribute" +" would be mapped to the i-th value in the specified 'values_*' attribute. It" +" implies that input's element type and the element type of the specified" +" 'keys_*' should be identical while the output type is identical to the" +" specified 'values_*' attribute. If an input element can not be found in the" +" specified 'keys_*' attribute, the 'default_*' that matches the specified" +" 'values_*' attribute may be used as its output value.
" +" Let's consider an example which maps a string tensor to an integer tensor." +" Assume and 'keys_strings' is [\"Amy\", \"Sally\"], 'values_int64s' is [5, 6]," +" and 'default_int64' is '-1'. The input [\"Dori\", \"Amy\", \"Amy\", \"Sally\"," +" \"Sally\"] would be mapped to [-1, 5, 5, 6, 6].
" +" Since this operator is an one-to-one mapping, its input and output shapes" +" are the same. Notice that only one of 'keys_*'/'values_*' can be set.
" +" For key look-up, bit-wise comparison is used so even a float NaN can be" +" mapped to a value in 'values_*' attribute.
" + +#### Attributes: + +| Attribute | MLIR Type | Description | +| :-------: | :-------: | ----------- | +`default_float` | FloatAttr | 32-bit float attribute +`default_int64` | IntegerAttr | 64-bit signless integer attribute +`default_string` | StringAttr | string attribute +`keys_floats` | ArrayAttr | 32-bit float array attribute +`keys_int64s` | ArrayAttr | 64-bit integer array attribute +`keys_strings` | ArrayAttr | string array attribute +`values_floats` | ArrayAttr | 32-bit float array attribute +`values_int64s` | ArrayAttr | 64-bit integer array attribute +`values_strings` | ArrayAttr | string array attribute + +#### Operands: + +| Operand | Description | +| :-----: | ----------- | +`X` | memref of any type values or tensor of any type values + +#### Results: + +| Result | Description | +| :----: | ----------- | +`Y` | memref of any type values or tensor of any type values + ### `onnx.LeakyRelu` (ONNXLeakyReluOp) ONNX LeakyRelu operation @@ -2045,6 +2296,68 @@ ONNX Less operation | :----: | ----------- | `C` | tensor of 1-bit signless integer values or memref of 1-bit signless integer values +### `onnx.LinearClassifier` (ONNXLinearClassifierOp) + +ONNX LinearClassifier operation + +"Linear classifier" + +#### Attributes: + +| Attribute | MLIR Type | Description | +| :-------: | :-------: | ----------- | +`classlabels_ints` | ArrayAttr | 64-bit integer array attribute +`classlabels_strings` | ArrayAttr | string array attribute +`coefficients` | ArrayAttr | 32-bit float array attribute +`intercepts` | ArrayAttr | 32-bit float array attribute +`multi_class` | IntegerAttr | 64-bit signless integer attribute +`post_transform` | StringAttr | string attribute + +#### Operands: + +| Operand | Description | +| :-----: | ----------- | +`X` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values + +#### Results: + +| Result | Description | +| :----: | ----------- | +`Y` | memref of any type values or tensor of any type values +`Z` | memref of any type values or tensor of any type values + +### `onnx.LinearRegressor` (ONNXLinearRegressorOp) + +ONNX LinearRegressor operation + +"Generalized linear regression evaluation.
" +" If targets is set to 1 (default) then univariate regression is performed.
" +" If targets is set to M then M sets of coefficients must be passed in as a sequence" +" and M results will be output for each input n in N.
" +" The coefficients array is of length n, and the coefficients for each target are contiguous." +" Intercepts are optional but if provided must match the number of targets." + +#### Attributes: + +| Attribute | MLIR Type | Description | +| :-------: | :-------: | ----------- | +`coefficients` | ArrayAttr | 32-bit float array attribute +`intercepts` | ArrayAttr | 32-bit float array attribute +`post_transform` | StringAttr | string attribute +`targets` | IntegerAttr | 64-bit signless integer attribute + +#### Operands: + +| Operand | Description | +| :-----: | ----------- | +`X` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values + +#### Results: + +| Result | Description | +| :----: | ----------- | +`Y` | memref of any type values or tensor of any type values + ### `onnx.Log` (ONNXLogOp) ONNX Log operation @@ -2744,6 +3057,39 @@ ONNX NonZero operation | :----: | ----------- | `Y` | memref of any type values or tensor of any type values +### `onnx.Normalizer` (ONNXNormalizerOp) + +ONNX Normalizer operation + +"Normalize the input. There are three normalization modes, which have the corresponding formulas," +" defined using element-wise infix operators '/' and '^' and tensor-wide functions 'max' and 'sum':
" +"
" +" Max: Y = X / max(X)
" +" L1: Y = X / sum(X)
" +" L2: Y = sqrt(X^2 / sum(X^2)}
" +" In all modes, if the divisor is zero, Y == X." +"
" +" For batches, that is, [N,C] tensors, normalization is done along the C axis. In other words, each row" +" of the batch is normalized independently." + +#### Attributes: + +| Attribute | MLIR Type | Description | +| :-------: | :-------: | ----------- | +`norm` | StringAttr | string attribute + +#### Operands: + +| Operand | Description | +| :-----: | ----------- | +`X` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values + +#### Results: + +| Result | Description | +| :----: | ----------- | +`Y` | memref of any type values or tensor of any type values + ### `onnx.Not` (ONNXNotOp) ONNX Not operation @@ -2762,6 +3108,39 @@ ONNX Not operation | :----: | ----------- | `Y` | tensor of 1-bit signless integer values or memref of 1-bit signless integer values +### `onnx.OneHotEncoder` (ONNXOneHotEncoderOp) + +ONNX OneHotEncoder operation + +"Replace each input element with an array of ones and zeros, where a single" +" one is placed at the index of the category that was passed in. The total category count " +" will determine the size of the extra dimension of the output array Y.
" +" For example, if we pass a tensor with a single value of 4, and a category count of 8, " +" the output will be a tensor with ``[0,0,0,0,1,0,0,0]``.
" +" This operator assumes every input feature is from the same set of categories.
" +" If the input is a tensor of float, int32, or double, the data will be cast" +" to integers and the cats_int64s category list will be used for the lookups." + +#### Attributes: + +| Attribute | MLIR Type | Description | +| :-------: | :-------: | ----------- | +`cats_int64s` | ArrayAttr | 64-bit integer array attribute +`cats_strings` | ArrayAttr | string array attribute +`zeros` | IntegerAttr | 64-bit signless integer attribute + +#### Operands: + +| Operand | Description | +| :-----: | ----------- | +`X` | memref of any type values or tensor of any type values + +#### Results: + +| Result | Description | +| :----: | ----------- | +`Y` | memref of any type values or tensor of any type values + ### `onnx.OneHot` (ONNXOneHotOp) ONNX OneHot operation @@ -3945,6 +4324,97 @@ ONNX Round operation | :----: | ----------- | `Y` | tensor of 16-bit float or 32-bit float or 64-bit float values or memref of 16-bit float or 32-bit float or 64-bit float values +### `onnx.SVMClassifier` (ONNXSVMClassifierOp) + +ONNX SVMClassifier operation + +"Support Vector Machine classifier" + +#### Attributes: + +| Attribute | MLIR Type | Description | +| :-------: | :-------: | ----------- | +`classlabels_ints` | ArrayAttr | 64-bit integer array attribute +`classlabels_strings` | ArrayAttr | string array attribute +`coefficients` | ArrayAttr | 32-bit float array attribute +`kernel_params` | ArrayAttr | 32-bit float array attribute +`kernel_type` | StringAttr | string attribute +`post_transform` | StringAttr | string attribute +`prob_a` | ArrayAttr | 32-bit float array attribute +`prob_b` | ArrayAttr | 32-bit float array attribute +`rho` | ArrayAttr | 32-bit float array attribute +`support_vectors` | ArrayAttr | 32-bit float array attribute +`vectors_per_class` | ArrayAttr | 64-bit integer array attribute + +#### Operands: + +| Operand | Description | +| :-----: | ----------- | +`X` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values + +#### Results: + +| Result | Description | +| :----: | ----------- | +`Y` | memref of any type values or tensor of any type values +`Z` | memref of any type values or tensor of any type values + +### `onnx.SVMRegressor` (ONNXSVMRegressorOp) + +ONNX SVMRegressor operation + +"Support Vector Machine regression prediction and one-class SVM anomaly detection." + +#### Attributes: + +| Attribute | MLIR Type | Description | +| :-------: | :-------: | ----------- | +`coefficients` | ArrayAttr | 32-bit float array attribute +`kernel_params` | ArrayAttr | 32-bit float array attribute +`kernel_type` | StringAttr | string attribute +`n_supports` | IntegerAttr | 64-bit signless integer attribute +`one_class` | IntegerAttr | 64-bit signless integer attribute +`post_transform` | StringAttr | string attribute +`rho` | ArrayAttr | 32-bit float array attribute +`support_vectors` | ArrayAttr | 32-bit float array attribute + +#### Operands: + +| Operand | Description | +| :-----: | ----------- | +`X` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values + +#### Results: + +| Result | Description | +| :----: | ----------- | +`Y` | memref of any type values or tensor of any type values + +### `onnx.Scaler` (ONNXScalerOp) + +ONNX Scaler operation + +"Rescale input data, for example to standardize features by removing the mean and scaling to unit variance." + +#### Attributes: + +| Attribute | MLIR Type | Description | +| :-------: | :-------: | ----------- | +`offset` | ArrayAttr | 32-bit float array attribute +`scale` | ArrayAttr | 32-bit float array attribute + +#### Operands: + +| Operand | Description | +| :-----: | ----------- | +`X` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values + +#### Results: + +| Result | Description | +| :----: | ----------- | +`Y` | memref of any type values or tensor of any type values + ### `onnx.Scan` (ONNXScanOp) ONNX Scan operation @@ -5161,6 +5631,104 @@ ONNX Transpose operation | :----: | ----------- | `transposed` | memref of any type values or tensor of any type values +### `onnx.TreeEnsembleClassifier` (ONNXTreeEnsembleClassifierOp) + +ONNX TreeEnsembleClassifier operation + +"Tree Ensemble classifier. Returns the top class for each of N inputs.
" +" The attributes named 'nodes_X' form a sequence of tuples, associated by " +" index into the sequences, which must all be of equal length. These tuples" +" define the nodes.
" +" Similarly, all fields prefixed with 'class_' are tuples of votes at the leaves." +" A leaf may have multiple votes, where each vote is weighted by" +" the associated class_weights index.
" +" One and only one of classlabels_strings or classlabels_int64s" +" will be defined. The class_ids are indices into this list." + +#### Attributes: + +| Attribute | MLIR Type | Description | +| :-------: | :-------: | ----------- | +`base_values` | ArrayAttr | 32-bit float array attribute +`class_ids` | ArrayAttr | 64-bit integer array attribute +`class_nodeids` | ArrayAttr | 64-bit integer array attribute +`class_treeids` | ArrayAttr | 64-bit integer array attribute +`class_weights` | ArrayAttr | 32-bit float array attribute +`classlabels_int64s` | ArrayAttr | 64-bit integer array attribute +`classlabels_strings` | ArrayAttr | string array attribute +`nodes_falsenodeids` | ArrayAttr | 64-bit integer array attribute +`nodes_featureids` | ArrayAttr | 64-bit integer array attribute +`nodes_hitrates` | ArrayAttr | 32-bit float array attribute +`nodes_missing_value_tracks_true` | ArrayAttr | 64-bit integer array attribute +`nodes_modes` | ArrayAttr | string array attribute +`nodes_nodeids` | ArrayAttr | 64-bit integer array attribute +`nodes_treeids` | ArrayAttr | 64-bit integer array attribute +`nodes_truenodeids` | ArrayAttr | 64-bit integer array attribute +`nodes_values` | ArrayAttr | 32-bit float array attribute +`post_transform` | StringAttr | string attribute + +#### Operands: + +| Operand | Description | +| :-----: | ----------- | +`X` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values + +#### Results: + +| Result | Description | +| :----: | ----------- | +`Y` | memref of any type values or tensor of any type values +`Z` | memref of any type values or tensor of any type values + +### `onnx.TreeEnsembleRegressor` (ONNXTreeEnsembleRegressorOp) + +ONNX TreeEnsembleRegressor operation + +"Tree Ensemble regressor. Returns the regressed values for each input in N.
" +" All args with nodes_ are fields of a tuple of tree nodes, and" +" it is assumed they are the same length, and an index i will decode the" +" tuple across these inputs. Each node id can appear only once" +" for each tree id.
" +" All fields prefixed with target_ are tuples of votes at the leaves.
" +" A leaf may have multiple votes, where each vote is weighted by" +" the associated target_weights index.
" +" All trees must have their node ids start at 0 and increment by 1.
" +" Mode enum is BRANCH_LEQ, BRANCH_LT, BRANCH_GTE, BRANCH_GT, BRANCH_EQ, BRANCH_NEQ, LEAF" + +#### Attributes: + +| Attribute | MLIR Type | Description | +| :-------: | :-------: | ----------- | +`aggregate_function` | StringAttr | string attribute +`base_values` | ArrayAttr | 32-bit float array attribute +`n_targets` | IntegerAttr | 64-bit signless integer attribute +`nodes_falsenodeids` | ArrayAttr | 64-bit integer array attribute +`nodes_featureids` | ArrayAttr | 64-bit integer array attribute +`nodes_hitrates` | ArrayAttr | 32-bit float array attribute +`nodes_missing_value_tracks_true` | ArrayAttr | 64-bit integer array attribute +`nodes_modes` | ArrayAttr | string array attribute +`nodes_nodeids` | ArrayAttr | 64-bit integer array attribute +`nodes_treeids` | ArrayAttr | 64-bit integer array attribute +`nodes_truenodeids` | ArrayAttr | 64-bit integer array attribute +`nodes_values` | ArrayAttr | 32-bit float array attribute +`post_transform` | StringAttr | string attribute +`target_ids` | ArrayAttr | 64-bit integer array attribute +`target_nodeids` | ArrayAttr | 64-bit integer array attribute +`target_treeids` | ArrayAttr | 64-bit integer array attribute +`target_weights` | ArrayAttr | 32-bit float array attribute + +#### Operands: + +| Operand | Description | +| :-----: | ----------- | +`X` | tensor of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values or memref of 32-bit float or 64-bit float or 64-bit signless integer or 32-bit signless integer values + +#### Results: + +| Result | Description | +| :----: | ----------- | +`Y` | memref of any type values or tensor of any type values + ### `onnx.Unique` (ONNXUniqueOp) ONNX Unique operation @@ -5370,3 +5938,31 @@ ONNX Xor operation | :----: | ----------- | `C` | tensor of 1-bit signless integer values or memref of 1-bit signless integer values +### `onnx.ZipMap` (ONNXZipMapOp) + +ONNX ZipMap operation + +"Creates a map from the input and the attributes.
" +" The values are provided by the input tensor, while the keys are specified by the attributes." +" Must provide keys in either classlabels_strings or classlabels_int64s (but not both).
" +" The columns of the tensor correspond one-by-one to the keys specified by the attributes. There must be as many columns as keys.
" + +#### Attributes: + +| Attribute | MLIR Type | Description | +| :-------: | :-------: | ----------- | +`classlabels_int64s` | ArrayAttr | 64-bit integer array attribute +`classlabels_strings` | ArrayAttr | string array attribute + +#### Operands: + +| Operand | Description | +| :-----: | ----------- | +`X` | memref of any type values or tensor of any type values + +#### Results: + +| Result | Description | +| :----: | ----------- | +`Z` | tensor of tensor of 32-bit float or 64-bit signless integer values values or memref of 32-bit float or 64-bit signless integer values + diff --git a/src/Builder/CMakeLists.txt b/src/Builder/CMakeLists.txt index d42a867..f20409b 100644 --- a/src/Builder/CMakeLists.txt +++ b/src/Builder/CMakeLists.txt @@ -30,8 +30,3 @@ target_include_directories(OMBuilder # the compilation will fail. add_dependencies(OMBuilder OMONNXOpsInc) add_dependencies(OMBuilder OMONNXOps OMResultTypeInferenceOpInterface) - -if (INCLUDE_ONNX_ML) - add_dependencies(OMBuilder OMMLONNXOpsInc) - add_dependencies(OMBuilder OMMLONNXOps) -endif() diff --git a/src/Builder/FrontendDialectTransformer.cpp b/src/Builder/FrontendDialectTransformer.cpp index ecae7b0..00ab212 100644 --- a/src/Builder/FrontendDialectTransformer.cpp +++ b/src/Builder/FrontendDialectTransformer.cpp @@ -404,9 +404,6 @@ private: // one known reeason is the optional input #include "src/Builder/OpBuildTable.inc" -#if INCLUDE_ONNX_ML == 1 -#include "src/Builder/MLOpBuildTable.inc" -#endif } /*! diff --git a/src/Builder/OpBuildTable.inc b/src/Builder/OpBuildTable.inc index 2b3f7bf..3e842fd 100644 --- a/src/Builder/OpBuildTable.inc +++ b/src/Builder/OpBuildTable.inc @@ -316,3 +316,39 @@ if (opName == "Where") buildOperation(node); if (opName == "Xor") buildOperation(node); +if (opName == "ArrayFeatureExtractor") + buildOperation(node); +if (opName == "Binarizer") + buildOperation(node); +if (opName == "CastMap") + buildOperation(node); +if (opName == "CategoryMapper") + buildOperation(node); +if (opName == "DictVectorizer") + buildOperation(node); +if (opName == "FeatureVectorizer") + buildOperation(node); +if (opName == "Imputer") + buildOperation(node); +if (opName == "LabelEncoder") + buildOperation(node); +if (opName == "LinearClassifier") + buildOperation(node); +if (opName == "LinearRegressor") + buildOperation(node); +if (opName == "Normalizer") + buildOperation(node); +if (opName == "OneHotEncoder") + buildOperation(node); +if (opName == "SVMClassifier") + buildOperation(node); +if (opName == "SVMRegressor") + buildOperation(node); +if (opName == "Scaler") + buildOperation(node); +if (opName == "TreeEnsembleClassifier") + buildOperation(node); +if (opName == "TreeEnsembleRegressor") + buildOperation(node); +if (opName == "ZipMap") + buildOperation(node); diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 03292ec..2725545 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -70,11 +70,6 @@ endif() # (except system libraries such as libc). add_dependencies(onnx-mlir OMKrnlOpsInc OMONNXOpsInc) -if (INCLUDE_ONNX_ML) - target_link_libraries(MainUtils OMMLONNXOps) - add_dependencies(MainUtils OMMLONNXOpsInc) -endif() - add_dependencies(onnx-mlir cruntime) add_dependencies(onnx-mlir EmbeddedDataLoader) diff --git a/src/Dialect/CMakeLists.txt b/src/Dialect/CMakeLists.txt index 9454959..e4e1b9b 100644 --- a/src/Dialect/CMakeLists.txt +++ b/src/Dialect/CMakeLists.txt @@ -1,5 +1,2 @@ add_subdirectory(Krnl) add_subdirectory(ONNX) -if (INCLUDE_ONNX_ML) - add_subdirectory(MLONNX) -endif() diff --git a/src/Dialect/MLONNX/CMakeLists.txt b/src/Dialect/MLONNX/CMakeLists.txt deleted file mode 100644 index 7b29c75..0000000 --- a/src/Dialect/MLONNX/CMakeLists.txt +++ /dev/null @@ -1,31 +0,0 @@ -set(LLVM_TARGET_DEFINITIONS MLONNXOps.td) -onnx_mlir_tablegen(MLONNXOps.hpp.inc -gen-op-decls "-I${ONNX_MLIR_SRC_ROOT}/compiler/pass") -onnx_mlir_tablegen(MLONNXOps.cpp.inc -gen-op-defs "-I${ONNX_MLIR_SRC_ROOT}/compiler/pass") - -set(GEN_DOC_FILE ${CMAKE_BINARY_DIR}/docs/Dialects/mlonnx.md) -add_public_tablegen_target(OMMLONNXOpsIncGen) - -# Header dependencies target for MLONNXOps.hpp -add_custom_target(OMMLONNXOpsInc - DEPENDS OMMLONNXOpsIncGen - OMPromotableConstOperandsOpInterfaceIncGen - OMResultTypeInferenceOpInterfaceIncGen - ShapeInferenceOpInterfaceIncGen) - -add_library(OMMLONNXOps - MLONNXOps.cpp - MLONNXOps.hpp) -target_include_directories(OMMLONNXOps - PRIVATE - ${ONNX_MLIR_SRC_ROOT} - ${ONNX_MLIR_BIN_ROOT} - ${ONNX_MLIR_SRC_ROOT}) -# Header dependencies -add_dependencies(OMMLONNXOps OMMLONNXOpsInc) -# Linking dependencies -add_dependencies(OMMLONNXOps - OMPromotableConstOperandsOpInterface - OMResultTypeInferenceOpInterface - OMShapeInferenceOpInterface) - -add_onnx_mlir_dialect_doc(mlonnx MLONNXOps.td) diff --git a/src/Dialect/MLONNX/MLONNXOps.cpp b/src/Dialect/MLONNX/MLONNXOps.cpp deleted file mode 100644 index 0b5c6ec..0000000 --- a/src/Dialect/MLONNX/MLONNXOps.cpp +++ /dev/null @@ -1,47 +0,0 @@ -//===------------------ MLONNXOps.cpp - ONNX ML Operations ----------------===// -// -// Copyright 2019-2020 The IBM Research Authors. -// -// ============================================================================= -// -// This file provides definition of ONNX ML dialect operations. -// -//===----------------------------------------------------------------------===// - -#include "mlir/Dialect/Traits.h" -#include "mlir/IR/Block.h" -#include "mlir/IR/Builders.h" -#include "mlir/IR/Function.h" -#include "mlir/IR/IntegerSet.h" -#include "mlir/IR/Matchers.h" -#include "mlir/IR/Module.h" -#include "mlir/IR/OpImplementation.h" -#include "mlir/IR/PatternMatch.h" -#include "llvm/ADT/SetVector.h" -#include "llvm/ADT/SmallBitVector.h" - -#include "MLONNXOps.hpp" - -using namespace mlir; -using namespace mlir::OpTrait::util; - -//===----------------------------------------------------------------------===// -// MLONNXOpsDialect -//===----------------------------------------------------------------------===// - -/// Dialect creation, the instance will be owned by the context. This is the -/// point of registration of custom types and operations for the dialect. -MLONNXOpsDialect::MLONNXOpsDialect(mlir::MLIRContext *ctx) - : mlir::Dialect(getDialectNamespace(), ctx) { - addOperations< -#define GET_OP_LIST -#include "src/Dialect/MLONNX/MLONNXOps.cpp.inc" - >(); -} - -//===----------------------------------------------------------------------===// -// TableGen'd op method definitions -//===----------------------------------------------------------------------===// - -#define GET_OP_CLASSES -#include "src/Dialect/MLONNX/MLONNXOps.cpp.inc" diff --git a/src/Dialect/MLONNX/MLONNXOps.hpp b/src/Dialect/MLONNX/MLONNXOps.hpp deleted file mode 100644 index 9474422..0000000 --- a/src/Dialect/MLONNX/MLONNXOps.hpp +++ /dev/null @@ -1,44 +0,0 @@ -//===----------------- MLONNXOps.hpp - ONNX ML Operations ----_------------===// -// -// Copyright 2019 The IBM Research Authors. -// -// ============================================================================= -// -// This file defines ONNX ML operations in the MLIR operation set. -// -//===----------------------------------------------------------------------===// - -#pragma once - -#include -#include - -#include "mlir/Dialect/StandardOps/IR/Ops.h" -#include "mlir/IR/Builders.h" -#include "mlir/IR/Dialect.h" -#include "mlir/IR/OpDefinition.h" -#include "mlir/IR/StandardTypes.h" - -#include "src/Interface/PromotableConstOperandsOpInterface.hpp" -#include "src/Interface/ResultTypeInferenceOpInterface.hpp" -#include "src/Interface/ShapeInferenceInterface.hpp" - -namespace mlir { - -class MLONNXOpsDialect : public Dialect { -public: - MLONNXOpsDialect(MLIRContext *context); - - /// Provide a utility accessor to the dialect namespace. This is used by - /// several utilities for casting between dialects. - static StringRef getDialectNamespace() { return "mlonnx"; } -}; - -/// Include the auto-generated header file containing the declarations of the -/// ONNX operations. -#define GET_OP_CLASSES -#include "src/Dialect/MLONNX/MLONNXOps.hpp.inc" - -} // end namespace mlir - -namespace onnx_mlir {} diff --git a/src/Dialect/MLONNX/MLONNXOps.td b/src/Dialect/MLONNX/MLONNXOps.td deleted file mode 100644 index 296442e..0000000 --- a/src/Dialect/MLONNX/MLONNXOps.td +++ /dev/null @@ -1,72 +0,0 @@ -//===-- MLONNXOps.td -- ONNX ML Dialect Operation Definitions -*- tablegen -==// -// -// Copyright 2019-2020 The IBM Research Authors -// -// ============================================================================= -// -// Defines ONNX ML Dialect operations. -// -//===----------------------------------------------------------------------===// - -#ifdef MLONNX_OPS -#else -#define MLONNX_OPS - -#ifdef OP_BASE -#else -include "mlir/IR/OpBase.td" -#endif // OP_BASE - -#ifdef SHAPE_INFERENCE_INTERFACE -#else -include "src/Interface/ShapeInferenceInterface.td" -#endif // SHAPE_INFERENCE_INTERFACE - -#ifdef PROMOTABLE_CONST_OPERANDS_OP_INTERFACE -#else -include "src/Interface/PromotableConstOperandsOpInterface.td" -#endif // PROMOTABLE_CONST_OPERANDS_OP_INTERFACE - -#ifdef RESULT_TYPE_INFERENCE_OP_INTERFACE -#else -include "src/Interface/ResultTypeInferenceOpInterface.td" -#endif // RESULT_TYPE_INFERENCE_OP_INTERFACE - -def MLONNX_Dialect : Dialect { - let name = "mlonnx"; - let cppNamespace = ""; -} - -// Base class for ONNX dialect operations. This operation inherits from the base -// `Op` class in OpBase.td, and provides: -// * The parent dialect of the operation. -// * The mnemonic for the operation, or the name without the dialect prefix. -// * A list of traits for the operation. -class MLONNX_Op traits = []> : - Op; - -//===----------------------------------------------------------------------===// -// MLONNX Operations -//===----------------------------------------------------------------------===// - -//the tablegen code onnxop.in is generated with gen_doc.py -//clone and install onnx -// git clone --recursive https://github.com/onnx/onnx.git -// set up env for anaconda3 and for ONNX MLIR (BOOSTROOT, cmake, gcc ...) -// cd onnx -//install onnx -// CC=gcc CXX=g++ pip install -e . -//run the script -// python onnx/defs/gen_doc.py -//result is in docs/onnx_ops.td.inc -//current limitations: -// 1. Attributes are not processed -// 2. output type inference not implemented except Add -// 3. Type Attribute: 'optional' and 'Variadic hetergeneous' are ignored -// 4. type of string, complex64 and complex128 for input/output are ignored -// 5. unsigned int are treated as signed one - -include "mlir/Interfaces/SideEffectInterfaces.td" -include "src/Dialect/MLONNX/MLONNXOps.td.inc" - -#endif // MLONNX_OPS diff --git a/src/Dialect/MLONNX/MLONNXOps.td.inc b/src/Dialect/MLONNX/MLONNXOps.td.inc deleted file mode 100644 index c288113..0000000 --- a/src/Dialect/MLONNX/MLONNXOps.td.inc +++ /dev/null @@ -1,571 +0,0 @@ -//******************************************************** -// Do not modify this file directly. -// This file is automatically generated via script. -// Details can be found in docs/readonnxdefs.md . -//******************************************************** - -def MLONNXArrayFeatureExtractorOp:MLONNX_Op<"ArrayFeatureExtractor", - [NoSideEffect]> { - let summary = "ONNX ArrayFeatureExtractor operation"; - let description = [{ - "Select elements of the input tensor based on the indices passed.
" - " The indices are applied to the last axes of the tensor." - }]; - let arguments = (ins AnyTypeOf<[AnyMemRef, AnyTensor]>:$X, - AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); - let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Z); - let extraClassDeclaration = [{ - static int getNumberOfOperands() { - return 2; - } - static int getNumberOfResults() { - return 1; - } - static std::vector getTypeMap() { - return {20}; - } - }]; -} - -def MLONNXBinarizerOp:MLONNX_Op<"Binarizer", - [NoSideEffect]> { - let summary = "ONNX Binarizer operation"; - let description = [{ - "Maps the values of the input tensor to either 0 or 1, element-wise, based on the outcome of a comparison against a threshold value." - }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$X, - DefaultValuedAttr:$threshold); - let results = (outs AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$Y); - let extraClassDeclaration = [{ - static int getNumberOfOperands() { - return 1; - } - static int getNumberOfResults() { - return 1; - } - static std::vector getTypeMap() { - return {20}; - } - }]; -} - -def MLONNXCastMapOp:MLONNX_Op<"CastMap", - [NoSideEffect]> { - let summary = "ONNX CastMap operation"; - let description = [{ - "Converts a map to a tensor.
The map key must be an int64 and the values will be ordered" - " in ascending order based on this key.
The operator supports dense packing or sparse packing." - " If using sparse packing, the key cannot exceed the max_map-1 value." - }]; - let arguments = (ins AnyTypeOf<[TupleOf<[TensorOf<[I64]>]>, MemRefOf<[I64]>]>:$X, - DefaultValuedAttr:$cast_to, - DefaultValuedAttr:$map_form, - DefaultValuedAttr:$max_map); - let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); - let extraClassDeclaration = [{ - static int getNumberOfOperands() { - return 1; - } - static int getNumberOfResults() { - return 1; - } - static std::vector getTypeMap() { - return {-1}; - } - }]; -} - -def MLONNXCategoryMapperOp:MLONNX_Op<"CategoryMapper", - [NoSideEffect]> { - let summary = "ONNX CategoryMapper operation"; - let description = [{ - "Converts strings to integers and vice versa.
" - " Two sequences of equal length are used to map between integers and strings," - " with strings and integers at the same index detailing the mapping.
" - " Each operator converts either integers to strings or strings to integers, depending " - " on which default value attribute is provided. Only one default value attribute" - " should be defined.
" - " If the string default value is set, it will convert integers to strings." - " If the int default value is set, it will convert strings to integers." - }]; - let arguments = (ins AnyTypeOf<[AnyMemRef, AnyTensor]>:$X, - OptionalAttr:$cats_int64s, - OptionalAttr:$cats_strings, - DefaultValuedAttr:$default_int64, - DefaultValuedAttr:$default_string); - let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); - let extraClassDeclaration = [{ - static int getNumberOfOperands() { - return 1; - } - static int getNumberOfResults() { - return 1; - } - static std::vector getTypeMap() { - return {-1}; - } - }]; -} - -def MLONNXDictVectorizerOp:MLONNX_Op<"DictVectorizer", - [NoSideEffect]> { - let summary = "ONNX DictVectorizer operation"; - let description = [{ - "Uses an index mapping to convert a dictionary to an array.
" - " Given a dictionary, each key is looked up in the vocabulary attribute corresponding to" - " the key type. The index into the vocabulary array at which the key is found is then" - " used to index the output 1-D tensor 'Y' and insert into it the value found in the dictionary 'X'.
" - " The key type of the input map must correspond to the element type of the defined vocabulary attribute." - " Therefore, the output array will be equal in length to the index mapping vector parameter." - " All keys in the input dictionary must be present in the index mapping vector." - " For each item in the input dictionary, insert its value in the output array." - " Any keys not present in the input dictionary, will be zero in the output array.
" - " For example: if the ``string_vocabulary`` parameter is set to ``[\"a\", \"c\", \"b\", \"z\"]``," - " then an input of ``{\"a\": 4, \"c\": 8}`` will produce an output of ``[4, 8, 0, 0]``." - " " - }]; - let arguments = (ins AnyTypeOf<[TupleOf<[TensorOf<[I64,F32,F64]>]>, MemRefOf<[I64,F32,F64]>]>:$X, - OptionalAttr:$int64_vocabulary, - OptionalAttr:$string_vocabulary); - let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); - let extraClassDeclaration = [{ - static int getNumberOfOperands() { - return 1; - } - static int getNumberOfResults() { - return 1; - } - static std::vector getTypeMap() { - return {-1}; - } - }]; -} - -def MLONNXFeatureVectorizerOp:MLONNX_Op<"FeatureVectorizer", - [NoSideEffect]> { - let summary = "ONNX FeatureVectorizer operation"; - let description = [{ - "Concatenates input tensors into one continuous output.
" - " All input shapes are 2-D and are concatenated along the second dimention. 1-D tensors are treated as [1,C]." - " Inputs are copied to the output maintaining the order of the input arguments.
" - " All inputs must be integers or floats, while the output will be all floating point values." - }]; - let arguments = (ins Variadic, MemRefOf<[I32,I64,F32,F64]>]>>:$X, - OptionalAttr:$inputdimensions); - let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); - let extraClassDeclaration = [{ - static int getNumberOfOperands() { - return -1; - } - static int getNumberOfResults() { - return 1; - } - static std::vector getTypeMap() { - return {-1}; - } - }]; -} - -def MLONNXImputerOp:MLONNX_Op<"Imputer", - [NoSideEffect]> { - let summary = "ONNX Imputer operation"; - let description = [{ - "Replaces inputs that equal one value with another, leaving all other elements alone.
" - " This operator is typically used to replace missing values in situations where they have a canonical" - " representation, such as -1, 0, NaN, or some extreme value.
" - " One and only one of imputed_value_floats or imputed_value_int64s should be defined -- floats if the input tensor" - " holds floats, integers if the input tensor holds integers. The imputed values must all fit within the" - " width of the tensor element type. One and only one of the replaced_value_float or replaced_value_int64 should be defined," - " which one depends on whether floats or integers are being processed.
" - " The imputed_value attribute length can be 1 element, or it can have one element per input feature.
In other words, if the input tensor has the shape [*,F], then the length of the attribute array may be 1 or F. If it is 1, then it is broadcast along the last dimension and applied to each feature." - }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$X, - OptionalAttr:$imputed_value_floats, - OptionalAttr:$imputed_value_int64s, - DefaultValuedAttr:$replaced_value_float, - DefaultValuedAttr:$replaced_value_int64); - let results = (outs AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$Y); - let extraClassDeclaration = [{ - static int getNumberOfOperands() { - return 1; - } - static int getNumberOfResults() { - return 1; - } - static std::vector getTypeMap() { - return {20}; - } - }]; -} - -def MLONNXLabelEncoderOp:MLONNX_Op<"LabelEncoder", - [NoSideEffect]> { - let summary = "ONNX LabelEncoder operation"; - let description = [{ - "Maps each element in the input tensor to another value.
" - " The mapping is determined by the two parallel attributes, 'keys_*' and" - " 'values_*' attribute. The i-th value in the specified 'keys_*' attribute" - " would be mapped to the i-th value in the specified 'values_*' attribute. It" - " implies that input's element type and the element type of the specified" - " 'keys_*' should be identical while the output type is identical to the" - " specified 'values_*' attribute. If an input element can not be found in the" - " specified 'keys_*' attribute, the 'default_*' that matches the specified" - " 'values_*' attribute may be used as its output value.
" - " Let's consider an example which maps a string tensor to an integer tensor." - " Assume and 'keys_strings' is [\"Amy\", \"Sally\"], 'values_int64s' is [5, 6]," - " and 'default_int64' is '-1'. The input [\"Dori\", \"Amy\", \"Amy\", \"Sally\"," - " \"Sally\"] would be mapped to [-1, 5, 5, 6, 6].
" - " Since this operator is an one-to-one mapping, its input and output shapes" - " are the same. Notice that only one of 'keys_*'/'values_*' can be set.
" - " For key look-up, bit-wise comparison is used so even a float NaN can be" - " mapped to a value in 'values_*' attribute.
" - }]; - let arguments = (ins AnyTypeOf<[AnyMemRef, AnyTensor]>:$X, - DefaultValuedAttr:$default_float, - DefaultValuedAttr:$default_int64, - DefaultValuedAttr:$default_string, - OptionalAttr:$keys_floats, - OptionalAttr:$keys_int64s, - OptionalAttr:$keys_strings, - OptionalAttr:$values_floats, - OptionalAttr:$values_int64s, - OptionalAttr:$values_strings); - let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); - let extraClassDeclaration = [{ - static int getNumberOfOperands() { - return 1; - } - static int getNumberOfResults() { - return 1; - } - static std::vector getTypeMap() { - return {-1}; - } - }]; -} - -def MLONNXLinearClassifierOp:MLONNX_Op<"LinearClassifier", - [NoSideEffect]> { - let summary = "ONNX LinearClassifier operation"; - let description = [{ - "Linear classifier" - }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$X, - OptionalAttr:$classlabels_ints, - OptionalAttr:$classlabels_strings, - F32ArrayAttr:$coefficients, - OptionalAttr:$intercepts, - DefaultValuedAttr:$multi_class, - DefaultValuedAttr:$post_transform); - let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y, - AnyTypeOf<[AnyMemRef, AnyTensor]>:$Z); - let extraClassDeclaration = [{ - static int getNumberOfOperands() { - return 1; - } - static int getNumberOfResults() { - return 2; - } - static std::vector getTypeMap() { - return {-1,-1}; - } - }]; -} - -def MLONNXLinearRegressorOp:MLONNX_Op<"LinearRegressor", - [NoSideEffect]> { - let summary = "ONNX LinearRegressor operation"; - let description = [{ - "Generalized linear regression evaluation.
" - " If targets is set to 1 (default) then univariate regression is performed.
" - " If targets is set to M then M sets of coefficients must be passed in as a sequence" - " and M results will be output for each input n in N.
" - " The coefficients array is of length n, and the coefficients for each target are contiguous." - " Intercepts are optional but if provided must match the number of targets." - }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$X, - OptionalAttr:$coefficients, - OptionalAttr:$intercepts, - DefaultValuedAttr:$post_transform, - DefaultValuedAttr:$targets); - let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); - let extraClassDeclaration = [{ - static int getNumberOfOperands() { - return 1; - } - static int getNumberOfResults() { - return 1; - } - static std::vector getTypeMap() { - return {-1}; - } - }]; -} - -def MLONNXNormalizerOp:MLONNX_Op<"Normalizer", - [NoSideEffect]> { - let summary = "ONNX Normalizer operation"; - let description = [{ - "Normalize the input. There are three normalization modes, which have the corresponding formulas," - " defined using element-wise infix operators '/' and '^' and tensor-wide functions 'max' and 'sum':
" - "
" - " Max: Y = X / max(X)
" - " L1: Y = X / sum(X)
" - " L2: Y = sqrt(X^2 / sum(X^2)}
" - " In all modes, if the divisor is zero, Y == X." - "
" - " For batches, that is, [N,C] tensors, normalization is done along the C axis. In other words, each row" - " of the batch is normalized independently." - }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$X, - DefaultValuedAttr:$norm); - let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); - let extraClassDeclaration = [{ - static int getNumberOfOperands() { - return 1; - } - static int getNumberOfResults() { - return 1; - } - static std::vector getTypeMap() { - return {-1}; - } - }]; -} - -def MLONNXOneHotEncoderOp:MLONNX_Op<"OneHotEncoder", - [NoSideEffect]> { - let summary = "ONNX OneHotEncoder operation"; - let description = [{ - "Replace each input element with an array of ones and zeros, where a single" - " one is placed at the index of the category that was passed in. The total category count " - " will determine the size of the extra dimension of the output array Y.
" - " For example, if we pass a tensor with a single value of 4, and a category count of 8, " - " the output will be a tensor with ``[0,0,0,0,1,0,0,0]``.
" - " This operator assumes every input feature is from the same set of categories.
" - " If the input is a tensor of float, int32, or double, the data will be cast" - " to integers and the cats_int64s category list will be used for the lookups." - }]; - let arguments = (ins AnyTypeOf<[AnyMemRef, AnyTensor]>:$X, - OptionalAttr:$cats_int64s, - OptionalAttr:$cats_strings, - DefaultValuedAttr:$zeros); - let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); - let extraClassDeclaration = [{ - static int getNumberOfOperands() { - return 1; - } - static int getNumberOfResults() { - return 1; - } - static std::vector getTypeMap() { - return {-1}; - } - }]; -} - -def MLONNXSVMClassifierOp:MLONNX_Op<"SVMClassifier", - [NoSideEffect]> { - let summary = "ONNX SVMClassifier operation"; - let description = [{ - "Support Vector Machine classifier" - }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$X, - OptionalAttr:$classlabels_ints, - OptionalAttr:$classlabels_strings, - OptionalAttr:$coefficients, - OptionalAttr:$kernel_params, - DefaultValuedAttr:$kernel_type, - DefaultValuedAttr:$post_transform, - OptionalAttr:$prob_a, - OptionalAttr:$prob_b, - OptionalAttr:$rho, - OptionalAttr:$support_vectors, - OptionalAttr:$vectors_per_class); - let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y, - AnyTypeOf<[AnyMemRef, AnyTensor]>:$Z); - let extraClassDeclaration = [{ - static int getNumberOfOperands() { - return 1; - } - static int getNumberOfResults() { - return 2; - } - static std::vector getTypeMap() { - return {-1,-1}; - } - }]; -} - -def MLONNXSVMRegressorOp:MLONNX_Op<"SVMRegressor", - [NoSideEffect]> { - let summary = "ONNX SVMRegressor operation"; - let description = [{ - "Support Vector Machine regression prediction and one-class SVM anomaly detection." - }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$X, - OptionalAttr:$coefficients, - OptionalAttr:$kernel_params, - DefaultValuedAttr:$kernel_type, - DefaultValuedAttr:$n_supports, - DefaultValuedAttr:$one_class, - DefaultValuedAttr:$post_transform, - OptionalAttr:$rho, - OptionalAttr:$support_vectors); - let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); - let extraClassDeclaration = [{ - static int getNumberOfOperands() { - return 1; - } - static int getNumberOfResults() { - return 1; - } - static std::vector getTypeMap() { - return {-1}; - } - }]; -} - -def MLONNXScalerOp:MLONNX_Op<"Scaler", - [NoSideEffect]> { - let summary = "ONNX Scaler operation"; - let description = [{ - "Rescale input data, for example to standardize features by removing the mean and scaling to unit variance." - }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$X, - OptionalAttr:$offset, - OptionalAttr:$scale); - let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); - let extraClassDeclaration = [{ - static int getNumberOfOperands() { - return 1; - } - static int getNumberOfResults() { - return 1; - } - static std::vector getTypeMap() { - return {-1}; - } - }]; -} - -def MLONNXTreeEnsembleClassifierOp:MLONNX_Op<"TreeEnsembleClassifier", - [NoSideEffect]> { - let summary = "ONNX TreeEnsembleClassifier operation"; - let description = [{ - "Tree Ensemble classifier. Returns the top class for each of N inputs.
" - " The attributes named 'nodes_X' form a sequence of tuples, associated by " - " index into the sequences, which must all be of equal length. These tuples" - " define the nodes.
" - " Similarly, all fields prefixed with 'class_' are tuples of votes at the leaves." - " A leaf may have multiple votes, where each vote is weighted by" - " the associated class_weights index.
" - " One and only one of classlabels_strings or classlabels_int64s" - " will be defined. The class_ids are indices into this list." - }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$X, - OptionalAttr:$base_values, - OptionalAttr:$class_ids, - OptionalAttr:$class_nodeids, - OptionalAttr:$class_treeids, - OptionalAttr:$class_weights, - OptionalAttr:$classlabels_int64s, - OptionalAttr:$classlabels_strings, - OptionalAttr:$nodes_falsenodeids, - OptionalAttr:$nodes_featureids, - OptionalAttr:$nodes_hitrates, - OptionalAttr:$nodes_missing_value_tracks_true, - OptionalAttr:$nodes_modes, - OptionalAttr:$nodes_nodeids, - OptionalAttr:$nodes_treeids, - OptionalAttr:$nodes_truenodeids, - OptionalAttr:$nodes_values, - DefaultValuedAttr:$post_transform); - let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y, - AnyTypeOf<[AnyMemRef, AnyTensor]>:$Z); - let extraClassDeclaration = [{ - static int getNumberOfOperands() { - return 1; - } - static int getNumberOfResults() { - return 2; - } - static std::vector getTypeMap() { - return {-1,-1}; - } - }]; -} - -def MLONNXTreeEnsembleRegressorOp:MLONNX_Op<"TreeEnsembleRegressor", - [NoSideEffect]> { - let summary = "ONNX TreeEnsembleRegressor operation"; - let description = [{ - "Tree Ensemble regressor. Returns the regressed values for each input in N.
" - " All args with nodes_ are fields of a tuple of tree nodes, and" - " it is assumed they are the same length, and an index i will decode the" - " tuple across these inputs. Each node id can appear only once" - " for each tree id.
" - " All fields prefixed with target_ are tuples of votes at the leaves.
" - " A leaf may have multiple votes, where each vote is weighted by" - " the associated target_weights index.
" - " All trees must have their node ids start at 0 and increment by 1.
" - " Mode enum is BRANCH_LEQ, BRANCH_LT, BRANCH_GTE, BRANCH_GT, BRANCH_EQ, BRANCH_NEQ, LEAF" - }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$X, - DefaultValuedAttr:$aggregate_function, - OptionalAttr:$base_values, - OptionalAttr:$n_targets, - OptionalAttr:$nodes_falsenodeids, - OptionalAttr:$nodes_featureids, - OptionalAttr:$nodes_hitrates, - OptionalAttr:$nodes_missing_value_tracks_true, - OptionalAttr:$nodes_modes, - OptionalAttr:$nodes_nodeids, - OptionalAttr:$nodes_treeids, - OptionalAttr:$nodes_truenodeids, - OptionalAttr:$nodes_values, - DefaultValuedAttr:$post_transform, - OptionalAttr:$target_ids, - OptionalAttr:$target_nodeids, - OptionalAttr:$target_treeids, - OptionalAttr:$target_weights); - let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); - let extraClassDeclaration = [{ - static int getNumberOfOperands() { - return 1; - } - static int getNumberOfResults() { - return 1; - } - static std::vector getTypeMap() { - return {-1}; - } - }]; -} - -def MLONNXZipMapOp:MLONNX_Op<"ZipMap", - [NoSideEffect]> { - let summary = "ONNX ZipMap operation"; - let description = [{ - "Creates a map from the input and the attributes.
" - " The values are provided by the input tensor, while the keys are specified by the attributes." - " Must provide keys in either classlabels_strings or classlabels_int64s (but not both).
" - " The columns of the tensor correspond one-by-one to the keys specified by the attributes. There must be as many columns as keys.
" - }]; - let arguments = (ins AnyTypeOf<[AnyMemRef, AnyTensor]>:$X, - OptionalAttr:$classlabels_int64s, - OptionalAttr:$classlabels_strings); - let results = (outs AnyTypeOf<[TensorOf<[TensorOf<[F32,I64]>]>, MemRefOf<[F32,I64]>]>:$Z); - let extraClassDeclaration = [{ - static int getNumberOfOperands() { - return 1; - } - static int getNumberOfResults() { - return 1; - } - static std::vector getTypeMap() { - return {-1}; - } - }]; -} - diff --git a/src/Dialect/ONNX/ONNXOps.td.inc b/src/Dialect/ONNX/ONNXOps.td.inc index d2b5c57..5bf9a39 100644 --- a/src/Dialect/ONNX/ONNXOps.td.inc +++ b/src/Dialect/ONNX/ONNXOps.td.inc @@ -5666,3 +5666,568 @@ def ONNXXorOp:ONNX_Op<"Xor", }]; } +def ONNXArrayFeatureExtractorOp:ONNX_Op<"ArrayFeatureExtractor", + [NoSideEffect]> { + let summary = "ONNX ArrayFeatureExtractor operation"; + let description = [{ + "Select elements of the input tensor based on the indices passed.
" + " The indices are applied to the last axes of the tensor." + }]; + let arguments = (ins AnyTypeOf<[AnyMemRef, AnyTensor]>:$X, + AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); + let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Z); + let extraClassDeclaration = [{ + static int getNumberOfOperands() { + return 2; + } + static int getNumberOfResults() { + return 1; + } + static std::vector getTypeMap() { + return {20}; + } + }]; +} + +def ONNXBinarizerOp:ONNX_Op<"Binarizer", + [NoSideEffect]> { + let summary = "ONNX Binarizer operation"; + let description = [{ + "Maps the values of the input tensor to either 0 or 1, element-wise, based on the outcome of a comparison against a threshold value." + }]; + let arguments = (ins AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$X, + DefaultValuedAttr:$threshold); + let results = (outs AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$Y); + let extraClassDeclaration = [{ + static int getNumberOfOperands() { + return 1; + } + static int getNumberOfResults() { + return 1; + } + static std::vector getTypeMap() { + return {20}; + } + }]; +} + +def ONNXCastMapOp:ONNX_Op<"CastMap", + [NoSideEffect]> { + let summary = "ONNX CastMap operation"; + let description = [{ + "Converts a map to a tensor.
The map key must be an int64 and the values will be ordered" + " in ascending order based on this key.
The operator supports dense packing or sparse packing." + " If using sparse packing, the key cannot exceed the max_map-1 value." + }]; + let arguments = (ins AnyTypeOf<[TupleOf<[TensorOf<[I64]>]>, MemRefOf<[I64]>]>:$X, + DefaultValuedAttr:$cast_to, + DefaultValuedAttr:$map_form, + DefaultValuedAttr:$max_map); + let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); + let extraClassDeclaration = [{ + static int getNumberOfOperands() { + return 1; + } + static int getNumberOfResults() { + return 1; + } + static std::vector getTypeMap() { + return {-1}; + } + }]; +} + +def ONNXCategoryMapperOp:ONNX_Op<"CategoryMapper", + [NoSideEffect]> { + let summary = "ONNX CategoryMapper operation"; + let description = [{ + "Converts strings to integers and vice versa.
" + " Two sequences of equal length are used to map between integers and strings," + " with strings and integers at the same index detailing the mapping.
" + " Each operator converts either integers to strings or strings to integers, depending " + " on which default value attribute is provided. Only one default value attribute" + " should be defined.
" + " If the string default value is set, it will convert integers to strings." + " If the int default value is set, it will convert strings to integers." + }]; + let arguments = (ins AnyTypeOf<[AnyMemRef, AnyTensor]>:$X, + OptionalAttr:$cats_int64s, + OptionalAttr:$cats_strings, + DefaultValuedAttr:$default_int64, + DefaultValuedAttr:$default_string); + let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); + let extraClassDeclaration = [{ + static int getNumberOfOperands() { + return 1; + } + static int getNumberOfResults() { + return 1; + } + static std::vector getTypeMap() { + return {-1}; + } + }]; +} + +def ONNXDictVectorizerOp:ONNX_Op<"DictVectorizer", + [NoSideEffect]> { + let summary = "ONNX DictVectorizer operation"; + let description = [{ + "Uses an index mapping to convert a dictionary to an array.
" + " Given a dictionary, each key is looked up in the vocabulary attribute corresponding to" + " the key type. The index into the vocabulary array at which the key is found is then" + " used to index the output 1-D tensor 'Y' and insert into it the value found in the dictionary 'X'.
" + " The key type of the input map must correspond to the element type of the defined vocabulary attribute." + " Therefore, the output array will be equal in length to the index mapping vector parameter." + " All keys in the input dictionary must be present in the index mapping vector." + " For each item in the input dictionary, insert its value in the output array." + " Any keys not present in the input dictionary, will be zero in the output array.
" + " For example: if the ``string_vocabulary`` parameter is set to ``[\"a\", \"c\", \"b\", \"z\"]``," + " then an input of ``{\"a\": 4, \"c\": 8}`` will produce an output of ``[4, 8, 0, 0]``." + " " + }]; + let arguments = (ins AnyTypeOf<[TupleOf<[TensorOf<[I64,F32,F64]>]>, MemRefOf<[I64,F32,F64]>]>:$X, + OptionalAttr:$int64_vocabulary, + OptionalAttr:$string_vocabulary); + let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); + let extraClassDeclaration = [{ + static int getNumberOfOperands() { + return 1; + } + static int getNumberOfResults() { + return 1; + } + static std::vector getTypeMap() { + return {-1}; + } + }]; +} + +def ONNXFeatureVectorizerOp:ONNX_Op<"FeatureVectorizer", + [NoSideEffect]> { + let summary = "ONNX FeatureVectorizer operation"; + let description = [{ + "Concatenates input tensors into one continuous output.
" + " All input shapes are 2-D and are concatenated along the second dimention. 1-D tensors are treated as [1,C]." + " Inputs are copied to the output maintaining the order of the input arguments.
" + " All inputs must be integers or floats, while the output will be all floating point values." + }]; + let arguments = (ins Variadic, MemRefOf<[I32,I64,F32,F64]>]>>:$X, + OptionalAttr:$inputdimensions); + let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); + let extraClassDeclaration = [{ + static int getNumberOfOperands() { + return -1; + } + static int getNumberOfResults() { + return 1; + } + static std::vector getTypeMap() { + return {-1}; + } + }]; +} + +def ONNXImputerOp:ONNX_Op<"Imputer", + [NoSideEffect]> { + let summary = "ONNX Imputer operation"; + let description = [{ + "Replaces inputs that equal one value with another, leaving all other elements alone.
" + " This operator is typically used to replace missing values in situations where they have a canonical" + " representation, such as -1, 0, NaN, or some extreme value.
" + " One and only one of imputed_value_floats or imputed_value_int64s should be defined -- floats if the input tensor" + " holds floats, integers if the input tensor holds integers. The imputed values must all fit within the" + " width of the tensor element type. One and only one of the replaced_value_float or replaced_value_int64 should be defined," + " which one depends on whether floats or integers are being processed.
" + " The imputed_value attribute length can be 1 element, or it can have one element per input feature.
In other words, if the input tensor has the shape [*,F], then the length of the attribute array may be 1 or F. If it is 1, then it is broadcast along the last dimension and applied to each feature." + }]; + let arguments = (ins AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$X, + OptionalAttr:$imputed_value_floats, + OptionalAttr:$imputed_value_int64s, + DefaultValuedAttr:$replaced_value_float, + DefaultValuedAttr:$replaced_value_int64); + let results = (outs AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$Y); + let extraClassDeclaration = [{ + static int getNumberOfOperands() { + return 1; + } + static int getNumberOfResults() { + return 1; + } + static std::vector getTypeMap() { + return {20}; + } + }]; +} + +def ONNXLabelEncoderOp:ONNX_Op<"LabelEncoder", + [NoSideEffect]> { + let summary = "ONNX LabelEncoder operation"; + let description = [{ + "Maps each element in the input tensor to another value.
" + " The mapping is determined by the two parallel attributes, 'keys_*' and" + " 'values_*' attribute. The i-th value in the specified 'keys_*' attribute" + " would be mapped to the i-th value in the specified 'values_*' attribute. It" + " implies that input's element type and the element type of the specified" + " 'keys_*' should be identical while the output type is identical to the" + " specified 'values_*' attribute. If an input element can not be found in the" + " specified 'keys_*' attribute, the 'default_*' that matches the specified" + " 'values_*' attribute may be used as its output value.
" + " Let's consider an example which maps a string tensor to an integer tensor." + " Assume and 'keys_strings' is [\"Amy\", \"Sally\"], 'values_int64s' is [5, 6]," + " and 'default_int64' is '-1'. The input [\"Dori\", \"Amy\", \"Amy\", \"Sally\"," + " \"Sally\"] would be mapped to [-1, 5, 5, 6, 6].
" + " Since this operator is an one-to-one mapping, its input and output shapes" + " are the same. Notice that only one of 'keys_*'/'values_*' can be set.
" + " For key look-up, bit-wise comparison is used so even a float NaN can be" + " mapped to a value in 'values_*' attribute.
" + }]; + let arguments = (ins AnyTypeOf<[AnyMemRef, AnyTensor]>:$X, + DefaultValuedAttr:$default_float, + DefaultValuedAttr:$default_int64, + DefaultValuedAttr:$default_string, + OptionalAttr:$keys_floats, + OptionalAttr:$keys_int64s, + OptionalAttr:$keys_strings, + OptionalAttr:$values_floats, + OptionalAttr:$values_int64s, + OptionalAttr:$values_strings); + let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); + let extraClassDeclaration = [{ + static int getNumberOfOperands() { + return 1; + } + static int getNumberOfResults() { + return 1; + } + static std::vector getTypeMap() { + return {-1}; + } + }]; +} + +def ONNXLinearClassifierOp:ONNX_Op<"LinearClassifier", + [NoSideEffect]> { + let summary = "ONNX LinearClassifier operation"; + let description = [{ + "Linear classifier" + }]; + let arguments = (ins AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$X, + OptionalAttr:$classlabels_ints, + OptionalAttr:$classlabels_strings, + F32ArrayAttr:$coefficients, + OptionalAttr:$intercepts, + DefaultValuedAttr:$multi_class, + DefaultValuedAttr:$post_transform); + let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y, + AnyTypeOf<[AnyMemRef, AnyTensor]>:$Z); + let extraClassDeclaration = [{ + static int getNumberOfOperands() { + return 1; + } + static int getNumberOfResults() { + return 2; + } + static std::vector getTypeMap() { + return {-1,-1}; + } + }]; +} + +def ONNXLinearRegressorOp:ONNX_Op<"LinearRegressor", + [NoSideEffect]> { + let summary = "ONNX LinearRegressor operation"; + let description = [{ + "Generalized linear regression evaluation.
" + " If targets is set to 1 (default) then univariate regression is performed.
" + " If targets is set to M then M sets of coefficients must be passed in as a sequence" + " and M results will be output for each input n in N.
" + " The coefficients array is of length n, and the coefficients for each target are contiguous." + " Intercepts are optional but if provided must match the number of targets." + }]; + let arguments = (ins AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$X, + OptionalAttr:$coefficients, + OptionalAttr:$intercepts, + DefaultValuedAttr:$post_transform, + DefaultValuedAttr:$targets); + let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); + let extraClassDeclaration = [{ + static int getNumberOfOperands() { + return 1; + } + static int getNumberOfResults() { + return 1; + } + static std::vector getTypeMap() { + return {-1}; + } + }]; +} + +def ONNXNormalizerOp:ONNX_Op<"Normalizer", + [NoSideEffect]> { + let summary = "ONNX Normalizer operation"; + let description = [{ + "Normalize the input. There are three normalization modes, which have the corresponding formulas," + " defined using element-wise infix operators '/' and '^' and tensor-wide functions 'max' and 'sum':
" + "
" + " Max: Y = X / max(X)
" + " L1: Y = X / sum(X)
" + " L2: Y = sqrt(X^2 / sum(X^2)}
" + " In all modes, if the divisor is zero, Y == X." + "
" + " For batches, that is, [N,C] tensors, normalization is done along the C axis. In other words, each row" + " of the batch is normalized independently." + }]; + let arguments = (ins AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$X, + DefaultValuedAttr:$norm); + let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); + let extraClassDeclaration = [{ + static int getNumberOfOperands() { + return 1; + } + static int getNumberOfResults() { + return 1; + } + static std::vector getTypeMap() { + return {-1}; + } + }]; +} + +def ONNXOneHotEncoderOp:ONNX_Op<"OneHotEncoder", + [NoSideEffect]> { + let summary = "ONNX OneHotEncoder operation"; + let description = [{ + "Replace each input element with an array of ones and zeros, where a single" + " one is placed at the index of the category that was passed in. The total category count " + " will determine the size of the extra dimension of the output array Y.
" + " For example, if we pass a tensor with a single value of 4, and a category count of 8, " + " the output will be a tensor with ``[0,0,0,0,1,0,0,0]``.
" + " This operator assumes every input feature is from the same set of categories.
" + " If the input is a tensor of float, int32, or double, the data will be cast" + " to integers and the cats_int64s category list will be used for the lookups." + }]; + let arguments = (ins AnyTypeOf<[AnyMemRef, AnyTensor]>:$X, + OptionalAttr:$cats_int64s, + OptionalAttr:$cats_strings, + DefaultValuedAttr:$zeros); + let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); + let extraClassDeclaration = [{ + static int getNumberOfOperands() { + return 1; + } + static int getNumberOfResults() { + return 1; + } + static std::vector getTypeMap() { + return {-1}; + } + }]; +} + +def ONNXSVMClassifierOp:ONNX_Op<"SVMClassifier", + [NoSideEffect]> { + let summary = "ONNX SVMClassifier operation"; + let description = [{ + "Support Vector Machine classifier" + }]; + let arguments = (ins AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$X, + OptionalAttr:$classlabels_ints, + OptionalAttr:$classlabels_strings, + OptionalAttr:$coefficients, + OptionalAttr:$kernel_params, + DefaultValuedAttr:$kernel_type, + DefaultValuedAttr:$post_transform, + OptionalAttr:$prob_a, + OptionalAttr:$prob_b, + OptionalAttr:$rho, + OptionalAttr:$support_vectors, + OptionalAttr:$vectors_per_class); + let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y, + AnyTypeOf<[AnyMemRef, AnyTensor]>:$Z); + let extraClassDeclaration = [{ + static int getNumberOfOperands() { + return 1; + } + static int getNumberOfResults() { + return 2; + } + static std::vector getTypeMap() { + return {-1,-1}; + } + }]; +} + +def ONNXSVMRegressorOp:ONNX_Op<"SVMRegressor", + [NoSideEffect]> { + let summary = "ONNX SVMRegressor operation"; + let description = [{ + "Support Vector Machine regression prediction and one-class SVM anomaly detection." + }]; + let arguments = (ins AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$X, + OptionalAttr:$coefficients, + OptionalAttr:$kernel_params, + DefaultValuedAttr:$kernel_type, + DefaultValuedAttr:$n_supports, + DefaultValuedAttr:$one_class, + DefaultValuedAttr:$post_transform, + OptionalAttr:$rho, + OptionalAttr:$support_vectors); + let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); + let extraClassDeclaration = [{ + static int getNumberOfOperands() { + return 1; + } + static int getNumberOfResults() { + return 1; + } + static std::vector getTypeMap() { + return {-1}; + } + }]; +} + +def ONNXScalerOp:ONNX_Op<"Scaler", + [NoSideEffect]> { + let summary = "ONNX Scaler operation"; + let description = [{ + "Rescale input data, for example to standardize features by removing the mean and scaling to unit variance." + }]; + let arguments = (ins AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$X, + OptionalAttr:$offset, + OptionalAttr:$scale); + let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); + let extraClassDeclaration = [{ + static int getNumberOfOperands() { + return 1; + } + static int getNumberOfResults() { + return 1; + } + static std::vector getTypeMap() { + return {-1}; + } + }]; +} + +def ONNXTreeEnsembleClassifierOp:ONNX_Op<"TreeEnsembleClassifier", + [NoSideEffect]> { + let summary = "ONNX TreeEnsembleClassifier operation"; + let description = [{ + "Tree Ensemble classifier. Returns the top class for each of N inputs.
" + " The attributes named 'nodes_X' form a sequence of tuples, associated by " + " index into the sequences, which must all be of equal length. These tuples" + " define the nodes.
" + " Similarly, all fields prefixed with 'class_' are tuples of votes at the leaves." + " A leaf may have multiple votes, where each vote is weighted by" + " the associated class_weights index.
" + " One and only one of classlabels_strings or classlabels_int64s" + " will be defined. The class_ids are indices into this list." + }]; + let arguments = (ins AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$X, + OptionalAttr:$base_values, + OptionalAttr:$class_ids, + OptionalAttr:$class_nodeids, + OptionalAttr:$class_treeids, + OptionalAttr:$class_weights, + OptionalAttr:$classlabels_int64s, + OptionalAttr:$classlabels_strings, + OptionalAttr:$nodes_falsenodeids, + OptionalAttr:$nodes_featureids, + OptionalAttr:$nodes_hitrates, + OptionalAttr:$nodes_missing_value_tracks_true, + OptionalAttr:$nodes_modes, + OptionalAttr:$nodes_nodeids, + OptionalAttr:$nodes_treeids, + OptionalAttr:$nodes_truenodeids, + OptionalAttr:$nodes_values, + DefaultValuedAttr:$post_transform); + let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y, + AnyTypeOf<[AnyMemRef, AnyTensor]>:$Z); + let extraClassDeclaration = [{ + static int getNumberOfOperands() { + return 1; + } + static int getNumberOfResults() { + return 2; + } + static std::vector getTypeMap() { + return {-1,-1}; + } + }]; +} + +def ONNXTreeEnsembleRegressorOp:ONNX_Op<"TreeEnsembleRegressor", + [NoSideEffect]> { + let summary = "ONNX TreeEnsembleRegressor operation"; + let description = [{ + "Tree Ensemble regressor. Returns the regressed values for each input in N.
" + " All args with nodes_ are fields of a tuple of tree nodes, and" + " it is assumed they are the same length, and an index i will decode the" + " tuple across these inputs. Each node id can appear only once" + " for each tree id.
" + " All fields prefixed with target_ are tuples of votes at the leaves.
" + " A leaf may have multiple votes, where each vote is weighted by" + " the associated target_weights index.
" + " All trees must have their node ids start at 0 and increment by 1.
" + " Mode enum is BRANCH_LEQ, BRANCH_LT, BRANCH_GTE, BRANCH_GT, BRANCH_EQ, BRANCH_NEQ, LEAF" + }]; + let arguments = (ins AnyTypeOf<[TensorOf<[F32,F64,I64,I32]>, MemRefOf<[F32,F64,I64,I32]>]>:$X, + DefaultValuedAttr:$aggregate_function, + OptionalAttr:$base_values, + OptionalAttr:$n_targets, + OptionalAttr:$nodes_falsenodeids, + OptionalAttr:$nodes_featureids, + OptionalAttr:$nodes_hitrates, + OptionalAttr:$nodes_missing_value_tracks_true, + OptionalAttr:$nodes_modes, + OptionalAttr:$nodes_nodeids, + OptionalAttr:$nodes_treeids, + OptionalAttr:$nodes_truenodeids, + OptionalAttr:$nodes_values, + DefaultValuedAttr:$post_transform, + OptionalAttr:$target_ids, + OptionalAttr:$target_nodeids, + OptionalAttr:$target_treeids, + OptionalAttr:$target_weights); + let results = (outs AnyTypeOf<[AnyMemRef, AnyTensor]>:$Y); + let extraClassDeclaration = [{ + static int getNumberOfOperands() { + return 1; + } + static int getNumberOfResults() { + return 1; + } + static std::vector getTypeMap() { + return {-1}; + } + }]; +} + +def ONNXZipMapOp:ONNX_Op<"ZipMap", + [NoSideEffect]> { + let summary = "ONNX ZipMap operation"; + let description = [{ + "Creates a map from the input and the attributes.
" + " The values are provided by the input tensor, while the keys are specified by the attributes." + " Must provide keys in either classlabels_strings or classlabels_int64s (but not both).
" + " The columns of the tensor correspond one-by-one to the keys specified by the attributes. There must be as many columns as keys.
" + }]; + let arguments = (ins AnyTypeOf<[AnyMemRef, AnyTensor]>:$X, + OptionalAttr:$classlabels_int64s, + OptionalAttr:$classlabels_strings); + let results = (outs AnyTypeOf<[TensorOf<[TensorOf<[F32,I64]>]>, MemRefOf<[F32,I64]>]>:$Z); + let extraClassDeclaration = [{ + static int getNumberOfOperands() { + return 1; + } + static int getNumberOfResults() { + return 1; + } + static std::vector getTypeMap() { + return {-1}; + } + }]; +} + diff --git a/src/MainUtils.cpp b/src/MainUtils.cpp index 99f283d..50f2a7f 100644 --- a/src/MainUtils.cpp +++ b/src/MainUtils.cpp @@ -246,7 +246,6 @@ void registerDialects() { mlir::registerDialect(); mlir::registerDialect(); mlir::registerDialect(); - mlir::registerDialect(); mlir::registerDialect(); } diff --git a/src/MainUtils.hpp b/src/MainUtils.hpp index 834dbbd..2ccb60f 100644 --- a/src/MainUtils.hpp +++ b/src/MainUtils.hpp @@ -22,7 +22,6 @@ #include "src/Builder/FrontendDialectTransformer.hpp" #include "src/Dialect/Krnl/KrnlOps.hpp" -#include "src/Dialect/MLONNX/MLONNXOps.hpp" #include "src/Dialect/ONNX/ONNXOps.hpp" #include "src/Pass/Passes.hpp" diff --git a/src/Tool/ONNXMLIROpt/CMakeLists.txt b/src/Tool/ONNXMLIROpt/CMakeLists.txt index e1d0741..edb8986 100644 --- a/src/Tool/ONNXMLIROpt/CMakeLists.txt +++ b/src/Tool/ONNXMLIROpt/CMakeLists.txt @@ -14,8 +14,3 @@ target_link_libraries(onnx-mlir-opt ${OMLibs} ${MLIRLibs} onnx) - -if (INCLUDE_ONNX_ML) - target_link_libraries(onnx-mlir-opt OMMLONNXOps) - add_dependencies(onnx-mlir-opt OMMLONNXOpsInc) -endif() diff --git a/src/Tool/ONNXMLIROpt/ONNXMLIROpt.cpp b/src/Tool/ONNXMLIROpt/ONNXMLIROpt.cpp index bf8888f..d94e2e7 100644 --- a/src/Tool/ONNXMLIROpt/ONNXMLIROpt.cpp +++ b/src/Tool/ONNXMLIROpt/ONNXMLIROpt.cpp @@ -20,7 +20,6 @@ #include #include "src/Dialect/Krnl/KrnlOps.hpp" -#include "src/Dialect/MLONNX/MLONNXOps.hpp" #include "src/Dialect/ONNX/ONNXOps.hpp" #include "src/InitOMPasses.hpp" #include "src/Pass/Passes.hpp" @@ -69,7 +68,6 @@ int main(int argc, char **argv) { llvm::InitLLVM y(argc, argv); mlir::registerDialect(); - mlir::registerDialect(); mlir::registerDialect(); initOMPasses(); diff --git a/test/mlir/onnx/onnx_structure.mlir b/test/mlir/onnx/onnx_structure.mlir index f974c84..b5033a6 100644 --- a/test/mlir/onnx/onnx_structure.mlir +++ b/test/mlir/onnx/onnx_structure.mlir @@ -3,7 +3,7 @@ //===----------------------------------------------------------------------===// // CHECK-LABEL: @check_map1(%arg0: tuple, tensor<10xi64>>) -> tensor<*xi64> { func @check_map1(%arg0: tuple, tensor<10xi64>>) -> tensor<*xi64> { - %0 = "mlonnx.CastMap"(%arg0) {cast_to = "TO_FLOAT", map_form = "DENSE", max_map = 1 : i64} : (tuple, tensor<10xi64>>) -> tensor<*xi64> + %0 = "onnx.CastMap"(%arg0) {cast_to = "TO_FLOAT", map_form = "DENSE", max_map = 1 : i64} : (tuple, tensor<10xi64>>) -> tensor<*xi64> return %0 : tensor<*xi64> - // CHECK-NEXT: %0 = "mlonnx.CastMap"(%arg0) {cast_to = "TO_FLOAT", map_form = "DENSE", max_map = 1 : i64} : (tuple, tensor<10xi64>>) -> tensor<*xi64> + // CHECK-NEXT: %0 = "onnx.CastMap"(%arg0) {cast_to = "TO_FLOAT", map_form = "DENSE", max_map = 1 : i64} : (tuple, tensor<10xi64>>) -> tensor<*xi64> } diff --git a/utils/CMakeLists.txt b/utils/CMakeLists.txt index b3aa2a6..92710b2 100644 --- a/utils/CMakeLists.txt +++ b/utils/CMakeLists.txt @@ -23,35 +23,5 @@ add_custom_target(OMONNXOpsIncTranslation DEPENDS OMONNXOpsTableGenIncGen OMONNXOpsBuildTableIncGen) -# Invoke gen_onnx_mlir.py to obtain MLONNXOps.td.inc, MLOpBuildTable.inc. -add_custom_command(OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/MLONNXOps.td.inc - ${CMAKE_CURRENT_SOURCE_DIR}/MLOpBuildTable.inc - COMMAND python ${CMAKE_CURRENT_SOURCE_DIR}/gen_onnx_mlir.py --domain="ONNX_ML" - DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/gen_onnx_mlir.py) - -# Move the generated files to respective destinations: -# MLONNXOps.td.inc -> src/Dialect/MLONNX/MLONNXOps.td.inc -add_custom_target(OMMLONNXOpsTableGenIncGen - COMMAND ${CMAKE_COMMAND} -E rename - ${CMAKE_CURRENT_SOURCE_DIR}/MLONNXOps.td.inc - ${ONNX_MLIR_SRC_ROOT}/src/Dialect/MLONNX/MLONNXOps.td.inc - DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/MLONNXOps.td.inc) - -# MLOpBuildTable.inc -> src/Builder/MLOpBuildTable.inc -add_custom_target(OMMLONNXOpsBuildTableIncGen - COMMAND ${CMAKE_COMMAND} -E rename - ${CMAKE_CURRENT_SOURCE_DIR}/MLOpBuildTable.inc - ${ONNX_MLIR_SRC_ROOT}/src/Builder/MLOpBuildTable.inc - DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/MLOpBuildTable.inc) - -add_custom_target(OMMLONNXOpsIncTranslation - DEPENDS OMMLONNXOpsTableGenIncGen - OMMLONNXOpsBuildTableIncGen) - add_custom_target(OMONNXCheckVersion COMMAND python ${CMAKE_CURRENT_SOURCE_DIR}/gen_onnx_mlir.py --check-operation-version) - -add_custom_target(OMMLONNXCheckVersion - COMMAND python ${CMAKE_CURRENT_SOURCE_DIR}/gen_onnx_mlir.py - --check-operation-version --domain="ONNX_ML") - diff --git a/utils/gen_onnx_mlir.py b/utils/gen_onnx_mlir.py index c498c95..cbdc86d 100644 --- a/utils/gen_onnx_mlir.py +++ b/utils/gen_onnx_mlir.py @@ -36,9 +36,6 @@ parser.add_argument("--check-operation-version", " newer version of operation compared with version stored in version_dicts", action="store_true", default=False) -parser.add_argument("--domain", - help="specify domain, ONNX or ONNX_ML", - default = "ONNX") args = parser.parse_args() @@ -50,7 +47,7 @@ check_operation_version = args.check_operation_version # run this script with --check-operation-version flag. # Update this dictionary when a newer version is implemented # TODO: how to keep the old version -onnx_version_dict = {'Abs': 6, +version_dict = {'Abs': 6, 'Acos': 7, 'Acosh': 9, 'Add': 7, @@ -205,9 +202,8 @@ onnx_version_dict = {'Abs': 6, 'Unsqueeze': 11, 'Upsample': 10, 'Where': 9, - 'Xor': 7} - -onnx_ml_version_dict = {'ArrayFeatureExtractor': 1, + 'Xor': 7, + 'ArrayFeatureExtractor': 1, 'Binarizer': 1, 'CastMap': 1, 'CategoryMapper': 1, @@ -334,15 +330,8 @@ MAX_NUM_TYPES=20 SNIPPETS = collect_snippets() SAMPLE_IMPLEMENTATIONS = collect_sample_implementations() -ONNX_ML = bool(args.domain == "ONNX_ML") - -sys.stderr.write("ONNX_ML {}\n".format(ONNX_ML)) def should_render_domain(domain): # type: (Text) -> bool - if domain == ONNX_ML_DOMAIN and not ONNX_ML: - return False - elif ONNX_ML and domain != ONNX_ML_DOMAIN: - return False return True @@ -708,10 +697,7 @@ def get_type_inference_func(s, indent, type_inference_code): def gen_op_def(schema): indent = inc_indent() - if (ONNX_ML) : - s = 'def MLONNX{0}Op:MLONNX_Op<"{0}",\n'.format(schema.name) - else : - s = 'def ONNX{0}Op:ONNX_Op<"{0}",\n'.format(schema.name) + s = 'def ONNX{0}Op:ONNX_Op<"{0}",\n'.format(schema.name) # Generate decl for op traits. traits = ["NoSideEffect"] @@ -881,12 +867,8 @@ def gen_op_importer(schema, file): if OpSchema.FormalParameterOption.Variadic == output.option: expected_num_results = -1 - if ONNX_ML: - handler_func = special_op_handler.get( - schema.name, "buildOperation".format(schema.name)) - else: - handler_func = special_op_handler.get( - schema.name, "buildOperation".format(schema.name)) + handler_func = special_op_handler.get( + schema.name, "buildOperation".format(schema.name)) # Special handlers currently require expected num operands/results to be specified. # TODO: remove special handlers. @@ -920,10 +902,6 @@ def build_operator_schemas(): for domain, _supportmap in sorted(index.items()): if not should_render_domain(domain): continue - if domain == ONNX_ML_DOMAIN: - version_dict = onnx_ml_version_dict - else: - version_dict = onnx_version_dict processed_supportmap = list() for _support, _namemap in sorted(_supportmap.items()): processed_namemap = list() @@ -1006,19 +984,13 @@ if __name__ == '__main__': if args.dry_run_onnx_ops: op_def = StringIO() else: - if args.domain == 'ONNX_ML': - op_def_file_path = os.path.join(curr_dir, 'MLONNXOps.td.inc') - else: - op_def_file_path = os.path.join(curr_dir, 'ONNXOps.td.inc') + op_def_file_path = os.path.join(curr_dir, 'ONNXOps.td.inc') op_def = io.open(op_def_file_path, 'w', newline='') if args.dry_run_op_build_table: op_importer = StringIO() else: - if args.domain == 'ONNX_ML': - op_importer_file_path = os.path.join(curr_dir, 'MLOpBuildTable.inc') - else : - op_importer_file_path = os.path.join(curr_dir, 'OpBuildTable.inc') + op_importer_file_path = os.path.join(curr_dir, 'OpBuildTable.inc') op_importer = io.open(op_importer_file_path, 'w', newline='') main(Args)