From 523e1c57623e00e61a6299846bf0bb202937c8fa Mon Sep 17 00:00:00 2001
From: xg-zheng <2444521156@qq.com>
Date: Wed, 1 Mar 2023 09:53:17 +0000
Subject: [PATCH 1/9] [Frontend][Paddle]Add
 tile/mish/stack/unstack/silu/softshrink/where op for paddle frontend

---
 python/tvm/relay/frontend/paddlepaddle.py     | 100 +++++++++++
 .../frontend/paddlepaddle/test_forward.py     | 164 ++++++++++++++++++
 2 files changed, 264 insertions(+)

diff --git a/python/tvm/relay/frontend/paddlepaddle.py b/python/tvm/relay/frontend/paddlepaddle.py
index 78895e4b49e0..068e5712a0b2 100755
--- a/python/tvm/relay/frontend/paddlepaddle.py
+++ b/python/tvm/relay/frontend/paddlepaddle.py
@@ -105,6 +105,16 @@ def convert_unary_op(g, op, block):
     g.add_node(op.output("Out")[0], out)
 
 
+def convert_tile(g, op, block):
+    """Operator converter for tile."""
+
+    x = g.get_node(op.input("X")[0])
+    reps = op.attr("repeat_times")
+    op_func = get_relay_op(op.type)
+    out = op_func(x, reps=reps)
+    g.add_node(op.output("Out")[0], out)
+
+
 def convert_binary_logical_op(g, op, block):
     """Operator converter for logical op."""
 
@@ -1084,6 +1094,23 @@ def convert_meshgrid(g, op, block):
         g.add_node(op.output("Out")[i], out)
 
 
+def convert_mish(g, op, block):
+    """Operator converter for mish."""
+
+    x = g.get_node(op.input("X")[0])
+    dtype = infer_type(x).checked_type.dtype
+    threshold = op.attr("threshold")
+    condition = tvm.relay.greater(x, tvm.relay.const(threshold, dtype))
+    softplus_0 = x
+    exp = _op.exp(x)
+    add = _op.add(exp, tvm.relay.const(1.0, dtype))
+    softplus_1 = _op.log(add)
+    softplus = _op.where(condition, softplus_0, softplus_1)
+    tanh = _op.tanh(softplus)
+    out = _op.multiply(x, tanh)
+    g.add_node(op.output("Out")[0], out)
+
+
 def convert_mul(g, op, block):
     """Operator converter for mul."""
 
@@ -1785,6 +1812,14 @@ def convert_shape(g, op, block):
     g.add_node(op.output("Out")[0], out)
 
 
+def convert_silu(g, op, block):
+    """Operator converter for silu."""
+
+    x = g.get_node(op.input("X")[0])
+    out = _op.multiply(x, _op.sigmoid(x))
+    g.add_node(op.output("Out")[0], out)
+
+
 def convert_size(g, op, block):
     """Operator converter for size."""
 
@@ -1950,6 +1985,30 @@ def convert_softsign(g, op, block):
     g.add_node(op.output("Out")[0], out)
 
 
+def convert_softshrink(g, op, block):
+    """Operator converter for softshrink."""
+
+    threshold = op.attr("lambda")
+    x = g.get_node(op.input("X")[0])
+    dtype = infer_type(x).checked_type.dtype
+    threshold_right = _expr.const(threshold, dtype)
+    threshold_left = _expr.const(-1.0 * threshold, dtype)
+    middle = _expr.const(0.0, dtype)
+    condition_0 = tvm.relay.logical_and(
+        tvm.relay.less_equal(x, threshold_right), tvm.relay.greater_equal(x, threshold_left)
+    )
+    calc_middle = tvm.relay.where(condition_0, middle, x)
+
+    sub_threshold = _op.subtract(x, threshold_right)
+    condition_1 = tvm.relay.greater(calc_middle, threshold_right)
+    calc_right = tvm.relay.where(condition_1, sub_threshold, calc_middle)
+
+    add_threshold = _op.add(x, threshold_right)
+    condition_2 = tvm.relay.less(calc_right, threshold_left)
+    calc_left = tvm.relay.where(condition_2, add_threshold, calc_right)
+    g.add_node(op.output("Out")[0], calc_left)
+
+
 def convert_split(g, op, block):
     """Operator converter for split."""
 
@@ -1994,6 +2053,18 @@ def convert_split(g, op, block):
         g.add_node(op.output("Out")[i], out_i)
 
 
+def convert_stack(g, op, blcok):
+    """Operator converter for stack."""
+
+    x = op.input("X")
+    all_inputs = []
+    for inp in x:
+        all_inputs.append(g.get_node(inp))
+    axis = op.attr("axis")
+    out = _op.stack(all_inputs, axis)
+    g.add_node(op.output("Y")[0], out)
+
+
 def convert_square(g, op, block):
     """Operator converter for square."""
 
@@ -2074,6 +2145,28 @@ def convert_unsqueeze(g, op, block):
     g.add_node(op.output("Out")[0], x)
 
 
