diff --git a/docs/Dialects/onnx.md b/docs/Dialects/onnx.md index 3996ad35d6..5470bd6bc0 100644 --- a/docs/Dialects/onnx.md +++ b/docs/Dialects/onnx.md @@ -1114,13 +1114,13 @@ Effects: `MemoryEffects::Effect{}` | Operand | Description | | :-----: | ----------- | -| `input` | tensor of 16-bit float values or tensor of 32-bit float values or tensor of 64-bit float values or tensor of 8-bit signless integer values or tensor of 16-bit signless integer values or tensor of 32-bit signless integer values or tensor of 64-bit signless integer values or tensor of 8-bit unsigned integer values or tensor of 16-bit unsigned integer values or tensor of 32-bit unsigned integer values or tensor of 64-bit unsigned integer values or tensor of 1-bit signless integer values or tensor of string type values or tensor of bfloat16 type values or tensor of f8E4M3FN type values or tensor of f8E4M3FNUZ type values or tensor of f8E5M2 type values or tensor of f8E5M2FNUZ type values +| `input` | tensor of 16-bit float values or tensor of 32-bit float values or tensor of 64-bit float values or tensor of 8-bit signless integer values or tensor of 16-bit signless integer values or tensor of 32-bit signless integer values or tensor of 64-bit signless integer values or tensor of 8-bit unsigned integer values or tensor of 16-bit unsigned integer values or tensor of 32-bit unsigned integer values or tensor of 64-bit unsigned integer values or tensor of 1-bit signless integer values or tensor of string type values or tensor of bfloat16 type values or tensor of f8E4M3FN type values or tensor of f8E4M3FNUZ type values or tensor of f8E5M2 type values or tensor of f8E5M2FNUZ type values or tensor of 4-bit unsigned integer values or tensor of 4-bit signless integer values #### Results: | Result | Description | | :----: | ----------- | -| `output` | tensor of 16-bit float values or tensor of 32-bit float values or tensor of 64-bit float values or tensor of 8-bit signless integer values or tensor of 16-bit signless integer values or tensor of 32-bit signless integer values or tensor of 64-bit signless integer values or tensor of 8-bit unsigned integer values or tensor of 16-bit unsigned integer values or tensor of 32-bit unsigned integer values or tensor of 64-bit unsigned integer values or tensor of 1-bit signless integer values or tensor of string type values or tensor of bfloat16 type values or tensor of f8E4M3FN type values or tensor of f8E4M3FNUZ type values or tensor of f8E5M2 type values or tensor of f8E5M2FNUZ type values +| `output` | tensor of 16-bit float values or tensor of 32-bit float values or tensor of 64-bit float values or tensor of 8-bit signless integer values or tensor of 16-bit signless integer values or tensor of 32-bit signless integer values or tensor of 64-bit signless integer values or tensor of 8-bit unsigned integer values or tensor of 16-bit unsigned integer values or tensor of 32-bit unsigned integer values or tensor of 64-bit unsigned integer values or tensor of 1-bit signless integer values or tensor of string type values or tensor of bfloat16 type values or tensor of f8E4M3FN type values or tensor of f8E4M3FNUZ type values or tensor of f8E5M2 type values or tensor of f8E5M2FNUZ type values or tensor of 4-bit unsigned integer values or tensor of 4-bit signless integer values ### `onnx.CategoryMapper` (ONNXCategoryMapperOp) diff --git a/src/Builder/OpBuildTable.inc b/src/Builder/OpBuildTable.inc index 067839b22f..469b714b8d 100644 --- a/src/Builder/OpBuildTable.inc +++ b/src/Builder/OpBuildTable.inc @@ -5,8 +5,8 @@ //******************************************************** op_dialect_version_map_["Abs"] = {13}; -op_dialect_version_map_["Acos"] = {7}; -op_dialect_version_map_["Acosh"] = {9}; +op_dialect_version_map_["Acos"] = {22}; +op_dialect_version_map_["Acosh"] = {22}; op_dialect_version_map_["Adagrad"] = {1}; op_dialect_version_map_["Adam"] = {1}; op_dialect_version_map_["Add"] = {14}; @@ -14,13 +14,13 @@ op_dialect_version_map_["And"] = {7}; op_dialect_version_map_["ArgMax"] = {13}; op_dialect_version_map_["ArgMin"] = {13}; op_dialect_version_map_["ArrayFeatureExtractor"] = {1}; -op_dialect_version_map_["Asin"] = {7}; -op_dialect_version_map_["Asinh"] = {9}; -op_dialect_version_map_["Atan"] = {7}; -op_dialect_version_map_["Atanh"] = {9}; -op_dialect_version_map_["AveragePool"] = {19}; +op_dialect_version_map_["Asin"] = {22}; +op_dialect_version_map_["Asinh"] = {22}; +op_dialect_version_map_["Atan"] = {22}; +op_dialect_version_map_["Atanh"] = {22}; +op_dialect_version_map_["AveragePool"] = {22}; op_dialect_version_map_["BatchNormalization"] = {15}; -op_dialect_version_map_["Bernoulli"] = {15}; +op_dialect_version_map_["Bernoulli"] = {22}; op_dialect_version_map_["Binarizer"] = {1}; op_dialect_version_map_["BitShift"] = {11}; op_dialect_version_map_["BitwiseAnd"] = {18}; @@ -41,41 +41,41 @@ op_dialect_version_map_["Concat"] = {13}; op_dialect_version_map_["ConcatFromSequence"] = {11}; op_dialect_version_map_["Constant"] = {19}; op_dialect_version_map_["ConstantOfShape"] = {20}; -op_dialect_version_map_["Conv"] = {11}; +op_dialect_version_map_["Conv"] = {22}; op_dialect_version_map_["ConvInteger"] = {10}; -op_dialect_version_map_["ConvTranspose"] = {11}; -op_dialect_version_map_["Cos"] = {7}; -op_dialect_version_map_["Cosh"] = {9}; +op_dialect_version_map_["ConvTranspose"] = {22}; +op_dialect_version_map_["Cos"] = {22}; +op_dialect_version_map_["Cosh"] = {22}; op_dialect_version_map_["Col2Im"] = {18}; op_dialect_version_map_["CumSum"] = {14}; -op_dialect_version_map_["DeformConv"] = {19}; +op_dialect_version_map_["DeformConv"] = {22}; op_dialect_version_map_["DepthToSpace"] = {13}; op_dialect_version_map_["DequantizeLinear"] = {19}; -op_dialect_version_map_["Det"] = {11}; +op_dialect_version_map_["Det"] = {22}; op_dialect_version_map_["DFT"] = {20, 17}; op_dialect_version_map_["DictVectorizer"] = {1}; op_dialect_version_map_["Div"] = {14}; -op_dialect_version_map_["Dropout"] = {13}; +op_dialect_version_map_["Dropout"] = {22}; op_dialect_version_map_["DynamicQuantizeLinear"] = {11}; op_dialect_version_map_["Einsum"] = {12}; -op_dialect_version_map_["Elu"] = {6}; +op_dialect_version_map_["Elu"] = {22}; op_dialect_version_map_["Equal"] = {19}; op_dialect_version_map_["Erf"] = {13}; op_dialect_version_map_["Exp"] = {13}; op_dialect_version_map_["Expand"] = {13}; -op_dialect_version_map_["EyeLike"] = {9}; +op_dialect_version_map_["EyeLike"] = {22}; op_dialect_version_map_["FeatureVectorizer"] = {1}; op_dialect_version_map_["Flatten"] = {13}; op_dialect_version_map_["Floor"] = {13}; -op_dialect_version_map_["GRU"] = {14}; +op_dialect_version_map_["GRU"] = {22}; op_dialect_version_map_["Gather"] = {13}; op_dialect_version_map_["GatherElements"] = {13}; op_dialect_version_map_["GatherND"] = {13}; op_dialect_version_map_["Gelu"] = {20}; op_dialect_version_map_["Gemm"] = {13}; -op_dialect_version_map_["GlobalAveragePool"] = {1}; +op_dialect_version_map_["GlobalAveragePool"] = {22}; op_dialect_version_map_["GlobalLpPool"] = {2}; -op_dialect_version_map_["GlobalMaxPool"] = {1}; +op_dialect_version_map_["GlobalMaxPool"] = {22}; op_dialect_version_map_["Gradient"] = {1}; op_dialect_version_map_["Greater"] = {13}; op_dialect_version_map_["GreaterOrEqual"] = {16}; @@ -83,18 +83,18 @@ op_dialect_version_map_["GridSample"] = {16}; op_dialect_version_map_["GroupNormalization"] = {21, 18}; op_dialect_version_map_["HammingWindow"] = {17}; op_dialect_version_map_["HannWindow"] = {17}; -op_dialect_version_map_["HardSigmoid"] = {6}; +op_dialect_version_map_["HardSigmoid"] = {22}; op_dialect_version_map_["Hardmax"] = {13}; -op_dialect_version_map_["HardSwish"] = {14}; +op_dialect_version_map_["HardSwish"] = {22}; op_dialect_version_map_["Identity"] = {19}; op_dialect_version_map_["If"] = {19}; op_dialect_version_map_["Imputer"] = {1}; -op_dialect_version_map_["InstanceNormalization"] = {6}; +op_dialect_version_map_["InstanceNormalization"] = {22}; op_dialect_version_map_["IsInf"] = {20}; op_dialect_version_map_["IsNaN"] = {20}; op_dialect_version_map_["LayerNormalization"] = {17}; op_dialect_version_map_["LRN"] = {13}; -op_dialect_version_map_["LSTM"] = {14}; +op_dialect_version_map_["LSTM"] = {22}; op_dialect_version_map_["LabelEncoder"] = {2}; op_dialect_version_map_["LeakyRelu"] = {16}; op_dialect_version_map_["Less"] = {13}; @@ -104,25 +104,25 @@ op_dialect_version_map_["LinearRegressor"] = {1}; op_dialect_version_map_["Log"] = {13}; op_dialect_version_map_["LogSoftmax"] = {13}; op_dialect_version_map_["Loop"] = {19}; -op_dialect_version_map_["LpNormalization"] = {1}; -op_dialect_version_map_["LpPool"] = {18}; +op_dialect_version_map_["LpNormalization"] = {22}; +op_dialect_version_map_["LpPool"] = {22}; op_dialect_version_map_["MatMul"] = {13}; op_dialect_version_map_["MatMulInteger"] = {10}; op_dialect_version_map_["Max"] = {13}; -op_dialect_version_map_["MaxPool"] = {12}; -op_dialect_version_map_["MaxRoiPool"] = {1}; -op_dialect_version_map_["MaxUnpool"] = {11}; +op_dialect_version_map_["MaxPool"] = {22}; +op_dialect_version_map_["MaxRoiPool"] = {22}; +op_dialect_version_map_["MaxUnpool"] = {22}; op_dialect_version_map_["Mean"] = {13}; op_dialect_version_map_["MeanVarianceNormalization"] = {13}; op_dialect_version_map_["MelWeightMatrix"] = {17}; op_dialect_version_map_["Min"] = {13}; -op_dialect_version_map_["Mish"] = {18}; +op_dialect_version_map_["Mish"] = {22}; op_dialect_version_map_["Mod"] = {13}; op_dialect_version_map_["Momentum"] = {1}; op_dialect_version_map_["Mul"] = {14}; -op_dialect_version_map_["Multinomial"] = {7}; +op_dialect_version_map_["Multinomial"] = {22}; op_dialect_version_map_["Neg"] = {13}; -op_dialect_version_map_["NegativeLogLikelihoodLoss"] = {13}; +op_dialect_version_map_["NegativeLogLikelihoodLoss"] = {22}; op_dialect_version_map_["NonMaxSuppression"] = {11}; op_dialect_version_map_["NonZero"] = {13}; op_dialect_version_map_["Normalizer"] = {1}; @@ -139,11 +139,11 @@ op_dialect_version_map_["Pow"] = {15}; op_dialect_version_map_["QLinearConv"] = {10}; op_dialect_version_map_["QLinearMatMul"] = {10}; op_dialect_version_map_["QuantizeLinear"] = {19}; -op_dialect_version_map_["RNN"] = {14}; -op_dialect_version_map_["RandomNormal"] = {1}; -op_dialect_version_map_["RandomNormalLike"] = {1}; -op_dialect_version_map_["RandomUniform"] = {1}; -op_dialect_version_map_["RandomUniformLike"] = {1}; +op_dialect_version_map_["RNN"] = {22}; +op_dialect_version_map_["RandomNormal"] = {22}; +op_dialect_version_map_["RandomNormalLike"] = {22}; +op_dialect_version_map_["RandomUniform"] = {22}; +op_dialect_version_map_["RandomUniformLike"] = {22}; op_dialect_version_map_["Range"] = {11}; op_dialect_version_map_["Reciprocal"] = {13}; op_dialect_version_map_["ReduceL1"] = {18, 13}; @@ -160,8 +160,8 @@ op_dialect_version_map_["Relu"] = {14}; op_dialect_version_map_["Reshape"] = {19}; op_dialect_version_map_["Resize"] = {19, 18, 13, 11, 10}; op_dialect_version_map_["ReverseSequence"] = {10}; -op_dialect_version_map_["RoiAlign"] = {16}; -op_dialect_version_map_["Round"] = {11}; +op_dialect_version_map_["RoiAlign"] = {22}; +op_dialect_version_map_["Round"] = {22}; op_dialect_version_map_["SVMClassifier"] = {1}; op_dialect_version_map_["SVMRegressor"] = {1}; op_dialect_version_map_["Scaler"] = {1}; @@ -169,7 +169,7 @@ op_dialect_version_map_["Scan"] = {19}; op_dialect_version_map_["Scatter"] = {11}; op_dialect_version_map_["ScatterElements"] = {18}; op_dialect_version_map_["ScatterND"] = {18}; -op_dialect_version_map_["Selu"] = {6}; +op_dialect_version_map_["Selu"] = {22}; op_dialect_version_map_["SequenceAt"] = {11}; op_dialect_version_map_["SequenceConstruct"] = {11}; op_dialect_version_map_["SequenceEmpty"] = {11}; @@ -181,14 +181,14 @@ op_dialect_version_map_["Shape"] = {19}; op_dialect_version_map_["Shrink"] = {9}; op_dialect_version_map_["Sigmoid"] = {13}; op_dialect_version_map_["Sign"] = {13}; -op_dialect_version_map_["Sin"] = {7}; -op_dialect_version_map_["Sinh"] = {9}; +op_dialect_version_map_["Sin"] = {22}; +op_dialect_version_map_["Sinh"] = {22}; op_dialect_version_map_["Size"] = {19}; op_dialect_version_map_["Slice"] = {13}; op_dialect_version_map_["Softmax"] = {13, 11}; op_dialect_version_map_["SoftmaxCrossEntropyLoss"] = {13}; -op_dialect_version_map_["Softplus"] = {1}; -op_dialect_version_map_["Softsign"] = {1}; +op_dialect_version_map_["Softplus"] = {22}; +op_dialect_version_map_["Softsign"] = {22}; op_dialect_version_map_["SpaceToDepth"] = {13}; op_dialect_version_map_["Split"] = {18, 13, 11}; op_dialect_version_map_["SplitToSequence"] = {11}; @@ -198,10 +198,10 @@ op_dialect_version_map_["StringNormalizer"] = {10}; op_dialect_version_map_["STFT"] = {17}; op_dialect_version_map_["Sub"] = {14}; op_dialect_version_map_["Sum"] = {13}; -op_dialect_version_map_["Tan"] = {7}; +op_dialect_version_map_["Tan"] = {22}; op_dialect_version_map_["Tanh"] = {13}; op_dialect_version_map_["TfIdfVectorizer"] = {9}; -op_dialect_version_map_["ThresholdedRelu"] = {10}; +op_dialect_version_map_["ThresholdedRelu"] = {22}; op_dialect_version_map_["Tile"] = {13}; op_dialect_version_map_["TopK"] = {11}; op_dialect_version_map_["Transpose"] = {13}; diff --git a/src/Dialect/ONNX/ONNXOps.td.inc b/src/Dialect/ONNX/ONNXOps.td.inc index 685c5438be..fd9961a5e0 100644 --- a/src/Dialect/ONNX/ONNXOps.td.inc +++ b/src/Dialect/ONNX/ONNXOps.td.inc @@ -51,8 +51,8 @@ def ONNXAcosOp:ONNX_Op<"Acos", let description = [{ Calculates the arccosine (inverse of cosine) of the given input tensor, element-wise. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -80,8 +80,8 @@ def ONNXAcoshOp:ONNX_Op<"Acosh", let description = [{ Calculates the hyperbolic arccosine of the given input tensor element-wise. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -298,8 +298,8 @@ def ONNXAsinOp:ONNX_Op<"Asin", let description = [{ Calculates the arcsine (inverse of sine) of the given input tensor, element-wise. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -327,8 +327,8 @@ def ONNXAsinhOp:ONNX_Op<"Asinh", let description = [{ Calculates the hyperbolic arcsine of the given input tensor element-wise. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -356,8 +356,8 @@ def ONNXAtanOp:ONNX_Op<"Atan", let description = [{ Calculates the arctangent (inverse of tangent) of the given input tensor, element-wise. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -385,8 +385,8 @@ def ONNXAtanhOp:ONNX_Op<"Atanh", let description = [{ Calculates the hyperbolic arctangent of the given input tensor element-wise. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -426,7 +426,7 @@ def ONNXAveragePoolOp:ONNX_Op<"AveragePool", ``` output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1) ``` - if ceil_mode is enabled. `pad_shape[i]` is the sum of pads along axis `i`. + if ceil_mode is enabled. `pad_shape[i]` is the sum of pads along axis `i`. Sliding windows that would start in the right padded region are ignored. `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following when ceil_mode is enabled: ``` @@ -445,7 +445,7 @@ def ONNXAveragePoolOp:ONNX_Op<"AveragePool", The output of each pooling window is divided by the number of elements (exclude pad when attribute count_include_pad is zero). }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, DefaultValuedStrAttr:$auto_pad, DefaultValuedAttr:$ceil_mode, DefaultValuedAttr:$count_include_pad, @@ -453,7 +453,7 @@ def ONNXAveragePoolOp:ONNX_Op<"AveragePool", I64ArrayAttr:$kernel_shape, OptionalAttr:$pads, OptionalAttr:$strides); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -563,10 +563,10 @@ def ONNXBernoulliOp:ONNX_Op<"Bernoulli", This operator is non-deterministic and may not produce the same values in different implementations (even if a seed is specified). }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input, + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input, OptionalAttr:$dtype, OptionalAttr:$seed); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, TensorOf<[BF16]>, TensorOf<[UI8]>, TensorOf<[UI16]>, TensorOf<[UI32]>, TensorOf<[UI64]>, TensorOf<[I8]>, TensorOf<[I16]>, TensorOf<[I32]>, TensorOf<[I64]>, TensorOf<[I1]>]>:$output); + let results = (outs AnyTypeOf<[TensorOf<[UI8]>, TensorOf<[UI16]>, TensorOf<[UI32]>, TensorOf<[UI64]>, TensorOf<[I8]>, TensorOf<[I16]>, TensorOf<[I32]>, TensorOf<[I64]>, TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, TensorOf<[I1]>]>:$output); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -1400,16 +1400,16 @@ def ONNXConvOp:ONNX_Op<"Conv", The convolution operator consumes an input tensor and a filter, and computes the output. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$W, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$B, + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$W, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$B, DefaultValuedStrAttr:$auto_pad, OptionalAttr:$dilations, DefaultValuedAttr:$group, OptionalAttr:$kernel_shape, OptionalAttr:$pads, OptionalAttr:$strides); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); let builders = [ OpBuilder<(ins "Value":$X, "Value":$W, "Value":$B, "StringAttr":$auto_pad, "ArrayAttr":$dilations, "IntegerAttr":$group, "ArrayAttr":$kernel_shape, "ArrayAttr":$pads, "ArrayAttr":$strides), [{ auto resultType = UnrankedTensorType::get(mlir::cast(X.getType()).getElementType()); @@ -1500,9 +1500,9 @@ def ONNXConvTransposeOp:ONNX_Op<"ConvTranspose", }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$W, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$B, + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$W, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$B, DefaultValuedStrAttr:$auto_pad, OptionalAttr:$dilations, DefaultValuedAttr:$group, @@ -1511,7 +1511,7 @@ def ONNXConvTransposeOp:ONNX_Op<"ConvTranspose", OptionalAttr:$output_shape, OptionalAttr:$pads, OptionalAttr:$strides); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 3; @@ -1540,8 +1540,8 @@ def ONNXCosOp:ONNX_Op<"Cos", let description = [{ Calculates the cosine of the given input tensor, element-wise. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -1569,8 +1569,8 @@ def ONNXCoshOp:ONNX_Op<"Cosh", let description = [{ Calculates the hyperbolic cosine of the given input tensor element-wise. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -1732,18 +1732,18 @@ def ONNXDeformConvOp:ONNX_Op<"DeformConv", Performs deformable convolution as described in https://arxiv.org/abs/1703.06211 and https://arxiv.org/abs/1811.11168. This operator specification supports the general N-D case. Note that most common use cases have 2D or 3D data. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$W, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$offset, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$B, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$mask, + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$W, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$offset, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$B, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$mask, OptionalAttr:$dilations, DefaultValuedAttr:$group, OptionalAttr:$kernel_shape, DefaultValuedAttr:$offset_group, OptionalAttr:$pads, OptionalAttr:$strides); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 5; @@ -1870,8 +1870,8 @@ def ONNXDetOp:ONNX_Op<"Det", The output is a tensor of shape `[*]`, containing the determinants of all input submatrices. e.g., When the input is 2-D, the output is a scalar(shape is empty: `[]`). }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -1967,11 +1967,11 @@ def ONNXDropoutOp:ONNX_Op<"Dropout", ``` This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, TensorOf<[BF16]>]>:$data, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$ratio, + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, TensorOf<[F8E4M3FN]>, TensorOf<[F8E4M3FNUZ]>, TensorOf<[F8E5M2]>, TensorOf<[F8E5M2FNUZ]>]>:$data, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, TensorOf<[F8E4M3FN]>, TensorOf<[F8E4M3FNUZ]>, TensorOf<[F8E5M2]>, TensorOf<[F8E5M2FNUZ]>, NoneType]>:$ratio, AnyTypeOf<[TensorOf<[I1]>, NoneType]>:$training_mode, OptionalAttr:$seed); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, TensorOf<[BF16]>]>:$output, + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, TensorOf<[F8E4M3FN]>, TensorOf<[F8E4M3FNUZ]>, TensorOf<[F8E5M2]>, TensorOf<[F8E5M2FNUZ]>]>:$output, AnyTypeOf<[TensorOf<[I1]>, NoneType]>:$mask); let extraClassDeclaration = [{ static int getNumberOfOperands() { @@ -2115,9 +2115,9 @@ def ONNXEluOp:ONNX_Op<"Elu", 0`, `f(x) = x for x >= 0`., is applied to the tensor elementwise. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, DefaultValuedAttr:$alpha); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -2314,10 +2314,10 @@ def ONNXEyeLikeOp:ONNX_Op<"EyeLike", The 'dtype' argument must be one of the data types specified in the 'DataType' enum field in the TensorProto message and be valid as an output type. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, TensorOf<[I8]>, TensorOf<[I16]>, TensorOf<[I32]>, TensorOf<[I64]>, TensorOf<[UI8]>, TensorOf<[UI16]>, TensorOf<[UI32]>, TensorOf<[UI64]>, TensorOf<[I1]>]>:$input, + let arguments = (ins AnyTypeOf<[TensorOf<[UI8]>, TensorOf<[UI16]>, TensorOf<[UI32]>, TensorOf<[UI64]>, TensorOf<[I8]>, TensorOf<[I16]>, TensorOf<[I32]>, TensorOf<[I64]>, TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, TensorOf<[I1]>]>:$input, OptionalAttr:$dtype, DefaultValuedAttr:$k); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, TensorOf<[I8]>, TensorOf<[I16]>, TensorOf<[I32]>, TensorOf<[I64]>, TensorOf<[UI8]>, TensorOf<[UI16]>, TensorOf<[UI32]>, TensorOf<[UI64]>, TensorOf<[I1]>]>:$output); + let results = (outs AnyTypeOf<[TensorOf<[UI8]>, TensorOf<[UI16]>, TensorOf<[UI32]>, TensorOf<[UI64]>, TensorOf<[I8]>, TensorOf<[I16]>, TensorOf<[I32]>, TensorOf<[I64]>, TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, TensorOf<[I1]>]>:$output); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -2456,12 +2456,12 @@ def ONNXGRUOp:ONNX_Op<"GRU", * Ht = (1 - zt) (.) ht + zt (.) Ht-1 This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$W, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$R, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$B, + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$W, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$R, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$B, AnyTypeOf<[TensorOf<[I32]>, NoneType]>:$sequence_lens, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$initial_h, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$initial_h, OptionalAttr:$activation_alpha, OptionalAttr:$activation_beta, OptionalAttr:$activations, @@ -2470,8 +2470,8 @@ def ONNXGRUOp:ONNX_Op<"GRU", OptionalAttr:$hidden_size, DefaultValuedAttr:$layout, DefaultValuedAttr:$linear_before_reset); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$Y, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$Y_h); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$Y, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$Y_h); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 6; @@ -2861,8 +2861,8 @@ def ONNXGlobalAveragePoolOp:ONNX_Op<"GlobalAveragePool", the values in the same channel. This is equivalent to AveragePool with kernel size equal to the spatial dimension of input tensor. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -2925,8 +2925,8 @@ def ONNXGlobalMaxPoolOp:ONNX_Op<"GlobalMaxPool", the values in the same channel. This is equivalent to MaxPool with kernel size equal to the spatial dimension of input tensor. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -3280,10 +3280,10 @@ def ONNXHardSigmoidOp:ONNX_Op<"HardSigmoid", (Tensor) where the HardSigmoid function, y = max(0, min(1, alpha * x + beta)), is applied to the tensor elementwise. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, DefaultValuedAttr:$alpha, DefaultValuedAttr:$beta); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -3313,8 +3313,8 @@ def ONNXHardSwishOp:ONNX_Op<"HardSwish", the HardSwish function, y = x * max(0, min(1, alpha * x + beta)) = x * HardSigmoid(x), where alpha = 1/6 and beta = 0.5, is applied to the tensor elementwise. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -3461,11 +3461,11 @@ def ONNXInstanceNormalizationOp:ONNX_Op<"InstanceNormalization", where mean and variance are computed per instance per channel. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$scale, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$B, + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$scale, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$B, DefaultValuedAttr:$epsilon); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 3; @@ -3647,14 +3647,14 @@ def ONNXLSTMOp:ONNX_Op<"LSTM", * Ht = ot (.) h(Ct) This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$W, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$R, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$B, + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$W, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$R, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$B, AnyTypeOf<[TensorOf<[I32]>, NoneType]>:$sequence_lens, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$initial_h, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$initial_c, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$P, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$initial_h, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$initial_c, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$P, OptionalAttr:$activation_alpha, OptionalAttr:$activation_beta, OptionalAttr:$activations, @@ -3663,9 +3663,9 @@ def ONNXLSTMOp:ONNX_Op<"LSTM", OptionalAttr:$hidden_size, DefaultValuedAttr:$input_forget, DefaultValuedAttr:$layout); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$Y, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$Y_h, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$Y_c); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$Y, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$Y_h, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$Y_c); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 8; @@ -4155,10 +4155,10 @@ def ONNXLpNormalizationOp:ONNX_Op<"LpNormalization", let description = [{ Given a matrix, apply Lp-normalization along the provided axis. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input, + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input, DefaultValuedAttr:$axis, DefaultValuedAttr:$p); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -4208,7 +4208,7 @@ def ONNXLpPoolOp:ONNX_Op<"LpPool", pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + {kernelSpatialShape} - input_spatial_shape[i] ``` }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, DefaultValuedStrAttr:$auto_pad, DefaultValuedAttr:$ceil_mode, OptionalAttr:$dilations, @@ -4216,7 +4216,7 @@ def ONNXLpPoolOp:ONNX_Op<"LpPool", DefaultValuedAttr:$p, OptionalAttr:$pads, OptionalAttr:$strides); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -4352,7 +4352,7 @@ def ONNXMaxPoolOp:ONNX_Op<"MaxPool", ``` output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1) ``` - if ceil_mode is enabled. `pad_shape[i]` is the sum of pads along axis `i`. + if ceil_mode is enabled. `pad_shape[i]` is the sum of pads along axis `i`. Sliding windows that would start in the right padded region are ignored. `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following when ceil_mode is enabled: ``` @@ -4371,7 +4371,7 @@ def ONNXMaxPoolOp:ONNX_Op<"MaxPool", The output of each pooling window is maximum number of elements exclude pad. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, TensorOf<[I8]>, TensorOf<[UI8]>]>:$X, + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, TensorOf<[I8]>, TensorOf<[UI8]>]>:$X, DefaultValuedStrAttr:$auto_pad, DefaultValuedAttr:$ceil_mode, OptionalAttr:$dilations, @@ -4379,7 +4379,7 @@ def ONNXMaxPoolOp:ONNX_Op<"MaxPool", OptionalAttr:$pads, DefaultValuedAttr:$storage_order, OptionalAttr:$strides); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, TensorOf<[I8]>, TensorOf<[UI8]>]>:$Y, + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, TensorOf<[I8]>, TensorOf<[UI8]>]>:$Y, AnyTypeOf<[TensorOf<[I64]>, NoneType]>:$Indices); let extraClassDeclaration = [{ static int getNumberOfOperands() { @@ -4410,11 +4410,11 @@ def ONNXMaxRoiPoolOp:ONNX_Op<"MaxRoiPool", apply max pooling across each RoI, to produce output 4-D tensor of shape (num_rois, channels, pooled_shape[0], pooled_shape[1]). }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$rois, + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$rois, I64ArrayAttr:$pooled_shape, DefaultValuedAttr:$spatial_scale); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 2; @@ -4459,13 +4459,13 @@ def ONNXMaxUnpoolOp:ONNX_Op<"MaxUnpool", which define the exact unpooling op. The attributes typically have the same values as the corresponding pooling op that the unpooling op is trying to invert. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, TensorOf<[I64]>:$I, AnyTypeOf<[TensorOf<[I64]>, NoneType]>:$output_shape, I64ArrayAttr:$kernel_shape, OptionalAttr:$pads, OptionalAttr:$strides); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 3; @@ -4635,8 +4635,8 @@ def ONNXMishOp:ONNX_Op<"Mish", mish(x) = x * tanh(softplus(x)) = x * tanh(ln(1 + e^{x})) ``` }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -4765,7 +4765,7 @@ def ONNXMultinomialOp:ONNX_Op<"Multinomial", Generate a tensor of samples from a multinomial distribution according to the probabilities of each of the possible outcomes. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input, + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input, DefaultValuedAttr:$dtype, DefaultValuedAttr:$sample_size, OptionalAttr:$seed); @@ -4938,12 +4938,12 @@ def ONNXNegativeLogLikelihoodLossOp:ONNX_Op<"NegativeLogLikelihoodLoss", // -1.57 ``` }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input, + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input, AnyTypeOf<[TensorOf<[I32]>, TensorOf<[I64]>]>:$target, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$weight, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$weight, OptionalAttr:$ignore_index, DefaultValuedStrAttr:$reduction); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$loss); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$loss); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 3; @@ -6050,12 +6050,12 @@ def ONNXRNNOp:ONNX_Op<"RNN", * Ht = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Wbi + Rbi) This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$W, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$R, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$B, + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$W, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$R, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$B, AnyTypeOf<[TensorOf<[I32]>, NoneType]>:$sequence_lens, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$initial_h, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$initial_h, OptionalAttr:$activation_alpha, OptionalAttr:$activation_beta, DefaultValuedAttr:$activations, @@ -6063,8 +6063,8 @@ def ONNXRNNOp:ONNX_Op<"RNN", DefaultValuedStrAttr:$direction, OptionalAttr:$hidden_size, DefaultValuedAttr:$layout); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$Y, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$Y_h); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$Y, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, NoneType]>:$Y_h); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 6; @@ -6103,7 +6103,7 @@ def ONNXRandomNormalOp:ONNX_Op<"RandomNormal", DefaultValuedAttr:$scale, OptionalAttr:$seed, I64ArrayAttr:$shape); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 0; @@ -6137,12 +6137,12 @@ def ONNXRandomNormalLikeOp:ONNX_Op<"RandomNormalLike", The 'dtype' argument must be one of the data types specified in the 'DataType' enum field in the TensorProto message, and be valid as an output type. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[UI8]>, TensorOf<[UI16]>, TensorOf<[UI32]>, TensorOf<[UI64]>, TensorOf<[I8]>, TensorOf<[I16]>, TensorOf<[I32]>, TensorOf<[I64]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, TensorOf<[StringType]>, TensorOf<[I1]>, TensorOf<[Complex]>, TensorOf<[Complex]>]>:$input, + let arguments = (ins AnyTypeOf<[TensorOf<[UI8]>, TensorOf<[UI16]>, TensorOf<[UI32]>, TensorOf<[UI64]>, TensorOf<[I8]>, TensorOf<[I16]>, TensorOf<[I32]>, TensorOf<[I64]>, TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, TensorOf<[StringType]>, TensorOf<[I1]>, TensorOf<[Complex]>, TensorOf<[Complex]>]>:$input, OptionalAttr:$dtype, DefaultValuedAttr:$mean, DefaultValuedAttr:$scale, OptionalAttr:$seed); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -6181,7 +6181,7 @@ def ONNXRandomUniformOp:ONNX_Op<"RandomUniform", DefaultValuedAttr:$low, OptionalAttr:$seed, I64ArrayAttr:$shape); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 0; @@ -6215,12 +6215,12 @@ def ONNXRandomUniformLikeOp:ONNX_Op<"RandomUniformLike", The 'dtype' argument must be one of the data types specified in the 'DataType' enum field in the TensorProto message and be valid as an output type. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[UI8]>, TensorOf<[UI16]>, TensorOf<[UI32]>, TensorOf<[UI64]>, TensorOf<[I8]>, TensorOf<[I16]>, TensorOf<[I32]>, TensorOf<[I64]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, TensorOf<[StringType]>, TensorOf<[I1]>, TensorOf<[Complex]>, TensorOf<[Complex]>]>:$input, + let arguments = (ins AnyTypeOf<[TensorOf<[UI8]>, TensorOf<[UI16]>, TensorOf<[UI32]>, TensorOf<[UI64]>, TensorOf<[I8]>, TensorOf<[I16]>, TensorOf<[I32]>, TensorOf<[I64]>, TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>, TensorOf<[StringType]>, TensorOf<[I1]>, TensorOf<[Complex]>, TensorOf<[Complex]>]>:$input, OptionalAttr:$dtype, DefaultValuedAttr:$high, DefaultValuedAttr:$low, OptionalAttr:$seed); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -7616,8 +7616,8 @@ def ONNXRoiAlignOp:ONNX_Op<"RoiAlign", the value of the sampled locations are computed directly through bilinear interpolation. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, - AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$rois, + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, + AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$rois, TensorOf<[I64]>:$batch_indices, DefaultValuedStrAttr:$coordinate_transformation_mode, DefaultValuedStrAttr:$mode, @@ -7625,7 +7625,7 @@ def ONNXRoiAlignOp:ONNX_Op<"RoiAlign", DefaultValuedAttr:$output_width, DefaultValuedAttr:$sampling_ratio, DefaultValuedAttr:$spatial_scale); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 3; @@ -7667,8 +7667,8 @@ def ONNXRoundOp:ONNX_Op<"Round", round([-4.5]) = [-4.0] ``` }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -8182,10 +8182,10 @@ def ONNXSeluOp:ONNX_Op<"Selu", `y = gamma * (alpha * e^x - alpha) for x <= 0`, `y = gamma * x for x > 0`, is applied to the tensor elementwise. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, DefaultValuedAttr:$alpha, DefaultValuedAttr:$gamma); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -8616,8 +8616,8 @@ def ONNXSinOp:ONNX_Op<"Sin", let description = [{ Calculates the sine of the given input tensor, element-wise. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -8645,8 +8645,8 @@ def ONNXSinhOp:ONNX_Op<"Sinh", let description = [{ Calculates the hyperbolic sine of the given input tensor element-wise. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -8963,8 +8963,8 @@ def ONNXSoftplusOp:ONNX_Op<"Softplus", (Tensor) where the softplus function, y = ln(exp(x) + 1), is applied to the tensor elementwise. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -8992,8 +8992,8 @@ def ONNXSoftsignOp:ONNX_Op<"Softsign", let description = [{ Calculates the softsign (x/(1+|x|)) of the given input tensor element-wise. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -9482,8 +9482,8 @@ def ONNXTanOp:ONNX_Op<"Tan", let description = [{ Calculates the tangent of the given input tensor, element-wise. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$input); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$output); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; @@ -9606,9 +9606,9 @@ def ONNXThresholdedReluOp:ONNX_Op<"ThresholdedRelu", (Tensor) where the rectified linear function, y = x for x > alpha, y = 0 otherwise, is applied to the tensor elementwise. }]; - let arguments = (ins AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, + let arguments = (ins AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$X, DefaultValuedAttr:$alpha); - let results = (outs AnyTypeOf<[TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); + let results = (outs AnyTypeOf<[TensorOf<[BF16]>, TensorOf<[F16]>, TensorOf<[F32]>, TensorOf<[F64]>]>:$Y); let extraClassDeclaration = [{ static int getNumberOfOperands() { return 1; diff --git a/utils/gen_onnx_mlir.py b/utils/gen_onnx_mlir.py index a32c931521..d3a4068bd0 100755 --- a/utils/gen_onnx_mlir.py +++ b/utils/gen_onnx_mlir.py @@ -86,8 +86,8 @@ version_dict = { "Abs": [13], - "Acos": [7], - "Acosh": [9], + "Acos": [22], + "Acosh": [22], "Adagrad": [1], "Adam": [1], "Add": [14], @@ -95,13 +95,13 @@ "ArgMax": [13], "ArgMin": [13], "ArrayFeatureExtractor": [1], - "Asin": [7], - "Asinh": [9], - "Atan": [7], - "Atanh": [9], - "AveragePool": [19], + "Asin": [22], + "Asinh": [22], + "Atan": [22], + "Atanh": [22], + "AveragePool": [22], "BatchNormalization": [15], - "Bernoulli": [15], + "Bernoulli": [22], "Binarizer": [1], "BitShift": [11], "BitwiseAnd": [18], @@ -122,41 +122,41 @@ "ConcatFromSequence": [11], "Constant": [19], "ConstantOfShape": [20], - "Conv": [11], + "Conv": [22], "ConvInteger": [10], - "ConvTranspose": [11], - "Cos": [7], - "Cosh": [9], + "ConvTranspose": [22], + "Cos": [22], + "Cosh": [22], "Col2Im": [18], "CumSum": [14], - "DeformConv": [19], + "DeformConv": [22], "DepthToSpace": [13], "DequantizeLinear": [19], - "Det": [11], + "Det": [22], "DFT": [20, 17], "DictVectorizer": [1], "Div": [14], - "Dropout": [13], + "Dropout": [22], "DynamicQuantizeLinear": [11], "Einsum": [12], - "Elu": [6], + "Elu": [22], "Equal": [19], "Erf": [13], "Exp": [13], "Expand": [13], - "EyeLike": [9], + "EyeLike": [22], "FeatureVectorizer": [1], "Flatten": [13], "Floor": [13], - "GRU": [14], + "GRU": [22], "Gather": [13], "GatherElements": [13], "GatherND": [13], "Gelu": [20], "Gemm": [13], - "GlobalAveragePool": [1], + "GlobalAveragePool": [22], "GlobalLpPool": [2], - "GlobalMaxPool": [1], + "GlobalMaxPool": [22], "Gradient": [1], "Greater": [13], "GreaterOrEqual": [16], @@ -164,18 +164,18 @@ "GroupNormalization": [21, 18], "HammingWindow": [17], "HannWindow": [17], - "HardSigmoid": [6], + "HardSigmoid": [22], "Hardmax": [13], - "HardSwish": [14], + "HardSwish": [22], "Identity": [19], "If": [19], "Imputer": [1], - "InstanceNormalization": [6], + "InstanceNormalization": [22], "IsInf": [20], "IsNaN": [20], "LayerNormalization": [17], "LRN": [13], - "LSTM": [14], + "LSTM": [22], "LabelEncoder": [2], "LeakyRelu": [16], "Less": [13], @@ -185,25 +185,25 @@ "Log": [13], "LogSoftmax": [13], "Loop": [19], - "LpNormalization": [1], - "LpPool": [18], + "LpNormalization": [22], + "LpPool": [22], "MatMul": [13], "MatMulInteger": [10], "Max": [13], - "MaxPool": [12], - "MaxRoiPool": [1], - "MaxUnpool": [11], + "MaxPool": [22], + "MaxRoiPool": [22], + "MaxUnpool": [22], "Mean": [13], "MeanVarianceNormalization": [13], "MelWeightMatrix": [17], "Min": [13], - "Mish": [18], + "Mish": [22], "Mod": [13], "Momentum": [1], "Mul": [14], - "Multinomial": [7], + "Multinomial": [22], "Neg": [13], - "NegativeLogLikelihoodLoss": [13], + "NegativeLogLikelihoodLoss": [22], "NonMaxSuppression": [11], "NonZero": [13], "Normalizer": [1], @@ -220,11 +220,11 @@ "QLinearConv": [10], "QLinearMatMul": [10], "QuantizeLinear": [19], - "RNN": [14], - "RandomNormal": [1], - "RandomNormalLike": [1], - "RandomUniform": [1], - "RandomUniformLike": [1], + "RNN": [22], + "RandomNormal": [22], + "RandomNormalLike": [22], + "RandomUniform": [22], + "RandomUniformLike": [22], "Range": [11], "Reciprocal": [13], "ReduceL1": [18, 13], @@ -241,8 +241,8 @@ "Reshape": [19], "Resize": [19, 18, 13, 11, 10], "ReverseSequence": [10], - "RoiAlign": [16], - "Round": [11], + "RoiAlign": [22], + "Round": [22], "SVMClassifier": [1], "SVMRegressor": [1], "Scaler": [1], @@ -250,7 +250,7 @@ "Scatter": [11], "ScatterElements": [18], "ScatterND": [18], - "Selu": [6], + "Selu": [22], "SequenceAt": [11], "SequenceConstruct": [11], "SequenceEmpty": [11], @@ -262,14 +262,14 @@ "Shrink": [9], "Sigmoid": [13], "Sign": [13], - "Sin": [7], - "Sinh": [9], + "Sin": [22], + "Sinh": [22], "Size": [19], "Slice": [13], "Softmax": [13, 11], "SoftmaxCrossEntropyLoss": [13], - "Softplus": [1], - "Softsign": [1], + "Softplus": [22], + "Softsign": [22], "SpaceToDepth": [13], "Split": [18, 13, 11], "SplitToSequence": [11], @@ -279,10 +279,10 @@ "STFT": [17], "Sub": [14], "Sum": [13], - "Tan": [7], + "Tan": [22], "Tanh": [13], "TfIdfVectorizer": [9], - "ThresholdedRelu": [10], + "ThresholdedRelu": [22], "Tile": [13], "TopK": [11], "Transpose": [13],