From 6ad439a351401324cf08a34ffdcb6cb0a1a83a3b Mon Sep 17 00:00:00 2001 From: mbs-octoml Date: Mon, 11 Jul 2022 16:23:34 -0700 Subject: [PATCH 1/2] [Relay] Move TOpPattern registration for nn.* to C++ Some of the Collage machinery is best tested from C++, but requires Relay ops to have their "TOpPattern" registered. However since the nn.* ops register on the Python side tests can't rely on those ops. The easy fix is to just move the registration to the RELAY_REGISTER_OP block. However since kOpaque is the default I did not preserve those registrations. There's still a few dozen more exotic ops still registered on the Python side. I've left them be. --- python/tvm/relay/op/nn/_nn.py | 72 +--------------------------------- src/relay/op/nn/bitserial.cc | 9 +++-- src/relay/op/nn/convolution.cc | 48 +++++++++++++++-------- src/relay/op/nn/correlation.cc | 3 +- src/relay/op/nn/nn.cc | 44 +++++++++++++++------ src/relay/op/nn/pooling.cc | 16 ++++++++ src/relay/op/nn/sparse.cc | 12 ++++-- 7 files changed, 97 insertions(+), 107 deletions(-) diff --git a/python/tvm/relay/op/nn/_nn.py b/python/tvm/relay/op/nn/_nn.py index 3e16cae88db1..ff213f098319 100644 --- a/python/tvm/relay/op/nn/_nn.py +++ b/python/tvm/relay/op/nn/_nn.py @@ -31,27 +31,21 @@ from .. import op as reg from .. import strategy from .._tensor import elemwise_shape_func -from ..op import OpPattern from ..strategy.generic import is_depthwise_conv2d # relu reg.register_broadcast_schedule("nn.relu") -reg.register_pattern("nn.relu", OpPattern.ELEMWISE) - # softmax reg.register_strategy("nn.softmax", strategy.softmax_strategy) -reg.register_pattern("nn.softmax", OpPattern.OUT_ELEMWISE_FUSABLE) # fast softmax reg.register_strategy("nn.fast_softmax", strategy.fast_softmax_strategy) -reg.register_pattern("nn.fast_softmax", OpPattern.OUT_ELEMWISE_FUSABLE) # log_softmax reg.register_strategy("nn.log_softmax", strategy.log_softmax_strategy) -reg.register_pattern("nn.log_softmax", OpPattern.OUT_ELEMWISE_FUSABLE) @reg.register_legalize("nn.matmul") @@ -77,7 +71,6 @@ def legalize_matmul(attrs, inputs, types): # matmul reg.register_strategy("nn.matmul", strategy.matmul_strategy) -reg.register_pattern("nn.matmul", reg.OpPattern.OUT_ELEMWISE_FUSABLE) @reg.register_legalize("nn.dense") @@ -103,7 +96,6 @@ def legalize_dense(attrs, inputs, types): # dense reg.register_strategy("nn.dense", strategy.dense_strategy) -reg.register_pattern("nn.dense", reg.OpPattern.OUT_ELEMWISE_FUSABLE) @reg.register_alter_op_layout("nn.dense") @@ -114,7 +106,6 @@ def alter_op_layout_dense(attrs, inputs, tinfos, out_type): # dense_pack reg.register_strategy("nn.contrib_dense_pack", strategy.dense_pack_strategy) -reg.register_pattern("nn.contrib_dense_pack", reg.OpPattern.OUT_ELEMWISE_FUSABLE) # fifo_buffer @@ -124,7 +115,6 @@ def compute_fifo_buffer(attrs, inputs, out_type): reg.register_injective_schedule("nn.fifo_buffer") -reg.register_pattern("nn.fifo_buffer", OpPattern.OPAQUE) @reg.register_legalize("nn.batch_matmul") @@ -150,12 +140,10 @@ def legalize_batch_matmul(attrs, inputs, types): # batch_matmul reg.register_strategy("nn.batch_matmul", strategy.batch_matmul_strategy) -reg.register_pattern("nn.batch_matmul", reg.OpPattern.OUT_ELEMWISE_FUSABLE) # batch_norm reg.register_strategy("nn.batch_norm", strategy.batch_norm_strategy) -reg.register_pattern("nn.batch_norm", reg.OpPattern.OUT_ELEMWISE_FUSABLE) # sparse_dense @@ -166,7 +154,6 @@ def compute_sparse_dense(attrs, inputs, out_type): reg.register_strategy("nn.sparse_dense", strategy.sparse_dense_strategy) -reg.register_pattern("nn.sparse_dense", reg.OpPattern.OUT_ELEMWISE_FUSABLE) @reg.register_alter_op_layout("nn.sparse_dense") @@ -177,7 +164,6 @@ def alter_op_layout_sparse_dense(attrs, inputs, tinfos, out_type): # sparse_add reg.register_strategy("nn.sparse_add", strategy.sparse_add_strategy) -reg.register_pattern("nn.sparse_add", reg.OpPattern.OPAQUE) @reg.register_compute("nn.internal.sparse_dense_padded") @@ -187,7 +173,6 @@ def compute_sparse_dense_padded(attrs, inputs, out_type): reg.register_strategy("nn.internal.sparse_dense_padded", strategy.sparse_dense_padded_strategy) -reg.register_pattern("nn.internal.sparse_dense_padded", reg.OpPattern.OUT_ELEMWISE_FUSABLE) # sparse_transpose @@ -198,7 +183,6 @@ def compute_sparse_transpose(attrs, inputs, out_type): reg.register_schedule("nn.sparse_transpose", strategy.schedule_sparse_transpose) -reg.register_pattern("nn.sparse_transpose", reg.OpPattern.OUT_ELEMWISE_FUSABLE) # sparse_conv2d @@ -213,17 +197,14 @@ def compute_sparse_conv2d(attrs, inputs, out_type): reg.register_strategy("nn.sparse_conv2d", strategy.sparse_conv2d_strategy) -reg.register_pattern("nn.sparse_conv2d", reg.OpPattern.OUT_ELEMWISE_FUSABLE) # conv1d reg.register_strategy("nn.conv1d", strategy.conv1d_strategy) -reg.register_pattern("nn.conv1d", OpPattern.OUT_ELEMWISE_FUSABLE) # conv2d reg.register_strategy("nn.conv2d", strategy.conv2d_strategy) -reg.register_pattern("nn.conv2d", OpPattern.OUT_ELEMWISE_FUSABLE) @reg.register_alter_op_layout("nn.conv2d") @@ -331,7 +312,6 @@ def convert_conv2d(attrs, inputs, tinfos, desired_layouts): # conv2d_transpose reg.register_strategy("nn.conv2d_transpose", strategy.conv2d_transpose_strategy) -reg.register_pattern("nn.conv2d_transpose", OpPattern.OUT_ELEMWISE_FUSABLE) @reg.register_legalize("nn.conv2d_transpose") @@ -400,7 +380,6 @@ def convert_conv2d_transpose(attrs, inputs, tinfos, desired_layouts): # conv3d_transpose reg.register_strategy("nn.conv3d_transpose", strategy.conv3d_transpose_strategy) -reg.register_pattern("nn.conv3d_transpose", OpPattern.OUT_ELEMWISE_FUSABLE) @reg.register_legalize("nn.conv3d_transpose") @@ -426,7 +405,6 @@ def legalize_conv3d_transpose(attrs, inputs, types): # conv3d reg.register_strategy("nn.conv3d", strategy.conv3d_strategy) -reg.register_pattern("nn.conv3d", OpPattern.OUT_ELEMWISE_FUSABLE) @reg.register_alter_op_layout("nn.conv3d") @@ -483,9 +461,6 @@ def convert_conv3d(attrs, inputs, tinfos, desired_layouts): "nn.contrib_conv3d_winograd_without_weight_transform", strategy.conv3d_winograd_without_weight_transfrom_strategy, ) -reg.register_pattern( - "nn.contrib_conv3d_winograd_without_weight_transform", OpPattern.OUT_ELEMWISE_FUSABLE -) @reg.register_compute("nn.contrib_conv3d_winograd_weight_transform") @@ -499,27 +474,22 @@ def compute_contrib_conv3d_winograd_weight_transform(attrs, inputs, out_dtype): "nn.contrib_conv3d_winograd_weight_transform", strategy.schedule_conv3d_winograd_weight_transform, ) -reg.register_pattern("nn.contrib_conv3d_winograd_weight_transform", OpPattern.OUT_ELEMWISE_FUSABLE) # conv1d_transpose reg.register_strategy("nn.conv1d_transpose", strategy.conv1d_transpose_strategy) -reg.register_pattern("nn.conv1d_transpose", OpPattern.OUT_ELEMWISE_FUSABLE) # bias_add reg.register_injective_schedule("nn.bias_add") -reg.register_pattern("nn.bias_add", OpPattern.BROADCAST) # max_pool1d reg.register_schedule("nn.max_pool1d", strategy.schedule_pool) -reg.register_pattern("nn.max_pool1d", OpPattern.OUT_ELEMWISE_FUSABLE) # max_pool2d reg.register_schedule("nn.max_pool2d", strategy.schedule_pool) -reg.register_pattern("nn.max_pool2d", OpPattern.OUT_ELEMWISE_FUSABLE) @reg.register_convert_op_layout("nn.max_pool2d") @@ -548,17 +518,14 @@ def convert_max_pool2d(attrs, inputs, tinfos, desired_layouts): # max_pool3d reg.register_schedule("nn.max_pool3d", strategy.schedule_pool) -reg.register_pattern("nn.max_pool3d", OpPattern.OUT_ELEMWISE_FUSABLE) # avg_pool1d reg.register_schedule("nn.avg_pool1d", strategy.schedule_pool) -reg.register_pattern("nn.avg_pool1d", OpPattern.OUT_ELEMWISE_FUSABLE) # avg_pool2d reg.register_schedule("nn.avg_pool2d", strategy.schedule_pool) -reg.register_pattern("nn.avg_pool2d", OpPattern.OUT_ELEMWISE_FUSABLE) @reg.register_convert_op_layout("nn.avg_pool2d") @@ -587,32 +554,26 @@ def convert_avg_pool2d(attrs, inputs, tinfos, desired_layouts): # avg_pool3d reg.register_schedule("nn.avg_pool3d", strategy.schedule_pool) -reg.register_pattern("nn.avg_pool3d", OpPattern.OUT_ELEMWISE_FUSABLE) # max_pool2d_grad reg.register_schedule("nn.max_pool2d_grad", strategy.schedule_pool_grad) -reg.register_pattern("nn.max_pool2d_grad", OpPattern.OUT_ELEMWISE_FUSABLE) # avg_pool2d_grad reg.register_schedule("nn.avg_pool2d_grad", strategy.schedule_pool_grad) -reg.register_pattern("nn.avg_pool2d_grad", OpPattern.OUT_ELEMWISE_FUSABLE) # adaptive_max_pool1d reg.register_schedule("nn.adaptive_max_pool1d", strategy.schedule_adaptive_pool) -reg.register_pattern("nn.adaptive_max_pool1d", OpPattern.OUT_ELEMWISE_FUSABLE) # adaptive_avg_pool1d reg.register_schedule("nn.adaptive_avg_pool1d", strategy.schedule_adaptive_pool) -reg.register_pattern("nn.adaptive_avg_pool1d", OpPattern.OUT_ELEMWISE_FUSABLE) # global_max_pool2d reg.register_schedule("nn.global_max_pool2d", strategy.schedule_adaptive_pool) -reg.register_pattern("nn.global_max_pool2d", OpPattern.OUT_ELEMWISE_FUSABLE) @reg.register_convert_op_layout("nn.global_max_pool2d") @@ -641,7 +602,6 @@ def convert_global_max_pool2d(attrs, inputs, tinfos, desired_layouts): # global_avg_pool2d reg.register_schedule("nn.global_avg_pool2d", strategy.schedule_adaptive_pool) -reg.register_pattern("nn.global_avg_pool2d", OpPattern.OUT_ELEMWISE_FUSABLE) @reg.register_convert_op_layout("nn.global_avg_pool2d") @@ -670,37 +630,30 @@ def convert_global_avg_pool2d(attrs, inputs, tinfos, desired_layouts): # adaptive_max_pool2d reg.register_schedule("nn.adaptive_max_pool2d", strategy.schedule_adaptive_pool) -reg.register_pattern("nn.adaptive_max_pool2d", OpPattern.OUT_ELEMWISE_FUSABLE) # adaptive_avg_pool2d reg.register_schedule("nn.adaptive_avg_pool2d", strategy.schedule_adaptive_pool) -reg.register_pattern("nn.adaptive_avg_pool2d", OpPattern.OUT_ELEMWISE_FUSABLE) # adaptive_max_pool3d reg.register_schedule("nn.adaptive_max_pool3d", strategy.schedule_adaptive_pool) -reg.register_pattern("nn.adaptive_max_pool3d", OpPattern.OUT_ELEMWISE_FUSABLE) # adaptive_avg_pool3d reg.register_schedule("nn.adaptive_avg_pool3d", strategy.schedule_adaptive_pool) -reg.register_pattern("nn.adaptive_avg_pool3d", OpPattern.OUT_ELEMWISE_FUSABLE) # leaky_relu reg.register_broadcast_schedule("nn.leaky_relu") -reg.register_pattern("nn.leaky_relu", OpPattern.ELEMWISE) # prelu reg.register_broadcast_schedule("nn.prelu") -reg.register_pattern("nn.prelu", OpPattern.BROADCAST) # flatten reg.register_broadcast_schedule("nn.batch_flatten") -reg.register_pattern("nn.batch_flatten", OpPattern.INJECTIVE) # lrn @@ -712,7 +665,6 @@ def compute_lrn(attrs, inputs, out_dtype): reg.register_schedule("nn.lrn", strategy.schedule_lrn) -reg.register_pattern("nn.lrn", OpPattern.OPAQUE) # upsampling @@ -783,18 +735,13 @@ def mirror_pad_func(attrs, inputs, _): "nn.contrib_conv2d_winograd_without_weight_transform", strategy.conv2d_winograd_without_weight_transfrom_strategy, ) -reg.register_pattern( - "nn.contrib_conv2d_winograd_without_weight_transform", OpPattern.OUT_ELEMWISE_FUSABLE -) + # conv2d_gemm related operators reg.register_strategy( "nn.contrib_conv2d_gemm_without_weight_transform", strategy.conv2d_gemm_without_weight_transform_strategy, ) -reg.register_pattern( - "nn.contrib_conv2d_gemm_without_weight_transform", OpPattern.OUT_ELEMWISE_FUSABLE -) @reg.register_compute("nn.contrib_conv2d_gemm_weight_transform") @@ -807,7 +754,6 @@ def compute_contrib_conv2d_gemm_weight_transform(attrs, inputs, out_dtype): reg.register_schedule( "nn.contrib_conv2d_gemm_weight_transform", strategy.schedule_conv2d_gemm_weight_transform ) -reg.register_pattern("nn.contrib_conv2d_gemm_weight_transform", OpPattern.OUT_ELEMWISE_FUSABLE) @reg.register_compute("nn.contrib_conv2d_winograd_weight_transform") @@ -821,7 +767,6 @@ def compute_contrib_conv2d_winograd_weight_transform(attrs, inputs, out_dtype): "nn.contrib_conv2d_winograd_weight_transform", strategy.schedule_conv2d_winograd_weight_transform, ) -reg.register_pattern("nn.contrib_conv2d_winograd_weight_transform", OpPattern.OUT_ELEMWISE_FUSABLE) @reg.register_compute("nn.contrib_conv2d_winograd_nnpack_weight_transform") @@ -838,21 +783,17 @@ def compute_contrib_conv2d_winograd_nnpack_weight_transform(attrs, inputs, out_d "nn.contrib_conv2d_winograd_nnpack_weight_transform", strategy.schedule_conv2d_winograd_nnpack_weight_transform, ) -reg.register_pattern("nn.contrib_conv2d_winograd_nnpack_weight_transform", OpPattern.OPAQUE) # conv2d_NCHWc reg.register_strategy("nn.contrib_conv2d_NCHWc", strategy.conv2d_NCHWc_strategy) -reg.register_pattern("nn.contrib_conv2d_NCHWc", OpPattern.OUT_ELEMWISE_FUSABLE) # depthwise_conv2d_NCHWc reg.register_strategy("nn.contrib_depthwise_conv2d_NCHWc", strategy.depthwise_conv2d_NCHWc_strategy) -reg.register_pattern("nn.contrib_depthwise_conv2d_NCHWc", OpPattern.OUT_ELEMWISE_FUSABLE) # deformable_conv2d reg.register_strategy("nn.deformable_conv2d", strategy.deformable_conv2d_strategy) -reg.register_pattern("nn.deformable_conv2d", OpPattern.OUT_ELEMWISE_FUSABLE) @reg.register_alter_op_layout("nn.deformable_conv2d") @@ -950,12 +891,10 @@ def compute_bitpack(attrs, inputs, out_dtype): reg.register_schedule("nn.bitpack", strategy.schedule_bitpack) -reg.register_pattern("nn.bitpack", OpPattern.INJECTIVE) # bitserial_conv2d reg.register_strategy("nn.bitserial_conv2d", strategy.bitserial_conv2d_strategy) -reg.register_pattern("nn.bitserial_conv2d", OpPattern.OUT_ELEMWISE_FUSABLE) @reg.register_legalize("nn.bitserial_conv2d") @@ -981,7 +920,6 @@ def legalize_bitserial_conv2d(attrs, inputs, types): # bitserial_dense reg.register_strategy("nn.bitserial_dense", strategy.bitserial_dense_strategy) -reg.register_pattern("nn.bitserial_dense", reg.OpPattern.OUT_ELEMWISE_FUSABLE) # cross_entropy @@ -992,7 +930,6 @@ def compute_cross_entropy(attrs, inputs, out_dtype): reg.register_reduce_schedule("nn.cross_entropy") -reg.register_pattern("nn.cross_entropy", OpPattern.OPAQUE) # dilate @@ -1002,7 +939,6 @@ def compute_dilate(attrs, inputs, out_dtype): reg.register_broadcast_schedule("nn.dilate") -reg.register_pattern("nn.dilate", OpPattern.INJECTIVE) # cross_entropy_with_logits @@ -1013,7 +949,6 @@ def compute_cross_entropy_with_logits(attrs, inputs, out_dtype): reg.register_reduce_schedule("nn.cross_entropy_with_logits") -reg.register_pattern("nn.cross_entropy_with_logits", OpPattern.OPAQUE) # nll_loss @@ -1024,7 +959,6 @@ def compute_nll_loss(attrs, inputs, out_dtype): reg.register_reduce_schedule("nn.nll_loss") -reg.register_pattern("nn.nll_loss", OpPattern.OUT_ELEMWISE_FUSABLE) # depth_to_space @@ -1037,7 +971,6 @@ def compute_depth_to_space(attrs, inputs, out_dtype): reg.register_injective_schedule("nn.depth_to_space") -reg.register_pattern("nn.depth_to_space", OpPattern.INJECTIVE) # space_to_depth @@ -1049,12 +982,10 @@ def compute_space_to_depth(attrs, inputs, out_dtype): reg.register_injective_schedule("nn.space_to_depth") -reg.register_pattern("nn.space_to_depth", OpPattern.INJECTIVE) # correlation reg.register_strategy("nn.correlation", strategy.correlation_strategy) -reg.register_pattern("nn.correlation", OpPattern.OUT_ELEMWISE_FUSABLE) # space_to_batch_nd and batch_to_space_nd @@ -1063,7 +994,6 @@ def compute_space_to_depth(attrs, inputs, out_dtype): reg.register_strategy("nn.conv2d_backward_weight", strategy.conv2d_backward_weight_strategy) -reg.register_pattern("nn.conv2d_backward_weight", OpPattern.OUT_ELEMWISE_FUSABLE) @reg.register_legalize("nn.conv2d_backward_weight") diff --git a/src/relay/op/nn/bitserial.cc b/src/relay/op/nn/bitserial.cc index ddb582043ddb..496aa3514d88 100644 --- a/src/relay/op/nn/bitserial.cc +++ b/src/relay/op/nn/bitserial.cc @@ -113,7 +113,8 @@ efficient implementation of bitserial operations. .set_attrs_type() .add_argument("data", "Tensor", "Input data.") .set_support_level(2) - .add_type_rel("BitPack", BitPackRel); + .add_type_rel("BitPack", BitPackRel) + .set_attr("TOpPattern", kInjective); // relay.nn.bitserial_conv2d TVM_REGISTER_NODE_TYPE(BinaryConv2DAttrs); @@ -192,7 +193,8 @@ on some platforms. .set_support_level(2) .add_type_rel("BinaryConv2D", BinaryConv2DRel) .set_attr("FInferCorrectLayout", - BinaryConv2DInferCorrectLayout); + BinaryConv2DInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable); // relay.nn.bitserial_dense TVM_REGISTER_NODE_TYPE(BinaryDenseAttrs); @@ -251,7 +253,8 @@ RELAY_REGISTER_OP("nn.bitserial_dense") .add_argument("data", "2D Tensor", "Input data.") .add_argument("weight", "2D Tensor", "Weight matrix.") .set_support_level(1) - .add_type_rel("BinaryDense", BinaryDenseRel); + .add_type_rel("BinaryDense", BinaryDenseRel) + .set_attr("TOpPattern", kOutEWiseFusable); } // namespace relay } // namespace tvm diff --git a/src/relay/op/nn/convolution.cc b/src/relay/op/nn/convolution.cc index de14d059df83..a807c2f83072 100644 --- a/src/relay/op/nn/convolution.cc +++ b/src/relay/op/nn/convolution.cc @@ -173,7 +173,8 @@ with the layer input to produce a tensor of outputs. .add_argument("weight", "Tensor", "The weight tensor.") .set_support_level(2) .add_type_rel("Conv1D", Conv1DRel) - .set_attr("FInferCorrectLayout", ConvInferCorrectLayout); + .set_attr("FInferCorrectLayout", ConvInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable); // relay.nn.conv2d TVM_REGISTER_NODE_TYPE(Conv2DAttrs); @@ -404,7 +405,8 @@ with the layer input to produce a tensor of outputs. .add_argument("weight", "Tensor", "The weight tensor.") .set_support_level(2) .add_type_rel("Conv2D", Conv2DRel) - .set_attr("FInferCorrectLayout", ConvInferCorrectLayout); + .set_attr("FInferCorrectLayout", ConvInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable); // relay.nn.conv3d TVM_REGISTER_NODE_TYPE(Conv3DAttrs); @@ -577,7 +579,8 @@ with the layer input to produce a tensor of outputs. .add_argument("weight", "Tensor", "The weight tensor.") .set_support_level(2) .add_type_rel("Conv3D", Conv3DRel) - .set_attr("FInferCorrectLayout", ConvInferCorrectLayout); + .set_attr("FInferCorrectLayout", ConvInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable); // relay.nn.conv3d_transpose TVM_REGISTER_NODE_TYPE(Conv3DTransposeAttrs); @@ -738,7 +741,8 @@ said convolution. .set_support_level(2) .set_attr("FInferCorrectLayout", ConvInferCorrectLayout) - .add_type_rel("Conv3DTranspose", Conv3DTransposeRel); + .add_type_rel("Conv3DTranspose", Conv3DTransposeRel) + .set_attr("TOpPattern", kOutEWiseFusable); // relay.nn.conv2d_transpose TVM_REGISTER_NODE_TYPE(Conv2DTransposeAttrs); @@ -906,7 +910,8 @@ v (batch_size, channels, out_height, out_width) if `layout` is `NCHW` .set_support_level(2) .set_attr("FInferCorrectLayout", ConvInferCorrectLayout) - .add_type_rel("Conv2DTranspose", Conv2DTransposeRel); + .add_type_rel("Conv2DTranspose", Conv2DTransposeRel) + .set_attr("TOpPattern", kOutEWiseFusable); // relay.nn.conv1d_transpose TVM_REGISTER_NODE_TYPE(Conv1DTransposeAttrs); @@ -1042,7 +1047,8 @@ said convolution. .add_argument("data", "Tensor", "The input tensor.") .add_argument("weight", "Tensor", "The weight tensor.") .set_support_level(2) - .add_type_rel("Conv1DTranspose", Conv1DTransposeRel); + .add_type_rel("Conv1DTranspose", Conv1DTransposeRel) + .set_attr("TOpPattern", kOutEWiseFusable); // relay.nn.contrib_conv2d_winograd_without_weight_transform TVM_REGISTER_NODE_TYPE(Conv2DWinogradAttrs); @@ -1077,7 +1083,8 @@ RELAY_REGISTER_OP("nn.contrib_conv2d_winograd_without_weight_transform") .set_support_level(10) .add_type_rel("Conv2DWinograd", Conv2DWinogradRel) .set_attr("FInferCorrectLayout", - ConvInferCorrectLayout); + ConvInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable); // relay.nn.contrib_conv2d_winograd_weight_transform TVM_REGISTER_NODE_TYPE(ConvWinogradWeightTransformAttrs); @@ -1122,7 +1129,8 @@ weight transformation in advance. .set_num_inputs(1) .add_argument("weight", "Tensor", "The weight tensor.") .set_support_level(10) - .add_type_rel("Conv2DWinogradWeightTransform", Conv2DWinogradWeightTransformRel); + .add_type_rel("Conv2DWinogradWeightTransform", Conv2DWinogradWeightTransformRel) + .set_attr("TOpPattern", kOutEWiseFusable); // relay.nn.contrib_conv3d_winograd_without_weight_transform TVM_REGISTER_NODE_TYPE(Conv3DWinogradAttrs); @@ -1239,7 +1247,8 @@ RELAY_REGISTER_OP("nn.contrib_conv3d_winograd_without_weight_transform") .set_support_level(10) .add_type_rel("Conv3DWinograd", Conv3DWinogradRel) .set_attr("FInferCorrectLayout", - ConvInferCorrectLayout); + ConvInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable); // relay.nn.contrib_conv3d_winograd_weight_transform TVM_REGISTER_GLOBAL("relay.op.nn._make.contrib_conv3d_winograd_weight_transform") @@ -1289,7 +1298,8 @@ weight transformation in advance. .set_num_inputs(1) .add_argument("weight", "Tensor", "The weight tensor.") .set_support_level(10) - .add_type_rel("Conv3DWinogradWeightTransform", Conv3DWinogradWeightTransformRel); + .add_type_rel("Conv3DWinogradWeightTransform", Conv3DWinogradWeightTransformRel) + .set_attr("TOpPattern", kOutEWiseFusable); // relay.nn.contrib_conv2d_winograd_nnpack_weight_transform TVM_REGISTER_NODE_TYPE(Conv2DWinogradNNPACKWeightTransformAttrs); @@ -1449,7 +1459,8 @@ RELAY_REGISTER_OP("nn.contrib_conv2d_gemm_without_weight_transform") .add_argument("weight", "Tensor", "The weight tensor.") .set_support_level(10) .add_type_rel("Conv2DGemm", Conv2DGemmRel) - .set_attr("FInferCorrectLayout", ConvInferCorrectLayout); + .set_attr("FInferCorrectLayout", ConvInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable); // relay.nn.contrib_conv2d_gemm_weight_transform @@ -1531,7 +1542,8 @@ weight transformation in advance. .set_num_inputs(1) .add_argument("weights", "Tensor", "The weights tensor.") .set_support_level(10) - .add_type_rel("Conv2DGemmWeightTransform", Conv2DGemmWeightTransformRel); + .add_type_rel("Conv2DGemmWeightTransform", Conv2DGemmWeightTransformRel) + .set_attr("TOpPattern", kOutEWiseFusable); // Positional relay function to create conv2d NCHWc operator // used by frontend FFI. @@ -1558,7 +1570,8 @@ RELAY_REGISTER_OP("nn.contrib_conv2d_NCHWc") .add_argument("weight", "Tensor", "The weight tensor.") .set_support_level(10) .add_type_rel("Conv2DNCHWc", Conv2DWinogradRel) - .set_attr("FInferCorrectLayout", ConvInferCorrectLayout); + .set_attr("FInferCorrectLayout", ConvInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable); // Positional relay function to create depthwise conv2d NCHWc operator // used by frontend FFI. @@ -1585,7 +1598,8 @@ RELAY_REGISTER_OP("nn.contrib_depthwise_conv2d_NCHWc") .add_argument("weight", "Tensor", "The weight tensor.") .set_support_level(10) .add_type_rel("Conv2D", Conv2DRel) - .set_attr("FInferCorrectLayout", ConvInferCorrectLayout); + .set_attr("FInferCorrectLayout", ConvInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable); TVM_REGISTER_NODE_TYPE(DeformableConv2DAttrs); @@ -1738,7 +1752,8 @@ by concating all the *g* results. .add_argument("weight", "Tensor", "The weight tensor.") .set_support_level(5) .add_type_rel("DeformableConv2D", DeformableConv2DRel) - .set_attr("FInferCorrectLayout", DeformableConvInferCorrectLayout); + .set_attr("FInferCorrectLayout", DeformableConvInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable); // Positional relay function to create deformable_conv2d operator // used by frontend FFI. @@ -1858,7 +1873,8 @@ given the original input data and the output gradient. .add_argument("data", "Tensor", "The input tensor.") .set_support_level(2) .add_type_rel("Conv2DBackwardWeight", Conv2DBackwardWeightRel) - .set_attr("FInferCorrectLayout", ConvInferCorrectLayout); + .set_attr("FInferCorrectLayout", ConvInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable); } // namespace relay } // namespace tvm diff --git a/src/relay/op/nn/correlation.cc b/src/relay/op/nn/correlation.cc index 51b2eb55db7a..8abc9909e83c 100644 --- a/src/relay/op/nn/correlation.cc +++ b/src/relay/op/nn/correlation.cc @@ -129,7 +129,8 @@ where :math:`i` and :math:`j` enumerate spatial locations in :math:`f_{1}`, and .add_argument("data2", "Tensor", "Input data2 to the correlation.") .set_support_level(2) .set_attr("FInferCorrectLayout", CorrelationInferCorrectLayout) - .add_type_rel("Correlation", CorrelationRel); + .add_type_rel("Correlation", CorrelationRel) + .set_attr("TOpPattern", kOutEWiseFusable); } // namespace relay } // namespace tvm diff --git a/src/relay/op/nn/nn.cc b/src/relay/op/nn/nn.cc index e3e3bfbb973e..9e4b6fc8bb4a 100644 --- a/src/relay/op/nn/nn.cc +++ b/src/relay/op/nn/nn.cc @@ -95,6 +95,7 @@ RELAY_REGISTER_OP("nn.bias_add") .add_argument("bias", "1D Tensor", "Bias.") .set_support_level(1) .add_type_rel("BiasAdd", BiasAddRel) + .set_attr("TOpPattern", kBroadcast) .set_attr("FTVMCompute", [](const Attrs& attrs, const Array& inputs, const Type& out_type) { const auto* param = attrs.as(); @@ -191,7 +192,9 @@ RELAY_REGISTER_OP("nn.matmul") .add_argument("tensor_a", "nD Tensor", "The first input Tensor.") .add_argument("tensor_b", "2D Tensor", "The second input Tensor.") .set_support_level(1) - .add_type_rel("Matmul", MatmulRel); + .add_type_rel("Matmul", MatmulRel) + .set_attr("TOpPattern", kOutEWiseFusable); + // ------------------- relay.nn.matmul // ------------------- relay.nn.dense @@ -229,7 +232,8 @@ RELAY_REGISTER_OP("nn.dense") .add_argument("weight", "2D Tensor", "Weight matrix.") .set_support_level(1) .set_attr("FInferCorrectLayout", DenseInferCorrectLayout) - .add_type_rel("Dense", MatmulRel); + .add_type_rel("Dense", MatmulRel) + .set_attr("TOpPattern", kOutEWiseFusable); // ------------------- relay.nn.dense // ------------------- relay.nn.contrib_dense_pack @@ -296,7 +300,9 @@ RELAY_REGISTER_OP("nn.contrib_dense_pack") .add_argument("weight", "3D Tensor", "Packed weight matrix.") .set_support_level(10) .set_attr("FInferCorrectLayout", DensePackInferCorrectLayout) - .add_type_rel("DensePack", DensePackRel); + .add_type_rel("DensePack", DensePackRel) + .set_attr("TOpPattern", kOutEWiseFusable); + // ------------------- relay.nn.contrib_dense_pack // relay.leaky_relu @@ -324,6 +330,7 @@ RELAY_REGISTER_OP("nn.leaky_relu") .set_support_level(3) .add_type_rel("Identity", IdentityRel) .set_attr("FInferCorrectLayout", ElemwiseArbitraryLayout) + .set_attr("TOpPattern", kElemWise) .set_attr("FTVMCompute", [](const Attrs& attrs, const Array& inputs, const Type& out_type) { const auto* param = attrs.as(); @@ -390,6 +397,7 @@ where :math:`*` is an channelwise multiplication for each sample in the batch. .set_support_level(3) .add_type_rel("PRelu", PReluRel) .set_attr("FInferCorrectLayout", PReluInferCorrectLayout) + .set_attr("TOpPattern", kBroadcast) .set_attr("FTVMCompute", [](const Attrs& attrs, const Array& inputs, const Type& out_type) { const auto* param = attrs.as(); @@ -441,7 +449,8 @@ RELAY_REGISTER_OP("nn.softmax") .set_num_inputs(1) .add_argument("data", "Tensor", "The input tensor.") .set_support_level(1) - .add_type_rel("Softmax", SoftmaxRel); + .add_type_rel("Softmax", SoftmaxRel) + .set_attr("TOpPattern", kOutEWiseFusable); // relay.fast_softmax TVM_REGISTER_NODE_TYPE(SoftmaxAttrs); @@ -468,7 +477,8 @@ RELAY_REGISTER_OP("nn.fast_softmax") .set_num_inputs(1) .add_argument("data", "Tensor", "The input tensor.") .set_support_level(1) - .add_type_rel("Softmax", SoftmaxRel); + .add_type_rel("Softmax", SoftmaxRel) + .set_attr("TOpPattern", kOutEWiseFusable); // relay.nn.log_softmax TVM_REGISTER_GLOBAL("relay.op.nn._make.log_softmax").set_body_typed([](Expr data, int axis) { @@ -493,6 +503,7 @@ RELAY_REGISTER_OP("nn.log_softmax") .add_argument("data", "Tensor", "The input tensor.") .set_support_level(1) .add_type_rel("Softmax", SoftmaxRel) + .set_attr("TOpPattern", kOutEWiseFusable) .set_attr("FTVMCompute", [](const Attrs& attrs, const Array& inputs, const Type& out_type) { const auto* param = attrs.as(); @@ -561,6 +572,7 @@ Example:: .add_argument("data", "Tensor", "The input tensor.") .set_support_level(2) .add_type_rel("BatchFlatten", BatchFlattenRel) + .set_attr("TOpPattern", kInjective) .set_attr("FTVMCompute", [](const Attrs& attrs, const Array& inputs, const Type& out_type) { @@ -586,6 +598,7 @@ RELAY_REGISTER_OP("nn.relu") .set_support_level(1) .add_type_rel("Identity", IdentityRel) .set_attr("FInferCorrectLayout", ElemwiseArbitraryLayout) + .set_attr("TOpPattern", kElemWise) .set_attr("FTVMCompute", [](const Attrs& attrs, const Array& inputs, const Type& out_type) { return Array{topi::relu(inputs[0], 0.0f)}; @@ -693,8 +706,8 @@ The whole array is rescaled by ``1/(1-p)`` to keep the expected sum of the input .set_num_inputs(1) .add_argument("data", "Tensor", "Input to which dropout will be applied.") .set_support_level(1) - .set_attr("TOpPattern", kOpaque) .set_attr("FInferCorrectLayout", ElemwiseArbitraryLayout) + .set_attr("TOpPattern", kOpaque) .add_type_rel("Dropout", DropoutRel) .set_attr("TOpIsStateful", true); @@ -826,7 +839,8 @@ axis to be the last item in the input shape. .add_argument("moving_var", "Tensor", "Running variance of input.") .set_attr("FInferCorrectLayout", BatchNormInferCorrectLayout) .set_support_level(1) - .add_type_rel("BatchNorm", BatchNormRel); + .add_type_rel("BatchNorm", BatchNormRel) + .set_attr("TOpPattern", kOutEWiseFusable); // instance_norm TVM_REGISTER_NODE_TYPE(InstanceNormAttrs); @@ -1077,7 +1091,9 @@ Both `tensor_a` and `tensor_b` can be transposed. For legacy reason, we use NT f .add_argument("tensor_a", "3D Tensor", "The first input.") .add_argument("tensor_b", "3D Tensor", "The second input.") .set_support_level(10) - .add_type_rel("BatchMatmul", BatchMatmulRel); + .add_type_rel("BatchMatmul", BatchMatmulRel) + .set_attr("TOpPattern", kOutEWiseFusable); + // ------------------- relay.nn.batch_matmul // relay.nn.cross_entropy @@ -1165,7 +1181,8 @@ Dilate data with given dilation value (0 by default). .set_num_inputs(1) .add_argument("x", "1D Tensor", "Data to dilate.") .set_support_level(10) - .add_type_rel("Dilate", DilateRel); + .add_type_rel("Dilate", DilateRel) + .set_attr("TOpPattern", kInjective); // relay.nn.cross_entropy_with_logits // Positional relay function to create cross_entropy_with_logits operator used by frontend FFI. @@ -1269,7 +1286,8 @@ Negative log likelihood loss for given prediction and target. .add_argument("predictions", "Tensor", "The prediction tensor.") .add_argument("targets", "Tensor", "The target tensor.") .add_argument("weights", "Tensor", "The weight of each target values.") - .add_type_rel("NLLLoss", NLLLossRel); + .add_type_rel("NLLLoss", NLLLossRel) + .set_attr("TOpPattern", kOutEWiseFusable); bool DepthToSpaceRel(const Array& types, int num_inputs, const Attrs& attrs, const TypeReporter& reporter) { @@ -1332,7 +1350,8 @@ RELAY_REGISTER_OP("nn.depth_to_space") .set_num_inputs(1) .add_argument("data", "Tensor", "The input tensor") .set_support_level(5) - .add_type_rel("DepthToSpace", DepthToSpaceRel); + .add_type_rel("DepthToSpace", DepthToSpaceRel) + .set_attr("TOpPattern", kInjective); bool SpaceToDepthRel(const Array& types, int num_inputs, const Attrs& attrs, const TypeReporter& reporter) { @@ -1394,7 +1413,8 @@ RELAY_REGISTER_OP("nn.space_to_depth") .set_num_inputs(1) .add_argument("data", "Tensor", "The input tensor") .set_support_level(5) - .add_type_rel("SpaceToDepth", SpaceToDepthRel); + .add_type_rel("SpaceToDepth", SpaceToDepthRel) + .set_attr("TOpPattern", kInjective); // Positional relay function to create SpaceToBatchND operator // used by frontend FFI diff --git a/src/relay/op/nn/pooling.cc b/src/relay/op/nn/pooling.cc index cf44b308ce02..c56039f13ba3 100644 --- a/src/relay/op/nn/pooling.cc +++ b/src/relay/op/nn/pooling.cc @@ -216,6 +216,7 @@ RELAY_REGISTER_OP("nn.max_pool2d") .set_support_level(2) .add_type_rel("MaxPool2D", Pool2DRel) .set_attr("FInferCorrectLayout", PoolInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable) .set_attr("FTVMCompute", Pool2DCompute); // AvgPool2D @@ -255,6 +256,7 @@ Average pooling operation for one dimensional data. .set_support_level(2) .add_type_rel("AvgPool2D", Pool2DRel) .set_attr("FInferCorrectLayout", PoolInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable) .set_attr("FTVMCompute", Pool2DCompute); // relay.nn.global_pool_2d & relay.nn.max_pool_2d @@ -335,6 +337,7 @@ RELAY_REGISTER_OP("nn.global_avg_pool2d") .set_support_level(2) .add_type_rel("GlobalAvgPool2D", GlobalPool2DRel) .set_attr("FInferCorrectLayout", PoolInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable) .set_attr("FTVMCompute", GlobalPool2DCompute); // GlobalMaxPool @@ -363,6 +366,7 @@ RELAY_REGISTER_OP("nn.global_max_pool2d") .set_support_level(2) .add_type_rel("GlobalMaxPool2D", GlobalPool2DRel) .set_attr("FInferCorrectLayout", PoolInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable) .set_attr("FTVMCompute", GlobalPool2DCompute); // relay.nn.adaptive_pool_1d @@ -463,6 +467,7 @@ RELAY_REGISTER_OP("nn.adaptive_avg_pool1d") .add_type_rel("AdaptiveAvgPool1D", AdaptivePool1DRel) .set_attr("FInferCorrectLayout", PoolInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable) .set_attr("FTVMCompute", AdaptivePool1DCompute); // relay.nn.adaptive_max_pool1d @@ -498,6 +503,7 @@ RELAY_REGISTER_OP("nn.adaptive_max_pool1d") .add_type_rel("AdaptiveMaxPool1D", AdaptivePool1DRel) .set_attr("FInferCorrectLayout", PoolInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable) .set_attr("FTVMCompute", AdaptivePool1DCompute); // relay.nn.adaptive_pool_2d @@ -617,6 +623,7 @@ RELAY_REGISTER_OP("nn.adaptive_avg_pool2d") .add_type_rel("AdaptiveAvgPool2D", AdaptivePool2DRel) .set_attr("FInferCorrectLayout", PoolInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable) .set_attr("FTVMCompute", AdaptivePool2DCompute); // relay.nn.adaptive_max_pool2d @@ -654,6 +661,7 @@ RELAY_REGISTER_OP("nn.adaptive_max_pool2d") .add_type_rel("AdaptiveMaxPool2D", AdaptivePool2DRel) .set_attr("FInferCorrectLayout", PoolInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable) .set_attr("FTVMCompute", AdaptivePool2DCompute); // relay.nn.adaptive_pool3d @@ -788,6 +796,7 @@ RELAY_REGISTER_OP("nn.adaptive_max_pool3d") .add_type_rel("AdaptiveMaxPool3D", AdaptivePool3DRel) .set_attr("FInferCorrectLayout", PoolInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable) .set_attr("FTVMCompute", AdaptivePool3DCompute); // relay.nn.adaptive_max_pool3d @@ -823,6 +832,7 @@ RELAY_REGISTER_OP("nn.adaptive_avg_pool3d") .add_type_rel("AdaptiveAvgPool3D", AdaptivePool3DRel) .set_attr("FInferCorrectLayout", PoolInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable) .set_attr("FTVMCompute", AdaptivePool3DCompute); bool Pool2DGradRel(const Array& types, int num_inputs, const Attrs& attrs, @@ -930,6 +940,7 @@ RELAY_REGISTER_OP("nn.max_pool2d_grad") .add_argument("grad", "Tensor", "The grad tensor.") .set_support_level(2) .add_type_rel("MaxPool2DGrad", Pool2DGradRel) + .set_attr("TOpPattern", kOutEWiseFusable) .set_attr("FTVMCompute", Pool2DGradCompute); // AvgPool2DGrad @@ -979,6 +990,7 @@ RELAY_REGISTER_OP("nn.avg_pool2d_grad") .add_argument("grad", "Tensor", "The grad tensor.") .set_support_level(2) .add_type_rel("MaxPool2DGrad", Pool2DGradRel) + .set_attr("TOpPattern", kOutEWiseFusable) .set_attr("FTVMCompute", Pool2DGradCompute); // relay.nn.max_pool1d & relay.nn.avg_pool1d @@ -1101,6 +1113,7 @@ RELAY_REGISTER_OP("nn.max_pool1d") .set_support_level(2) .add_type_rel("MaxPool1D", Pool1DRel) .set_attr("FInferCorrectLayout", PoolInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable) .set_attr("FTVMCompute", Pool1DCompute); // AvgPool1D @@ -1138,6 +1151,7 @@ Average pooling operation for one dimensional data. .set_support_level(2) .add_type_rel("AvgPool1D", Pool1DRel) .set_attr("FInferCorrectLayout", PoolInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable) .set_attr("FTVMCompute", Pool1DCompute); // relay.nn.max_pool3d & relay.nn.avg_pool3d @@ -1291,6 +1305,7 @@ RELAY_REGISTER_OP("nn.max_pool3d") .set_support_level(2) .add_type_rel("MaxPool3D", Pool3DRel) .set_attr("FInferCorrectLayout", PoolInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable) .set_attr("FTVMCompute", Pool3DCompute); // AvgPool3D @@ -1331,6 +1346,7 @@ Average pooling operation for three dimensional data. .set_support_level(2) .add_type_rel("AvgPool3D", Pool3DRel) .set_attr("FInferCorrectLayout", PoolInferCorrectLayout) + .set_attr("TOpPattern", kOutEWiseFusable) .set_attr("FTVMCompute", Pool3DCompute); } // namespace relay diff --git a/src/relay/op/nn/sparse.cc b/src/relay/op/nn/sparse.cc index 7d21005cb4db..ebef7e21de7d 100644 --- a/src/relay/op/nn/sparse.cc +++ b/src/relay/op/nn/sparse.cc @@ -120,7 +120,8 @@ RELAY_REGISTER_OP("nn.sparse_dense") .add_argument("sparse_indices", "1D Tensor", "Sparse indices matrix.") .add_argument("sparse_indptr", "1D Tensor", "Sparse indptr matrix.") .set_support_level(1) - .add_type_rel("SparseDense", SparseDenseRel); + .add_type_rel("SparseDense", SparseDenseRel) + .set_attr("TOpPattern", kOutEWiseFusable); Expr MakeSparseDensePadded(Expr data, Expr weight_data, Expr weight_indices, Expr weight_indptr) { auto attrs = make_object(); @@ -151,7 +152,8 @@ which will be converted to this op when running on the GPU. .add_argument("weight_indices", "1D Tensor", "Weight indices matrix.") .add_argument("weight_indptr", "1D Tensor", "Weight indptr matrix.") .set_support_level(1) - .add_type_rel("SparseDense", SparseDenseRel); + .add_type_rel("SparseDense", SparseDenseRel) + .set_attr("TOpPattern", kOutEWiseFusable); // relay.nn.sparse_transpose TVM_REGISTER_NODE_TYPE(SparseTransposeAttrs); @@ -195,7 +197,8 @@ RELAY_REGISTER_OP("nn.sparse_transpose") .add_argument("sparse_indices", "1D Tensor", "Sparse indices matrix.") .add_argument("sparse_indptr", "1D Tensor", "Sparse index pointer matrix.") .set_support_level(1) - .add_type_rel("SparseTranspose", SparseTransposeRel); + .add_type_rel("SparseTranspose", SparseTransposeRel) + .set_attr("TOpPattern", kOutEWiseFusable); // relay.nn.sparse_add bool SparseAddRel(const Array& types, int num_inputs, const Attrs& attrs, @@ -300,7 +303,8 @@ RELAY_REGISTER_OP("nn.sparse_conv2d") .add_argument("sparse_indices", "1D Tensor", "Sparse indices matrix.") .add_argument("sparse_indptr", "1D Tensor", "Sparse indptr matrix.") .set_support_level(1) - .add_type_rel("SparseConv2d", SparseConv2dRel); + .add_type_rel("SparseConv2d", SparseConv2dRel) + .set_attr("TOpPattern", kOutEWiseFusable); } // namespace relay } // namespace tvm From 3063b76e45601e34af6d2e82c34b199aa73ee964 Mon Sep 17 00:00:00 2001 From: mbs-octoml Date: Tue, 12 Jul 2022 12:04:19 -0700 Subject: [PATCH 2/2] - D'oh! Even kOpaque ops must be registered. --- src/relay/op/nn/convolution.cc | 3 ++- src/relay/op/nn/nn.cc | 12 ++++++++---- src/relay/op/nn/sparse.cc | 3 ++- 3 files changed, 12 insertions(+), 6 deletions(-) diff --git a/src/relay/op/nn/convolution.cc b/src/relay/op/nn/convolution.cc index a807c2f83072..dabb1899713f 100644 --- a/src/relay/op/nn/convolution.cc +++ b/src/relay/op/nn/convolution.cc @@ -1357,7 +1357,8 @@ weight transformation in advance. .set_num_inputs(1) .add_argument("weight", "Tensor", "The weight tensor.") .set_support_level(10) - .add_type_rel("Conv2DWinogradNNPACKWeightTransform", Conv2DWinogradNNPACKWeightTransformRel); + .add_type_rel("Conv2DWinogradNNPACKWeightTransform", Conv2DWinogradNNPACKWeightTransformRel) + .set_attr("TOpPattern", kOpaque); // relay.nn.contrib_conv2d_gemm_without_weight_transform TVM_REGISTER_GLOBAL("relay.op.nn._make.contrib_conv2d_gemm_without_weight_transform") diff --git a/src/relay/op/nn/nn.cc b/src/relay/op/nn/nn.cc index 9e4b6fc8bb4a..9e73c6456401 100644 --- a/src/relay/op/nn/nn.cc +++ b/src/relay/op/nn/nn.cc @@ -161,7 +161,8 @@ Useful for .add_argument("data", "Tensor", "Latest input") .add_argument("buffer", "Tensor", "Buffer storing latest [length_buffer] inputs") .set_support_level(3) - .add_type_rel("FIFOBuffer", FIFOBufferRel); + .add_type_rel("FIFOBuffer", FIFOBufferRel) + .set_attr("TOpPattern", kOpaque); // ------------------- relay.nn.matmul TVM_REGISTER_NODE_TYPE(MatmulAttrs); @@ -638,7 +639,8 @@ centered at that value (zero padding is added where necessary). .set_num_inputs(1) .add_argument("data", "Tensor", "The input tensor.") .set_support_level(2) - .add_type_rel("Identity", IdentityRel); + .add_type_rel("Identity", IdentityRel) + .set_attr("TOpPattern", kOpaque); // Positional relay function to create L2Normalize operator used by frontend FFI. TVM_REGISTER_NODE_TYPE(L2NormalizeAttrs); @@ -1137,7 +1139,8 @@ Do log on the data - do not accept logits. .add_argument("x", "1D Tensor", "Predictions.") .add_argument("y", "1D Tensor", "Targets.") .set_support_level(10) - .add_type_rel("CrossEntropy", CrossEntropyRel); + .add_type_rel("CrossEntropy", CrossEntropyRel) + .set_attr("TOpPattern", kOpaque); // relay.nn.dilate TVM_REGISTER_NODE_TYPE(DilateAttrs); @@ -1203,7 +1206,8 @@ Accept logits. .add_argument("x", "1D Tensor", "Predictions.") .add_argument("y", "1D Tensor", "Targets.") .set_support_level(10) - .add_type_rel("CrossEntropy", CrossEntropyRel); + .add_type_rel("CrossEntropy", CrossEntropyRel) + .set_attr("TOpPattern", kOpaque); // Depth to space and space to depth TVM_REGISTER_NODE_TYPE(SubPixelAttrs); diff --git a/src/relay/op/nn/sparse.cc b/src/relay/op/nn/sparse.cc index ebef7e21de7d..e190a8b886e1 100644 --- a/src/relay/op/nn/sparse.cc +++ b/src/relay/op/nn/sparse.cc @@ -239,7 +239,8 @@ RELAY_REGISTER_OP("nn.sparse_add") .add_argument("sparse_indices", "1D Tensor", "Sparse indices vector.") .add_argument("sparse_indptr", "1D Tensor", "Sparse index pointer vector.") .set_support_level(1) - .add_type_rel("SparseAdd", SparseAddRel); + .add_type_rel("SparseAdd", SparseAddRel) + .set_attr("TOpPattern", kOpaque); TVM_REGISTER_NODE_TYPE(SparseConv2DAttrs);