Merge pull request apache#27 from wjj19950828/paddle_frontend

add 5 paddle ops

python/tvm/relay/frontend/paddlepaddle.py

@@ -706,6 +706,17 @@ def convert_hard_swish(g, op, block):
  g.add_node(op.output("Out")[0], out)
 
 
+def convert_index_select(g, op, block):
+ """Operator converter for index_select."""
+
+ dim = op.attr("dim")
+ x = g.get_node(op.input("X")[0])
+ index = g.get_node(op.input("Index")[0])
+ out = _op.take(x, indices=index, axis=dim, mode="clip")
+
+ g.add_node(op.output("Out")[0], out)
+
+
 def convert_layer_norm(g, op, block):
  """Operator converter for layer_norm."""
 
@@ -1034,6 +1045,33 @@ def convert_pow(g, op, block):
  g.add_node(op.output("Out")[0], out)
 
 
+def convert_norm(g, op, block):
+ """Operator converter for norm."""
+
+ x = g.get_node(op.input("X")[0])
+ dtype = infer_type(x).checked_type.dtype
+ axis = op.attr("axis")
+ keepdim = op.attr("keepdim")
+ if op.attr("asvector"):
+ axis = None
+ order = op.attr("porder")
+ if order == np.inf:
+ out = _op.reduce.max(_op.abs(x), axis=axis, keepdims=keepdim)
+ elif order == np.NINF:
+ out = _op.reduce.min(_op.abs(x), axis=axis, keepdims=keepdim)
+ else:
+ reci_order = _expr.const(1.0 / order, dtype=dtype)
+ order = _expr.const(order)
+ out = _op.power(
+ _op.reduce.sum(_op.power(_op.abs(x), order), axis=axis, keepdims=keepdim),
+ reci_order,
+ )
+ if op.attr("asvector") and not keepdim:
+ out = _op.expand_dims(out, axis=0)
+
+ g.add_node(op.output("Out")[0], out)
+
+
 def convert_range(g, op, block):
  """Operator converter for range."""
 
@@ -1534,6 +1572,7 @@ def convert_unsqueeze(g, op, block):
  "greater_than": convert_elementwise_op,
  "hard_sigmoid": convert_hard_sigmoid,
  "hard_swish": convert_hard_swish,
+ "index_select": convert_index_select,
  "isinf": convert_unary_op,
  "isinf_v2": convert_unary_op,
  "layer_norm": convert_layer_norm,
@@ -1543,6 +1582,7 @@ def convert_unsqueeze(g, op, block):
  "lookup_table": convert_lookup_table,
  "lookup_table_v2": convert_lookup_table,
  "log": convert_unary_op,
+ "log2": convert_unary_op,
  "log10": convert_unary_op,
  "log1p": convert_log1p,
  "logsumexp": convert_logsumexp,
@@ -1556,6 +1596,7 @@ def convert_unsqueeze(g, op, block):
  "pad2d": convert_padding,
  "pad3d": convert_padding,
  "pow": convert_pow,
+ "p_norm": convert_norm,
  "range": convert_range,
  "reduce_all": convert_reduce,
  "reduce_any": convert_reduce,

tests/python/frontend/paddlepaddle/test_forward.py

@@ -156,6 +156,7 @@ def forward(self, inputs):
  "exp",
  "floor",
  "log",
+ "log2",
  "log10",
  "log1p",
  "relu",
@@ -627,6 +628,26 @@ def ones_like2(inputs):
 
 
 @tvm.testing.uses_gpu
+def test_forward_ones():
+ @paddle.jit.to_static
+ def ones1(inputs):
+ ones = paddle.ones([1, 3, 10, 10])
+ out = inputs + ones
+ return out
+
+ @paddle.jit.to_static
+ def ones2(inputs):
+ shape = paddle.to_tensor([1, 3, 10, 10], dtype="int32")
+ ones = paddle.ones(shape)
+ out = inputs + ones
+ return out
+
+ input_shape = [1, 3, 10, 10]
+ input_data = paddle.rand(input_shape, dtype="float32")
+ verify_model(ones1, input_data=input_data)
+ verify_model(ones2, input_data=input_data)
+
+
 def test_forward_elemwise():
  class ElemwiseOp(nn.Layer):
  def __init__(self, op_name):
@@ -733,6 +754,23 @@ def hard_swish(inputs):
  verify_model(hard_swish, input_data=input_data)
 
 
+@tvm.testing.uses_gpu
+def test_forward_index_select():
+ @paddle.jit.to_static
+ def index_select1(x, index):
+ return paddle.index_select(x, index)
+
+ @paddle.jit.to_static
+ def index_select2(x, index):
+ return paddle.index_select(x, index, axis=1)
+
+ input_shape = [3, 10]
+ input_data = paddle.rand(input_shape, dtype="float32")
+ index = paddle.to_tensor(np.array([0, 1, 1]).astype('int32'))
+ verify_model(index_select1, input_data=[input_data, index])
+ verify_model(index_select2, input_data=[input_data, index])
+
+
 @tvm.testing.uses_gpu
 def test_forward_isinf():
  @paddle.jit.to_static
@@ -911,6 +949,97 @@ def forward(self, input1, input2):
  verify_model(MatMul1(), input_data=[input_data1, input_data2])
 
 
