未验证 提交 c8d6c146 编写于 作者: Z zhangxiaoci 提交者: GitHub

refactor reshape2/shape unittest for kunlun (#39665)

*test=kunlun
上级 0efa64c8
...@@ -14,194 +14,167 @@ ...@@ -14,194 +14,167 @@
from __future__ import print_function from __future__ import print_function
import unittest
import numpy as np import numpy as np
import sys import sys
import unittest
sys.path.append("..") sys.path.append("..")
from op_test import OpTest
import paddle import paddle
import paddle.fluid as fluid
from paddle.fluid import compiler, Program, program_guard
# situation 1: have shape( list, no tensor), no actual shape(Tensor)
class TestReshapeOp(OpTest):
def setUp(self):
self.init_data()
self.op_type = "reshape2"
self.inputs = {"X": np.random.random(self.ori_shape).astype("float32")}
self.attrs = {"shape": self.new_shape, "use_xpu": True}
self.outputs = {
"Out": self.inputs["X"].reshape(self.infered_shape),
'XShape': np.random.random(self.ori_shape).astype("float32")
}
def init_data(self):
self.ori_shape = (2, 60)
self.new_shape = (12, 10)
self.infered_shape = (12, 10)
def test_check_output(self):
if paddle.is_compiled_with_xpu():
place = paddle.XPUPlace(0)
self.check_output_with_place(place, no_check_set=['XShape'])
def test_check_grad(self):
if paddle.is_compiled_with_xpu():
place = paddle.XPUPlace(0)
self.check_grad_with_place(place, ["X"], "Out")
class TestReshapeOpDimInfer1(TestReshapeOp):
def init_data(self):
self.ori_shape = (5, 25)
self.new_shape = (5, -1, 5)
self.infered_shape = (5, -1, 5)
class TestReshapeOpDimInfer2(TestReshapeOp):
def init_data(self):
self.ori_shape = (10, 2, 6)
self.new_shape = (10, 0, 3, -1)
self.infered_shape = (10, 2, 3, -1)
# situation 2: have shape(list, no tensor), have actual shape(Tensor)
class TestReshapeOpWithInputShape(OpTest):
def setUp(self):
self.init_data()
self.op_type = "reshape2"
self.inputs = {
"X": np.random.random(self.ori_shape).astype("float32"),
"Shape": np.array(
self.actual_shape, dtype="int32")
}
self.attrs = {"shape": self.new_shape, "use_xpu": True}
self.outputs = {
"Out": self.inputs["X"].reshape(self.actual_shape),
'XShape': np.random.random(self.ori_shape).astype("float32")
}
def init_data(self):
self.ori_shape = (6, 20)
self.new_shape = (0, -1, 20)
self.actual_shape = (2, 3, 20)
def test_check_output(self):
if paddle.is_compiled_with_xpu():
place = paddle.XPUPlace(0)
self.check_output_with_place(place, no_check_set=['XShape'])
def test_check_grad(self):
if paddle.is_compiled_with_xpu():
place = paddle.XPUPlace(0)
self.check_grad_with_place(place, ["X"], "Out")
# Situation 3: have shape(list, have tensor), no actual shape(Tensor)
class TestReshapeOp_attr_ShapeTensor(OpTest):
def setUp(self):
self.init_data()
self.op_type = "reshape2"
shape_tensor = []
for index, ele in enumerate(self.new_shape):
shape_tensor.append(("x" + str(index), np.ones(
(1)).astype('int32') * ele))
self.inputs = {
"X": np.random.random(self.ori_shape).astype("float32"),
'ShapeTensor': shape_tensor
}
self.attrs = {'shape': self.shape, "use_xpu": True}
self.outputs = {
"Out": self.inputs["X"].reshape(self.infered_shape),
'XShape': np.random.random(self.ori_shape).astype("float32")
}
def init_data(self):
self.ori_shape = (4, 25)
self.new_shape = (10, 10)
self.infered_shape = (10, 10)
self.shape = (-1, -1)
def test_check_output(self):
if paddle.is_compiled_with_xpu():
place = paddle.XPUPlace(0)
self.check_output_with_place(place, no_check_set=['XShape'])
def test_check_grad(self):
if paddle.is_compiled_with_xpu():
place = paddle.XPUPlace(0)
self.check_grad_with_place(place, ["X"], "Out")
class TestReshapeOpDimInfer1_attr_ShapeTensor(TestReshapeOp_attr_ShapeTensor):
def init_data(self):
self.ori_shape = (5, 20)
self.new_shape = (5, -1, 20)
self.infered_shape = (5, -1, 20)
self.shape = (5, -1, -1)
class TestReshapeOpDimInfer2_attr_ShapeTensor(TestReshapeOp_attr_ShapeTensor):
def init_data(self):
self.ori_shape = (10, 2, 6)
self.new_shape = (10, 0, 3, -1)
self.infered_shape = (10, 2, 3, -1)
self.shape = (10, 0, 3, -1)
# Situation 4: have shape(Tensor), no actual shape(Tensor)
class TestReshapeOp_attr_OnlyShape(OpTest):
def setUp(self):
self.init_data()
self.op_type = "reshape2"
self.inputs = {
"X": np.random.random(self.ori_shape).astype("float32"),
"Shape": np.array(
self.new_shape, dtype="int32")
}
self.attrs = {"use_xpu": True}
self.outputs = {
"Out": self.inputs["X"].reshape(self.infered_shape),
'XShape': np.random.random(self.ori_shape).astype("float32")
}
def init_data(self):
self.ori_shape = (4, 25)
self.new_shape = (10, 10)
self.infered_shape = (10, 10)
def test_check_output(self):
if paddle.is_compiled_with_xpu():
place = paddle.XPUPlace(0)
self.check_output_with_place(place, no_check_set=['XShape'])
def test_check_grad(self):
if paddle.is_compiled_with_xpu():
place = paddle.XPUPlace(0)
self.check_grad_with_place(place, ["X"], "Out")
class TestReshapeOpDimInfer1_attr_OnlyShape(TestReshapeOp_attr_OnlyShape):
def init_data(self):
self.ori_shape = (5, 20)
self.new_shape = (5, -1, 10)
self.infered_shape = (5, -1, 10)
self.shape = (5, -1, -1)
class TestReshapeOpDimInfer2_attr_OnlyShape(TestReshapeOp_attr_OnlyShape):
def init_data(self):
self.ori_shape = (10, 2, 6)
self.new_shape = (10, 0, 3, -1)
self.infered_shape = (10, 2, 3, -1)
self.shape = (10, 0, 3, -1)
from op_test_xpu import XPUOpTest
from xpu.get_test_cover_info import create_test_class, get_xpu_op_support_types, XPUOpTestWrapper
paddle.enable_static()
class XPUTestReshapeOp(XPUOpTestWrapper):
def __init__(self):
self.op_name = "reshape2"
self.use_dynamic_create_class = False
# situation 1: have shape( list, no tensor), no actual shape(Tensor)
class TestReshapeOp(XPUOpTest):
def setUp(self):
self.init_data()
self.op_type = "reshape2"
self.init_test_input()
self.init_test_output()
self.init_attrs()
def init_data(self):
self.ori_shape = (2, 60)
self.new_shape = (12, 10)
self.infered_shape = (12, 10)
def init_test_input(self):
self.inputs = {
"X": np.random.random(self.ori_shape).astype(self.dtype)
}
def init_test_output(self):
self.outputs = {
"Out": self.inputs["X"].reshape(self.infered_shape),
'XShape': np.random.random(self.ori_shape).astype(self.dtype)
}
def init_attrs(self):
self.attrs = {"shape": self.new_shape, "use_xpu": True}
def test_check_output(self):
if paddle.is_compiled_with_xpu():
place = paddle.XPUPlace(0)
self.check_output_with_place(place, no_check_set=['XShape'])
def test_check_grad(self):
if paddle.is_compiled_with_xpu():
place = paddle.XPUPlace(0)
self.check_grad_with_place(place, ["X"], "Out")
class TestReshapeOpDimInfer1(TestReshapeOp):
def init_data(self):
self.ori_shape = (5, 25)
self.new_shape = (5, -1, 5)
self.infered_shape = (5, -1, 5)
class TestReshapeOpDimInfer2(TestReshapeOp):
def init_data(self):
self.ori_shape = (10, 2, 6)
self.new_shape = (10, 0, 3, -1)
self.infered_shape = (10, 2, 3, -1)
# situation 2: have shape(list, no tensor), have actual shape(Tensor)
class TestReshapeOpWithInputShape(TestReshapeOp):
def init_data(self):
self.ori_shape = (6, 20)
self.new_shape = (0, -1, 20)
self.actual_shape = (2, 3, 20)
def init_test_input(self):
self.inputs = {
"X": np.random.random(self.ori_shape).astype(self.dtype),
"Shape": np.array(
self.actual_shape, dtype="int32")
}
def init_test_output(self):
self.outputs = {
"Out": self.inputs["X"].reshape(self.actual_shape),
'XShape': np.random.random(self.ori_shape).astype(self.dtype)
}
# Situation 3: have shape(list, have tensor), no actual shape(Tensor)
class TestReshapeOp_attr_ShapeTensor(TestReshapeOp):
def init_data(self):
self.ori_shape = (4, 25)
self.new_shape = (10, 10)
self.infered_shape = (10, 10)
self.shape = (-1, -1)
def init_test_input(self):
shape_tensor = []
for index, ele in enumerate(self.new_shape):
shape_tensor.append(("x" + str(index), np.ones(
(1)).astype('int32') * ele))
self.inputs = {
"X": np.random.random(self.ori_shape).astype(self.dtype),
'ShapeTensor': shape_tensor
}
def init_attrs(self):
self.attrs = {'shape': self.shape, "use_xpu": True}
class TestReshapeOpDimInfer1_attr_ShapeTensor(
TestReshapeOp_attr_ShapeTensor):
def init_data(self):
self.ori_shape = (5, 20)
self.new_shape = (5, -1, 20)
self.infered_shape = (5, -1, 20)
self.shape = (5, -1, -1)
class TestReshapeOpDimInfer2_attr_ShapeTensor(
TestReshapeOp_attr_ShapeTensor):
def init_data(self):
self.ori_shape = (10, 2, 6)
self.new_shape = (10, 0, 3, -1)
self.infered_shape = (10, 2, 3, -1)
self.shape = (10, 0, 3, -1)
# Situation 4: have shape(Tensor), no actual shape(Tensor)
class TestReshapeOp_attr_OnlyShape(TestReshapeOp):
def init_data(self):
self.ori_shape = (4, 25)
self.new_shape = (10, 10)
self.infered_shape = (10, 10)
def init_test_input(self):
self.inputs = {
"X": np.random.random(self.ori_shape).astype(self.dtype),
"Shape": np.array(
self.new_shape, dtype="int32")
}
def init_attrs(self):
self.attrs = {"use_xpu": True}
class TestReshapeOpDimInfer1_attr_OnlyShape(TestReshapeOp_attr_OnlyShape):
def init_data(self):
self.ori_shape = (5, 20)
self.new_shape = (5, -1, 10)
self.infered_shape = (5, -1, 10)
self.shape = (5, -1, -1)
class TestReshapeOpDimInfer2_attr_OnlyShape(TestReshapeOp_attr_OnlyShape):
def init_data(self):
self.ori_shape = (10, 2, 6)
self.new_shape = (10, 0, 3, -1)
self.infered_shape = (10, 2, 3, -1)
self.shape = (10, 0, 3, -1)
support_types = get_xpu_op_support_types("reshape2")
for stype in support_types:
create_test_class(globals(), XPUTestReshapeOp, stype)
if __name__ == "__main__": if __name__ == "__main__":
unittest.main() unittest.main()
...@@ -18,77 +18,99 @@ import unittest ...@@ -18,77 +18,99 @@ import unittest
import numpy as np import numpy as np
import sys import sys
sys.path.append("..") sys.path.append("..")
from op_test import OpTest from op_test_xpu import XPUOpTest
from xpu.get_test_cover_info import create_test_class, get_xpu_op_support_types, XPUOpTestWrapper
import paddle import paddle
from paddle.fluid import core from paddle.fluid import core
from paddle.fluid.op import Operator from paddle.fluid.op import Operator
paddle.enable_static()
class TestShapeOp(OpTest):
def setUp(self):
self.op_type = "shape" class XPUTestShapeOp(XPUOpTestWrapper):
self.config() def __init__(self):
self.shape = [2, 3] self.op_name = "shape"
input = np.zeros(self.shape) self.use_dynamic_create_class = False
self.inputs = {'Input': input}
self.outputs = {'Out': np.array(self.shape)} class TestShapeOp(XPUOpTest):
def setUp(self):
def config(self): self.dtype = self.in_type
self.shape = [2, 3] self.op_type = "shape"
self.config()
def test_check_output(self): input = np.zeros(self.shape)
if paddle.is_compiled_with_xpu(): self.inputs = {'Input': input.astype(self.dtype)}
place = paddle.XPUPlace(0) self.outputs = {'Out': np.array(self.shape)}
self.check_output_with_place(place)
def config(self):
self.shape = [2, 3]
class case1(TestShapeOp):
def config(self): def test_check_output(self):
self.shape = [2] if paddle.is_compiled_with_xpu():
place = paddle.XPUPlace(0)
self.check_output_with_place(place)
class case2(TestShapeOp):
def config(self): class TestShapeOp1(TestShapeOp):
self.shape = [1, 2, 3] def config(self):
self.shape = [2]
class TestShapeWithSelectedRows(unittest.TestCase): class TestShapeOp2(TestShapeOp):
def get_places(self): def config(self):
places = [core.CPUPlace()] self.shape = [1, 2, 3]
if core.is_compiled_with_cuda():
places.append(core.CUDAPlace(0)) class TestShapeOp3(TestShapeOp):
if core.is_compiled_with_xpu(): def config(self):
places.append(core.XPUPlace(0)) self.shape = [1, 2, 3, 4]
return places
class TestShapeOp4(TestShapeOp):
def check_with_place(self, place): def config(self):
scope = core.Scope() self.shape = [1, 2, 3, 4, 1024]
x_rows = [0, 1, 5, 4, 19]
height = 20 class TestShapeOp5(TestShapeOp):
row_numel = 2 def config(self):
self.shape = [1, 2, 3, 4, 1, 201]
np_array = np.ones((len(x_rows), row_numel)).astype("float32")
class TestShapeWithSelectedRows(unittest.TestCase):
# initialize input variable X def setUp(self):
x = scope.var('X').get_selected_rows() self.dtype = self.in_type
x.set_rows(x_rows)
x.set_height(height) def get_places(self):
x_tensor = x.get_tensor() places = [core.CPUPlace()]
x_tensor.set(np_array, place) if core.is_compiled_with_cuda():
places.append(core.CUDAPlace(0))
# initialize input variable Out if core.is_compiled_with_xpu():
out_shape = scope.var("Out").get_tensor() places.append(core.XPUPlace(0))
op = Operator("shape", Input="X", Out="Out") return places
op.run(scope, place) def check_with_place(self, place):
scope = core.Scope()
out_shape = np.array(out_shape).tolist() x_rows = [0, 1, 5, 4, 19]
self.assertListEqual([5, 2], out_shape) height = 20
row_numel = 2
def test_check_output(self):
for place in self.get_places(): np_array = np.ones((len(x_rows), row_numel)).astype(self.dtype)
self.check_with_place(place)
# initialize input variable X
x = scope.var('X').get_selected_rows()
x.set_rows(x_rows)
x.set_height(height)
x_tensor = x.get_tensor()
x_tensor.set(np_array, place)
out_shape = scope.var("Out").get_tensor()
op = Operator("shape", Input="X", Out="Out")
op.run(scope, place)
out_shape = np.array(out_shape).tolist()
self.assertListEqual([5, 2], out_shape)
def test_check_output(self):
for place in self.get_places():
self.check_with_place(place)
support_types = get_xpu_op_support_types("shape")
for stype in support_types:
create_test_class(globals(), XPUTestShapeOp, stype)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册