+def convert_unstack(g, op, block):
+    """Operator converter for unstack."""
+
+    x = g.get_node(op.input("X")[0])
+    axis = op.attr("axis")
+    indices_or_sections = len(op.output("Y"))
+    outs = _op.split(x, indices_or_sections=indices_or_sections, axis=axis)
+    for i, out in enumerate(outs):
+        out = _op.squeeze(out, axis=axis)
+        g.add_node(op.output("Y")[i], out)
+
+
+def convert_where(g, op, block):
+    """Operator converter for where."""
+
+    condition = g.get_node(op.input("Condition")[0])
+    x = g.get_node(op.input("X")[0])
+    y = g.get_node(op.input("Y")[0])
+    out = _op.where(condition, x, y)
+    g.add_node(op.output("Out")[0], out)
+
+
 def convert_where_index(g, op, block):
     """Operator converter for where_index."""
 
@@ -2166,6 +2259,7 @@ def convert_where_index(g, op, block):
     "matmul": convert_matmul,
     "matmul_v2": convert_matmul,
     "meshgrid": convert_meshgrid,
+    "mish": convert_mish,
     "mul": convert_mul,
     "mv": convert_mv,
     "nearest_interp_v2": convert_interpolate,
@@ -2201,6 +2295,7 @@ def convert_where_index(g, op, block):
     "shape": convert_shape,
     "sigmoid": convert_unary_op,
     "sign": convert_unary_op,
+    "silu": convert_silu,
     "sin": convert_unary_op,
     "sinh": convert_unary_op,
     "size": convert_size,
@@ -2208,7 +2303,9 @@ def convert_where_index(g, op, block):
     "softmax": convert_softmax,
     "softplus": convert_softplus,
     "softsign": convert_softsign,
+    "softshrink": convert_softshrink,
     "split": convert_split,
+    "stack": convert_stack,
     "strided_slice": convert_slice,
     "sqrt": convert_unary_op,
     "square": convert_square,
@@ -2216,9 +2313,12 @@ def convert_where_index(g, op, block):
     "swish": convert_swish,
     "tan": convert_unary_op,
     "tanh": convert_unary_op,
+    "tile": convert_tile,
     "top_k_v2": convert_topk,
     "transpose2": convert_transpose,
     "unsqueeze2": convert_unsqueeze,
+    "unstack": convert_unstack,
+    "where": convert_where,
     "where_index": convert_where_index,
 }
 
diff --git a/tests/python/frontend/paddlepaddle/test_forward.py b/tests/python/frontend/paddlepaddle/test_forward.py
index 70fbf6aee554..8520fac2a33d 100755
--- a/tests/python/frontend/paddlepaddle/test_forward.py
+++ b/tests/python/frontend/paddlepaddle/test_forward.py
@@ -1784,5 +1784,169 @@ def where_index_1(inputs):
     verify_model(where_index_1, input_data=input_data, use_vm=True)
 
 