+@tvm.testing.uses_gpu
+def test_forward_norm():
+ class Norm1(nn.Layer):
+ @paddle.jit.to_static
+ def forward(self, inputs):
+ return paddle.norm(inputs, p=float("inf"), axis=None, keepdim=False)
+
+ class Norm2(nn.Layer):
+ @paddle.jit.to_static
+ def forward(self, inputs):
+ return paddle.norm(inputs, p=float("-inf"), axis=None, keepdim=False)
+
+ class Norm3(nn.Layer):
+ @paddle.jit.to_static
+ def forward(self, inputs):
+ return paddle.norm(inputs, p=float("-inf"), axis=None, keepdim=True)
+
+ class Norm4(nn.Layer):
+ @paddle.jit.to_static
+ def forward(self, inputs):
+ return paddle.norm(inputs, p=float("inf"), axis=[1, 2], keepdim=False)
+
+ class Norm5(nn.Layer):
+ @paddle.jit.to_static
+ def forward(self, inputs):
+ return paddle.norm(inputs, p=float("inf"), axis=-1, keepdim=True)
+
+ class Norm6(nn.Layer):
+ @paddle.jit.to_static
+ def forward(self, inputs):
+ return paddle.norm(inputs, p=float(0.5), axis=1, keepdim=True)
+
+ class Norm7(nn.Layer):
+ @paddle.jit.to_static
+ def forward(self, inputs):
+ return paddle.norm(inputs, p=float(1), axis=None, keepdim=False)
+
+ class Norm8(nn.Layer):
+ @paddle.jit.to_static
+ def forward(self, inputs):
+ return paddle.norm(inputs, p=float(2.0), axis=1, keepdim=False)
+
+ class Norm9(nn.Layer):
+ @paddle.jit.to_static
+ def forward(self, inputs):
+ return paddle.norm(inputs, p=float(-0.5), axis=[1, 2], keepdim=False)
+
+ class Norm10(nn.Layer):
+ @paddle.jit.to_static
+ def forward(self, inputs):
+ return paddle.norm(inputs, p=float(-2), axis=(1), keepdim=False)
+
+ input_shape = [1, 3, 10, 10]
+ input_data = paddle.rand(input_shape, dtype="float32")
+ verify_model(Norm1(), input_data=input_data)
+ verify_model(Norm2(), input_data=input_data)
+ verify_model(Norm3(), input_data=input_data)
+ verify_model(Norm4(), input_data=input_data)
+ verify_model(Norm5(), input_data=input_data)
+ verify_model(Norm6(), input_data=input_data)
+ verify_model(Norm7(), input_data=input_data)
+ verify_model(Norm8(), input_data=input_data)
+ verify_model(Norm9(), input_data=input_data)
+ verify_model(Norm10(), input_data=input_data)
+
+
+@tvm.testing.uses_gpu
+def test_forward_not_equal():
+ class Not_equal(nn.Layer):
+ @paddle.jit.to_static
+ def forward(self, x, y):
+ output = paddle.not_equal(x, y)
+ output = paddle.cast(output, "int32")
+ return output
+
+ x_shape = [10]
+ y_shape = [10]
+ x_data = paddle.randint(1, 10, x_shape, dtype="int32")
+ y_data = paddle.randint(1, 10, y_shape, dtype="int32")
+ x_data_1 = paddle.randint(1, 10, x_shape, dtype="int64")
+ y_data_1 = paddle.randint(1, 10, y_shape, dtype="int64")
+ verify_model(Not_equal(), input_data=[x_data, y_data])
+ verify_model(Not_equal(), input_data=[x_data_1, y_data_1])
+ # For broadcast
+ x_shape_1 = [10]
+ y_shape_1 = [10, 1]
+ x_data_2 = paddle.rand(x_shape_1, dtype="float32")
+ y_data_2 = paddle.rand(y_shape_1, dtype="float32")
+ verify_model(Not_equal(), input_data=[x_data_2, y_data_2])
+
+
 @tvm.testing.uses_gpu
 def test_forward_pool2d():
  @paddle.jit.to_static
@@ -1287,6 +1416,27 @@ def tile3(inputs, inputs2):
  verify_model(tile3, input_data=[input_data, input_data2])
 
 
+@tvm.testing.uses_gpu
+def test_forward_zeros():
+ @paddle.jit.to_static
+ def zeros1(inputs):
+ zeros = paddle.zeros([1, 3, 10, 10])
+ out = inputs + zeros
+ return out
+
+ @paddle.jit.to_static
+ def zeros2(inputs):
+ shape = paddle.to_tensor([1, 3, 10, 10], dtype="int32")
+ zeros = paddle.zeros(shape)
+ out = inputs + zeros
+ return out
+
+ input_shape = [1, 3, 10, 10]
+ input_data = paddle.rand(input_shape, dtype="float32")
+ verify_model(zeros1, input_data=input_data)
+ verify_model(zeros2, input_data=input_data)
+
+
 if __name__ == "__main__":
  test_forward_add_subtract()
  test_forward_addmm()
@@ -1306,12 +1456,14 @@ def tile3(inputs, inputs2):
  test_forward_expand()
  test_forward_flatten()
  test_forward_shape_full()
+ test_forward_ones()
  test_forward_ones_like()
  test_forward_gather_assign_value()
  test_forward_gather_nd()
  test_forward_gelu()
  test_forward_hard_sigmoid()
  test_forward_hard_swish()
+ test_forward_index_select()
  test_forward_interpolate()
  test_forward_isinf()
  test_forward_layer_norm()
@@ -1320,6 +1472,8 @@ def tile3(inputs, inputs2):
  test_forward_lstm()
  test_forward_matmul()
  test_forward_multiply()
+ test_forward_not_equal()
+ test_forward_norm()
  test_forward_pool2d()
  test_forward_pad()
  test_forward_pow()
@@ -1333,3 +1487,4 @@ def tile3(inputs, inputs2):
  test_forward_tile()
  test_forward_conv_transpose()
  test_forward_unary_op()
+ test_forward_zeros()