diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/acos_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/acos_zero_size_0_func.py new file mode 100644 index 0000000000..364f79e266 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/acos_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: acos_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.acos(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/acosh_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/acosh_zero_size_0_func.py new file mode 100644 index 0000000000..8f21da81fb --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/acosh_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: acosh_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.acosh(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/addmm_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/addmm_zero_size_0_func.py new file mode 100644 index 0000000000..feaeeb8c14 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/addmm_zero_size_0_func.py @@ -0,0 +1,55 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: addmm_zero_size_0_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, data, x, y, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.addmm(data, x, y, alpha=5.0, beta=0.5 ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1), dtype=paddle.float32, stop_gradient=False), + paddle.static.InputSpec(shape=(-1, -1, -1), dtype=paddle.float32, stop_gradient=False), + paddle.static.InputSpec(shape=(-1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = ( + paddle.to_tensor(-10 + (10 - -10) * np.random.random([100, 0]).astype('float32'), dtype='float32', stop_gradient=False), + paddle.to_tensor(-10 + (10 - -10) * np.random.random([100, 0]).astype('float32'), dtype='float32', stop_gradient=False), + paddle.to_tensor(-10 + (10 - -10) * np.random.random([100, 0]).astype('float32'), dtype='float32', stop_gradient=False), + ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ( + -10 + (10 - -10) * np.random.random([100, 0]).astype('float32'), + -10 + (10 - -10) * np.random.random([100, 0]).astype('float32'), + -10 + (10 - -10) * np.random.random([100, 0]).astype('float32'), + ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/allclose_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/allclose_zero_size_0_func.py new file mode 100644 index 0000000000..3e6fa76ec5 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/allclose_zero_size_0_func.py @@ -0,0 +1,52 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: allclose_zero_size_0_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, y, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.allclose(x, y, rtol=0.00001, atol=0.00000001 ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1), dtype=paddle.float32, stop_gradient=False), + paddle.static.InputSpec(shape=(-1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = ( + paddle.to_tensor(-1 + (1 - -1) * np.random.random([100, 0, 10]).astype('float32'), dtype='float32', stop_gradient=False), + paddle.to_tensor(-1 + (1 - -1) * np.random.random([100, 0, 10]).astype('float32'), dtype='float32', stop_gradient=False), + ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ( + -1 + (1 - -1) * np.random.random([100, 0, 10]).astype('float32'), + -1 + (1 - -1) * np.random.random([100, 0, 10]).astype('float32'), + ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/any_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/any_zero_size_0_func.py new file mode 100644 index 0000000000..a1a9e5a5d1 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/any_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: any_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.any(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, ), dtype=paddle.bool, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([0]).astype('bool'), dtype='bool', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([0]).astype('bool'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/arange_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/arange_zero_size_0_func.py new file mode 100644 index 0000000000..2ed65e492d --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/arange_zero_size_0_func.py @@ -0,0 +1,48 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: arange_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.arange( + start=0., + end=0., + step=0., + dtype="float32", + ) + return out + + + +def create_inputspec(): + inputspec = () + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = () + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = () + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/argmax_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/argmax_zero_size_0_func.py new file mode 100644 index 0000000000..8fb5b8537f --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/argmax_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: argmax_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.argmax(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/argsort_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/argsort_zero_size_0_func.py new file mode 100644 index 0000000000..e9bdefb3c3 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/argsort_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: argsort_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.argsort(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/asin_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/asin_zero_size_0_func.py new file mode 100644 index 0000000000..2e69290746 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/asin_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: asin_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.asin(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/asinh_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/asinh_zero_size_0_func.py new file mode 100644 index 0000000000..de68ee5a17 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/asinh_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: asinh_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.asinh(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/ceil_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/ceil_zero_size_0_func.py new file mode 100644 index 0000000000..92c7e81e49 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/ceil_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: ceil_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.ceil(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-10 + (10 - -10) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-10 + (10 - -10) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/clip_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/clip_zero_size_0_func.py new file mode 100644 index 0000000000..065358f316 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/clip_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: clip_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.clip(x, min=-5.0, max=5.0) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-10 + (10 - -10) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-10 + (10 - -10) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/cos_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/cos_zero_size_0_func.py new file mode 100644 index 0000000000..678cc46da0 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/cos_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: cos_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.cos(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-2 + (2 - -2) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-2 + (2 - -2) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/diag_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/diag_zero_size_0_func.py new file mode 100644 index 0000000000..ad1d8c0e37 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/diag_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: diag_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.diag(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 0]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/dot_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/dot_zero_size_0_func.py new file mode 100644 index 0000000000..f43c5fc6a7 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/dot_zero_size_0_func.py @@ -0,0 +1,52 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: dot_zero_size_0_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, y, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.dot(x, y, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1), dtype=paddle.float32, stop_gradient=False), + paddle.static.InputSpec(shape=(-1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = ( + paddle.to_tensor(-1 + (1 - -1) * np.random.random([100, 0]).astype('float32'), dtype='float32', stop_gradient=False), + paddle.to_tensor(-1 + (1 - -1) * np.random.random([100, 0]).astype('float32'), dtype='float32', stop_gradient=False), + ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ( + -1 + (1 - -1) * np.random.random([100, 0]).astype('float32'), + -1 + (1 - -1) * np.random.random([100, 0]).astype('float32'), + ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/equal_all_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/equal_all_zero_size_0_func.py new file mode 100644 index 0000000000..d79e0c269e --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/equal_all_zero_size_0_func.py @@ -0,0 +1,52 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: equal_all_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, y): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.equal_all(x, y ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1), dtype=paddle.int32, stop_gradient=False), + paddle.static.InputSpec(shape=(-1, -1, -1), dtype=paddle.int32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = ( + paddle.to_tensor(-2 + 4 * np.random.random([128, 0, 1]).astype('int32'), dtype='int32', stop_gradient=False), + paddle.to_tensor(-2 + 4 * np.random.random([128, 0, 1]).astype('int32'), dtype='int32', stop_gradient=False), + ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ( + (-2 + 4 * np.random.random([128, 0, 1])).astype('int32'), + (-2 + 4 * np.random.random([128, 0, 1])).astype('int32'), + ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/exp_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/exp_zero_size_0_func.py new file mode 100644 index 0000000000..6ba1325d6f --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/exp_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: exp_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.exp(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-2 + (2 - -2) * np.random.random([128, 0, 1]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-2 + (2 - -2) * np.random.random([128, 0, 1]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/flatten_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/flatten_zero_size_0_func.py new file mode 100644 index 0000000000..9c62e910c2 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/flatten_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: flatten_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.flatten(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/isnan_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/isnan_zero_size_0_func.py new file mode 100644 index 0000000000..af1edec106 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/isnan_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: isnan_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.isnan(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor([[-1.0, 2.0, 'nan'], ['-inf', 'inf', '-nan'], [2.4, 0.0, '-inf']], dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (np.array([[-1.0, 2.0, 'nan'], ['-inf', 'inf', '-nan'], [2.4, 0.0, '-inf']]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/log_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/log_zero_size_0_func.py new file mode 100644 index 0000000000..bd24e297cb --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/log_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: log_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.log(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (10 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (10 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/matmul_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/matmul_zero_size_0_func.py new file mode 100644 index 0000000000..3dd3ef83ff --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/matmul_zero_size_0_func.py @@ -0,0 +1,52 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: matmul_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, y): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.matmul(x, y ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = ( + paddle.to_tensor(-1 + 2 * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), + paddle.to_tensor(-1 + 2 * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), + ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ( + (-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'), + (-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'), + ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/max_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/max_zero_size_0_func.py new file mode 100644 index 0000000000..408addf32b --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/max_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: max_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.max(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/maximum_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/maximum_zero_size_0_func.py new file mode 100644 index 0000000000..5cc73e4924 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/maximum_zero_size_0_func.py @@ -0,0 +1,52 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: maximum_zero_size_0_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, y, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.maximum(x, y, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = ( + paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), + paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), + ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ( + -1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), + -1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), + ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/mean_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/mean_zero_size_0_func.py new file mode 100644 index 0000000000..a63159cf99 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/mean_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: mean_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.mean(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/min_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/min_zero_size_0_func.py new file mode 100644 index 0000000000..cf259fbfe4 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/min_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: min_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.min(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/mm_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/mm_zero_size_0_func.py index 58a195e76f..0ebaf0d424 100644 --- a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/mm_zero_size_0_func.py +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/mm_zero_size_0_func.py @@ -24,8 +24,8 @@ def forward(self, x, y, ): def create_inputspec(): inputspec = ( - paddle.static.InputSpec(shape=(-1, -1, -1), dtype=paddle.float32, stop_gradient=False), - paddle.static.InputSpec(shape=(-1, -1, -1), dtype=paddle.float32, stop_gradient=False), + paddle.static.InputSpec(shape=(-1, -1), dtype=paddle.float32, stop_gradient=False), + paddle.static.InputSpec(shape=(-1, -1), dtype=paddle.float32, stop_gradient=False), ) return inputspec diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/nonzero_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/nonzero_zero_size_0_func.py new file mode 100644 index 0000000000..6bd38fb085 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/nonzero_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: nonzero_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.nonzero(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.int32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (2 - -1) * np.random.random([12, 0, 10, 10]).astype('int32'), dtype='int32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (2 - -1) * np.random.random([12, 0, 10, 10]).astype('int32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/numel_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/numel_zero_size_0_func.py new file mode 100644 index 0000000000..0e72550369 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/numel_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: numel_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.numel(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/ones_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/ones_zero_size_0_func.py new file mode 100644 index 0000000000..ac17e95d52 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/ones_zero_size_0_func.py @@ -0,0 +1,43 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: ones_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.ones(shape=[128, 0, 1]) + return out + + + +def create_inputspec(): + inputspec = () + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = () + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = () + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/prod_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/prod_zero_size_0_func.py new file mode 100644 index 0000000000..23613e0682 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/prod_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: prod_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.prod(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/reshape_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/reshape_zero_size_0_func.py new file mode 100644 index 0000000000..e0262fa627 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/reshape_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: reshape_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.reshape(x, shape=[12, 0, 100, 1]) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/round_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/round_zero_size_0_func.py new file mode 100644 index 0000000000..cd7e4e8aa3 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/round_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: round_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.round(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-10 + (10 - -10) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-10 + (10 - -10) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/sin_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/sin_zero_size_0_func.py new file mode 100644 index 0000000000..5153749960 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/sin_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: sin_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.sin(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-2 + (2 - -2) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-2 + (2 - -2) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/sqrt_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/sqrt_zero_size_0_func.py new file mode 100644 index 0000000000..6eb34f271f --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/sqrt_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: sqrt_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.sqrt(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-2 + (2 - -2) * np.random.random([128, 0, 1]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-2 + (2 - -2) * np.random.random([128, 0, 1]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/squeeze_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/squeeze_zero_size_0_func.py new file mode 100644 index 0000000000..32fc870b87 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/squeeze_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: squeeze_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.squeeze(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0, 10, 1, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 0, 10, 1, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/std_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/std_zero_size_0_func.py new file mode 100644 index 0000000000..997fc57640 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/std_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: std_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.std(x, axis=0, unbiased=True, keepdim=False) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/sum_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/sum_zero_size_0_func.py new file mode 100644 index 0000000000..5e39b3418e --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/sum_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: sum_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.sum(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/tile_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/tile_zero_size_0_func.py new file mode 100644 index 0000000000..72c09ac8f3 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/tile_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: tile_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.tile(x, repeat_times=[2, 1]) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/trace_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/trace_zero_size_0_func.py new file mode 100644 index 0000000000..34f9e87b99 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/trace_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: trace_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.trace(x, offset=0, axis1=0, axis2=1) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 0]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/unique_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/unique_zero_size_0_func.py new file mode 100644 index 0000000000..e4b0fe2cd6 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/unique_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: unique_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.unique(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.int32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-5 + (5 - -5) * np.random.random([12, 0, 10, 10]).astype('int32'), dtype='int32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-5 + (5 - -5) * np.random.random([12, 0, 10, 10]).astype('int32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/unsqueeze_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/unsqueeze_zero_size_0_func.py new file mode 100644 index 0000000000..ec19204b1b --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/unsqueeze_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: unsqueeze_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.unsqueeze(x, axis=1) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/var_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/var_zero_size_0_func.py new file mode 100644 index 0000000000..e04fb6fdef --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/var_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: var_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.var(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/where_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/where_zero_size_0_func.py new file mode 100644 index 0000000000..26dbc4a5d0 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/where_zero_size_0_func.py @@ -0,0 +1,52 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: where_zero_size_0_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, y, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.where(x>y, x, y, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = ( + paddle.to_tensor(-10 + (10 - -10) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), + paddle.to_tensor(-10 + (10 - -10) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), + ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ( + -10 + (10 - -10) * np.random.random([12, 0, 10, 10]).astype('float32'), + -10 + (10 - -10) * np.random.random([12, 0, 10, 10]).astype('float32'), + ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/zeros_like_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/zeros_like_zero_size_0_func.py new file mode 100644 index 0000000000..7a27da9a63 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/zeros_like_zero_size_0_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: zeros_like_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.zeros_like(x, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, -1, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 0, 10, 10]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/zeros_zero_size_0_func.py b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/zeros_zero_size_0_func.py new file mode 100644 index 0000000000..fcd5bb0fcc --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/math_zero_size/zeros_zero_size_0_func.py @@ -0,0 +1,43 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: zeros_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.zeros(shape=[128, 0, 1]) + return out + + + +def create_inputspec(): + inputspec = () + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = () + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = () + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/nn_zero_size/BatchNorm2D_zero_size_class.py b/framework/e2e/PaddleLT_new/layerApicase/nn_zero_size/BatchNorm2D_zero_size_class.py new file mode 100644 index 0000000000..096d26e6cd --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/nn_zero_size/BatchNorm2D_zero_size_class.py @@ -0,0 +1,51 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: BatchNorm2D_zero_size_class + """ + + def __init__(self): + super(LayerCase, self).__init__() + self.func = paddle.nn.BatchNorm2D( + num_features=10, + momentum=0.9, + epsilon=0.00001, + data_format='NCHW', + ) + + def forward(self, data, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = self.func(data, ) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, 10, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-1 + (1 - -1) * np.random.random([12, 10, 10, 0]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-1 + (1 - -1) * np.random.random([12, 10, 10, 0]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/layerApicase/nn_zero_size/normalize_zero_size_func.py b/framework/e2e/PaddleLT_new/layerApicase/nn_zero_size/normalize_zero_size_func.py new file mode 100644 index 0000000000..491e729e50 --- /dev/null +++ b/framework/e2e/PaddleLT_new/layerApicase/nn_zero_size/normalize_zero_size_func.py @@ -0,0 +1,45 @@ +import numpy as np +import paddle + + +class LayerCase(paddle.nn.Layer): + """ + case名称: normalize_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, data, ): + """ + forward + """ + + paddle.seed(33) + np.random.seed(33) + out = paddle.nn.functional.normalize(data, p=2, axis=0, epsilon=0.000000000001) + return out + + + +def create_inputspec(): + inputspec = ( + paddle.static.InputSpec(shape=(-1, 0, -1, -1), dtype=paddle.float32, stop_gradient=False), + ) + return inputspec + +def create_tensor_inputs(): + """ + paddle tensor + """ + inputs = (paddle.to_tensor(-2 + (3 - -2) * np.random.random([3, 0, 1, 1]).astype('float32'), dtype='float32', stop_gradient=False), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (-2 + (3 - -2) * np.random.random([3, 0, 1, 1]).astype('float32'), ) + return inputs + diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/acos_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/acos_zero_size_0_func.py new file mode 100644 index 0000000000..439ac8052d --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/acos_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: acos_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.acos(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/acosh_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/acosh_zero_size_0_func.py new file mode 100644 index 0000000000..f4cf73f179 --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/acosh_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: acosh_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.acosh(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/addmm_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/addmm_zero_size_0_func.py new file mode 100644 index 0000000000..e91adc8a0b --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/addmm_zero_size_0_func.py @@ -0,0 +1,43 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: addmm_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, data, x, y ): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.addmm(data, x, y, alpha=5.0, beta=0.5 ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = ( + torch.tensor((-1 + 2 * np.random.random([100, 0, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), + torch.tensor((-1 + 2 * np.random.random([100, 0, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), + ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ( + (-1 + 2 * np.random.random([100, 0, 10])).astype('float32'), + (-1 + 2 * np.random.random([100, 0, 10])).astype('float32'), + ) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/allclose_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/allclose_zero_size_0_func.py new file mode 100644 index 0000000000..d8c7cd1034 --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/allclose_zero_size_0_func.py @@ -0,0 +1,43 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: allclose_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, y ): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.allclose(x, y, rtol=0.00001, atol=0.00000001 ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = ( + torch.tensor((-1 + 2 * np.random.random([100, 0, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), + torch.tensor((-1 + 2 * np.random.random([100, 0, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), + ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ( + (-1 + 2 * np.random.random([100, 0, 10])).astype('float32'), + (-1 + 2 * np.random.random([100, 0, 10])).astype('float32'), + ) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/any_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/any_zero_size_0_func.py new file mode 100644 index 0000000000..38920b7bd3 --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/any_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: any_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.any(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([0])).astype(np.bool), dtype=torch.bool, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([0])).astype('bool'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/arange_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/arange_zero_size_0_func.py new file mode 100644 index 0000000000..a1dfb8ca5d --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/arange_zero_size_0_func.py @@ -0,0 +1,41 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: arange_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, ): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.arange( + start=0., + end=0., + step=0., + ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = () + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = () + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/argmax_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/argmax_zero_size_0_func.py new file mode 100644 index 0000000000..7ff95f2a5d --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/argmax_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: argmax_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.argmax(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/argsort_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/argsort_zero_size_0_func.py new file mode 100644 index 0000000000..526e8f52dc --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/argsort_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: argsort_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.argsort(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/asin_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/asin_zero_size_0_func.py new file mode 100644 index 0000000000..e1caa55b2f --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/asin_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: asin_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.asin(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/asinh_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/asinh_zero_size_0_func.py new file mode 100644 index 0000000000..81ef4e1d6d --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/asinh_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: asinh_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.asinh(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/ceil_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/ceil_zero_size_0_func.py new file mode 100644 index 0000000000..30d50cc3a6 --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/ceil_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: ceil_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.ceil(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-10 + 20 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-10 + 20 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/clip_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/clip_zero_size_0_func.py new file mode 100644 index 0000000000..968e4a524c --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/clip_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: clip_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.clip(x, min=-5.0, max=5.0) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-10 + 20 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-10 + 20 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/cos_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/cos_zero_size_0_func.py new file mode 100644 index 0000000000..348d0093dd --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/cos_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: cos_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.cos(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-2 + 4 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-2 + 4 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/diag_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/diag_zero_size_0_func.py new file mode 100644 index 0000000000..f75d0933c0 --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/diag_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: diag_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.diag(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 0])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 0])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/dot_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/dot_zero_size_0_func.py new file mode 100644 index 0000000000..7f72a8cc86 --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/dot_zero_size_0_func.py @@ -0,0 +1,43 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: dot_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, y ): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.dot(x, y ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = ( + torch.tensor((-1 + 2 * np.random.random([100, 0])).astype(np.float32), dtype=torch.float32, requires_grad=True), + torch.tensor((-1 + 2 * np.random.random([100, 0])).astype(np.float32), dtype=torch.float32, requires_grad=True), + ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ( + (-1 + 2 * np.random.random([100, 0])).astype('float32'), + (-1 + 2 * np.random.random([100, 0])).astype('float32'), + ) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/equal_zero_size_0_func copy.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/equal_zero_size_0_func copy.py new file mode 100644 index 0000000000..42a7e9adef --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/equal_zero_size_0_func copy.py @@ -0,0 +1,43 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: equal_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, y ): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.equal(x, y ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = ( + torch.tensor((-2 + 4 * np.random.random([128, 0, 1])).astype(np.int32), dtype=torch.int32, requaluires_grad=True), + torch.tensor((-2 + 4 * np.random.random([128, 0, 1])).astype(np.int32), dtype=torch.int32, requaluires_grad=True), + ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ( + (-2 + 4 * np.random.random([128, 0, 1])).astype('int32'), + (-2 + 4 * np.random.random([128, 0, 1])).astype('int32'), + ) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/equal_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/equal_zero_size_0_func.py index fb2d76bc09..35a4db37e1 100644 --- a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/equal_zero_size_0_func.py +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/equal_zero_size_0_func.py @@ -5,7 +5,7 @@ class LayerCase(nn.Module): """ - case名称: equal_zero_size_func + case名称: eq_zero_size_func """ def __init__(self): @@ -17,7 +17,7 @@ def forward(self, x, y ): """ torch.manual_seed(33) np.random.seed(33) - out = torch.equal(x, y ) + out = torch.eq(x, y ) return out diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/exp_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/exp_zero_size_0_func.py new file mode 100644 index 0000000000..5097fe7803 --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/exp_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: exp_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.exp(x) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-2 + 4 * np.random.random([128, 0, 1])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-2 + 4 * np.random.random([128, 0, 1])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/flatten_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/flatten_zero_size_0_func.py new file mode 100644 index 0000000000..5d6dbd3f21 --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/flatten_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: flatten_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.flatten(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/isnan_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/isnan_zero_size_0_func.py new file mode 100644 index 0000000000..f8ac18a3b7 --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/isnan_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: isnan_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.isnan(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor([[-1.0, 2.0, 'nan'], ['-inf', 'inf', '-nan'], [2.4, 0.0, '-inf']], dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = (np.array([[-1.0, 2.0, 'nan'], ['-inf', 'inf', '-nan'], [2.4, 0.0, '-inf']]).astype('float32'), ) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/linspace_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/linspace_zero_size_0_func.py index 9b465a919d..69a76cd65e 100644 --- a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/linspace_zero_size_0_func.py +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/linspace_zero_size_0_func.py @@ -19,8 +19,8 @@ def forward(self, ): np.random.seed(33) out = torch.linspace( start=0, - stop=0, - num=0, + end=0, + steps=0, ) return out diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/log_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/log_zero_size_0_func.py new file mode 100644 index 0000000000..05e60eaa4c --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/log_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: log_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.log(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 11 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 11 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/matmul_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/matmul_zero_size_0_func.py new file mode 100644 index 0000000000..904d1046eb --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/matmul_zero_size_0_func.py @@ -0,0 +1,43 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: matmul_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, y ): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.matmul(x, y ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = ( + torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), + torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), + ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ( + (-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'), + (-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'), + ) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/max_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/max_zero_size_0_func.py new file mode 100644 index 0000000000..0e9caaed5d --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/max_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: max_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.max(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/maximum_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/maximum_zero_size_0_func.py new file mode 100644 index 0000000000..8edfe89fec --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/maximum_zero_size_0_func.py @@ -0,0 +1,43 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: maximum_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, y ): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.maximum(x, y ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = ( + torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), + torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), + ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ( + (-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'), + (-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'), + ) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/mean_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/mean_zero_size_0_func.py new file mode 100644 index 0000000000..3fafe696bc --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/mean_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: mean_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.mean(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/min_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/min_zero_size_0_func.py new file mode 100644 index 0000000000..2e89812819 --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/min_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: min_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.min(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/nonzero_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/nonzero_zero_size_0_func.py new file mode 100644 index 0000000000..42c11e011f --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/nonzero_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: nonzero_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.nonzero(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 3 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 3 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/numel_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/numel_zero_size_0_func.py new file mode 100644 index 0000000000..760ea3a6fe --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/numel_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: numel_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.numel(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/ones_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/ones_zero_size_0_func.py new file mode 100644 index 0000000000..ecb3017f1d --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/ones_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: ones_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, ): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.ones(size=[128, 0, 1]) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = () + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = () + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/prod_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/prod_zero_size_0_func.py new file mode 100644 index 0000000000..92eec7f444 --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/prod_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: prod_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.prod(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/reshape_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/reshape_zero_size_0_func.py new file mode 100644 index 0000000000..a9bbf99072 --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/reshape_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: reshape_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.reshape(x, shape=[12, 0, 100, 1]) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/round_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/round_zero_size_0_func.py new file mode 100644 index 0000000000..756315201f --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/round_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: round_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.round(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-10 + 20 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-10 + 20 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/sin_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/sin_zero_size_0_func.py new file mode 100644 index 0000000000..fdf2fd3cba --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/sin_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: sin_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.sin(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-2 + 4 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-2 + 4 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/sqrt_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/sqrt_zero_size_0_func.py new file mode 100644 index 0000000000..6e95b96b64 --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/sqrt_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: sqrt_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.sqrt(x) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-2 + 4 * np.random.random([128, 0, 1])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-2 + 4 * np.random.random([128, 0, 1])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/squeeze_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/squeeze_zero_size_0_func.py new file mode 100644 index 0000000000..61a7b48865 --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/squeeze_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: squeeze_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.squeeze(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 1, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 0, 10, 1, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/std_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/std_zero_size_0_func.py new file mode 100644 index 0000000000..16a41fb56d --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/std_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: std_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.std(x, dim=0, unbiased=True, keepdim=False) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/sum_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/sum_zero_size_0_func.py new file mode 100644 index 0000000000..b18708123f --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/sum_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: sum_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.sum(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/tile_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/tile_zero_size_0_func.py new file mode 100644 index 0000000000..266cbf6f3a --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/tile_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: tile_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.tile(x, repeat_times=[2, 1]) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/trace_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/trace_zero_size_0_func.py new file mode 100644 index 0000000000..f0814dd3d6 --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/trace_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: trace_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.trace(x, offset=0, axis1=0, axis2=1) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 0])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 0])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/unique_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/unique_zero_size_0_func.py new file mode 100644 index 0000000000..51c1c7f0c2 --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/unique_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: unique_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.unique(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-5 + 10 * np.random.random([12, 0, 10, 10])).astype(np.int32), dtype=torch.int32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-5 + 10 * np.random.random([12, 0, 10, 10])).astype('int32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/unsqueeze_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/unsqueeze_zero_size_0_func.py new file mode 100644 index 0000000000..189d97a1ba --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/unsqueeze_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: unsqueeze_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.unsqueeze(x, axis=1) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/var_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/var_zero_size_0_func.py new file mode 100644 index 0000000000..234a3dde31 --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/var_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: var_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.var(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/where_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/where_zero_size_0_func.py new file mode 100644 index 0000000000..c22e588dcc --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/where_zero_size_0_func.py @@ -0,0 +1,43 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: where_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x, y ): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.where(x>y, x, y ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = ( + torch.tensor((-10 + 20 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), + torch.tensor((-10 + 20 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), + ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ( + (-10 + 20 * np.random.random([12, 0, 10, 10])).astype('float32'), + (-10 + 20 * np.random.random([12, 0, 10, 10])).astype('float32'), + ) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/zeros_like_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/zeros_like_zero_size_0_func.py new file mode 100644 index 0000000000..c0f84678f8 --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/zeros_like_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: zeros_like_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, x): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.zeros_like(x, ) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 0, 10, 10])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 0, 10, 10])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/zeros_zero_size_0_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/zeros_zero_size_0_func.py new file mode 100644 index 0000000000..9df35a5293 --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/math_zero_size/zeros_zero_size_0_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: zeros_zero_size_func + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, ): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = torch.zeros(size=[128, 0, 1]) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = () + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = () + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/nn_zero_size/BatchNorm2D_zero_size_class.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/nn_zero_size/BatchNorm2D_zero_size_class.py new file mode 100644 index 0000000000..ad2f0303db --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/nn_zero_size/BatchNorm2D_zero_size_class.py @@ -0,0 +1,42 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: BatchNorm2d_zero_size_class + """ + + def __init__(self): + super(LayerCase, self).__init__() + self.func = nn.BatchNorm2d( + num_features=10, + momentum=0.9, + epsilon=0.00001, + ) + + def forward(self, data): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = self.func(data) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-1 + 2 * np.random.random([12, 10, 10, 0])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-1 + 2 * np.random.random([12, 10, 10, 0])).astype('float32'),) + return inputs diff --git a/framework/e2e/PaddleLT_new/torch_case/layerApicase/nn_zero_size/normalize_zero_size_func.py b/framework/e2e/PaddleLT_new/torch_case/layerApicase/nn_zero_size/normalize_zero_size_func.py new file mode 100644 index 0000000000..3bedd2775d --- /dev/null +++ b/framework/e2e/PaddleLT_new/torch_case/layerApicase/nn_zero_size/normalize_zero_size_func.py @@ -0,0 +1,37 @@ +import numpy as np +import torch +import torch.nn as nn + + +class LayerCase(nn.Module): + """ + case名称: normalize_zero_size_class + """ + + def __init__(self): + super(LayerCase, self).__init__() + + def forward(self, data): + """ + forward + """ + torch.manual_seed(33) + np.random.seed(33) + out = nn.functional.normalize(data, p=2, dim=0, eps=0.000000000001) + return out + + +def create_tensor_inputs(): + """ + PyTorch tensor + """ + inputs = (torch.tensor((-2 + 5 * np.random.random([3, 0, 1, 1])).astype(np.float32), dtype=torch.float32, requires_grad=True), ) + return inputs + + +def create_numpy_inputs(): + """ + numpy array + """ + inputs = ((-2 + 5 * np.random.random([3, 0, 1, 1])).astype('float32'),) + return inputs