+@tvm.testing.uses_gpu
+def test_forward_tile():
+    class Tile1(nn.Layer):
+        @paddle.jit.to_static
+        def forward(self, inputs):
+            return paddle.tile(inputs, repeat_times=[10], name="test1")
+
+    class Tile2(nn.Layer):
+        @paddle.jit.to_static
+        def forward(self, inputs):
+            return paddle.tile(inputs, repeat_times=[2, 3])
+
+    class Tile3(nn.Layer):
+        @paddle.jit.to_static
+        def forward(self, inputs):
+            return paddle.tile(inputs, repeat_times=[1, 2, 3], name="test3")
+
+    class Tile4(nn.Layer):
+        @paddle.jit.to_static
+        def forward(self, inputs):
+            return paddle.tile(inputs, repeat_times=[2, 3, 4, 1, 5])
+
+    input_shapes = [
+        [10],
+        [2, 3],
+        [3, 4, 5],
+        [5, 3, 1, 4],
+        [1, 3, 1, 6, 7],
+    ]
+    for input_shape in input_shapes:
+        input_data = paddle.randn(shape=input_shape, dtype="float32")
+        verify_model(Tile1(), input_data=input_data)
+
+
+@tvm.testing.uses_gpu
+def test_forward_mish():
+    class Mish(nn.Layer):
+        @paddle.jit.to_static
+        def forward(self, inputs):
+            return nn.functional.mish(inputs)
+
+    input_shapes = [[10], [2, 3], [5, 10, 11], [3, 4, 5, 6]]
+    for input_shape in input_shapes:
+        input_data = paddle.randn(shape=input_shape, dtype="float32")
+        verify_model(Mish(), input_data=input_data)
+        input_data += 20.0
+        verify_model(Mish(), input_data=input_data)
+
+    input_data = paddle.to_tensor([-5.0, 0.0, 5.0, 23.1, 20.0])
+    verify_model(Mish(), input_data=input_data)
+
+
+@tvm.testing.uses_gpu
+def test_forward_stack():
+    class Stack1(nn.Layer):
+        @paddle.jit.to_static
+        def forward(self, input0, input1, input2):
+            return paddle.stack([input0, input1, input2], axis=-1)
+
+    class Stack2(nn.Layer):
+        @paddle.jit.to_static
+        def forward(self, input0, input1, input2):
+            return paddle.stack([input0, input1, input2], axis=1)
+
+    class Stack3(nn.Layer):
+        @paddle.jit.to_static
+        def forward(self, input0, input1, input2):
+            return paddle.stack([input0, input1, input2], axis=2)
+
+    input_shapes = [[2, 3], [5, 10, 11], [3, 4, 5, 6]]
+    for input_shape in input_shapes:
+        input_data_0 = paddle.randn(shape=input_shape, dtype="float32")
+        input_data_1 = paddle.randn(shape=input_shape, dtype="float32")
+        input_data_2 = paddle.randn(shape=input_shape, dtype="float32")
+        verify_model(Stack1(), [input_data_0, input_data_1, input_data_2])
+        verify_model(Stack2(), [input_data_0, input_data_1, input_data_2])
+        verify_model(Stack3(), [input_data_0, input_data_1, input_data_2])
+
+
+@tvm.testing.uses_gpu
+def test_forward_unstack():
+    class UnStack1(nn.Layer):
+        @paddle.jit.to_static
+        def forward(self, inputs):
+            return paddle.unstack(inputs, axis=-1)
+
+    class UnStack2(nn.Layer):
+        @paddle.jit.to_static
+        def forward(self, inputs):
+            return paddle.unstack(inputs, axis=1)
+
+    class UnStack3(nn.Layer):
+        @paddle.jit.to_static
+        def forward(self, inputs):
+            return paddle.unstack(inputs, axis=0)
+
+    input_shapes = [[2, 3], [5, 10, 11], [3, 4, 5, 6], [1, 3, 4, 1, 1]]
+    for input_shape in input_shapes:
+        input_data = paddle.randn(shape=input_shape, dtype="float32")
+        verify_model(UnStack1(), input_data)
+        verify_model(UnStack2(), input_data)
+        verify_model(UnStack3(), input_data)
+
+
+@tvm.testing.uses_gpu
+def test_forward_silu():
+    class Silu(nn.Layer):
+        @paddle.jit.to_static
+        def forward(self, inputs):
+            return nn.functional.silu(inputs)
+
+    input_shapes = [[10], [2, 3], [5, 10, 11], [3, 4, 5, 6]]
+    for input_shape in input_shapes:
+        input_data = paddle.randn(shape=input_shape, dtype="float32")
+        verify_model(Silu(), input_data=input_data)
+
+
+@tvm.testing.uses_gpu
+def test_forward_softshrink():
+    @paddle.jit.to_static
+    def Softshrink1(input):
+        return nn.functional.softshrink(input, threshold=0.0)
+
+    @paddle.jit.to_static
+    def Softshrink2(input):
+        return nn.functional.softshrink(input, threshold=0.5)
+
+    @paddle.jit.to_static
+    def Softshrink3(input):
+        return nn.functional.softshrink(input, threshold=1.0)
+
+    x = paddle.to_tensor([-0.9, -0.2, 0.1, 0.8])
+    verify_model(Softshrink2, x)
+
+    input_shapes = [[10], [2, 3], [5, 10, 11], [3, 4, 5, 6]]
+    for input_shape in input_shapes:
+        input_data = paddle.randn(shape=input_shape, dtype="float32")
+        verify_model(Softshrink1, input_data=input_data)
+        verify_model(Softshrink2, input_data=input_data)
+        verify_model(Softshrink3, input_data=input_data)
+
+
+@tvm.testing.uses_gpu
+def test_forward_where():
+    @paddle.jit.to_static
+    def where1(x, y):
+        return paddle.where(x > 1, x, y)
+
+    @paddle.jit.to_static
+    def where2(x, y):
+        return paddle.where(x > y, x, y)
+
+    x = paddle.to_tensor([0.9383, 0.1983, 3.2, 1.2])
+    y = paddle.to_tensor([1.0, 1.0, 1.0, 1.0])
+    verify_model(where1, [x, y])
+
+    input_shapes = [[10], [2, 3], [5, 10, 11], [3, 4, 5, 6]]
+    for input_shape in input_shapes:
+        x = paddle.randn(shape=input_shape, dtype="float32")
+        y = paddle.randn(shape=input_shape, dtype="float32")
+        verify_model(where1, [x, y])
+        verify_model(where2, [x, y])
+
+
 if __name__ == "__main__":
     tvm.testing.main()

From e3b94e1590606e83285f77ff48f279fc591a62aa Mon Sep 17 00:00:00 2001
From: xg-zheng <2444521156@qq.com>
Date: Wed, 1 Mar 2023 11:52:31 +0000
Subject: [PATCH 2/9] fix convert tile and update test case

---
 python/tvm/relay/frontend/paddlepaddle.py     | 23 ++++++++++++++++++-
 .../frontend/paddlepaddle/test_forward.py     | 22 ++++++++++++++++--
 2 files changed, 42 insertions(+), 3 deletions(-)

diff --git a/python/tvm/relay/frontend/paddlepaddle.py b/python/tvm/relay/frontend/paddlepaddle.py
index 068e5712a0b2..962589cacc42 100755
--- a/python/tvm/relay/frontend/paddlepaddle.py
+++ b/python/tvm/relay/frontend/paddlepaddle.py
@@ -109,7 +109,28 @@ def convert_tile(g, op, block):
     """Operator converter for tile."""
 
     x = g.get_node(op.input("X")[0])
