Add contrib

python/tvm/relay/op/nn/_nn.py

@@ -265,23 +265,23 @@ def schedule_global_avg_pool2d(_, outs, target):
 
 
 # adaptive_max_pool2d
-@reg.register_schedule("nn.adaptive_max_pool2d")
-def schedule_adaptive_max_pool2d(_, outs, target):
+@reg.register_schedule("nn.contrib_adaptive_max_pool2d")
+def schedule_contrib_adaptive_max_pool2d(_, outs, target):
     """Schedule definition of adaptive_max_pool2d"""
     with target:
         return topi.generic.schedule_adaptive_pool(outs)
 
-reg.register_pattern("nn.adaptive_max_pool2d", OpPattern.OUT_ELEMWISE_FUSABLE)
+reg.register_pattern("nn.contrib_adaptive_max_pool2d", OpPattern.OUT_ELEMWISE_FUSABLE)
 
 
 # adaptive_avg_pool2d
-@reg.register_schedule("nn.adaptive_avg_pool2d")
-def schedule_adaptive_avg_pool2d(_, outs, target):
+@reg.register_schedule("nn.contrib_adaptive_avg_pool2d")
+def schedule_contrib_adaptive_avg_pool2d(_, outs, target):
     """Schedule definition of adaptive_avg_pool2d"""
     with target:
         return topi.generic.schedule_adaptive_pool(outs)
 
-reg.register_pattern("nn.adaptive_avg_pool2d", OpPattern.OUT_ELEMWISE_FUSABLE)
+reg.register_pattern("nn.contrib_adaptive_avg_pool2d", OpPattern.OUT_ELEMWISE_FUSABLE)
 
 
 # leaky_relu

python/tvm/relay/op/nn/nn.py

@@ -390,9 +390,9 @@ def global_avg_pool2d(data,
     return _make.global_avg_pool2d(data, layout)
 
 
-def adaptive_max_pool2d(data,
-                        output_size=None,
-                        layout="NCHW"):
+def contrib_adaptive_max_pool2d(data,
+                                output_size=None,
+                                layout="NCHW"):
     r"""2D adaptive max pooling operator. This operator is experimental.
 
     This operator takes data as input and does 2D max value calculation
@@ -434,11 +434,11 @@ def adaptive_max_pool2d(data,
         The computed result.
     """
     output_size = [] or output_size
-    return _make.adaptive_max_pool2d(data, output_size, layout)
+    return _make.contrib_adaptive_max_pool2d(data, output_size, layout)
 
-def adaptive_avg_pool2d(data,
-                        output_size=None,
-                        layout="NCHW"):
+def contrib_adaptive_avg_pool2d(data,
+                                output_size=None,
+                                layout="NCHW"):
     r"""2D adaptive average pooling operator. This operator is experimental.
 
     This operator takes data as input and does 2D average value calculation
@@ -480,7 +480,7 @@ def adaptive_avg_pool2d(data,
         The computed result.
     """
     output_size = [] or output_size
-    return _make.adaptive_avg_pool2d(data, output_size, layout)
+    return _make.contrib_adaptive_avg_pool2d(data, output_size, layout)
 
 
 def upsampling(data,

src/relay/op/nn/pooling.cc

@@ -486,14 +486,14 @@ Expr MakeAdaptiveAvgPool2D(Expr data,
   auto attrs = make_node<AdaptivePool2DAttrs>();
   attrs->output_size = std::move(output_size);
   attrs->layout = std::move(layout);
-  static const Op& op = Op::Get("nn.adaptive_avg_pool2d");
+  static const Op& op = Op::Get("nn.contrib_adaptive_avg_pool2d");
   return CallNode::make(op, {data}, Attrs(attrs), {});
 }
 
-TVM_REGISTER_API("relay.op.nn._make.adaptive_avg_pool2d")
+TVM_REGISTER_API("relay.op.nn._make.contrib_adaptive_avg_pool2d")
 .set_body_typed(MakeAdaptiveAvgPool2D);
 
-RELAY_REGISTER_OP("nn.adaptive_avg_pool2d")
+RELAY_REGISTER_OP("nn.contrib_adaptive_avg_pool2d")
   .describe(R"code(Adaptive average pooling operation for 2D data.
 
 - **data**: This depends on the `layout` parameter. Input is 4D array of shape
@@ -525,14 +525,14 @@ Expr MakeAdaptiveMaxPool2D(Expr data,
   auto attrs = make_node<AdaptivePool2DAttrs>();
   attrs->output_size = std::move(output_size);
   attrs->layout = std::move(layout);
-  static const Op& op = Op::Get("nn.adaptive_max_pool2d");
+  static const Op& op = Op::Get("nn.contrib_adaptive_max_pool2d");
   return CallNode::make(op, {data}, Attrs(attrs), {});
 }
 
-TVM_REGISTER_API("relay.op.nn._make.adaptive_max_pool2d")
+TVM_REGISTER_API("relay.op.nn._make.contrib_adaptive_max_pool2d")
 .set_body_typed(MakeAdaptiveMaxPool2D);
 
-RELAY_REGISTER_OP("nn.adaptive_max_pool2d")
+RELAY_REGISTER_OP("nn.contrib_adaptive_max_pool2d")
   .describe(R"code(Adaptive max pooling operation for 2D data.
 
 - **data**: This depends on the `layout` parameter. Input is 4D array of shape

tests/python/relay/test_op_level10.py

@@ -233,7 +233,7 @@ def end_index(index, odim, idim):
                     l_sl = slice(l_start, l_end)
                     np_out[i, j, k, l] = np_op(np_data[i, j, k_sl, l_sl])
 
-    opfunc = relay.nn.adaptive_avg_pool2d if pool_type == "avg" else relay.nn.adaptive_max_pool2d
+    opfunc = relay.nn.contrib_adaptive_avg_pool2d if pool_type == "avg" else relay.nn.contrib_adaptive_max_pool2d
     x = relay.var("x", relay.TensorType((n, c, h, w), "float32"))
     y = opfunc(x, out_size, layout)
     func = relay.Function([x], y)