-    reps = op.attr("repeat_times")
+    if op.input("RepeatTimes"):
+        reps = g.get_node(op.input("RepeatTimes")[0])
+        reps, infered = try_infer_value(reps, g.get_params())
+        if infered:
+            reps = reps.tolist()
+    elif op.input("repeat_times_tensor"):
+        reps = []
+        for rep_value in op.input("repeat_times_tensor"):
+            rep_value = g.get_node(rep_value).astype("int64")
+            reps.append(rep_value)
+        reps = _op.concatenate(reps, axis=0)
+        reps, infered = try_infer_value(reps, g.get_params())
+        if infered:
+            reps = reps.tolist()
+    else:
+        reps = op.attr("repeat_times")
+        infered = True
+
+    if not infered:
+        msg = 'Value {} in attribute "repeat_times" of operator Tile is not "valid."'
+        raise tvm.error.OpAttributeInvalid(msg.format(reps))
+
     op_func = get_relay_op(op.type)
     out = op_func(x, reps=reps)
     g.add_node(op.output("Out")[0], out)
diff --git a/tests/python/frontend/paddlepaddle/test_forward.py b/tests/python/frontend/paddlepaddle/test_forward.py
index 8520fac2a33d..83c4369d7e8d 100755
--- a/tests/python/frontend/paddlepaddle/test_forward.py
+++ b/tests/python/frontend/paddlepaddle/test_forward.py
@@ -1789,7 +1789,7 @@ def test_forward_tile():
     class Tile1(nn.Layer):
         @paddle.jit.to_static
         def forward(self, inputs):
-            return paddle.tile(inputs, repeat_times=[10], name="test1")
+            return paddle.tile(inputs, repeat_times=[10])
 
     class Tile2(nn.Layer):
         @paddle.jit.to_static
@@ -1799,13 +1799,26 @@ def forward(self, inputs):
     class Tile3(nn.Layer):
         @paddle.jit.to_static
         def forward(self, inputs):
-            return paddle.tile(inputs, repeat_times=[1, 2, 3], name="test3")
+            return paddle.tile(inputs, repeat_times=[1, 2, 3])
 
     class Tile4(nn.Layer):
         @paddle.jit.to_static
         def forward(self, inputs):
             return paddle.tile(inputs, repeat_times=[2, 3, 4, 1, 5])
 
+    class Tile5(nn.Layer):
+        @paddle.jit.to_static
+        def forward(self, inputs):
+            reps = paddle.to_tensor([3, 2])
+            return paddle.tile(inputs, repeat_times=reps)
+
+    class Tile6(nn.Layer):
+        @paddle.jit.to_static
+        def forward(self, inputs):
+            rep_0 = paddle.to_tensor([3])
+            rep_1 = paddle.to_tensor([2])
+            return paddle.tile(inputs, repeat_times=[rep_0, rep_1])
+
     input_shapes = [
         [10],
         [2, 3],
@@ -1816,6 +1829,11 @@ def forward(self, inputs):
     for input_shape in input_shapes:
         input_data = paddle.randn(shape=input_shape, dtype="float32")
         verify_model(Tile1(), input_data=input_data)
+        verify_model(Tile2(), input_data=input_data)
+        verify_model(Tile3(), input_data=input_data)
+        verify_model(Tile4(), input_data=input_data)
+        verify_model(Tile5(), input_data=input_data)
+        verify_model(Tile6(), input_data=input_data)
 
 
 @tvm.testing.uses_gpu

From 07cbe38d89d52603b34b8ba43dddfb6f6f69c1c4 Mon Sep 17 00:00:00 2001
From: xg-zheng <2444521156@qq.com>
Date: Wed, 1 Mar 2023 14:37:54 +0000
Subject: [PATCH 3/9] fix test case and tile dtype

---
 python/tvm/relay/frontend/paddlepaddle.py          | 2 +-
 tests/python/frontend/paddlepaddle/test_forward.py | 6 +++++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/python/tvm/relay/frontend/paddlepaddle.py b/python/tvm/relay/frontend/paddlepaddle.py
index 962589cacc42..5b52b850036d 100755
--- a/python/tvm/relay/frontend/paddlepaddle.py
+++ b/python/tvm/relay/frontend/paddlepaddle.py
@@ -117,7 +117,7 @@ def convert_tile(g, op, block):
     elif op.input("repeat_times_tensor"):
         reps = []
         for rep_value in op.input("repeat_times_tensor"):
-            rep_value = g.get_node(rep_value).astype("int64")
+            rep_value = g.get_node(rep_value).astype("int32")
             reps.append(rep_value)
         reps = _op.concatenate(reps, axis=0)
         reps, infered = try_infer_value(reps, g.get_params())
diff --git a/tests/python/frontend/paddlepaddle/test_forward.py b/tests/python/frontend/paddlepaddle/test_forward.py
index 83c4369d7e8d..2452e3681c50 100755
--- a/tests/python/frontend/paddlepaddle/test_forward.py
+++ b/tests/python/frontend/paddlepaddle/test_forward.py
@@ -1839,9 +1839,13 @@ def forward(self, inputs):
 @tvm.testing.uses_gpu
 def test_forward_mish():
     class Mish(nn.Layer):
+        def __init__(self, alpha=1.0, beta=1.0):
+            super(Mish, self).__init__()
+            self.mish = paddle.nn.Mish()
+
         @paddle.jit.to_static
         def forward(self, inputs):
-            return nn.functional.mish(inputs)
+            return self.mish(inputs)
 
     input_shapes = [[10], [2, 3], [5, 10, 11], [3, 4, 5, 6]]
     for input_shape in input_shapes:

From bd6dbf57fe96e05e1d6184b49312aa12ae4eaa64 Mon Sep 17 00:00:00 2001
From: xg-zheng <2444521156@qq.com>
Date: Wed, 1 Mar 2023 17:02:15 +0000
Subject: [PATCH 4/9] remove mish and tile

---
 python/tvm/relay/frontend/paddlepaddle.py     | 50 -------------
 .../frontend/paddlepaddle/test_forward.py     | 74 -------------------
 2 files changed, 124 deletions(-)

diff --git a/python/tvm/relay/frontend/paddlepaddle.py b/python/tvm/relay/frontend/paddlepaddle.py
index 5b52b850036d..8e5dd6b92bb7 100755
--- a/python/tvm/relay/frontend/paddlepaddle.py
+++ b/python/tvm/relay/frontend/paddlepaddle.py
@@ -105,37 +105,6 @@ def convert_unary_op(g, op, block):
     g.add_node(op.output("Out")[0], out)
 
 
-def convert_tile(g, op, block):
-    """Operator converter for tile."""
-
-    x = g.get_node(op.input("X")[0])
-    if op.input("RepeatTimes"):
-        reps = g.get_node(op.input("RepeatTimes")[0])
-        reps, infered = try_infer_value(reps, g.get_params())
-        if infered:
-            reps = reps.tolist()
-    elif op.input("repeat_times_tensor"):
-        reps = []
-        for rep_value in op.input("repeat_times_tensor"):
-            rep_value = g.get_node(rep_value).astype("int32")
-            reps.append(rep_value)
-        reps = _op.concatenate(reps, axis=0)
-        reps, infered = try_infer_value(reps, g.get_params())
-        if infered:
-            reps = reps.tolist()
-    else:
-        reps = op.attr("repeat_times")
-        infered = True
-
-    if not infered:
-        msg = 'Value {} in attribute "repeat_times" of operator Tile is not "valid."'
-        raise tvm.error.OpAttributeInvalid(msg.format(reps))
-
-    op_func = get_relay_op(op.type)
-    out = op_func(x, reps=reps)
-    g.add_node(op.output("Out")[0], out)
-
-
 def convert_binary_logical_op(g, op, block):
     """Operator converter for logical op."""
 
@@ -1115,23 +1084,6 @@ def convert_meshgrid(g, op, block):
         g.add_node(op.output("Out")[i], out)
 
 
-def convert_mish(g, op, block):
-    """Operator converter for mish."""
-
-    x = g.get_node(op.input("X")[0])
-    dtype = infer_type(x).checked_type.dtype
-    threshold = op.attr("threshold")
-    condition = tvm.relay.greater(x, tvm.relay.const(threshold, dtype))
-    softplus_0 = x
-    exp = _op.exp(x)
-    add = _op.add(exp, tvm.relay.const(1.0, dtype))
-    softplus_1 = _op.log(add)
-    softplus = _op.where(condition, softplus_0, softplus_1)
-    tanh = _op.tanh(softplus)
-    out = _op.multiply(x, tanh)
-    g.add_node(op.output("Out")[0], out)
-
-
 def convert_mul(g, op, block):
     """Operator converter for mul."""
 
@@ -2280,7 +2232,6 @@ def convert_where_index(g, op, block):
     "matmul": convert_matmul,
     "matmul_v2": convert_matmul,
     "meshgrid": convert_meshgrid,
-    "mish": convert_mish,
     "mul": convert_mul,
     "mv": convert_mv,
     "nearest_interp_v2": convert_interpolate,
@@ -2334,7 +2285,6 @@ def convert_where_index(g, op, block):
     "swish": convert_swish,
     "tan": convert_unary_op,
     "tanh": convert_unary_op,
-    "tile": convert_tile,
     "top_k_v2": convert_topk,
     "transpose2": convert_transpose,
     "unsqueeze2": convert_unsqueeze,
diff --git a/tests/python/frontend/paddlepaddle/test_forward.py b/tests/python/frontend/paddlepaddle/test_forward.py
index 2452e3681c50..50d1233becec 100755
--- a/tests/python/frontend/paddlepaddle/test_forward.py
+++ b/tests/python/frontend/paddlepaddle/test_forward.py
@@ -1784,80 +1784,6 @@ def where_index_1(inputs):
     verify_model(where_index_1, input_data=input_data, use_vm=True)
 
 
-@tvm.testing.uses_gpu
-def test_forward_tile():
-    class Tile1(nn.Layer):
-        @paddle.jit.to_static
-        def forward(self, inputs):
-            return paddle.tile(inputs, repeat_times=[10])
-
-    class Tile2(nn.Layer):
-        @paddle.jit.to_static
-        def forward(self, inputs):
-            return paddle.tile(inputs, repeat_times=[2, 3])
-
-    class Tile3(nn.Layer):
-        @paddle.jit.to_static
-        def forward(self, inputs):
-            return paddle.tile(inputs, repeat_times=[1, 2, 3])
-
-    class Tile4(nn.Layer):
-        @paddle.jit.to_static
-        def forward(self, inputs):
-            return paddle.tile(inputs, repeat_times=[2, 3, 4, 1, 5])
-
-    class Tile5(nn.Layer):
-        @paddle.jit.to_static
-        def forward(self, inputs):
-            reps = paddle.to_tensor([3, 2])
-            return paddle.tile(inputs, repeat_times=reps)
-
-    class Tile6(nn.Layer):
-        @paddle.jit.to_static
-        def forward(self, inputs):
-            rep_0 = paddle.to_tensor([3])
-            rep_1 = paddle.to_tensor([2])
-            return paddle.tile(inputs, repeat_times=[rep_0, rep_1])
-
-    input_shapes = [
-        [10],
-        [2, 3],
-        [3, 4, 5],
-        [5, 3, 1, 4],
-        [1, 3, 1, 6, 7],
-    ]
-    for input_shape in input_shapes:
-        input_data = paddle.randn(shape=input_shape, dtype="float32")
-        verify_model(Tile1(), input_data=input_data)
-        verify_model(Tile2(), input_data=input_data)
-        verify_model(Tile3(), input_data=input_data)
-        verify_model(Tile4(), input_data=input_data)
-        verify_model(Tile5(), input_data=input_data)
-        verify_model(Tile6(), input_data=input_data)
-
-
-@tvm.testing.uses_gpu
-def test_forward_mish():
-    class Mish(nn.Layer):
-        def __init__(self, alpha=1.0, beta=1.0):
-            super(Mish, self).__init__()
-            self.mish = paddle.nn.Mish()
-
-        @paddle.jit.to_static
-        def forward(self, inputs):
-            return self.mish(inputs)
-
-    input_shapes = [[10], [2, 3], [5, 10, 11], [3, 4, 5, 6]]
-    for input_shape in input_shapes:
-        input_data = paddle.randn(shape=input_shape, dtype="float32")
-        verify_model(Mish(), input_data=input_data)
-        input_data += 20.0
-        verify_model(Mish(), input_data=input_data)
-
-    input_data = paddle.to_tensor([-5.0, 0.0, 5.0, 23.1, 20.0])
-    verify_model(Mish(), input_data=input_data)
-
-
 @tvm.testing.uses_gpu
 def test_forward_stack():
     class Stack1(nn.Layer):

From 1293950898da47f00fd43b3f2b317a37d9185939 Mon Sep 17 00:00:00 2001
From: xg-zheng <2444521156@qq.com>
Date: Thu, 2 Mar 2023 04:08:01 +0000
Subject: [PATCH 5/9] fix tensor type error in test case

---
 python/tvm/relay/frontend/paddlepaddle.py     | 32 +++++++++++
 .../frontend/paddlepaddle/test_forward.py     | 55 +++++++++++++++++++
 2 files changed, 87 insertions(+)

diff --git a/python/tvm/relay/frontend/paddlepaddle.py b/python/tvm/relay/frontend/paddlepaddle.py
index 8e5dd6b92bb7..92f7c1498420 100755
--- a/python/tvm/relay/frontend/paddlepaddle.py
+++ b/python/tvm/relay/frontend/paddlepaddle.py
@@ -2069,6 +2069,37 @@ def convert_swish(g, op, block):
     g.add_node(op.output("Out")[0], out)
 
 
+def convert_tile(g, op, block):
+    """Operator converter for tile."""
+
+    x = g.get_node(op.input("X")[0])
+    if op.input("RepeatTimes"):
+        reps = g.get_node(op.input("RepeatTimes")[0])
+        reps, infered = try_infer_value(reps, g.get_params())
+        if infered:
+            reps = reps.tolist()
+    elif op.input("repeat_times_tensor"):
+        reps = []
+        for rep_value in op.input("repeat_times_tensor"):
+            rep_value = g.get_node(rep_value).astype("int32")
+            reps.append(rep_value)
+        reps = _op.concatenate(reps, axis=0)
+        reps, infered = try_infer_value(reps, g.get_params())
+        if infered:
+            reps = reps.tolist()
+    else:
+        reps = op.attr("repeat_times")
+        infered = True
+
+    if not infered:
+        msg = 'Value {} in attribute "repeat_times" of operator Tile is not "valid."'
+        raise tvm.error.OpAttributeInvalid(msg.format(reps))
+
+    op_func = get_relay_op(op.type)
+    out = op_func(x, reps=reps)
+    g.add_node(op.output("Out")[0], out)
+
+
 def convert_topk(g, op, block):
     """Operator converter for topk."""
 
@@ -2285,6 +2316,7 @@ def convert_where_index(g, op, block):
     "swish": convert_swish,
     "tan": convert_unary_op,
     "tanh": convert_unary_op,
+    "tile": convert_tile,
     "top_k_v2": convert_topk,
     "transpose2": convert_transpose,
     "unsqueeze2": convert_unsqueeze,
diff --git a/tests/python/frontend/paddlepaddle/test_forward.py b/tests/python/frontend/paddlepaddle/test_forward.py
index 50d1233becec..6ac18f5d848f 100755
--- a/tests/python/frontend/paddlepaddle/test_forward.py
+++ b/tests/python/frontend/paddlepaddle/test_forward.py
@@ -1896,5 +1896,60 @@ def where2(x, y):
         verify_model(where2, [x, y])
 
 
+@tvm.testing.uses_gpu
+def test_forward_tile():
+    class Tile1(nn.Layer):
+        @paddle.jit.to_static
+        def forward(self, inputs):
+            return paddle.tile(inputs, repeat_times=[10])
+
+    class Tile2(nn.Layer):
+        @paddle.jit.to_static
+        def forward(self, inputs):
+            return paddle.tile(inputs, repeat_times=[2, 3])
+
+    class Tile3(nn.Layer):
+        @paddle.jit.to_static
+        def forward(self, inputs):
+            return paddle.tile(inputs, repeat_times=[1, 2, 3])
+
+    class Tile4(nn.Layer):
+        @paddle.jit.to_static
+        def forward(self, inputs):
+            return paddle.tile(inputs, repeat_times=[2, 3, 4, 1, 5])
+
+    class Tile5(nn.Layer):
+        @paddle.jit.to_static
+        def forward(self, inputs):
+            reps = paddle.to_tensor([3, 2])
+            reps = paddle.cast(reps, "int32")
+            return paddle.tile(inputs, repeat_times=reps)
+
+    class Tile6(nn.Layer):
+        @paddle.jit.to_static
+        def forward(self, inputs):
+            rep_0 = paddle.to_tensor([3])
+            rep_1 = paddle.to_tensor([2])
+            rep_0 = paddle.cast(rep_0, "int32")
+            rep_1 = paddle.cast(rep_1, "int32")
+            return paddle.tile(inputs, repeat_times=[rep_0, rep_1])
+
+    input_shapes = [
+        [10],
+        [2, 3],
+        [3, 4, 5],
+        [5, 3, 1, 4],
+        [1, 3, 1, 6, 7],
+    ]
+    for input_shape in input_shapes:
+        input_data = paddle.randn(shape=input_shape, dtype="float32")
+        verify_model(Tile1(), input_data=input_data)
+        verify_model(Tile2(), input_data=input_data)
+        verify_model(Tile3(), input_data=input_data)
+        verify_model(Tile4(), input_data=input_data)
+        verify_model(Tile5(), input_data=input_data)
+        verify_model(Tile6(), input_data=input_data)
+
+
 if __name__ == "__main__":
     tvm.testing.main()

From ec005556b0cb35a4968ef2ce5e951840137fc89f Mon Sep 17 00:00:00 2001
From: xg-zheng <2444521156@qq.com>
Date: Mon, 6 Mar 2023 16:26:30 +0000
Subject: [PATCH 6/9] optimize convert softshrink

---
 python/tvm/relay/frontend/paddlepaddle.py | 21 +++++----------------
 1 file changed, 5 insertions(+), 16 deletions(-)

diff --git a/python/tvm/relay/frontend/paddlepaddle.py b/python/tvm/relay/frontend/paddlepaddle.py
index 92f7c1498420..3338170fc185 100755
--- a/python/tvm/relay/frontend/paddlepaddle.py
+++ b/python/tvm/relay/frontend/paddlepaddle.py
@@ -1961,25 +1961,14 @@ def convert_softsign(g, op, block):
 def convert_softshrink(g, op, block):
     """Operator converter for softshrink."""
 
-    threshold = op.attr("lambda")
     x = g.get_node(op.input("X")[0])
     dtype = infer_type(x).checked_type.dtype
-    threshold_right = _expr.const(threshold, dtype)
-    threshold_left = _expr.const(-1.0 * threshold, dtype)
-    middle = _expr.const(0.0, dtype)
-    condition_0 = tvm.relay.logical_and(
-        tvm.relay.less_equal(x, threshold_right), tvm.relay.greater_equal(x, threshold_left)
+    threshold = _expr.const(op.attr("lambda"), dtype=dtype)
+    zeros = _op.zeros_like(x)
+    out = _op.where(x < -threshold, x + threshold, zeros) + _op.where(
+        x > threshold, x - threshold, zeros
     )
-    calc_middle = tvm.relay.where(condition_0, middle, x)
-
-    sub_threshold = _op.subtract(x, threshold_right)
-    condition_1 = tvm.relay.greater(calc_middle, threshold_right)
-    calc_right = tvm.relay.where(condition_1, sub_threshold, calc_middle)
-
-    add_threshold = _op.add(x, threshold_right)
-    condition_2 = tvm.relay.less(calc_right, threshold_left)
-    calc_left = tvm.relay.where(condition_2, add_threshold, calc_right)
-    g.add_node(op.output("Out")[0], calc_left)
+    g.add_node(op.output("Out")[0], out)
 
 
 def convert_split(g, op, block):

From 278548a067555e1b8fff9953319b484a1a9bd932 Mon Sep 17 00:00:00 2001
From: xg-zheng <2444521156@qq.com>
Date: Tue, 7 Mar 2023 01:15:02 +0000
Subject: [PATCH 7/9] add convert mish and test case

---
 python/tvm/relay/frontend/paddlepaddle.py      | 16 ++++++++++++++++
 .../frontend/paddlepaddle/test_forward.py      | 18 ++++++++++++++++++
 2 files changed, 34 insertions(+)

diff --git a/python/tvm/relay/frontend/paddlepaddle.py b/python/tvm/relay/frontend/paddlepaddle.py
index 3338170fc185..5e3587274b5a 100755
--- a/python/tvm/relay/frontend/paddlepaddle.py
+++ b/python/tvm/relay/frontend/paddlepaddle.py
@@ -1084,6 +1084,21 @@ def convert_meshgrid(g, op, block):
         g.add_node(op.output("Out")[i], out)
 
 
+def convert_mish(g, op, block):
+    """Operator converter for mish."""
+
+    x = g.get_node(op.input("X")[0])
+    dtype = infer_type(x).checked_type.dtype
+    threshold = _expr.const(op.attr("threshold"), dtype=dtype)
+    exp = _op.exp(x)
+    add = _op.add(exp, _expr.const(1.0, dtype))
+    log = _op.log(add)
+    softplus = _op.where(x > threshold, x, log)
+    tanh = _op.tanh(softplus)
+    out = _op.multiply(x, tanh)
+    g.add_node(op.output("Out")[0], out)
+
+
 def convert_mul(g, op, block):
     """Operator converter for mul."""
 
@@ -2252,6 +2267,7 @@ def convert_where_index(g, op, block):
     "matmul": convert_matmul,
     "matmul_v2": convert_matmul,
     "meshgrid": convert_meshgrid,
+    "mish": convert_mish,
     "mul": convert_mul,
     "mv": convert_mv,
     "nearest_interp_v2": convert_interpolate,
diff --git a/tests/python/frontend/paddlepaddle/test_forward.py b/tests/python/frontend/paddlepaddle/test_forward.py
index 6ac18f5d848f..607e8c6a227b 100755
--- a/tests/python/frontend/paddlepaddle/test_forward.py
+++ b/tests/python/frontend/paddlepaddle/test_forward.py
@@ -1951,5 +1951,23 @@ def forward(self, inputs):
         verify_model(Tile6(), input_data=input_data)
 
 
+@tvm.testing.uses_gpu
+def test_forward_mish():
+    class Mish(nn.Layer):
+        @paddle.jit.to_static
+        def forward(self, inputs):
+            return nn.functional.mish(inputs)
+
+    input_shapes = [[10], [2, 3], [5, 10, 11], [3, 4, 5, 6]]
+    for input_shape in input_shapes:
+        input_data = paddle.randn(shape=input_shape, dtype="float32")
+        verify_model(Mish(), input_data=input_data)
+        input_data += 20.0
+        verify_model(Mish(), input_data=input_data)
+
+    input_data = paddle.to_tensor([-5.0, 0.0, 5.0, 23.1, 20.0])
+    verify_model(Mish(), input_data=input_data)
+
+
 if __name__ == "__main__":
     tvm.testing.main()

From 1808117f681abc99315c1fb6085c2856fe22527e Mon Sep 17 00:00:00 2001
From: xg-zheng <2444521156@qq.com>
Date: Tue, 7 Mar 2023 04:14:12 +0000
Subject: [PATCH 8/9] optimize mish implementation

---
 python/tvm/relay/frontend/paddlepaddle.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/python/tvm/relay/frontend/paddlepaddle.py b/python/tvm/relay/frontend/paddlepaddle.py
index 5e3587274b5a..4b849987ed81 100755
--- a/python/tvm/relay/frontend/paddlepaddle.py
+++ b/python/tvm/relay/frontend/paddlepaddle.py
@@ -1089,12 +1089,10 @@ def convert_mish(g, op, block):
 
     x = g.get_node(op.input("X")[0])
     dtype = infer_type(x).checked_type.dtype
-    threshold = _expr.const(op.attr("threshold"), dtype=dtype)
     exp = _op.exp(x)
     add = _op.add(exp, _expr.const(1.0, dtype))
     log = _op.log(add)
-    softplus = _op.where(x > threshold, x, log)
-    tanh = _op.tanh(softplus)
+    tanh = _op.tanh(log)
     out = _op.multiply(x, tanh)
     g.add_node(op.output("Out")[0], out)
 

From 613dfa22413020b04b9f23945dcd15129cf57f77 Mon Sep 17 00:00:00 2001
From: xg-zheng <2444521156@qq.com>
Date: Wed, 8 Mar 2023 02:17:04 +0000
Subject: [PATCH 9/9] modify mish test case

---
 .../python/frontend/paddlepaddle/test_forward.py  | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/tests/python/frontend/paddlepaddle/test_forward.py b/tests/python/frontend/paddlepaddle/test_forward.py
index 607e8c6a227b..4a34498556df 100755
--- a/tests/python/frontend/paddlepaddle/test_forward.py
+++ b/tests/python/frontend/paddlepaddle/test_forward.py
@@ -1959,14 +1959,15 @@ def forward(self, inputs):
             return nn.functional.mish(inputs)
 
     input_shapes = [[10], [2, 3], [5, 10, 11], [3, 4, 5, 6]]
-    for input_shape in input_shapes:
-        input_data = paddle.randn(shape=input_shape, dtype="float32")
+    if paddle.version.full_version >= "2.4.2":
+        for input_shape in input_shapes:
+            input_data = paddle.randn(shape=input_shape, dtype="float32")
+            verify_model(Mish(), input_data=input_data)
+            input_data += 20.0
+            verify_model(Mish(), input_data=input_data)
+
+        input_data = paddle.to_tensor([-5.0, 0.0, 5.0, 23.1, 20.0])
         verify_model(Mish(), input_data=input_data)
-        input_data += 20.0
-        verify_model(Mish(), input_data=input_data)
-
-    input_data = paddle.to_tensor([-5.0, 0.0, 5.0, 23.1, 20.0])
-    verify_model(Mish(), input_data=input_data)
 
 
 if __name__ == "__main__":