Star184
853
代码
代码
Issues165
Pull Requests325
流水线
项目讨论
Wiki
分析
Star184
853
已合并
Move UTs on PTA to OP-Plugin Part1 #1477
AtomGit-Bot创建于 2024年4月3日
Move UTs on PTA to OP-Plugin Part1 #1477
已合并
AtomGit-Bot创建于 2024年4月3日
从refs/pull/1477/head合入到master
共 75 个文件变更+7274-19
Mci/access_control_test.py+28-19
@@ -40,20 +40,21 @@ class AccurateTest(metaclass=ABCMeta):
40 return ut_files40 return ut_files
41 41 
42 def get_ut_files(self, regex):42 def get_ut_files(self, regex):
43- test_base_path = os.path.join(TEST_DIR, 'test_base_ops')43+ test_custom_path = os.path.join(TEST_DIR, 'test_custom_ops')
44- check_dir_path_readable(test_base_path)44+ check_dir_path_readable(test_custom_path)
45- ut_files = self.find_ut_by_regex(regex, test_base_path)45+ ut_files = self.find_ut_by_regex(regex, test_custom_path)
46- 46+
47 version_path = get_test_torch_version_path()47 version_path = get_test_torch_version_path()
48 test_version_path = os.path.join(TEST_DIR, version_path)48 test_version_path = os.path.join(TEST_DIR, version_path)
49 check_dir_path_readable(test_version_path)49 check_dir_path_readable(test_version_path)
50 version_ut_files = self.find_ut_by_regex(regex, test_version_path)50 version_ut_files = self.find_ut_by_regex(regex, test_version_path)
51- ut_files.extend(version_ut_files)51+ if not version_ut_files:
52- 52+ test_base_path = os.path.join(TEST_DIR, 'test_base_ops')
53- test_custom_path = os.path.join(TEST_DIR, 'test_custom_ops')53+ check_dir_path_readable(test_base_path)
54- check_dir_path_readable(test_custom_path)54+ base_ut_files = self.find_ut_by_regex(regex, test_base_path)
55- custom_ut_files = self.find_ut_by_regex(regex, test_custom_path)55+ ut_files.extend(base_ut_files)
56- ut_files.extend(custom_ut_files)56+ else:
57+ ut_files.extend(version_ut_files)
57 return ut_files58 return ut_files
58 59 
59 60 
@@ -80,20 +81,28 @@ class OpStrategy(AccurateTest):
80 return []81 return []
81 82 
82 83 
84+modify_file_hash = {}
85+ 
86+ 
83class DirectoryStrategy(AccurateTest):87class DirectoryStrategy(AccurateTest):
84 """88 """
85 Determine whether the modified files are test cases89 Determine whether the modified files are test cases
86 """90 """
87- def identify(self, modify_file):91+ def identify(self, modify_file, ut_files):
88 is_test_file = str(Path(modify_file).parts[0]) == "test" \92 is_test_file = str(Path(modify_file).parts[0]) == "test" \
89 and re.match("test_(.+).py", Path(modify_file).name)93 and re.match("test_(.+).py", Path(modify_file).name)
90- if is_test_file:94+ version_path = get_test_torch_version_path()
91- ut_files = []95+ if is_test_file and str(Path(modify_file).parts[1]) in [version_path, "test_custom_ops", "test_base_ops"]:
92- version_path = get_test_torch_version_path()96+ modify_file_path = os.path.join(BASE_DIR, modify_file)
93- if str(Path(modify_file).parts[1]) in [version_path, "test_custom_ops", "test_base_ops"]:97+ modify_file_name = Path(modify_file).name
94- ut_files.append(os.path.join(BASE_DIR, modify_file))98+ if modify_file_name in modify_file_hash:
95- return ut_files99+ if str(Path(modify_file).parts[1]) == version_path:
96- return []100+ ut_files.remove(modify_file_hash[modify_file_name])
101+ modify_file_hash[modify_file_name] = modify_file_path
102+ ut_files.append(modify_file_path)
103+ else:
104+ modify_file_hash[modify_file_name] = modify_file_path
105+ ut_files.append(modify_file_path)
97 106 
98 107 
99class CoreTestStrategy(AccurateTest):108class CoreTestStrategy(AccurateTest):
@@ -127,7 +136,7 @@ class TestMgr():
127 136 
128 def analyze(self):137 def analyze(self):
129 for modify_file in self.modify_files:138 for modify_file in self.modify_files:
130- self.test_files['ut_files'] += DirectoryStrategy().identify(modify_file)139+ DirectoryStrategy().identify(modify_file, self.test_files['ut_files'])
131 self.test_files['ut_files'] += OpStrategy().identify(modify_file)140 self.test_files['ut_files'] += OpStrategy().identify(modify_file)
132 unique_files = sorted(set(self.test_files['ut_files']))141 unique_files = sorted(set(self.test_files['ut_files']))
133 142 
Atest/test_base_ops/test___ior__.py+248-0
@@ -0,0 +1,248 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+ 
7+ 
8+class TestIor(TestCase):
9+ def generate_bool_data(self, shape):
10+ input1 = np.random.uniform(0, 1, shape).astype(np.float32)
11+ input1 = input1 < 0.5
12+ npu_input1 = torch.from_numpy(input1)
13+ return npu_input1
14+ 
15+ def generate_data(self, min_d, max_d, shape, dtype):
16+ input1 = np.random.uniform(min_d, max_d, shape).astype(dtype)
17+ input2 = np.random.uniform(min_d, max_d, shape).astype(dtype)
18+ npu_input1 = torch.from_numpy(input1)
19+ npu_input2 = torch.from_numpy(input2)
20+ return npu_input1, npu_input2
21+ 
22+ def generate_single_data(self, min_d, max_d, shape, dtype):
23+ input1 = np.random.uniform(min_d, max_d, shape).astype(dtype)
24+ npu_input1 = torch.from_numpy(input1)
25+ return npu_input1
26+ 
27+ def generate_int_scalar(self, min_d, max_d):
28+ scalar = np.random.randint(min_d, max_d)
29+ return scalar
30+ 
31+ def cpu_op_exec(self, input1, input2):
32+ output = input1.__ior__(input2)
33+ output = output.numpy()
34+ return output
35+ 
36+ def npu_op_exec(self, input1, input2):
37+ input1 = input1.to("npu")
38+ input2 = input2.to("npu")
39+ output = input1.__ior__(input2)
40+ output = output.to("cpu")
41+ output = output.numpy()
42+ return output
43+ 
44+ def npu_op_exec_scalar(self, input1, input2):
45+ input1 = input1.to("npu")
46+ output = input1.__ior__(input2)
47+ output = output.to("cpu")
48+ output = output.numpy()
49+ return output
50+ 
51+ def test___ior___bool(self, device="npu"):
52+ npu_input1 = self.generate_bool_data((1, 31, 149, 2))
53+ npu_input2 = self.generate_bool_data((1, 31, 149, 2))
54+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
55+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
56+ self.assertRtolEqual(cpu_output, npu_output)
57+ 
58+ def test___ior___bool_scalar(self, device="npu"):
59+ npu_input1 = self.generate_bool_data((1, 31, 149, 2))
60+ npu_input2 = False
61+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
62+ npu_output = self.npu_op_exec_scalar(npu_input1, npu_input2)
63+ self.assertRtolEqual(cpu_output, npu_output)
64+ 
65+ def test___ior___uint8(self, device="npu"):
66+ npu_input1, npu_input2 = self.generate_data(0, 255, (1, 31, 149, 2), np.uint8)
67+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
68+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
69+ self.assertRtolEqual(cpu_output, npu_output)
70+ 
71+ def test___ior___int8(self, device="npu"):
72+ npu_input1, npu_input2 = self.generate_data(-128, 127, (1, 31, 149, 2), np.int8)
73+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
74+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
75+ self.assertRtolEqual(cpu_output, npu_output)
76+ 
77+ def test___ior___int32_001(self, device="npu"):
78+ npu_input1, npu_input2 = self.generate_data(
79+ -2147483648, -2147483648, (1, 31, 149, 2), np.int32
80+ )
81+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
82+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
83+ self.assertRtolEqual(cpu_output, npu_output)
84+ 
85+ def test___ior___int32_002(self, device="npu"):
86+ npu_input1, npu_input2 = self.generate_data(
87+ 2147483647, 2147483647, (128), np.int32
88+ )
89+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
90+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
91+ self.assertRtolEqual(cpu_output, npu_output)
92+ 
93+ def test___ior___int32_003(self, device="npu"):
94+ npu_input1, npu_input2 = self.generate_data(
95+ -2147483648, 2147483647, (184965, 1), np.int32
96+ )
97+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
98+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
99+ self.assertRtolEqual(cpu_output, npu_output)
100+ 
101+ def test___ior___int32_004(self, device="npu"):
102+ npu_input1, npu_input2 = self.generate_data(
103+ -2147483648, 2147483647, (1, 31, 149, 2), np.int32
104+ )
105+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
106+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
107+ self.assertRtolEqual(cpu_output, npu_output)
108+ 
109+ def test___ior___int32_005(self, device="npu"):
110+ npu_input1, npu_input2 = self.generate_data(
111+ -2147483648, 2147483647, (2, 31, 149, 2), np.int32
112+ )
113+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
114+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
115+ self.assertRtolEqual(cpu_output, npu_output)
116+ 
117+ def test___ior___int32_006(self, device="npu"):
118+ npu_input1, npu_input2 = self.generate_data(
119+ -2147483648, 2147483647, (4, 31, 149, 2), np.int32
120+ )
121+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
122+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
123+ self.assertRtolEqual(cpu_output, npu_output)
124+ 
125+ def test___ior___int32_007(self, device="npu"):
126+ npu_input1, npu_input2 = self.generate_data(
127+ -2147483648, 2147483647, (2048, 31, 1, 2), np.int32
128+ )
129+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
130+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
131+ self.assertRtolEqual(cpu_output, npu_output)
132+ 
133+ def test___ior___int32_008(self, device="npu"):
134+ npu_input1, npu_input2 = self.generate_data(
135+ -2147483648, 2147483647, (8, 7, 149), np.int32
136+ )
137+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
138+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
139+ self.assertRtolEqual(cpu_output, npu_output)
140+ 
141+ def test___ior___int32_009(self, device="npu"):
142+ npu_input1, npu_input2 = self.generate_data(
143+ -2147483648, 2147483647, (65535, 1, 1, 1), np.int32
144+ )
145+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
146+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
147+ self.assertRtolEqual(cpu_output, npu_output)
148+ 
149+ def test___ior___int32_010(self, device="npu"):
150+ npu_input1, npu_input2 = self.generate_data(
151+ -2147483648, 2147483647, (1, 1, 1, 8192), np.int32
152+ )
153+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
154+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
155+ self.assertRtolEqual(cpu_output, npu_output)
156+ 
157+ def test___ior___int32_011(self, device="npu"):
158+ npu_input1, npu_input2 = self.generate_data(
159+ -2147483648, 2147483647, (1, 1, 1, 16384), np.int32
160+ )
161+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
162+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
163+ self.assertRtolEqual(cpu_output, npu_output)
164+ 
165+ def test___ior___int32_012(self, device="npu"):
166+ npu_input1, npu_input2 = self.generate_data(
167+ -2147483648, 2147483647, (1, 1, 1, 32768), np.int32
168+ )
169+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
170+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
171+ self.assertRtolEqual(cpu_output, npu_output)
172+ 
173+ def test___ior___int32_013(self, device="npu"):
174+ npu_input1, npu_input2 = self.generate_data(
175+ -2147483648, 2147483647, (1, 1, 1, 65535), np.int32
176+ )
177+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
178+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
179+ self.assertRtolEqual(cpu_output, npu_output)
180+ 
181+ def test___ior___int32_014(self, device="npu"):
182+ npu_input1, npu_input2 = self.generate_data(
183+ -2147483648, 2147483647, (1, 1, 1, 131072), np.int32
184+ )
185+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
186+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
187+ self.assertRtolEqual(cpu_output, npu_output)
188+ 
189+ def test___ior___int32_015(self, device="npu"):
190+ npu_input1, npu_input2 = self.generate_data(
191+ -2147483648, 2147483647, (1, 1, 1, 196608), np.int32
192+ )
193+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
194+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
195+ self.assertRtolEqual(cpu_output, npu_output)
196+ 
197+ def test___ior___int32_016(self, device="npu"):
198+ npu_input1, npu_input2 = self.generate_data(
199+ -2147483648, 2147483647, (1, 1, 1, 262144), np.int32
200+ )
201+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
202+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
203+ self.assertRtolEqual(cpu_output, npu_output)
204+ 
205+ def test___ior___int32_017(self, device="npu"):
206+ npu_input1, npu_input2 = self.generate_data(
207+ -2147483648, 2147483647, (1, 1, 1, 393216), np.int32
208+ )
209+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
210+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
211+ self.assertRtolEqual(cpu_output, npu_output)
212+ 
213+ def test___ior___int32_018(self, device="npu"):
214+ npu_input1, npu_input2 = self.generate_data(
215+ -2147483648, 2147483647, (1, 1, 1, 524288), np.int32
216+ )
217+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
218+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
219+ self.assertRtolEqual(cpu_output, npu_output)
220+ 
221+ def test___ior___int32_019(self, device="npu"):
222+ npu_input1, npu_input2 = self.generate_data(
223+ -2147483648, 2147483647, (1, 1, 1, 655360), np.int32
224+ )
225+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
226+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
227+ self.assertRtolEqual(cpu_output, npu_output)
228+ 
229+ def test___ior___int32_020(self, device="npu"):
230+ npu_input1, npu_input2 = self.generate_data(
231+ -2147483648, 2147483647, (1, 1, 1, 786432), np.int32
232+ )
233+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
234+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
235+ self.assertRtolEqual(cpu_output, npu_output)
236+ 
237+ def test___ior___int_scalar(self, device="npu"):
238+ npu_input1 = self.generate_single_data(
239+ -2147483648, 2147483647, (1, 31, 149, 2), np.int32
240+ )
241+ npu_input2 = self.generate_int_scalar(-2147483648, 2147483647)
242+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2)
243+ npu_output = self.npu_op_exec_scalar(npu_input1, npu_input2)
244+ self.assertRtolEqual(cpu_output, npu_output)
245+ 
246+ 
247+if __name__ == "__main__":
248+ run_tests()
Atest/test_base_ops/test___or__.py+61-0
@@ -0,0 +1,61 @@
1+import copy
2+import torch
3+import numpy as np
4+import torch_npu
5+ 
6+from torch_npu.testing.testcase import TestCase, run_tests
7+from torch_npu.testing.common_utils import create_common_tensor
8+ 
9+ 
10+class Test__Or__(TestCase):
11+ def cpu_op_exec(self, input1, input2):
12+ output = input1.__or__(input2)
13+ if output.dtype != torch.int32:
14+ output = output.to(torch.int32)
15+ return output.numpy()
16+ 
17+ def npu_op_exec(self, input1, input2):
18+ output = input1.__or__(input2)
19+ output = output.to("cpu")
20+ if output.dtype != torch.int32:
21+ output = output.to(torch.int32)
22+ return output.numpy()
23+ 
24+ def test___Or___shape_format(self, device="npu"):
25+ shape_format = [
26+ [[np.int32, 0, [256, 1000]], [1]],
27+ [[np.int32, 0, [256, 1000]], [np.int32, 0, [256, 1000]]],
28+ [[np.int16, 0, [256, 1000]], [2]],
29+ [[np.int16, 0, [256, 1000]], [np.int16, 0, [256, 1000]]],
30+ [[np.int8, 0, [256, 1000]], [3]],
31+ [[np.int8, 0, [256, 1000]], [np.int8, 0, [256, 1000]]],
32+ ]
33+ 
34+ for item in shape_format:
35+ if len(item[1]) > 1:
36+ cpu_input1, npu_input1 = create_common_tensor(item[0], 0, 100)
37+ cpu_input2, npu_input2 = create_common_tensor(item[1], 0, 100)
38+ cpu_output = self.cpu_op_exec(cpu_input1, cpu_input2)
39+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
40+ self.assertRtolEqual(cpu_output, npu_output)
41+ else:
42+ cpu_input1, npu_input1 = create_common_tensor(item[0], 0, 100)
43+ cpu_output = self.cpu_op_exec(cpu_input1, item[1][0])
44+ npu_output = self.npu_op_exec(npu_input1, item[1][0])
45+ self.assertRtolEqual(cpu_output, npu_output)
46+ 
47+ cpu_input1 = torch.tensor([True, False, True, False, True], dtype=torch.bool)
48+ npu_input1 = torch.tensor(
49+ [True, False, True, False, True], dtype=torch.bool, device="npu"
50+ )
51+ cpu_input2 = torch.tensor([True, False, True, False, False], dtype=torch.bool)
52+ npu_input2 = torch.tensor(
53+ [True, False, True, False, False], dtype=torch.bool, device="npu"
54+ )
55+ cpu_output = self.cpu_op_exec(cpu_input1, cpu_input2)
56+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
57+ self.assertRtolEqual(cpu_output, npu_output)
58+ 
59+ 
60+if __name__ == "__main__":
61+ run_tests()
Atest/test_base_ops/test__aminmax.py+123-0
@@ -0,0 +1,123 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestAminmax(TestCase):
10+ def cpu_op_exec(self, input0):
11+ output = torch._aminmax(input0)
12+ output0 = output[0].numpy()
13+ output1 = output[1].numpy()
14+ return output0, output1
15+ 
16+ def npu_op_exec(self, input0):
17+ output = torch._aminmax(input0)
18+ output0 = output[0].cpu().numpy()
19+ output1 = output[1].cpu().numpy()
20+ return output0, output1
21+ 
22+ def cpu_op_dim_exec(self, input0, dim, keepdim):
23+ output = torch._aminmax(input0, dim, keepdim)
24+ output0 = output[0].numpy()
25+ output1 = output[1].numpy()
26+ return output0, output1
27+ 
28+ def npu_op_dim_exec(self, input0, dim, keepdim):
29+ output = torch._aminmax(input0, dim, keepdim)
30+ output0 = output[0].cpu().numpy()
31+ output1 = output[1].cpu().numpy()
32+ return output0, output1
33+ 
34+ def cpu_op_exec_out(self, input0, in_dim, in_keepdim, min_in, max_in):
35+ output = torch.aminmax(
36+ input0, dim=in_dim, keepdim=in_keepdim, out=(min_in, max_in)
37+ )
38+ output0 = output[0].numpy()
39+ output1 = output[1].numpy()
40+ return output0, output1
41+ 
42+ def npu_op_exec_out(self, input0, in_dim, in_keepdim, min_in, max_in):
43+ output = torch.aminmax(
44+ input0, dim=in_dim, keepdim=in_keepdim, out=(min_in, max_in)
45+ )
46+ output0 = output[0].cpu().numpy()
47+ output1 = output[1].cpu().numpy()
48+ return output0, output1
49+ 
50+ def test__aminmax_shape_format(self):
51+ shape_format = [
52+ [np.float16, 0, [256, 1000]],
53+ [np.float32, 0, [1000]],
54+ [np.int8, 0, [256, 1000, 4, 4]],
55+ [np.int16, 0, [1000, 128, 3]],
56+ [np.int32, 0, [256]],
57+ [np.uint8, 0, [100, 128, 1000]],
58+ [np.int64, 0, [100, 128, 1000]],
59+ ]
60+ 
61+ for item in shape_format:
62+ cpu_input, npu_input = create_common_tensor(item, 0, 100)
63+ if cpu_input.dtype == torch.half:
64+ cpu_input = cpu_input.to(torch.float)
65+ 
66+ cpu_output0, cpu_output1 = self.cpu_op_exec(cpu_input)
67+ npu_output0, npu_output1 = self.npu_op_exec(npu_input)
68+ 
69+ self.assertRtolEqual(cpu_output0.astype(npu_output0.dtype), npu_output0)
70+ self.assertRtolEqual(cpu_output1.astype(npu_output1.dtype), npu_output1)
71+ 
72+ def test__aminmax_dim_shape_format(self):
73+ shape_format = [
74+ [np.float16, 0, [64, 4]],
75+ [np.float32, 0, [32, 4, 16, 8]],
76+ ]
77+ 
78+ for item in shape_format:
79+ cpu_input, npu_input = create_common_tensor(item, 0, 100)
80+ dim = np.random.randint(len(item[2]))
81+ keepdim = np.random.randint(10) > 4
82+ if cpu_input.dtype == torch.half:
83+ cpu_input = cpu_input.to(torch.float)
84+ 
85+ cpu_output0, cpu_output1 = self.cpu_op_dim_exec(cpu_input, dim, keepdim)
86+ npu_output0, npu_output1 = self.npu_op_dim_exec(npu_input, dim, keepdim)
87+ 
88+ self.assertRtolEqual(cpu_output0.astype(npu_output0.dtype), npu_output0)
89+ self.assertRtolEqual(cpu_output1.astype(npu_output1.dtype), npu_output1)
90+ 
91+ def test__aminmax_out_shape_format(self):
92+ shape_format = [
93+ [np.float16, 0, [64, 4]],
94+ [np.float32, 0, [32, 4, 16, 8]],
95+ ]
96+ 
97+ for item in shape_format:
98+ cpu_input, npu_input = create_common_tensor(item, 0, 100)
99+ dim = np.random.randint(len(item[2]))
100+ keepdim = np.random.randint(10) > 4
101+ if cpu_input.dtype == torch.half:
102+ cpu_input = cpu_input.to(torch.float)
103+ 
104+ out_temp = torch._aminmax(cpu_input, dim, keepdim)[0]
105+ out_size = out_temp.size()
106+ cpu_out_min = torch.zeros(out_size).to(cpu_input.dtype)
107+ cpu_out_max = torch.zeros(out_size).to(cpu_input.dtype)
108+ npu_out_min = torch.zeros(out_size).npu().to(npu_input.dtype)
109+ npu_out_max = torch.zeros(out_size).npu().to(npu_input.dtype)
110+ 
111+ cpu_output0, cpu_output1 = self.cpu_op_exec_out(
112+ cpu_input, dim, keepdim, cpu_out_min, cpu_out_max
113+ )
114+ npu_output0, npu_output1 = self.npu_op_exec_out(
115+ npu_input, dim, keepdim, npu_out_min, npu_out_max
116+ )
117+ 
118+ self.assertRtolEqual(cpu_output0.astype(npu_output0.dtype), npu_output0)
119+ self.assertRtolEqual(cpu_output1.astype(npu_output1.dtype), npu_output1)
120+ 
121+ 
122+if __name__ == "__main__":
123+ run_tests()
Atest/test_base_ops/test__iRshift__.py+49-0
@@ -0,0 +1,49 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestiRshift(TestCase):
10+ def cpu_op_exec(self, input1, input2):
11+ input1.__irshift__(input2)
12+ output = input1.numpy()
13+ return output
14+ 
15+ def npu_op_exec(self, input1, input2):
16+ input1.__irshift__(input2)
17+ output = input1.to("cpu")
18+ output = output.numpy()
19+ return output
20+ 
21+ def test_iRshift_tensor(self, device="npu"):
22+ format_list = [0]
23+ shape_list = [(256, 32, 56)]
24+ shape_format = [[np.int32, i, j] for i in format_list for j in shape_list]
25+ for item in shape_format:
26+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 100)
27+ cpu_input2 = torch.tensor([1]).to(torch.int32)
28+ npu_input2 = cpu_input2.npu()
29+ cpu_output = self.cpu_op_exec(cpu_input1, cpu_input2)
30+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
31+ cpu_output = cpu_output.astype(npu_output.dtype)
32+ self.assertRtolEqual(cpu_output, npu_output)
33+ 
34+ def test_iRshift_scalar(self, device="npu"):
35+ format_list = [0]
36+ shape_list = [(256, 32, 56)]
37+ shape_format = [[np.int32, i, j] for i in format_list for j in shape_list]
38+ for item in shape_format:
39+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 100)
40+ cpu_input2 = torch.tensor(1).to(torch.int32)
41+ npu_input2 = cpu_input2.npu()
42+ cpu_output = self.cpu_op_exec(cpu_input1, cpu_input2)
43+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
44+ cpu_output = cpu_output.astype(npu_output.dtype)
45+ self.assertRtolEqual(cpu_output, npu_output)
46+ 
47+ 
48+if __name__ == "__main__":
49+ run_tests()
Atest/test_base_ops/test__ilshift__.py+49-0
@@ -0,0 +1,49 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestiLshift(TestCase):
10+ def cpu_op_exec(self, input1, input2):
11+ input1.__ilshift__(input2)
12+ output = input1.numpy()
13+ return output
14+ 
15+ def npu_op_exec(self, input1, input2):
16+ input1.__ilshift__(input2)
17+ output = input1.to("cpu")
18+ output = output.numpy()
19+ return output
20+ 
21+ def test_ilshift_tensor(self, device="npu"):
22+ format_list = [0]
23+ shape_list = [(256, 32, 56)]
24+ shape_format = [[np.int32, i, j] for i in format_list for j in shape_list]
25+ for item in shape_format:
26+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 100)
27+ cpu_input2 = torch.tensor([1]).to(torch.int32)
28+ npu_input2 = cpu_input2.npu()
29+ cpu_output = self.cpu_op_exec(cpu_input1, cpu_input2)
30+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
31+ cpu_output = cpu_output.astype(npu_output.dtype)
32+ self.assertRtolEqual(cpu_output, npu_output)
33+ 
34+ def test_ilshift_scalar(self, device="npu"):
35+ format_list = [0]
36+ shape_list = [(256, 32, 56)]
37+ shape_format = [[np.int32, i, j] for i in format_list for j in shape_list]
38+ for item in shape_format:
39+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 100)
40+ cpu_input2 = torch.tensor(1).to(torch.int32)
41+ npu_input2 = cpu_input2.npu()
42+ cpu_output = self.cpu_op_exec(cpu_input1, cpu_input2)
43+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
44+ cpu_output = cpu_output.astype(npu_output.dtype)
45+ self.assertRtolEqual(cpu_output, npu_output)
46+ 
47+ 
48+if __name__ == "__main__":
49+ run_tests()
Atest/test_base_ops/test__lshift__.py+49-0
@@ -0,0 +1,49 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestLshift(TestCase):
10+ def cpu_op_exec(self, input1, input2):
11+ output = input1.__lshift__(input2)
12+ output = output.numpy()
13+ return output
14+ 
15+ def npu_op_exec(self, input1, input2):
16+ output = input1.__lshift__(input2)
17+ output = output.to("cpu")
18+ output = output.numpy()
19+ return output
20+ 
21+ def test_lshift_tensor(self, device="npu"):
22+ format_list = [0]
23+ shape_list = [(256, 32, 56)]
24+ shape_format = [[np.int32, i, j] for i in format_list for j in shape_list]
25+ for item in shape_format:
26+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 100)
27+ cpu_input2 = torch.tensor([1]).to(torch.int32)
28+ npu_input2 = cpu_input2.npu()
29+ cpu_output = self.cpu_op_exec(cpu_input1, cpu_input2)
30+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
31+ cpu_output = cpu_output.astype(npu_output.dtype)
32+ self.assertRtolEqual(cpu_output, npu_output)
33+ 
34+ def test_lshift_scalar(self, device="npu"):
35+ format_list = [0]
36+ shape_list = [(256, 32, 56)]
37+ shape_format = [[np.int32, i, j] for i in format_list for j in shape_list]
38+ for item in shape_format:
39+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 100)
40+ cpu_input2 = torch.tensor(1).to(torch.int32)
41+ npu_input2 = cpu_input2.npu()
42+ cpu_output = self.cpu_op_exec(cpu_input1, cpu_input2)
43+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
44+ cpu_output = cpu_output.astype(npu_output.dtype)
45+ self.assertRtolEqual(cpu_output, npu_output)
46+ 
47+ 
48+if __name__ == "__main__":
49+ run_tests()
Atest/test_base_ops/test__rshift__.py+49-0
@@ -0,0 +1,49 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestRshift(TestCase):
10+ def cpu_op_exec(self, input1, input2):
11+ output = input1.__rshift__(input2)
12+ output = output.numpy()
13+ return output
14+ 
15+ def npu_op_exec(self, input1, input2):
16+ output = input1.__rshift__(input2)
17+ output = output.to("cpu")
18+ output = output.numpy()
19+ return output
20+ 
21+ def test_rshift_tensor(self, device="npu"):
22+ format_list = [0]
23+ shape_list = [(256, 32, 56)]
24+ shape_format = [[np.int32, i, j] for i in format_list for j in shape_list]
25+ for item in shape_format:
26+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 100)
27+ cpu_input2 = torch.tensor([1]).to(torch.int32)
28+ npu_input2 = cpu_input2.npu()
29+ cpu_output = self.cpu_op_exec(cpu_input1, cpu_input2)
30+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
31+ cpu_output = cpu_output.astype(npu_output.dtype)
32+ self.assertRtolEqual(cpu_output, npu_output)
33+ 
34+ def test_rshift_scalar(self, device="npu"):
35+ format_list = [0]
36+ shape_list = [(256, 32, 56)]
37+ shape_format = [[np.int32, i, j] for i in format_list for j in shape_list]
38+ for item in shape_format:
39+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 100)
40+ cpu_input2 = torch.tensor(1).to(torch.int32)
41+ npu_input2 = cpu_input2.npu()
42+ cpu_output = self.cpu_op_exec(cpu_input1, cpu_input2)
43+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
44+ cpu_output = cpu_output.astype(npu_output.dtype)
45+ self.assertRtolEqual(cpu_output, npu_output)
46+ 
47+ 
48+if __name__ == "__main__":
49+ run_tests()
Atest/test_base_ops/test__svd_helper.py+43-0
@@ -0,0 +1,43 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestSvdHelper(TestCase):
10+ def cpu_op_exec(self, input1, some, compute_uv=False):
11+ output_u, output_s, output_v = torch.svd(input1, some, compute_uv)
12+ return output_u, output_s, output_v
13+ 
14+ def npu_op_exec(self, input1, some, compute_uv=False):
15+ output_u, output_s, output_v = torch.svd(input1, some, compute_uv)
16+ output_u = output_u.cpu()
17+ output_s = output_s.cpu()
18+ output_v = output_v.cpu()
19+ return output_u, output_s, output_v
20+ 
21+ def test_svd_fp32(self):
22+ shape_format = [
23+ [[np.float32, -1, [5, 3]]],
24+ [[np.float32, -1, [2, 3, 4]]],
25+ ]
26+ for item in shape_format:
27+ cpu_input, npu_input = create_common_tensor(item[0], 0, 100)
28+ 
29+ cpu_u, cpu_s, cpu_v = self.cpu_op_exec(cpu_input, some=True)
30+ npu_u, npu_s, npu_v = self.npu_op_exec(npu_input, some=True)
31+ self.assertRtolEqual(cpu_u, npu_u)
32+ self.assertRtolEqual(cpu_s, npu_s)
33+ self.assertRtolEqual(cpu_v, npu_v)
34+ 
35+ cpu_u, cpu_s, cpu_v = self.cpu_op_exec(cpu_input, some=False)
36+ npu_u, npu_s, npu_v = self.npu_op_exec(npu_input, some=False)
37+ self.assertRtolEqual(cpu_u, npu_u)
38+ self.assertRtolEqual(cpu_s, npu_s)
39+ self.assertRtolEqual(cpu_v, npu_v)
40+ 
41+ 
42+if __name__ == "__main__":
43+ run_tests()
Atest/test_base_ops/test_abs.py+45-0
@@ -0,0 +1,45 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestAbs(TestCase):
10+ def cpu_op_exec(self, input1):
11+ output = torch.abs(input1)
12+ output = output.numpy()
13+ return output
14+ 
15+ def npu_op_exec(self, input1):
16+ output = torch.abs(input1)
17+ output = output.to("cpu")
18+ output = output.numpy()
19+ return output
20+ 
21+ def test_abs_shape_format_fp16(self, device="npu"):
22+ format_list = [0, 3]
23+ shape_list = [[5], [5, 10], [1, 3, 2], [52, 15, 15, 20]]
24+ shape_format = [[np.float16, i, j] for i in format_list for j in shape_list]
25+ for item in shape_format:
26+ cpu_input, npu_input = create_common_tensor(item, -10, 10)
27+ cpu_input = cpu_input.to(torch.float32)
28+ cpu_output = self.cpu_op_exec(cpu_input)
29+ npu_output = self.npu_op_exec(npu_input)
30+ cpu_output = cpu_output.astype(np.float16)
31+ self.assertRtolEqual(cpu_output, npu_output)
32+ 
33+ def test_abs_shape_format_fp32(self, device="npu"):
34+ format_list = [0, 3]
35+ shape_list = [[5], [5, 10], [1, 3, 2], [52, 15, 15, 20]]
36+ shape_format = [[np.float32, i, j] for i in format_list for j in shape_list]
37+ for item in shape_format:
38+ cpu_input, npu_input = create_common_tensor(item, -10, 10)
39+ cpu_output = self.cpu_op_exec(cpu_input)
40+ npu_output = self.npu_op_exec(npu_input)
41+ self.assertRtolEqual(cpu_output, npu_output)
42+ 
43+ 
44+if __name__ == "__main__":
45+ run_tests()
Atest/test_base_ops/test_absolute.py+45-0
@@ -0,0 +1,45 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestAbs(TestCase):
10+ def cpu_op_exec(self, input1):
11+ output = torch.absolute(input1)
12+ output = output.numpy()
13+ return output
14+ 
15+ def npu_op_exec(self, input1):
16+ output = torch.absolute(input1)
17+ output = output.to("cpu")
18+ output = output.numpy()
19+ return output
20+ 
21+ def test_abs_shape_format_fp16(self):
22+ format_list = [0, 3]
23+ shape_list = [[5], [5, 10], [1, 3, 2], [52, 15, 15, 20]]
24+ shape_format = [[np.float16, i, j] for i in format_list for j in shape_list]
25+ for item in shape_format:
26+ cpu_input, npu_input = create_common_tensor(item, -10, 10)
27+ cpu_input = cpu_input.to(torch.float32)
28+ cpu_output = self.cpu_op_exec(cpu_input)
29+ npu_output = self.npu_op_exec(npu_input)
30+ cpu_output = cpu_output.astype(np.float16)
31+ self.assertRtolEqual(cpu_output, npu_output)
32+ 
33+ def test_abs_shape_format_fp32(self):
34+ format_list = [0, 3]
35+ shape_list = [[5], [5, 10], [1, 3, 2], [52, 15, 15, 20]]
36+ shape_format = [[np.float32, i, j] for i in format_list for j in shape_list]
37+ for item in shape_format:
38+ cpu_input, npu_input = create_common_tensor(item, -10, 10)
39+ cpu_output = self.cpu_op_exec(cpu_input)
40+ npu_output = self.npu_op_exec(npu_input)
41+ self.assertRtolEqual(cpu_output, npu_output)
42+ 
43+ 
44+if __name__ == "__main__":
45+ run_tests()
Atest/test_base_ops/test_acosh.py+74-0
@@ -0,0 +1,74 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestAcosh(TestCase):
10+ def cpu_op_exec(self, input1):
11+ output = torch.acosh(input1)
12+ output = output.numpy()
13+ return output
14+ 
15+ def npu_op_exec(self, input1):
16+ output = torch.acosh(input1)
17+ output = output.to("cpu")
18+ output = output.numpy()
19+ return output
20+ 
21+ def npu_op_exec_out(self, input1, input2):
22+ torch.acosh(input1, out=input2)
23+ output = input2.to("cpu")
24+ output = output.numpy()
25+ return output
26+ 
27+ def cpu_inp_op_exec(self, input1):
28+ output = torch.acosh_(input1)
29+ output = output.numpy()
30+ return output
31+ 
32+ def npu_inp_op_exec(self, input1):
33+ output = torch.acosh_(input1)
34+ output = output.to("cpu")
35+ output = output.numpy()
36+ return output
37+ 
38+ def test_acosh_common_shape_format(self):
39+ shape_format1 = [
40+ [[np.float32, 0, (5, 3)]],
41+ ]
42+ for item in shape_format1:
43+ cpu_input1, npu_input1 = create_common_tensor(item[0], -10, 10)
44+ cpu_output = self.cpu_op_exec(cpu_input1)
45+ npu_output = self.npu_op_exec(npu_input1)
46+ mask = ~(np.isnan(cpu_output) | np.isinf(cpu_output))
47+ self.assertRtolEqual(cpu_output[mask], npu_output[mask], 0.001)
48+ 
49+ def test_acosh_out_common_shape_format(self):
50+ shape_format1 = [
51+ [[np.float32, 0, (4, 3)], [np.float32, 0, (4, 3)]],
52+ ]
53+ for item in shape_format1:
54+ cpu_input1, npu_input1 = create_common_tensor(item[0], -10, 10)
55+ cpu_input2, npu_input2 = create_common_tensor(item[1], -10, 10)
56+ cpu_output = self.cpu_op_exec(cpu_input1)
57+ npu_output = self.npu_op_exec_out(npu_input1, npu_input2)
58+ mask = ~(np.isnan(cpu_output) | np.isinf(cpu_output))
59+ self.assertRtolEqual(cpu_output[mask], npu_output[mask], 0.001)
60+ 
61+ def test_acosh_inp_common_shape_format(self):
62+ shape_format1 = [
63+ [[np.float32, 0, (5, 3)]],
64+ ]
65+ for item in shape_format1:
66+ cpu_input1, npu_input1 = create_common_tensor(item[0], -10, 10)
67+ cpu_output = self.cpu_inp_op_exec(cpu_input1)
68+ npu_output = self.npu_inp_op_exec(npu_input1)
69+ mask = ~(np.isnan(cpu_output) | np.isinf(cpu_output))
70+ self.assertRtolEqual(cpu_output[mask], npu_output[mask], 0.001)
71+ 
72+ 
73+if __name__ == "__main__":
74+ run_tests()
Atest/test_base_ops/test_adaptive_avg_pool1d.py+51-0
@@ -0,0 +1,51 @@
1+import torch
2+import torch.nn as nn
3+import numpy as np
4+import torch_npu
5+ 
6+from torch_npu.testing.testcase import TestCase, run_tests
7+from torch_npu.testing.common_utils import create_common_tensor
8+ 
9+ 
10+class TestAdaptiveAvgPool1d(TestCase):
11+ def cpu_op_exec(self, input1, output_size):
12+ m = nn.AdaptiveAvgPool1d(output_size)
13+ output = m(input1)
14+ return output
15+ 
16+ def npu_op_exec(self, input1, output_size):
17+ m = nn.AdaptiveAvgPool1d(output_size).npu()
18+ output = m(input1)
19+ return output.cpu()
20+ 
21+ def test_AdaptiveAvgPool1d_shape_format_fp16(self, device="npu"):
22+ shape_format = [
23+ [np.float16, 0, (64, 10, 16)],
24+ [np.float16, -1, (256, 2048, 8)],
25+ [np.float16, 3, (32, 16, 16)],
26+ ]
27+ output_list = [(4), (3)]
28+ for item in shape_format:
29+ cpu_input, npu_input = create_common_tensor(item, 1, 10)
30+ for output_size in output_list:
31+ cpu_output = self.cpu_op_exec(cpu_input.float(), output_size).half()
32+ npu_output = self.npu_op_exec(npu_input, output_size)
33+ self.assertRtolEqual(cpu_output, npu_output, prec16=0.002)
34+ 
35+ def test_AdaptiveAvgPool1d_shape_format_fp32(self, device="npu"):
36+ shape_format = [
37+ [np.float32, 0, (64, 10, 16)],
38+ [np.float32, -1, (256, 2048, 8)],
39+ [np.float32, 3, (32, 16, 16)],
40+ ]
41+ output_list = [(4), (3), (1)]
42+ for item in shape_format:
43+ cpu_input, npu_input = create_common_tensor(item, 1, 10)
44+ for output_size in output_list:
45+ cpu_output = self.cpu_op_exec(cpu_input, output_size)
46+ npu_output = self.npu_op_exec(npu_input, output_size)
47+ self.assertRtolEqual(cpu_output, npu_output, 0.001)
48+ 
49+ 
50+if __name__ == "__main__":
51+ run_tests()
Atest/test_base_ops/test_adaptive_avg_pool2d_backward.py+61-0
@@ -0,0 +1,61 @@
1+import torch
2+import numpy as np
3+from torch.nn import functional as F
4+import torch_npu
5+ 
6+from torch_npu.testing.testcase import TestCase, run_tests
7+ 
8+ 
9+class TestAdaptiveAvgPool2dBackward(TestCase):
10+ def cpu_op_exec(self, input_x, input_grad):
11+ input_x.requires_grad_(True)
12+ m = torch.nn.AdaptiveAvgPool2d(input_grad)
13+ if input_x.dtype == torch.half:
14+ output = m(input_x.float()).half()
15+ else:
16+ output = m(input_x)
17+ output.backward(output)
18+ out = output.detach(), input_x.grad
19+ return out
20+ 
21+ def npu_op_exec(self, input_x, input_grad):
22+ input_x.requires_grad_(True)
23+ m = torch.nn.AdaptiveAvgPool2d(input_grad)
24+ output = m(input_x)
25+ output.backward(output)
26+ out = output.detach().cpu(), input_x.grad.cpu()
27+ return out
28+ 
29+ def test_adaptiveAvgPool2d_backward_1(self):
30+ torch.manual_seed(123)
31+ cpu_input = torch.randn((1, 8, 9), dtype=torch.float32)
32+ npu_input = cpu_input.npu()
33+ output_size = np.array((2, 3))
34+ cpu_output = self.cpu_op_exec(cpu_input, output_size)
35+ npu_output = self.npu_op_exec(npu_input, output_size)
36+ self.assertRtolEqual(cpu_output[0], npu_output[0], prec=1e-3)
37+ self.assertRtolEqual(cpu_output[1], npu_output[1], prec=1e-3)
38+ 
39+ def test_adaptiveAvgPool2d_backward_2(self):
40+ torch.manual_seed(123)
41+ cpu_input = torch.randn((1, 3, 3, 3), dtype=torch.float32)
42+ npu_input = cpu_input.npu()
43+ output_size = np.array((2, 2))
44+ cpu_output = self.cpu_op_exec(cpu_input, output_size)
45+ npu_output = self.npu_op_exec(npu_input, output_size)
46+ self.assertRtolEqual(cpu_output[0], npu_output[0], prec=1e-3)
47+ self.assertRtolEqual(cpu_output[1], npu_output[1], prec=1e-3)
48+ 
49+ def test_adaptiveAvgPool2d_backward_fp16(self):
50+ input_x = np.random.uniform(0, 1, (1, 3, 6, 6)).astype(np.float16)
51+ cpu_input = torch.from_numpy(input_x)
52+ npu_input = cpu_input.npu()
53+ output_size = np.array((5, 5))
54+ cpu_output = self.cpu_op_exec(cpu_input, output_size)
55+ npu_output = self.npu_op_exec(npu_input, output_size)
56+ self.assertRtolEqual(cpu_output[0], npu_output[0])
57+ self.assertRtolEqual(cpu_output[1], npu_output[1])
58+ 
59+ 
60+if __name__ == "__main__":
61+ run_tests()
Atest/test_base_ops/test_adaptive_avg_pool3d.py+55-0
@@ -0,0 +1,55 @@
1+import torch
2+import torch.nn as nn
3+import numpy as np
4+import torch_npu
5+ 
6+from torch_npu.testing.testcase import TestCase, run_tests
7+from torch_npu.testing.common_utils import create_common_tensor
8+ 
9+ 
10+class TestAdaptiveAvgPool3d(TestCase):
11+ def cpu_op_exec(self, input1, output_size):
12+ m = nn.AdaptiveAvgPool3d(output_size)
13+ output = m(input1)
14+ return output.numpy()
15+ 
16+ def npu_op_exec(self, input1, output_size):
17+ m = nn.AdaptiveAvgPool3d(output_size)
18+ output = m(input1).cpu()
19+ return output.numpy()
20+ 
21+ def test_adaptive_avg_pool3d_shape_format_fp16(self, device="npu"):
22+ shape_format = [
23+ [np.float16, -1, (64, 10, 16, 32)],
24+ [np.float16, -1, (4, 16, 8, 4, 2)],
25+ [np.float16, -1, (2, 16, 4, 32)],
26+ [np.float16, -1, (4, 16, 8, 4, 16)],
27+ ]
28+ output_list = [(1, 1, 1)]
29+ for item in shape_format:
30+ cpu_input, npu_input = create_common_tensor(item, 1, 10)
31+ cpu_input = cpu_input.to(torch.float32)
32+ for output_size in output_list:
33+ cpu_output = self.cpu_op_exec(cpu_input, output_size)
34+ npu_output = self.npu_op_exec(npu_input, output_size)
35+ cpu_output = cpu_output.astype(npu_output.dtype)
36+ self.assertRtolEqual(cpu_output, npu_output)
37+ 
38+ def test_adaptive_avg_pool3d_shape_format_fp32(self, device="npu"):
39+ shape_format = [
40+ [np.float32, -1, (64, 10, 16, 32)],
41+ [np.float32, -1, (4, 2, 2, 4, 316)],
42+ [np.float32, -1, (2, 16, 4, 32)],
43+ [np.float32, -1, (4, 16, 8, 4, 16)],
44+ ]
45+ output_list = [(1, 1, 1)]
46+ for item in shape_format:
47+ cpu_input, npu_input = create_common_tensor(item, 1, 10)
48+ for output_size in output_list:
49+ cpu_output = self.cpu_op_exec(cpu_input, output_size)
50+ npu_output = self.npu_op_exec(npu_input, output_size)
51+ self.assertRtolEqual(cpu_output, npu_output)
52+ 
53+ 
54+if __name__ == "__main__":
55+ run_tests()
Atest/test_base_ops/test_adaptive_avg_pool3d_backward.py+47-0
@@ -0,0 +1,47 @@
1+import torch
2+import numpy as np
3+from torch.nn import functional as F
4+import torch_npu
5+ 
6+from torch_npu.testing.testcase import TestCase, run_tests
7+from torch_npu.testing.common_utils import create_common_tensor
8+ 
9+ 
10+class TestAdaptiveAvgPool3dBackward(TestCase):
11+ def cpu_op_exec(self, input_x, output_size):
12+ input_x.requires_grad_(True)
13+ m = torch.nn.AdaptiveAvgPool3d(output_size)
14+ output = m(input_x)
15+ ones = torch.ones_like(output)
16+ output.backward(ones)
17+ out = input_x.grad
18+ return out.numpy()
19+ 
20+ def npu_op_exec(self, input_x, output_size):
21+ input_x.requires_grad_(True)
22+ m = torch.nn.AdaptiveAvgPool3d(output_size)
23+ output = m(input_x)
24+ ones = torch.ones_like(output)
25+ output.backward(ones)
26+ out = input_x.grad.cpu()
27+ return out.numpy()
28+ 
29+ def test_adaptive_avg_pool3d_backward(self, device="npu"):
30+ dtype_list = [np.float16, np.float32]
31+ format_list = [-1]
32+ shape_list = [[2, 3, 7, 7], [1, 2, 3, 6, 6], [6, 5, 8, 10], [2, 5, 6, 8, 9]]
33+ # pylint:disable = complicate-comprehension
34+ shape_format = [
35+ [i, j, k] for i in dtype_list for j in format_list for k in shape_list
36+ ]
37+ output_sizes = [[1, 1, 1]]
38+ for item in shape_format:
39+ cpu_input, npu_input = create_common_tensor(item, 1, 10)
40+ for output_size in output_sizes:
41+ cpu_output = self.cpu_op_exec(cpu_input, output_size)
42+ npu_output = self.npu_op_exec(npu_input, output_size)
43+ self.assertRtolEqual(cpu_output, npu_output)
44+ 
45+ 
46+if __name__ == "__main__":
47+ run_tests()
Atest/test_base_ops/test_adaptive_max_pool2d.py+53-0
@@ -0,0 +1,53 @@
1+import torch
2+import torch.nn as nn
3+import torch.nn.functional as F
4+import numpy as np
5+ 
6+from torch_npu.testing.testcase import TestCase, run_tests
7+from torch_npu.testing.common_utils import create_common_tensor
8+ 
9+ 
10+class TestAdaptiveMaxPool2d(TestCase):
11+ def cpu_op_exec(self, input1, output_size):
12+ m = nn.AdaptiveMaxPool2d(output_size)
13+ output = m(input1)
14+ return output.numpy()
15+ 
16+ def npu_op_exec(self, input1, output_size):
17+ m = nn.AdaptiveMaxPool2d(output_size).npu()
18+ output = m(input1)
19+ return output.cpu().numpy()
20+ 
21+ def test_adaptiveMaxPool2d_shape_format_fp32_6(self):
22+ format_list = [-1]
23+ # (1, 8, 9) IndexError
24+ shape_list = [(1, 5, 9, 9)]
25+ shape_format = [
26+ [np.float32, i, j] for i in format_list for j in shape_list
27+ ]
28+ output_list = [(3, 3)]
29+ for item in shape_format:
30+ cpu_input, npu_input = create_common_tensor(item, 0, 100)
31+ for output_size in output_list:
32+ cpu_output = self.cpu_op_exec(cpu_input, output_size)
33+ npu_output = self.npu_op_exec(npu_input, output_size)
34+ 
35+ self.assertRtolEqual(cpu_output, npu_output, 0.0004)
36+ 
37+ def test_adaptiveMaxPool2d_case_in_photo2cartoon(self):
38+ cpu_x = torch.rand(1, 256, 31, 31)
39+ npu_x = cpu_x.npu()
40+ cpu_out = F.adaptive_max_pool2d(cpu_x, 1)
41+ npu_out = F.adaptive_max_pool2d(npu_x, 1)
42+ self.assertRtolEqual(cpu_out, npu_out.cpu(), 0.0003)
43+ 
44+ def test_adaptiveMaxPool2d_case_in_photo2cartoon_fp16(self):
45+ cpu_x = torch.rand(1, 256, 31, 31).half()
46+ npu_x = cpu_x.npu()
47+ cpu_out = F.adaptive_max_pool2d(cpu_x.float(), 1).half()
48+ npu_out = F.adaptive_max_pool2d(npu_x, 1)
49+ self.assertRtolEqual(cpu_out, npu_out.cpu())
50+ 
51+ 
52+if __name__ == "__main__":
53+ run_tests()
Atest/test_base_ops/test_adaptive_max_pool2d_backward.py+66-0
@@ -0,0 +1,66 @@
1+import torch
2+import torch.nn as nn
3+import torch.nn.functional as F
4+import numpy as np
5+ 
6+from torch_npu.testing.testcase import TestCase, run_tests
7+from torch_npu.testing.common_utils import create_common_tensor
8+ 
9+ 
10+class TestAdaptiveMaxPool2dBackward(TestCase):
11+ def cpu_op_exec(self, input_tensor, output_size):
12+ input_tensor.requires_grad = True
13+ m = nn.AdaptiveMaxPool2d(output_size)
14+ output = m(input_tensor)
15+ output.backward(output)
16+ cpu_grad = input_tensor.grad
17+ return cpu_grad
18+ 
19+ def npu_op_exec(self, input_tensor, output_size):
20+ input_tensor.requires_grad = True
21+ m = nn.AdaptiveMaxPool2d(output_size)
22+ output = m(input_tensor)
23+ output.backward(output)
24+ npu_grad = input_tensor.grad
25+ npu_grad = npu_grad.to("cpu")
26+ return npu_grad
27+ 
28+ def test_adaptiveMaxPool2d_shape_format_fp32_6(self):
29+ format_list = [0, 3]
30+ shape_list = [(1, 3, 8, 9)]
31+ shape_format = [[np.float16, i, j] for i in format_list for j in shape_list]
32+ output_list = [(2, 3)]
33+ for item in shape_format:
34+ cpu_input, npu_input = create_common_tensor(item, 0, 100)
35+ for output_size in output_list:
36+ cpu_input = cpu_input.to(torch.float32)
37+ cpu_output = self.cpu_op_exec(cpu_input, output_size)
38+ cpu_output = cpu_output.to(torch.float16)
39+ npu_output = self.npu_op_exec(npu_input, output_size)
40+ self.assertRtolEqual(cpu_output, npu_output)
41+ 
42+ def test_adaptiveMaxPool2d_backward_case_in_photo2cartoon(self):
43+ cpu_x = torch.rand(1, 256, 31, 31)
44+ npu_x = cpu_x.npu()
45+ cpu_x.requires_grad = True
46+ npu_x.requires_grad = True
47+ cpu_out = F.adaptive_max_pool2d(cpu_x, 1)
48+ npu_out = F.adaptive_max_pool2d(npu_x, 1)
49+ cpu_out.backward(torch.ones_like(cpu_out))
50+ npu_out.backward(torch.ones_like(npu_out))
51+ self.assertRtolEqual(cpu_x.grad, npu_x.grad.cpu(), 0.0003)
52+ 
53+ def test_adaptiveMaxPool2d_backward_case_in_photo2cartoon_fp16(self):
54+ cpu_x = torch.rand(1, 256, 31, 31).half()
55+ npu_x = cpu_x.npu()
56+ cpu_x.requires_grad = True
57+ npu_x.requires_grad = True
58+ cpu_out = F.adaptive_max_pool2d(cpu_x.float(), 1).half()
59+ npu_out = F.adaptive_max_pool2d(npu_x, 1)
60+ cpu_out.backward(torch.ones_like(cpu_out))
61+ npu_out.backward(torch.ones_like(npu_out))
62+ self.assertRtolEqual(cpu_x.grad, npu_x.grad.cpu())
63+ 
64+ 
65+if __name__ == "__main__":
66+ run_tests()
Atest/test_base_ops/test_add.py+471-0
@@ -0,0 +1,471 @@
1+import torch
2+import numpy as np
3+ 
4+import torch_npu
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestAdd(TestCase):
10+ def cpu_op_out_exec(self, input1, input2, output):
11+ torch.add(input1, input2, alpha=1, out=output)
12+ output = output.numpy()
13+ return output
14+ 
15+ def npu_op_out_exec_new(self, input1, input2, output):
16+ torch.add(input1, input2, alpha=1, out=output)
17+ output = output.to("cpu")
18+ output = output.numpy()
19+ return output
20+ 
21+ def cpu_op_exec(self, input1, input2):
22+ output = torch.add(input1, input2, alpha=1)
23+ output = output.numpy()
24+ return output
25+ 
26+ def cpu_tensor_op_exec(self, input1, input2):
27+ output = input1.add(input2, alpha=1)
28+ output = output.numpy()
29+ return output
30+ 
31+ def npu_tensor_op_exec(self, input1, input2):
32+ output = input1.add(input2, alpha=1)
33+ output = output.to("cpu")
34+ output = output.numpy()
35+ return output
36+ 
37+ def npu_op_exec_new(self, input1, input2):
38+ output = torch.add(input1, input2, alpha=1)
39+ output = output.to("cpu")
40+ output = output.numpy()
41+ return output
42+ 
43+ def cpu_op_exec_alpha(self, input1, input2):
44+ output = torch.add(input1, input2, alpha=3)
45+ output = output.numpy()
46+ return output
47+ 
48+ def npu_op_exec_new_alpha(self, input1, input2):
49+ output = torch.add(input1, input2, alpha=3)
50+ output = output.to("cpu")
51+ output = output.numpy()
52+ return output
53+ 
54+ def cpu_op_scalar_exec(self, input1, scalar):
55+ output = torch.add(input1, scalar, alpha=1)
56+ output = output.numpy()
57+ return output
58+ 
59+ def npu_op_scalar_exec_new(self, input1, scalar):
60+ output = torch.add(input1, scalar, alpha=1)
61+ output = output.to("cpu")
62+ output = output.numpy()
63+ return output
64+ 
65+ def cpu_op_scalar_exec_alpha(self, input1, scalar):
66+ output = torch.add(input1, scalar, alpha=3)
67+ output = output.numpy()
68+ return output
69+ 
70+ def npu_op_scalar_exec_new_alpha(self, input1, scalar):
71+ output = torch.add(input1, scalar, alpha=3)
72+ output = output.to("cpu")
73+ output = output.numpy()
74+ return output
75+ 
76+ def add_scalar_result(self, shape_format):
77+ for item in shape_format:
78+ cpu_input, npu_input = create_common_tensor(item[0], 0, 100)
79+ if cpu_input.dtype == torch.float16:
80+ cpu_input = cpu_input.to(torch.float32)
81+ cpu_output = self.cpu_op_scalar_exec(cpu_input, item[1])
82+ npu_output = self.npu_op_exec_new(npu_input, item[1])
83+ cpu_output = cpu_output.astype(npu_output.dtype)
84+ 
85+ self.assertRtolEqual(cpu_output, npu_output)
86+ 
87+ def add_scalar_alpha_result(self, shape_format):
88+ for item in shape_format:
89+ cpu_input, npu_input = create_common_tensor(item[0], 0, 100)
90+ if cpu_input.dtype == torch.float16:
91+ cpu_input = cpu_input.to(torch.float32)
92+ cpu_output = self.cpu_op_scalar_exec_alpha(cpu_input, item[1])
93+ npu_output = self.npu_op_scalar_exec_new_alpha(npu_input, item[1])
94+ cpu_output = cpu_output.astype(npu_output.dtype)
95+ 
96+ self.assertRtolEqual(cpu_output, npu_output)
97+ 
98+ def add_result(self, shape_format):
99+ for item in shape_format:
100+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 100)
101+ cpu_input2, npu_input2 = create_common_tensor(item, 0, 100)
102+ if cpu_input1.dtype == torch.float16:
103+ cpu_input1 = cpu_input1.to(torch.float32)
104+ cpu_input2 = cpu_input2.to(torch.float32)
105+ 
106+ cpu_output = self.cpu_op_exec(cpu_input1, cpu_input2)
107+ npu_output = self.npu_op_exec_new(npu_input1, npu_input2)
108+ cpu_output = cpu_output.astype(npu_output.dtype)
109+ 
110+ self.assertRtolEqual(cpu_output, npu_output)
111+ 
112+ def add_out_result(self, shape_format):
113+ for item in shape_format:
114+ cpuout = torch.randn(3)
115+ npuout = torch.randn(3).to("npu")
116+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 100)
117+ cpu_input2, npu_input2 = create_common_tensor(item, 0, 100)
118+ if cpu_input1.dtype == torch.float16:
119+ cpu_input1 = cpu_input1.to(torch.float32)
120+ cpu_input2 = cpu_input2.to(torch.float32)
121+ 
122+ cpu_output = self.cpu_op_out_exec(cpu_input1, cpu_input2, cpuout)
123+ npu_output = self.npu_op_out_exec_new(npu_input1, npu_input2, npuout)
124+ cpu_output = cpu_output.astype(npu_output.dtype)
125+ 
126+ self.assertRtolEqual(cpu_output, npu_output)
127+ 
128+ def add_alpha_result(self, shape_format):
129+ for item in shape_format:
130+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 100)
131+ cpu_input2, npu_input2 = create_common_tensor(item, 0, 100)
132+ if cpu_input1.dtype == torch.float16:
133+ cpu_input1 = cpu_input1.to(torch.float32)
134+ cpu_input2 = cpu_input2.to(torch.float32)
135+ 
136+ cpu_output = self.cpu_op_exec_alpha(cpu_input1, cpu_input2)
137+ npu_output = self.npu_op_exec_new_alpha(npu_input1, npu_input2)
138+ cpu_output = cpu_output.astype(npu_output.dtype)
139+ 
140+ self.assertRtolEqual(cpu_output, npu_output)
141+ 
142+ def test_add_scalar_shape_format_fp16_1d(self):
143+ format_list = [0, 3]
144+ scalar_list = [0, 1]
145+ shape_format = [
146+ [[np.float16, i, [18]], k] for i in format_list for k in scalar_list
147+ ]
148+ self.add_scalar_result(shape_format)
149+ 
150+ def test_add_scalar_shape_format_fp32_1d(self):
151+ format_list = [0, 3]
152+ scalar_list = [0, 1]
153+ shape_format = [
154+ [[np.float32, i, [18]], k] for i in format_list for k in scalar_list
155+ ]
156+ self.add_scalar_result(shape_format)
157+ 
158+ def test_add_scalar_shape_format_fp16_2d(self):
159+ format_list = [0, 3, 29]
160+ scalar_list = [0, 1]
161+ shape_format = [
162+ [[np.float16, i, [5, 256]], k] for i in format_list for k in scalar_list
163+ ]
164+ self.add_scalar_result(shape_format)
165+ 
166+ def test_add_scalar_shape_format_fp32_2d(self):
167+ format_list = [0, 3, 29]
168+ scalar_list = [0, 1]
169+ shape_format = [
170+ [[np.float32, i, [5, 256]], k] for i in format_list for k in scalar_list
171+ ]
172+ self.add_scalar_result(shape_format)
173+ 
174+ def test_add_scalar_shape_format_fp16_3d(self):
175+ format_list = [0, 3, 29]
176+ scalar_list = [0, 1]
177+ shape_format = [
178+ [[np.float16, i, [32, 3, 3]], k] for i in format_list for k in scalar_list
179+ ]
180+ self.add_scalar_result(shape_format)
181+ 
182+ def test_add_scalar_shape_format_fp32_3d(self):
183+ format_list = [0, 3, 29]
184+ scalar_list = [0, 1]
185+ shape_format = [
186+ [[np.float32, i, [32, 3, 3]], k] for i in format_list for k in scalar_list
187+ ]
188+ self.add_scalar_result(shape_format)
189+ 
190+ def test_add_scalar_shape_format_fp16_4d(self):
191+ format_list = [0, 3, 29]
192+ scalar_list = [0, 1]
193+ shape_format = [
194+ [[np.float16, i, [64, 112, 7, 7]], k]
195+ for i in format_list
196+ for k in scalar_list
197+ ]
198+ self.add_scalar_result(shape_format)
199+ 
200+ def test_add_scalar_shape_format_fp32_4d(self):
201+ format_list = [0, 3, 29]
202+ scalar_list = [0, 1]
203+ shape_format = [
204+ [[np.float32, i, [64, 112, 7, 7]], k]
205+ for i in format_list
206+ for k in scalar_list
207+ ]
208+ self.add_scalar_result(shape_format)
209+ 
210+ def test_add_scalar_shape_format_fp16_1d(self):
211+ format_list = [0, 3]
212+ scalar_list = [0, 1]
213+ shape_format = [
214+ [[np.float16, i, [18]], k] for i in format_list for k in scalar_list
215+ ]
216+ self.add_scalar_alpha_result(shape_format)
217+ 
218+ def test_add_scalar_shape_format_fp32_1d(self):
219+ format_list = [0, 3]
220+ scalar_list = [0, 1]
221+ shape_format = [
222+ [[np.float32, i, [18]], k] for i in format_list for k in scalar_list
223+ ]
224+ self.add_scalar_alpha_result(shape_format)
225+ 
226+ def test_add_scalar_shape_format_fp16_2d(self):
227+ format_list = [0, 3, 29]
228+ scalar_list = [0, 1]
229+ shape_format = [
230+ [[np.float16, i, [5, 256]], k] for i in format_list for k in scalar_list
231+ ]
232+ self.add_scalar_alpha_result(shape_format)
233+ 
234+ def test_add_scalar_shape_format_fp32_2d(self):
235+ format_list = [0, 3, 29]
236+ scalar_list = [0, 1]
237+ shape_format = [
238+ [[np.float32, i, [5, 256]], k] for i in format_list for k in scalar_list
239+ ]
240+ self.add_scalar_alpha_result(shape_format)
241+ 
242+ def test_add_scalar_shape_format_fp16_3d(self):
243+ format_list = [0, 3, 29]
244+ scalar_list = [0, 1]
245+ shape_format = [
246+ [[np.float16, i, [32, 3, 3]], k] for i in format_list for k in scalar_list
247+ ]
248+ self.add_scalar_alpha_result(shape_format)
249+ 
250+ def test_add_scalar_shape_format_fp32_3d(self):
251+ format_list = [0, 3, 29]
252+ scalar_list = [0, 1]
253+ shape_format = [
254+ [[np.float32, i, [32, 3, 3]], k] for i in format_list for k in scalar_list
255+ ]
256+ self.add_scalar_alpha_result(shape_format)
257+ 
258+ def test_add_scalar_shape_format_fp16_4d(self):
259+ format_list = [0, 3, 29]
260+ scalar_list = [0, 1]
261+ shape_format = [
262+ [[np.float16, i, [64, 112, 7, 7]], k]
263+ for i in format_list
264+ for k in scalar_list
265+ ]
266+ self.add_scalar_alpha_result(shape_format)
267+ 
268+ def test_add_scalar_shape_format_fp32_4d(self):
269+ format_list = [0, 3, 29]
270+ scalar_list = [0, 1]
271+ shape_format = [
272+ [[np.float32, i, [64, 112, 7, 7]], k]
273+ for i in format_list
274+ for k in scalar_list
275+ ]
276+ self.add_scalar_alpha_result(shape_format)
277+ 
278+ def test_add_shape_format_fp16_1d(self):
279+ format_list = [0, 3]
280+ shape_format = [[np.float16, i, [64]] for i in format_list]
281+ self.add_result(shape_format)
282+ 
283+ def test_add_shape_format_fp32_1d(self):
284+ format_list = [0, 3]
285+ shape_format = [[np.float32, i, [64]] for i in format_list]
286+ self.add_result(shape_format)
287+ 
288+ def test_add_shape_format_fp16_2d(self):
289+ format_list = [0, 3, 29]
290+ shape_format = [[np.float16, i, [5, 256]] for i in format_list]
291+ self.add_result(shape_format)
292+ 
293+ def test_add_shape_format_fp32_2d(self):
294+ format_list = [0, 3, 29]
295+ shape_format = [[np.float32, i, [5, 256]] for i in format_list]
296+ self.add_result(shape_format)
297+ 
298+ def test_add_shape_format_fp16_3d(self):
299+ format_list = [0, 3, 29]
300+ shape_format = [[np.float16, i, [32, 3, 3]] for i in format_list]
301+ self.add_result(shape_format)
302+ 
303+ def test_add_shape_format_fp32_3d(self):
304+ format_list = [0, 3, 29]
305+ shape_format = [[np.float32, i, [32, 3, 3]] for i in format_list]
306+ self.add_result(shape_format)
307+ 
308+ def test_add_shape_format_fp16_4d(self):
309+ format_list = [0, 3, 29]
310+ shape_format = [[np.float16, i, [64, 112, 7, 7]] for i in format_list]
311+ self.add_result(shape_format)
312+ 
313+ def test_add_shape_format_fp32_4d(self):
314+ format_list = [0, 3, 29]
315+ shape_format = [[np.float32, i, [64, 112, 7, 7]] for i in format_list]
316+ self.add_result(shape_format)
317+ 
318+ def test_add_shape_format_fp16_1d(self):
319+ format_list = [0, 3]
320+ shape_format = [[np.float16, i, [64]] for i in format_list]
321+ self.add_alpha_result(shape_format)
322+ 
323+ def test_add_shape_format_fp32_1d(self):
324+ format_list = [0, 3]
325+ shape_format = [[np.float32, i, [64]] for i in format_list]
326+ self.add_alpha_result(shape_format)
327+ 
328+ def test_add_shape_format_fp16_2d(self):
329+ format_list = [0, 3, 29]
330+ shape_format = [[np.float16, i, [5, 256]] for i in format_list]
331+ self.add_alpha_result(shape_format)
332+ 
333+ def test_add_shape_format_fp32_2d(self):
334+ format_list = [0, 3, 29]
335+ shape_format = [[np.float32, i, [5, 256]] for i in format_list]
336+ self.add_alpha_result(shape_format)
337+ 
338+ def test_add_shape_format_fp16_3d(self):
339+ format_list = [0, 3, 29]
340+ shape_format = [[np.float16, i, [32, 3, 3]] for i in format_list]
341+ self.add_alpha_result(shape_format)
342+ 
343+ def test_add_shape_format_fp32_3d(self):
344+ format_list = [0, 3, 29]
345+ shape_format = [[np.float32, i, [32, 3, 3]] for i in format_list]
346+ self.add_alpha_result(shape_format)
347+ 
348+ def test_add_shape_format_fp16_4d(self):
349+ format_list = [0, 3, 29]
350+ shape_format = [[np.float16, i, [64, 112, 7, 7]] for i in format_list]
351+ self.add_alpha_result(shape_format)
352+ 
353+ def test_add_shape_format_fp32_4d(self):
354+ format_list = [0, 3, 29]
355+ shape_format = [[np.float32, i, [64, 112, 7, 7]] for i in format_list]
356+ self.add_alpha_result(shape_format)
357+ 
358+ def test_add_mix_dtype(self):
359+ cpu_input1, npu_input1 = create_common_tensor([np.int32, 0, (2, 3)], 1, 100)
360+ cpu_input2, npu_input2 = create_common_tensor([np.float32, 0, (2, 3)], 1, 100)
361+ cpu_output = torch.add(cpu_input1, cpu_input2)
362+ npu_output = torch.add(npu_input1, npu_input2)
363+ npu_output = npu_output.to("cpu")
364+ self.assertRtolEqual(cpu_output, npu_output)
365+ 
366+ def test_add_scalar_check_5d_5d_match(self):
367+ ca = torch.randn(4)
368+ cb = ca.view(2, 2).transpose(1, 0)
369+ na = ca.npu()
370+ nb = cb.npu()
371+ caout = torch.add(ca, 1)
372+ cbout = torch.add(cb, 1)
373+ naout = torch.add(na, 1)
374+ nbout = torch.add(nb, 1)
375+ naout = naout.to("cpu")
376+ nbout = nbout.to("cpu")
377+ self.assertRtolEqual(caout, naout)
378+ self.assertRtolEqual(cbout, nbout)
379+ 
380+ def test_add_different_dtype(self):
381+ cpu_x1 = torch.rand(2, 3, 4)
382+ cpu_other1 = torch.rand(2, 3, 4).uniform_(1, 10).long()
383+ npu_x1 = cpu_x1.npu()
384+ npu_other1 = cpu_other1.npu()
385+ cpu_out1 = cpu_x1 + cpu_other1
386+ npu_out1 = npu_x1 + npu_other1
387+ 
388+ cpu_x2 = 1.5
389+ cpu_other2 = torch.rand(2, 3, 4).uniform_(1, 10).long()
390+ npu_x2 = 1.5
391+ npu_other2 = cpu_other2.npu()
392+ cpu_out2 = cpu_x2 + cpu_other2
393+ npu_out2 = npu_x2 + npu_other2
394+ 
395+ cpu_x3 = torch.rand(2, 3, 4).int()
396+ cpu_other3 = 3
397+ npu_x3 = cpu_x3.npu()
398+ npu_other3 = 3
399+ cpu_out3 = cpu_x3 + cpu_other3
400+ npu_out3 = npu_x3 + npu_other3
401+ 
402+ self.assertRtolEqual(cpu_out1, npu_out1.cpu())
403+ self.assertRtolEqual(cpu_out2, npu_out2.cpu())
404+ self.assertRtolEqual(cpu_out3, npu_out3.cpu())
405+ 
406+ def test_add_inplace_and_out_mix_dtype(self):
407+ dtype_list = [
408+ [np.int32, np.int64, np.int64],
409+ [np.int64, np.int32, np.int64],
410+ [np.float32, np.float16, np.float32],
411+ [np.float16, np.float32, np.float32],
412+ [np.int64, np.float32, np.float32],
413+ ]
414+ for item in dtype_list:
415+ cpu_input1, npu_input1 = create_common_tensor(
416+ [item[0], 0, (2, 3, 4)], -100, 100
417+ )
418+ cpu_input2, npu_input2 = create_common_tensor(
419+ [item[1], 0, (2, 3, 4)], -100, 100
420+ )
421+ _, npu_output = create_common_tensor([item[2], 0, (2, 3, 4)], 1, 100)
422+ 
423+ if item[0] == np.int64 and item[1] == np.float32:
424+ try:
425+ npu_input1.add_(npu_input2)
426+ except RuntimeError as e:
427+ self.assertRegex(
428+ str(e),
429+ "result type Float can't be cast to the desired output type Long",
430+ )
431+ else:
432+ cpu_input1.add_(cpu_input2)
433+ npu_input1.add_(npu_input2)
434+ self.assertRtolEqual(cpu_input1, npu_input1.cpu())
435+ 
436+ cpu_output = torch.add(cpu_input1, cpu_input2)
437+ torch.add(npu_input1, npu_input2, out=npu_output)
438+ self.assertRtolEqual(cpu_output, npu_output.cpu())
439+ 
440+ def test_tensor_add_fp16(self):
441+ format_list = [0, 3, 29]
442+ shape_format = [[np.float16, i, [5, 256]] for i in format_list]
443+ for item in shape_format:
444+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 100)
445+ cpu_input2, npu_input2 = create_common_tensor(item, 0, 100)
446+ if cpu_input1.dtype == torch.float16:
447+ cpu_input1 = cpu_input1.to(torch.float32)
448+ cpu_input2 = cpu_input2.to(torch.float32)
449+ 
450+ cpu_output = self.cpu_tensor_op_exec(cpu_input1, cpu_input2)
451+ npu_output = self.npu_tensor_op_exec(npu_input1, npu_input2)
452+ cpu_output = cpu_output.astype(npu_output.dtype)
453+ 
454+ self.assertRtolEqual(cpu_output, npu_output)
455+ 
456+ def test_tensor_add_fp32(self):
457+ format_list = [0, 3, 29]
458+ shape_format = [[np.float32, i, [5, 256]] for i in format_list]
459+ for item in shape_format:
460+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 100)
461+ cpu_input2, npu_input2 = create_common_tensor(item, 0, 100)
462+ 
463+ cpu_output = self.cpu_tensor_op_exec(cpu_input1, cpu_input2)
464+ npu_output = self.npu_tensor_op_exec(npu_input1, npu_input2)
465+ cpu_output = cpu_output.astype(npu_output.dtype)
466+ 
467+ self.assertRtolEqual(cpu_output, npu_output)
468+ 
469+ 
470+if __name__ == "__main__":
471+ run_tests()
Atest/test_base_ops/test_add_relu.py+218-0
@@ -0,0 +1,218 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestAddRelu(TestCase):
10+ def cpu_op_exec(self, input1, input2):
11+ output = torch._VF._add_relu(input1, input2, alpha=1)
12+ output = output.numpy()
13+ return output
14+ 
15+ def npu_op_exec_new(self, input1, input2):
16+ output = torch._VF._add_relu(input1, input2, alpha=1)
17+ output = output.to("cpu")
18+ output = output.numpy()
19+ return output
20+ 
21+ def npu_op_exec_new_out(self, input1, input2, output):
22+ torch._VF._add_relu(input1, input2, out=output, alpha=1)
23+ output = output.to("cpu")
24+ output = output.numpy()
25+ return output
26+ 
27+ def cpu_op_inp_exec(self, input1, input2):
28+ output = torch._VF._add_relu_(input1, input2, alpha=1)
29+ output = output.numpy()
30+ return output
31+ 
32+ def npu_op_inp_exec(self, input1, input2):
33+ output = torch._VF._add_relu_(input1, input2, alpha=1)
34+ output = output.to("cpu")
35+ output = output.numpy()
36+ return output
37+ 
38+ def cpu_op_exec_alpha(self, input1, input2):
39+ output = torch._VF._add_relu(input1, input2, alpha=3)
40+ output = output.numpy()
41+ return output
42+ 
43+ def npu_op_exec_new_alpha(self, input1, input2):
44+ output = torch._VF._add_relu(input1, input2, alpha=3)
45+ output = output.to("cpu")
46+ output = output.numpy()
47+ return output
48+ 
49+ def add_relu_result(self, shape_format):
50+ for item in shape_format:
51+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 100)
52+ cpu_input2, npu_input2 = create_common_tensor(item, 0, 100)
53+ if cpu_input1.dtype == torch.float16:
54+ cpu_input1 = cpu_input1.to(torch.float32)
55+ cpu_input2 = cpu_input2.to(torch.float32)
56+ 
57+ cpu_output = self.cpu_op_exec(cpu_input1, cpu_input2)
58+ npu_output = self.npu_op_exec_new(npu_input1, npu_input2)
59+ cpu_output = cpu_output.astype(npu_output.dtype)
60+ 
61+ self.assertRtolEqual(cpu_output, npu_output)
62+ 
63+ def add_relu_out_result(self, shape_format):
64+ for item in shape_format:
65+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 100)
66+ cpu_input2, npu_input2 = create_common_tensor(item, 0, 100)
67+ cpu_input3, npu_input3 = create_common_tensor(item, 0, 100)
68+ if cpu_input1.dtype == torch.float16:
69+ cpu_input1 = cpu_input1.to(torch.float32)
70+ cpu_input2 = cpu_input2.to(torch.float32)
71+ 
72+ cpu_output = self.cpu_op_exec(cpu_input1, cpu_input2)
73+ npu_output = self.npu_op_exec_new_out(npu_input1, npu_input2, npu_input3)
74+ cpu_output = cpu_output.astype(npu_output.dtype)
75+ 
76+ self.assertRtolEqual(cpu_output, npu_output)
77+ 
78+ def add_relu_inp_result(self, shape_format):
79+ for item in shape_format:
80+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 100)
81+ cpu_input2, npu_input2 = create_common_tensor(item, 0, 100)
82+ if cpu_input1.dtype == torch.float16:
83+ cpu_input1 = cpu_input1.to(torch.float32)
84+ cpu_input2 = cpu_input2.to(torch.float32)
85+ 
86+ cpu_output = self.cpu_op_exec(cpu_input1, cpu_input2)
87+ npu_output = self.npu_op_inp_exec(npu_input1, npu_input2)
88+ cpu_output = cpu_output.astype(npu_output.dtype)
89+ 
90+ self.assertRtolEqual(cpu_output, npu_output)
91+ 
92+ def add_relu_alpha_result(self, shape_format):
93+ for item in shape_format:
94+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 100)
95+ cpu_input2, npu_input2 = create_common_tensor(item, 0, 100)
96+ if cpu_input1.dtype == torch.float16:
97+ cpu_input1 = cpu_input1.to(torch.float32)
98+ cpu_input2 = cpu_input2.to(torch.float32)
99+ 
100+ cpu_output = self.cpu_op_exec_alpha(cpu_input1, cpu_input2)
101+ npu_output = self.npu_op_exec_new_alpha(npu_input1, npu_input2)
102+ cpu_output = cpu_output.astype(npu_output.dtype)
103+ 
104+ self.assertRtolEqual(cpu_output, npu_output)
105+ 
106+ def test_add_relu_shape_format_fp32_1d(self):
107+ format_list = [0, 3]
108+ shape_format = [[np.float32, i, [64]] for i in format_list]
109+ self.add_relu_result(shape_format)
110+ 
111+ def test_add_relu_shape_format_fp16_2d(self):
112+ format_list = [0, 3, 29]
113+ shape_format = [[np.float16, i, [5, 256]] for i in format_list]
114+ self.add_relu_result(shape_format)
115+ 
116+ def test_add_relu_shape_format_fp32_2d(self):
117+ format_list = [0, 3, 29]
118+ shape_format = [[np.float32, i, [5, 256]] for i in format_list]
119+ self.add_relu_result(shape_format)
120+ 
121+ def test_add_relu_shape_format_fp16_3d(self):
122+ format_list = [0, 3, 29]
123+ shape_format = [[np.float16, i, [32, 3, 3]] for i in format_list]
124+ self.add_relu_result(shape_format)
125+ 
126+ def test_add_relu_shape_format_fp32_3d(self):
127+ format_list = [0, 3, 29]
128+ shape_format = [[np.float32, i, [32, 3, 3]] for i in format_list]
129+ self.add_relu_result(shape_format)
130+ 
131+ def test_add_relu_shape_format_fp16_4d(self):
132+ format_list = [0, 3, 29]
133+ shape_format = [[np.float16, i, [64, 112, 7, 7]] for i in format_list]
134+ self.add_relu_result(shape_format)
135+ 
136+ def test_add_relu_shape_format_fp32_4d(self):
137+ format_list = [0, 3, 29]
138+ shape_format = [[np.float32, i, [64, 112, 7, 7]] for i in format_list]
139+ self.add_relu_result(shape_format)
140+ 
141+ def test_add_relu_out_shape_format_fp32_1d(self):
142+ format_list = [0, 3]
143+ shape_format = [[np.float32, i, [64]] for i in format_list]
144+ self.add_relu_out_result(shape_format)
145+ 
146+ def test_add_relu_out_shape_format_fp16_2d(self):
147+ format_list = [0, 3, 29]
148+ shape_format = [[np.float16, i, [5, 256]] for i in format_list]
149+ self.add_relu_out_result(shape_format)
150+ 
151+ def test_add_relu_inp_shape_format_fp32_2d(self):
152+ format_list = [0, 3, 29]
153+ shape_format = [[np.float32, i, [5, 256]] for i in format_list]
154+ self.add_relu_inp_result(shape_format)
155+ 
156+ def test_add_relu_inp_shape_format_fp16_3d(self):
157+ format_list = [0, 3, 29]
158+ shape_format = [[np.float16, i, [32, 3, 3]] for i in format_list]
159+ self.add_relu_inp_result(shape_format)
160+ 
161+ def test_add_relu_inp_shape_format_fp32_3d(self):
162+ format_list = [0, 3, 29]
163+ shape_format = [[np.float32, i, [32, 3, 3]] for i in format_list]
164+ self.add_relu_inp_result(shape_format)
165+ 
166+ def test_add_relu_inp_shape_format_fp16_4d(self):
167+ format_list = [0, 3, 29]
168+ shape_format = [[np.float16, i, [64, 112, 7, 7]] for i in format_list]
169+ self.add_relu_inp_result(shape_format)
170+ 
171+ def test_add_relu_inp_shape_format_fp32_4d(self):
172+ format_list = [0, 3, 29]
173+ shape_format = [[np.float32, i, [64, 112, 7, 7]] for i in format_list]
174+ self.add_relu_inp_result(shape_format)
175+ 
176+ def test_add_relu_shape_format_fp16_1d(self):
177+ format_list = [0, 3]
178+ shape_format = [[np.float16, i, [64]] for i in format_list]
179+ self.add_relu_alpha_result(shape_format)
180+ 
181+ def test_add_relu_alpha_shape_format_fp32_1d(self):
182+ format_list = [0, 3]
183+ shape_format = [[np.float32, i, [64]] for i in format_list]
184+ self.add_relu_alpha_result(shape_format)
185+ 
186+ def test_add_relu_alpha_shape_format_fp16_2d(self):
187+ format_list = [0, 3, 29]
188+ shape_format = [[np.float16, i, [5, 256]] for i in format_list]
189+ self.add_relu_alpha_result(shape_format)
190+ 
191+ def test_add_relu_alpha_shape_format_fp32_2d(self):
192+ format_list = [0, 3, 29]
193+ shape_format = [[np.float32, i, [5, 256]] for i in format_list]
194+ self.add_relu_alpha_result(shape_format)
195+ 
196+ def test_add_relu_alpha_shape_format_fp16_3d(self):
197+ format_list = [0, 3, 29]
198+ shape_format = [[np.float16, i, [32, 3, 3]] for i in format_list]
199+ self.add_relu_alpha_result(shape_format)
200+ 
201+ def test_add_relu_alpha_shape_format_fp32_3d(self):
202+ format_list = [0, 3, 29]
203+ shape_format = [[np.float32, i, [32, 3, 3]] for i in format_list]
204+ self.add_relu_alpha_result(shape_format)
205+ 
206+ def test_add_relu_alpha_shape_format_fp16_4d(self):
207+ format_list = [0, 3, 29]
208+ shape_format = [[np.float16, i, [64, 112, 7, 7]] for i in format_list]
209+ self.add_relu_alpha_result(shape_format)
210+ 
211+ def test_add_relu_alpha_shape_format_fp32_4d(self):
212+ format_list = [0, 3, 29]
213+ shape_format = [[np.float32, i, [64, 112, 7, 7]] for i in format_list]
214+ self.add_relu_alpha_result(shape_format)
215+ 
216+ 
217+if __name__ == "__main__":
218+ run_tests()
Atest/test_base_ops/test_addbmm.py+161-0
@@ -0,0 +1,161 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestAddbmm(TestCase):
10+ def generate_scalar(self, dtype, min_d, max_d):
11+ if dtype == "float32":
12+ scalar = np.random.uniform(min_d, max_d)
13+ if dtype == "int32":
14+ scalar = np.random.randint(min_d, max_d)
15+ return scalar
16+ 
17+ def cpu_op_exec(self, input1, input2, input3, scalar1, scalar2):
18+ output = torch.addbmm(input1, input2, input3, beta=scalar1, alpha=scalar2)
19+ output = output.numpy()
20+ return output
21+ 
22+ def npu_op_exec(self, input1, input2, input3, scalar1, scalar2):
23+ input1 = input1.to("npu")
24+ input2 = input2.to("npu")
25+ input3 = input3.to("npu")
26+ output = torch.addbmm(input1, input2, input3, beta=scalar1, alpha=scalar2)
27+ output = output.to("cpu")
28+ output = output.numpy()
29+ return output
30+ 
31+ # pylint:disable = huawei-too-many-arguments
32+ def npu_op_exec_out(self, input1, input2, input3, scalar1, scalar2, input4):
33+ input1 = input1.to("npu")
34+ input2 = input2.to("npu")
35+ input3 = input3.to("npu")
36+ output = input4.to("npu")
37+ torch.addbmm(input1, input2, input3, beta=scalar1, alpha=scalar2, out=output)
38+ output = output.to("cpu")
39+ output = output.numpy()
40+ return output
41+ 
42+ def npu_op_exec_inplace(self, input1, input2, input3, scalar1, scalar2):
43+ input1 = input1.to("npu")
44+ input2 = input2.to("npu")
45+ input3 = input3.to("npu")
46+ input1.addbmm_(input2, input3, beta=scalar1, alpha=scalar2)
47+ output = input1.to("cpu")
48+ output = output.numpy()
49+ return output
50+ 
51+ def cpu_op_transpose_exec(self, input1, input2, input3, scalar1, scalar2):
52+ input3_t = np.transpose(input3, (0, 2, 1))
53+ output = torch.addbmm(input1, input2, input3_t, beta=scalar1, alpha=scalar2)
54+ output = output.numpy()
55+ return output
56+ 
57+ # pylint:disable = huawei-too-many-arguments
58+ def npu_op_transpose_exec(self, input1, input2, input3, scalar1, scalar2):
59+ input1 = input1.to("npu")
60+ input2 = input2.to("npu")
61+ input3 = input3.to("npu")
62+ input3_t = torch.permute(input3, (0, 2, 1))
63+ output = torch.addbmm(input1, input2, input3_t, beta=scalar1, alpha=scalar2)
64+ output = output.to("cpu")
65+ output = output.numpy()
66+ return output
67+ 
68+ def test_addbmm(self):
69+ shape_format = [
70+ [
71+ [np.float16, 0, [3, 5]],
72+ [np.float16, 0, [10, 3, 4]],
73+ [np.float16, 0, [10, 4, 5]],
74+ "float32",
75+ ],
76+ ]
77+ 
78+ for item in shape_format:
79+ cpu_input1, npu_input1 = create_common_tensor(item[0], 0, 1)
80+ cpu_input2, npu_input2 = create_common_tensor(item[1], 0, 1)
81+ cpu_input3, npu_input3 = create_common_tensor(item[2], 0, 1)
82+ cpu_input4, npu_input4 = create_common_tensor(item[0], 0, 1)
83+ 
84+ scalar1 = self.generate_scalar(item[3], 0, 2)
85+ scalar2 = self.generate_scalar(item[3], 0, 2)
86+ 
87+ cpu_output = self.cpu_op_exec(
88+ cpu_input1.float(),
89+ cpu_input2.float(),
90+ cpu_input3.float(),
91+ scalar1,
92+ scalar2,
93+ )
94+ npu_output = self.npu_op_exec(
95+ npu_input1.float(),
96+ npu_input2.float(),
97+ npu_input3.float(),
98+ scalar1,
99+ scalar2,
100+ )
101+ 
102+ npu_output1 = self.npu_op_exec_out(
103+ npu_input1.float(),
104+ npu_input2.float(),
105+ npu_input3.float(),
106+ scalar1,
107+ scalar2,
108+ npu_input4.float(),
109+ )
110+ npu_output2 = self.npu_op_exec_inplace(
111+ npu_input1.float(),
112+ npu_input2.float(),
113+ npu_input3.float(),
114+ scalar1,
115+ scalar2,
116+ )
117+ 
118+ self.assertRtolEqual(cpu_output, npu_output, prec=1.0e-3, prec16=1.0e-3)
119+ self.assertRtolEqual(cpu_output, npu_output1, prec=1.0e-3, prec16=1.0e-3)
120+ self.assertRtolEqual(cpu_output, npu_output2, prec=1.0e-3, prec16=1.0e-3)
121+ 
122+ def test_addbmm_transpose(self):
123+ shape_format = [
124+ [
125+ [np.float16, 0, [4, 5]],
126+ [np.float16, 0, [10, 4, 7]],
127+ [np.float16, 0, [10, 5, 7]],
128+ "float32",
129+ ],
130+ ]
131+ 
132+ for item in shape_format:
133+ cpu_input1, npu_input1 = create_common_tensor(item[0], 0, 1)
134+ cpu_input2, npu_input2 = create_common_tensor(item[1], 0, 1)
135+ cpu_input3, npu_input3 = create_common_tensor(item[2], 0, 1)
136+ 
137+ scalar1 = self.generate_scalar(item[3], 0, 2)
138+ scalar2 = self.generate_scalar(item[3], 0, 2)
139+ 
140+ cpu_transpose_output = self.cpu_op_transpose_exec(
141+ cpu_input1.float(),
142+ cpu_input2.float(),
143+ cpu_input3.float(),
144+ scalar1,
145+ scalar2,
146+ )
147+ npu_transpose_output = self.npu_op_transpose_exec(
148+ npu_input1.float(),
149+ npu_input2.float(),
150+ npu_input3.float(),
151+ scalar1,
152+ scalar2,
153+ )
154+ 
155+ self.assertRtolEqual(
156+ cpu_transpose_output, npu_transpose_output, prec=1.0e-3, prec16=1.0e-3
157+ )
158+ 
159+ 
160+if __name__ == "__main__":
161+ run_tests()
Atest/test_base_ops/test_addcdiv.py+288-0
@@ -0,0 +1,288 @@
1+import copy
2+import torch
3+import numpy as np
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+ 
7+ 
8+class TestAddcdiv(TestCase):
9+ def cpu_op_inp_input3_noncontiguous_exec(self, input1, input2, input3, scalar):
10+ input3_strided = input3.as_strided([2, 2], [1, 2], 2)
11+ input1.addcdiv_(input2, input3_strided, value=scalar)
12+ output = input1.numpy()
13+ return output
14+ 
15+ def npu_op_inp_input3_noncontiguous_exec(self, input1, input2, input3, scalar):
16+ input1 = input1.to("npu")
17+ input2 = input2.to("npu")
18+ input3 = input3.to("npu")
19+ input3_as_strided = input3.as_strided([2, 2], [1, 2], 2)
20+ input1.addcdiv_(input2, input3_as_strided, value=scalar)
21+ output = input1.to("cpu")
22+ output = output.numpy()
23+ return output
24+ 
25+ def non_zero_rand(self, size, dtype, device="npu"):
26+ if dtype.is_floating_point:
27+ a = torch.rand(size=size, dtype=dtype, device="cpu")
28+ a = a.to("npu")
29+ elif dtype == torch.uint8:
30+ a = torch.randint(1, 5, size=size, dtype=dtype, device="cpu").to(device)
31+ else:
32+ a = torch.randint(-5, 5, size=size, dtype=dtype, device="cpu").to(device)
33+ return a.type(dtype)
34+ 
35+ def cpu_op_exec(self, input1, input2, input3, scalar):
36+ output = torch.addcdiv(input1, input2, input3, value=scalar)
37+ return output
38+ 
39+ def npu_op_exec(self, input1, input2, input3, scalar):
40+ input1 = input1.to("npu")
41+ input2 = input2.to("npu")
42+ input3 = input3.to("npu")
43+ output = torch.addcdiv(input1, input2, input3, value=scalar)
44+ output = output.to("cpu")
45+ return output
46+ 
47+ def cpu_op_exec_out(self, input1, input2, input3, scalar, output):
48+ torch.addcdiv(input1, input2, input3, value=scalar, out=output)
49+ output = output.numpy()
50+ return output
51+ 
52+ def npu_op_exec_out(self, input1, input2, input3, scalar, output):
53+ input1 = input1.to("npu")
54+ input2 = input2.to("npu")
55+ input3 = input3.to("npu")
56+ output = output.to("npu")
57+ torch.addcdiv(input1, input2, input3, value=scalar, out=output)
58+ output = output.to("cpu").numpy()
59+ return output
60+ 
61+ def cpu_op_inp_contiguous_exec(self, input1, input2, input3, scalar):
62+ input1.addcdiv_(input2, input3, value=scalar)
63+ output = input1.numpy()
64+ return output
65+ 
66+ def npu_op_inp_contiguous_exec(self, input1, input2, input3, scalar):
67+ input1 = input1.to("npu")
68+ input2 = input2.to("npu")
69+ input3 = input3.to("npu")
70+ input1.addcdiv_(input2, input3, value=scalar)
71+ output = input1.to("cpu")
72+ output = output.numpy()
73+ return output
74+ 
75+ def cpu_op_inp_input1_noncontiguous_exec(self, input1, input2, input3, scalar):
76+ input1_strided = input1.as_strided([2, 2], [1, 2], 2)
77+ input1_strided.addcdiv_(input2, input3, value=scalar)
78+ output = input1.numpy()
79+ return output
80+ 
81+ def npu_op_inp_input1_noncontiguous_exec(self, input1, input2, input3, scalar):
82+ input1 = input1.to("npu")
83+ input2 = input2.to("npu")
84+ input3 = input3.to("npu")
85+ input1_as_strided = input1.as_strided([2, 2], [1, 2], 2)
86+ input1_as_strided.addcdiv_(input2, input3, value=scalar)
87+ output = input1.to("cpu")
88+ output = output.numpy()
89+ return output
90+ 
91+ def cpu_op_inp_input2_noncontiguous_exec(self, input1, input2, input3, scalar):
92+ input2_strided = input2.as_strided([2, 2], [1, 2], 2)
93+ input1.addcdiv_(input2_strided, input3, value=scalar)
94+ output = input1.numpy()
95+ return output
96+ 
97+ def npu_op_inp_input2_noncontiguous_exec(self, input1, input2, input3, scalar):
98+ input1 = input1.to("npu")
99+ input3 = input3.to("npu")
100+ input2 = input2.to("npu")
101+ input2_as_strided = input2.as_strided([2, 2], [1, 2], 2)
102+ input1.addcdiv_(input2_as_strided, input3, value=scalar)
103+ output = input1.to("cpu")
104+ output = output.numpy()
105+ return output
106+ 
107+ def generate_data(self, min1, max1, shape, dtype):
108+ input1 = np.random.uniform(min1, max1, shape).astype(dtype)
109+ input2 = np.random.uniform(min1, max1, shape).astype(dtype)
110+ input3 = np.random.uniform(min1, max1, shape).astype(dtype)
111+ npu_input1 = torch.from_numpy(input1)
112+ npu_input2 = torch.from_numpy(input2)
113+ npu_input3 = torch.from_numpy(input3)
114+ return npu_input1, npu_input2, npu_input3
115+ 
116+ def generate_single_data(self, min1, max1, shape, dtype):
117+ inputs = np.random.uniform(min1, max1, shape).astype(dtype)
118+ npu_input = torch.from_numpy(inputs)
119+ return npu_input
120+ 
121+ def generate_scalar(self, min1, max1):
122+ scalar = np.random.uniform(min1, max1)
123+ return scalar
124+ 
125+ def generate_int_scalar(self, min1, max1):
126+ scalar = np.random.randint(min1, max1)
127+ return scalar
128+ 
129+ def _test_addcdiv(self, a, alpha, b, c):
130+ actual = torch.addcdiv(a, b, c, value=alpha)
131+ if not actual.dtype.is_floating_point:
132+ alpha = int(alpha)
133+ try:
134+ expected = a + (alpha * b) / c
135+ except ZeroDivisionError:
136+ print("Divide-by-Zero Error!!")
137+ self.assertTrue(
138+ torch.allclose(expected.to("cpu"), actual.to("cpu"), equal_nan=True)
139+ )
140+ self.assertRtolEqual(actual.to("cpu"), torch.addcdiv(a, alpha, b, c).to("cpu"))
141+ 
142+ def test_addcdiv(self, device="npu"):
143+ """NPU does not support numpy.bool.
144+ 
145+ with self.maybeWarnsRegex(UserWarning, "This overload of addcdiv is deprecated"):
146+ self.assertRtolEqual(actual.to("cpu"), torch.addcdiv(a, alpha, b, c).to("cpu"))
147+ 
148+ """
149+ dtype_list = [
150+ torch.uint8,
151+ torch.int8,
152+ torch.int16,
153+ torch.int32,
154+ torch.int64,
155+ torch.float64,
156+ torch.complex64,
157+ torch.complex128,
158+ ]
159+ for dtype in torch.testing._internal.common_dtype.get_all_math_dtypes(device):
160+ if dtype in dtype_list:
161+ continue
162+ self._test_addcdiv(
163+ self.non_zero_rand((2, 2), dtype=dtype, device=device),
164+ 0.5,
165+ self.non_zero_rand((2, 2), dtype=dtype, device=device),
166+ self.non_zero_rand((2, 2), dtype=dtype, device=device),
167+ )
168+ 
169+ def test_addcdiv_float32(self):
170+ npu_input1, npu_input2, npu_input3 = self.generate_data(
171+ 1, 100, (5, 3), np.float32
172+ )
173+ scalar = self.generate_scalar(1, 10)
174+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2, npu_input3, scalar)
175+ npu_output = self.npu_op_exec(npu_input1, npu_input2, npu_input3, scalar)
176+ self.assertRtolEqual(cpu_output, npu_output)
177+ 
178+ def test_addcdiv_float32_out(self):
179+ npu_input1, npu_input2, npu_input3 = self.generate_data(
180+ 1, 100, (5, 3), np.float32
181+ )
182+ scalar = self.generate_scalar(1, 10)
183+ npu_input4 = self.generate_single_data(1, 100, (5, 3), np.float32)
184+ cpu_output = self.cpu_op_exec_out(
185+ npu_input1, npu_input2, npu_input3, scalar, npu_input4
186+ )
187+ npu_output = self.npu_op_exec_out(
188+ npu_input1, npu_input2, npu_input3, scalar, npu_input4
189+ )
190+ self.assertRtolEqual(cpu_output, npu_output)
191+ 
192+ def test_addcdiv_float32_broadcast(self):
193+ npu_input1 = self.generate_single_data(1, 100, (5, 3, 1), np.float32)
194+ npu_input2 = self.generate_single_data(1, 100, (5, 1, 5), np.float32)
195+ npu_input3 = self.generate_single_data(1, 100, (1, 1, 5), np.float32)
196+ scalar = self.generate_scalar(1, 10)
197+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2, npu_input3, scalar)
198+ npu_output = self.npu_op_exec(npu_input1, npu_input2, npu_input3, scalar)
199+ self.assertRtolEqual(cpu_output, npu_output)
200+ 
201+ def test_addcdiv_inp_contiguous_float32(self):
202+ npu_input1, npu_input2, npu_input3 = self.generate_data(
203+ 1, 100, (5, 3), np.float32
204+ )
205+ cpu_input1 = copy.deepcopy(npu_input1)
206+ cpu_input2 = copy.deepcopy(npu_input2)
207+ cpu_input3 = copy.deepcopy(npu_input3)
208+ scalar = self.generate_int_scalar(1, 10)
209+ cpu_output = self.cpu_op_inp_contiguous_exec(
210+ cpu_input1, cpu_input2, cpu_input3, scalar
211+ )
212+ npu_output = self.npu_op_inp_contiguous_exec(
213+ npu_input1, npu_input2, npu_input3, scalar
214+ )
215+ self.assertRtolEqual(cpu_output, npu_output)
216+ 
217+ def test_addcdiv_inp_input1_noncontiguous_float32(self):
218+ npu_input1 = self.generate_single_data(1, 100, (4, 3), np.float32)
219+ npu_input2 = self.generate_single_data(1, 100, (2, 2), np.float32)
220+ npu_input3 = self.generate_single_data(1, 100, (2, 2), np.float32)
221+ cpu_input1 = copy.deepcopy(npu_input1)
222+ cpu_input2 = copy.deepcopy(npu_input2)
223+ cpu_input3 = copy.deepcopy(npu_input3)
224+ scalar = self.generate_int_scalar(1, 10)
225+ cpu_output = self.cpu_op_inp_input1_noncontiguous_exec(
226+ cpu_input1, cpu_input2, cpu_input3, scalar
227+ )
228+ npu_output = self.npu_op_inp_input1_noncontiguous_exec(
229+ npu_input1, npu_input2, npu_input3, scalar
230+ )
231+ self.assertRtolEqual(cpu_output, npu_output)
232+ 
233+ def test_addcdiv_inp_input2_noncontiguous_float32(self):
234+ npu_input1 = self.generate_single_data(1, 100, (2, 2), np.float32)
235+ npu_input2 = self.generate_single_data(1, 100, (4, 3), np.float32)
236+ npu_input3 = self.generate_single_data(1, 100, (2, 2), np.float32)
237+ cpu_input1 = copy.deepcopy(npu_input1)
238+ cpu_input2 = copy.deepcopy(npu_input2)
239+ cpu_input3 = copy.deepcopy(npu_input3)
240+ scalar = self.generate_int_scalar(1, 10)
241+ cpu_output = self.cpu_op_inp_input2_noncontiguous_exec(
242+ cpu_input1, cpu_input2, cpu_input3, scalar
243+ )
244+ npu_output = self.npu_op_inp_input2_noncontiguous_exec(
245+ npu_input1, npu_input2, npu_input3, scalar
246+ )
247+ self.assertRtolEqual(cpu_output, npu_output)
248+ 
249+ def test_addcdiv_inp_input3_noncontiguous_float32(self):
250+ npu_input1 = self.generate_single_data(1, 100, (2, 2), np.float32)
251+ npu_input2 = self.generate_single_data(1, 100, (2, 2), np.float32)
252+ npu_input3 = self.generate_single_data(1, 100, (4, 3), np.float32)
253+ cpu_input1 = copy.deepcopy(npu_input1)
254+ cpu_input2 = copy.deepcopy(npu_input2)
255+ cpu_input3 = copy.deepcopy(npu_input3)
256+ scalar = self.generate_int_scalar(1, 10)
257+ cpu_output = self.cpu_op_inp_input3_noncontiguous_exec(
258+ cpu_input1, cpu_input2, cpu_input3, scalar
259+ )
260+ npu_output = self.npu_op_inp_input3_noncontiguous_exec(
261+ npu_input1, npu_input2, npu_input3, scalar
262+ )
263+ self.assertRtolEqual(cpu_output, npu_output)
264+ 
265+ def test_addcdiv_float64(self):
266+ cpu_input1, cpu_input2, cpu_input3 = self.generate_data(
267+ 1, 100, (5, 3), np.float64
268+ )
269+ scalar = self.generate_scalar(1, 10)
270+ cpu_output = self.cpu_op_exec(cpu_input1, cpu_input2, cpu_input3, scalar)
271+ npu_output = self.npu_op_exec(cpu_input1, cpu_input2, cpu_input3, scalar)
272+ self.assertRtolEqual(cpu_output, npu_output)
273+ 
274+ def test_addcdiv_float16(self):
275+ cpu_input1, cpu_input2, cpu_input3 = self.generate_data(
276+ 1, 100, (5, 3), np.float16
277+ )
278+ scalar = self.generate_scalar(1, 10)
279+ cpu_output = self.cpu_op_exec(
280+ cpu_input1.float(), cpu_input2.float(), cpu_input3.float(), scalar
281+ )
282+ npu_output = self.npu_op_exec(cpu_input1, cpu_input2, cpu_input3, scalar)
283+ cpu_output = cpu_output.to(npu_output.dtype)
284+ self.assertRtolEqual(cpu_output, npu_output)
285+ 
286+ 
287+if __name__ == "__main__":
288+ run_tests()
Atest/test_base_ops/test_addcmul.py+136-0
@@ -0,0 +1,136 @@
1+import sys
2+ 
3+import torch
4+import numpy as np
5+ 
6+import torch_npu
7+ 
8+from torch_npu.testing.testcase import TestCase, run_tests
9+from torch_npu.testing.common_utils import create_common_tensor
10+ 
11+ 
12+class TestAddCMul(TestCase):
13+ def generate_data(self, min_d, max_d, shape, dtype):
14+ input1 = np.random.uniform(min_d, max_d, shape).astype(dtype)
15+ input2 = np.random.uniform(min_d, max_d, shape).astype(dtype)
16+ input3 = np.random.uniform(min_d, max_d, shape).astype(dtype)
17+ npu_input1 = torch.from_numpy(input1)
18+ npu_input2 = torch.from_numpy(input2)
19+ npu_input3 = torch.from_numpy(input3)
20+ 
21+ return npu_input1, npu_input2, npu_input3
22+ 
23+ def generate_output_data(self, min_d, max_d, shape, dtype):
24+ output_y = np.random.uniform(min_d, max_d, shape).astype(dtype)
25+ npu_output_y = torch.from_numpy(output_y)
26+ return npu_output_y
27+ 
28+ def cpu_op_exec(self, input1, input2, input3, scalar):
29+ output = torch.addcmul(input1, input2, input3, value=scalar)
30+ output = output.numpy()
31+ return output
32+ 
33+ def cpu_op_exec_out(self, input1, input2, input3, scalar, output_y):
34+ output = output_y
35+ torch.addcmul(input1, input2, input3, value=scalar, out=output_y)
36+ output = output.numpy()
37+ return output
38+ 
39+ def npu_op_exec(self, input1, input2, input3, scalar):
40+ input1 = input1.to("npu")
41+ input2 = input2.to("npu")
42+ input3 = input3.to("npu")
43+ output = torch.addcmul(input1, input2, input3, value=scalar)
44+ output = output.to("cpu")
45+ output = output.numpy()
46+ return output
47+ 
48+ def npu_op_exec_out(self, input1, input2, input3, scalar, output_y):
49+ input1 = input1.to("npu")
50+ input2 = input2.to("npu")
51+ input3 = input3.to("npu")
52+ output = output_y.to("npu")
53+ torch.addcmul(input1, input2, input3, value=scalar, out=output)
54+ output = output.to("cpu")
55+ output = output.numpy()
56+ return output
57+ 
58+ def test_addcmul_3_3_float32(self, device="npu"):
59+ input1, input2, input3 = self.generate_data(0, 100, (3, 3), np.float32)
60+ cpu_output = self.cpu_op_exec(input1, input2, input3, 0.5)
61+ npu_output = self.npu_op_exec(input1, input2, input3, 0.5)
62+ self.assertRtolEqual(cpu_output, npu_output)
63+ 
64+ def test_addcmul_10_10_float32(self, device="npu"):
65+ input1, input2, input3 = self.generate_data(0, 100, (10, 10), np.float32)
66+ cpu_output = self.cpu_op_exec(input1, input2, input3, 0.5)
67+ npu_output = self.npu_op_exec(input1, input2, input3, 0.5)
68+ self.assertRtolEqual(cpu_output, npu_output)
69+ 
70+ def test_addcmul_3_3_float16(self, device="npu"):
71+ input1, input2, input3 = self.generate_data(0, 100, (3, 3), np.float16)
72+ input1_cpu = input1.float()
73+ input2_cpu = input2.float()
74+ input3_cpu = input3.float()
75+ cpu_output = self.cpu_op_exec(input1_cpu, input2_cpu, input3_cpu, 0.5).astype(
76+ np.float16
77+ )
78+ npu_output = self.npu_op_exec(input1, input2, input3, 0.5)
79+ self.assertRtolEqual(cpu_output, npu_output)
80+ 
81+ def test_addcmul_10_10_float16(self, device="npu"):
82+ input1, input2, input3 = self.generate_data(0, 100, (10, 10), np.float16)
83+ input1_cpu = input1.float()
84+ input2_cpu = input2.float()
85+ input3_cpu = input3.float()
86+ cpu_output = self.cpu_op_exec(input1_cpu, input2_cpu, input3_cpu, 0.5).astype(
87+ np.float16
88+ )
89+ npu_output = self.npu_op_exec(input1, input2, input3, 0.5)
90+ self.assertRtolEqual(cpu_output, npu_output)
91+ 
92+ def test_addcmul_10_23_float32(self, device="npu"):
93+ input1, input2, input3 = self.generate_data(0, 100, (10, 23), np.float32)
94+ cpu_output = self.cpu_op_exec(input1, input2, input3, 0.5)
95+ npu_output = self.npu_op_exec(input1, input2, input3, 0.5)
96+ self.assertRtolEqual(cpu_output, npu_output)
97+ 
98+ def test_tensor_addcmul_3_3_float32(self, device="npu"):
99+ input1, input2, input3 = self.generate_data(0, 100, (3, 3), np.float32)
100+ input1_npu = input1.npu()
101+ input2_npu = input2.npu()
102+ input3_npu = input3.npu()
103+ input1.addcmul_(input2, input3, value=0.5)
104+ input1_npu.addcmul_(input2_npu, input3_npu, value=0.5)
105+ self.assertRtolEqual(input1, input1_npu)
106+ 
107+ def test_tensor_addcmul_10_10_float32(self, device="npu"):
108+ input1, input2, input3 = self.generate_data(0, 100, (10, 10), np.float32)
109+ input1_npu = input1.npu()
110+ input2_npu = input2.npu()
111+ input3_npu = input3.npu()
112+ input1.addcmul_(input2, input3, value=0.5)
113+ input1_npu.addcmul_(input2_npu, input3_npu, value=0.5)
114+ self.assertRtolEqual(input1, input1_npu)
115+ 
116+ def test_tensor_addcmul_3_3_float16(self, device="npu"):
117+ input1, input2, input3 = self.generate_data(0, 100, (3, 3), np.float16)
118+ input1_npu = input1.npu()
119+ input2_npu = input2.npu()
120+ input3_npu = input3.npu()
121+ input1.addcmul_(input2, input3, value=0.5)
122+ input1_npu.addcmul_(input2_npu, input3_npu, value=0.5)
123+ self.assertRtolEqual(input1, input1_npu)
124+ 
125+ def test_tensor_addcmul_10_10_float16(self, device="npu"):
126+ input1, input2, input3 = self.generate_data(0, 100, (10, 10), np.float16)
127+ input1_npu = input1.npu()
128+ input2_npu = input2.npu()
129+ input3_npu = input3.npu()
130+ input1.addcmul_(input2, input3, value=0.5)
131+ input1_npu.addcmul_(input2_npu, input3_npu, value=0.5)
132+ self.assertRtolEqual(input1, input1_npu)
133+ 
134+ 
135+if __name__ == "__main__":
136+ run_tests()
Atest/test_base_ops/test_addmv.py+102-0
@@ -0,0 +1,102 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestAddmv(TestCase):
10+ def cpu_op_exec(self, a, b, c, alpha, beta):
11+ output = torch.addmv(c, a, b, alpha=alpha, beta=beta)
12+ output = output.numpy()
13+ return output
14+ 
15+ def npu_op_exec(self, a, b, c, alpha, beta):
16+ output = torch.addmv(c, a, b, alpha=alpha, beta=beta)
17+ output = output.to("cpu")
18+ output = output.numpy()
19+ return output
20+ 
21+ # pylint:disable = huawei-too-many-arguments
22+ def npu_op_exec_out(self, a, b, c, beta, alpha, input1):
23+ torch.addmv(c, a, b, alpha=alpha, beta=beta, out=input1)
24+ output = input1.to("cpu")
25+ output = output.numpy()
26+ return output
27+ 
28+ def test_addmv_fp16(self):
29+ shape_format = [
30+ [[np.float16, 3, (2, 3)], [np.float16, 3, (3,)], [np.float16, 3, (2,)]]
31+ ]
32+ for item in shape_format:
33+ 
34+ input_a, npu_input_a = create_common_tensor(item[0], -2, 2)
35+ input_b, npu_input_b = create_common_tensor(item[1], -2, 2)
36+ input_c, npu_input_c = create_common_tensor(item[2], -2, 2)
37+ 
38+ input_a = input_a.to(torch.float32)
39+ input_b = input_b.to(torch.float32)
40+ input_c = input_c.to(torch.float32)
41+ 
42+ cpu_output = self.cpu_op_exec(input_a, input_b, input_c, 1, 1)
43+ npu_output = self.npu_op_exec(npu_input_a, npu_input_b, npu_input_c, 1, 1)
44+ 
45+ cpu_output = cpu_output.astype(np.float16)
46+ self.assertRtolEqual(cpu_output, npu_output)
47+ 
48+ def test_addmv_out_fp16(self):
49+ shape_format = [
50+ [
51+ [np.float16, 3, (2, 3)],
52+ [np.float16, 3, (3,)],
53+ [np.float16, 3, (2,)],
54+ [np.float16, 3, (10,)],
55+ ]
56+ ]
57+ for item in shape_format:
58+ 
59+ input_a, npu_input_a = create_common_tensor(item[0], -2, 2)
60+ input_b, npu_input_b = create_common_tensor(item[1], -2, 2)
61+ input_c, npu_input_c = create_common_tensor(item[2], -2, 2)
62+ _, npu_input = create_common_tensor(item[3], -2, 2)
63+ 
64+ input_a = input_a.to(torch.float32)
65+ input_b = input_b.to(torch.float32)
66+ input_c = input_c.to(torch.float32)
67+ 
68+ cpu_output = self.cpu_op_exec(input_a, input_b, input_c, 1, 1)
69+ npu_output = self.npu_op_exec_out(
70+ npu_input_a, npu_input_b, npu_input_c, 1, 1, npu_input
71+ )
72+ cpu_output = cpu_output.astype(np.float16)
73+ 
74+ self.assertRtolEqual(cpu_output, npu_output)
75+ 
76+ def test_addmv_fp32(self):
77+ shape_format = [
78+ [[np.float16, 0, (2, 3)], [np.float16, 0, (3,)], [np.float16, 0, (2,)]],
79+ [
80+ [np.float16, 0, (3168, 320)],
81+ [np.float16, 0, (320,)],
82+ [np.float16, 0, (3168,)],
83+ ],
84+ ]
85+ for item in shape_format:
86+ 
87+ input_a, npu_input_a = create_common_tensor(item[0], -2, 2)
88+ input_b, npu_input_b = create_common_tensor(item[1], -2, 2)
89+ input_c, npu_input_c = create_common_tensor(item[2], -2, 2)
90+ 
91+ cpu_output = self.cpu_op_exec(
92+ input_a.float(), input_b.float(), input_c.float(), 1, 1
93+ )
94+ npu_output = self.npu_op_exec(
95+ npu_input_a.float(), npu_input_b.float(), npu_input_c.float(), 1, 1
96+ )
97+ 
98+ self.assertRtolEqual(cpu_output, npu_output, prec=1.0e-3, prec16=1.0e-3)
99+ 
100+ 
101+if __name__ == "__main__":
102+ run_tests()
Atest/test_base_ops/test_addr.py+83-0
@@ -0,0 +1,83 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestAddr(TestCase):
10+ def cpu_op_exec(self, input1, vec1, vec2, beta, alpha):
11+ output = torch.addr(input1, vec1, vec2, beta=beta, alpha=alpha)
12+ output = output.numpy()
13+ return output
14+ 
15+ def npu_op_exec(self, input1, vec1, vec2, beta, alpha):
16+ output = torch.addr(input1, vec1, vec2, beta=beta, alpha=alpha)
17+ output = output.to("cpu")
18+ output = output.numpy()
19+ return output
20+ 
21+ # pylint:disable = huawei-too-many-arguments
22+ def npu_op_exec_out(self, input1, input2, vec1, vec2, beta, alpha):
23+ torch.addr(input1, vec1, vec2, beta=beta, alpha=alpha, out=input2)
24+ output = input2.to("cpu")
25+ output = output.numpy()
26+ return output
27+ 
28+ def test_addr_common_shape_format(self):
29+ shape_format = [
30+ [[np.bool_, 0, (5, 3)], [np.bool_, 0, (5)], [np.bool_, 0, (3)]],
31+ [[np.bool_, 0, (5, 3)], [np.int32, 0, (5)], [np.int32, 0, (3)]],
32+ [[np.bool_, 0, (5, 3)], [np.float32, 0, (5)], [np.float32, 0, (3)]],
33+ [[np.bool_, 0, (5, 3)], [np.int32, 0, (5)], [np.float32, 0, (3)]],
34+ [[np.int32, 0, (5, 3)], [np.int32, 0, (5)], [np.int32, 0, (3)]],
35+ [[np.int32, 0, (5, 3)], [np.int32, 0, (5)], [np.float32, 0, (3)]],
36+ [[np.int32, 0, (5, 3)], [np.float32, 0, (5)], [np.float32, 0, (3)]],
37+ [[np.int32, 0, (5, 3)], [np.bool_, 0, (5)], [np.float32, 0, (3)]],
38+ [[np.float32, 0, (5, 3)], [np.float32, 0, (5)], [np.float32, 0, (3)]],
39+ [[np.float32, 0, (5, 3)], [np.int32, 0, (5)], [np.float32, 0, (3)]],
40+ [[np.float32, 0, (5, 3)], [np.int32, 0, (5)], [np.int32, 0, (3)]],
41+ [[np.float32, 0, (5, 3)], [np.int32, 0, (5)], [np.bool_, 0, (3)]],
42+ ]
43+ for item in shape_format:
44+ cpu_input1, npu_input1 = create_common_tensor(item[0], 1, 100)
45+ cpu_vec1, npu_vec1 = create_common_tensor(item[1], 1, 100)
46+ cpu_vec2, npu_vec2 = create_common_tensor(item[2], 1, 100)
47+ beta = 1
48+ alpha = 1
49+ cpu_output = self.cpu_op_exec(cpu_input1, cpu_vec1, cpu_vec2, beta, alpha)
50+ npu_output = self.npu_op_exec(npu_input1, npu_vec1, npu_vec2, beta, alpha)
51+ self.assertRtolEqual(cpu_output, npu_output)
52+ 
53+ def test_addr_out_common_shape_format(self):
54+ shape_format = [
55+ [
56+ [np.float32, 0, (5, 3)],
57+ [np.float32, 0, (5, 3)],
58+ [np.float32, 0, (5)],
59+ [np.float32, 0, (3)],
60+ ],
61+ [
62+ [np.int32, 0, (5, 3)],
63+ [np.int32, 0, (5, 3)],
64+ [np.int32, 0, (5)],
65+ [np.int32, 0, (3)],
66+ ],
67+ ]
68+ for item in shape_format:
69+ cpu_input1, npu_input1 = create_common_tensor(item[0], 1, 100)
70+ cpu_input2, npu_input2 = create_common_tensor(item[1], 1, 100)
71+ cpu_vec1, npu_vec1 = create_common_tensor(item[2], 1, 100)
72+ cpu_vec2, npu_vec2 = create_common_tensor(item[3], 1, 100)
73+ beta = 1
74+ alpha = 1
75+ cpu_output = self.cpu_op_exec(cpu_input1, cpu_vec1, cpu_vec2, beta, alpha)
76+ npu_output = self.npu_op_exec_out(
77+ npu_input1, npu_input2, npu_vec1, npu_vec2, beta, alpha
78+ )
79+ self.assertRtolEqual(cpu_output, npu_output)
80+ 
81+ 
82+if __name__ == "__main__":
83+ run_tests()
Atest/test_base_ops/test_affine_grid_generator.py+68-0
@@ -0,0 +1,68 @@
1+import torch
2+import numpy as np
3+from torch.nn import functional as F
4+import torch_npu
5+ 
6+from torch_npu.testing.testcase import TestCase, run_tests
7+ 
8+ 
9+class TestAffineGridGenerator(TestCase):
10+ def cpu_op_exec(self, theta, size, align_corners):
11+ output = F.affine_grid(theta, torch.Size(size), align_corners)
12+ output = output.numpy()
13+ return output
14+ 
15+ def npu_op_exec(self, theta, size, align_corners):
16+ theta = theta.npu()
17+ output = torch.affine_grid_generator(theta, size, align_corners)
18+ output = output.cpu().numpy()
19+ return output
20+ 
21+ def test_affine_grid_generator_2D(self, device="npu"):
22+ theta_list = [
23+ [1, 0, 0],
24+ [0, 1, 0],
25+ ]
26+ size = (1, 3, 10, 10)
27+ align_corners_list = [True, False]
28+ dtype_list = [torch.float32, torch.float16]
29+ shape_format = [
30+ [theta_list, size, i, j] for i in align_corners_list for j in dtype_list
31+ ]
32+ for item in shape_format:
33+ theta = torch.tensor([item[0]], dtype=item[3])
34+ cpu_input = theta
35+ npu_input = theta
36+ if cpu_input.dtype == torch.float16:
37+ cpu_input = cpu_input.to(torch.float32)
38+ cpu_output = self.cpu_op_exec(cpu_input, item[1], item[2])
39+ npu_output = self.npu_op_exec(npu_input, item[1], item[2])
40+ cpu_output = cpu_output.astype(npu_output.dtype)
41+ self.assertRtolEqual(cpu_output, npu_output, 0.001)
42+ 
43+ def test_affine_grid_generator_3D(self, device="npu"):
44+ theta_list = [
45+ [1, 0, 0, 0],
46+ [0, 1, 0, 0],
47+ [0, 0, 1, 0],
48+ ]
49+ size = (1, 3, 10, 10, 10)
50+ align_corners_list = [True, False]
51+ dtype_list = [torch.float16, torch.float32]
52+ shape_format = [
53+ [theta_list, size, i, j] for i in align_corners_list for j in dtype_list
54+ ]
55+ for item in shape_format:
56+ theta = torch.tensor([item[0]], dtype=item[3])
57+ cpu_input = theta
58+ npu_input = theta
59+ if cpu_input.dtype == torch.float16:
60+ cpu_input = cpu_input.to(torch.float32)
61+ cpu_output = self.cpu_op_exec(cpu_input, item[1], item[2])
62+ npu_output = self.npu_op_exec(npu_input, item[1], item[2])
63+ cpu_output = cpu_output.astype(npu_output.dtype)
64+ self.assertRtolEqual(cpu_output, npu_output, 0.001)
65+ 
66+ 
67+if __name__ == "__main__":
68+ run_tests()
Atest/test_base_ops/test_affine_grid_generator_backward.py+57-0
@@ -0,0 +1,57 @@
1+import torch
2+import numpy as np
3+from torch.nn import functional as F
4+import torch_npu
5+ 
6+from torch_npu.testing.testcase import TestCase, run_tests
7+from torch_npu.testing.common_utils import create_common_tensor
8+ 
9+ 
10+class TestAffineGridGeneratorBackward(TestCase):
11+ def test_affine_grid_generator_backward_common_shape(self, device="npu"):
12+ shape_list = [[100, 2, 3], [10, 2, 3]]
13+ shape_format = [[np.float32, -1, j] for j in shape_list]
14+ for item in shape_format:
15+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 1)
16+ size = torch.Size((item[2][0], 2, 28, 2))
17+ cpu_input1.requires_grad = True
18+ cpu_output = self.cpu_op_exec(cpu_input1, size)
19+ npu_input1.requires_grad = True
20+ npu_output = self.npu_op_exec(npu_input1, size)
21+ self.assertRtolEqual(cpu_output, npu_output)
22+ 
23+ def test_affine_grid_generator_backward_fp16(self, device="npu"):
24+ shape_list = [[100, 2, 3], [10, 2, 3]]
25+ shape_format = [[np.float16, -1, j] for j in shape_list]
26+ for item in shape_format:
27+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 1)
28+ cpu_input1 = cpu_input1.to(torch.float32)
29+ npu_input1 = npu_input1.to(torch.float32)
30+ size = torch.Size((item[2][0], 2, 28, 2))
31+ cpu_input1.requires_grad = True
32+ cpu_output = self.cpu_op_exec(cpu_input1, size)
33+ npu_input1.requires_grad = True
34+ npu_output = self.npu_op_exec(npu_input1, size)
35+ self.assertRtolEqual(
36+ cpu_output.astype(np.float16), npu_output.astype(np.float16)
37+ )
38+ 
39+ def cpu_op_exec(self, input1, size):
40+ out = F.affine_grid(input1, size, True)
41+ input1.requires_grad = True
42+ grad_output = torch.ones(out.size(), dtype=torch.float)
43+ out.backward(gradient=grad_output)
44+ output = input1.grad.numpy()
45+ return output
46+ 
47+ def npu_op_exec(self, input1, size):
48+ input1.requires_grad = True
49+ out = F.affine_grid(input1, size, True)
50+ grad_output = torch.ones(out.size(), dtype=torch.float).npu()
51+ out.backward(gradient=grad_output)
52+ output = input1.grad.to("cpu").numpy()
53+ return output
54+ 
55+ 
56+if __name__ == "__main__":
57+ run_tests()
Atest/test_base_ops/test_all.py+94-0
@@ -0,0 +1,94 @@
1+import itertools
2+import torch
3+import numpy as np
4+ 
5+import torch_npu
6+from torch_npu.testing.testcase import TestCase, run_tests
7+from torch_npu.testing.common_utils import create_common_tensor
8+ 
9+ 
10+class TestAll(TestCase):
11+ def create_bool_tensor(self, shape, minValue, maxValue):
12+ input1 = np.random.uniform(minValue, maxValue, shape)
13+ input1 = input1 > 0.5
14+ cpu_input = torch.from_numpy(input1)
15+ npu_input = torch.from_numpy(input1).to("npu")
16+ return cpu_input, npu_input
17+ 
18+ def cpu_op_exec(self, input1):
19+ output = input1.all()
20+ output = output.numpy()
21+ return output
22+ 
23+ def npu_op_exec(self, input1):
24+ output = input1.all()
25+ output = output.to("cpu").numpy()
26+ return output
27+ 
28+ def test_all_shape_format(self):
29+ shape_list = [[1024], [32, 1024], [32, 8, 1024], [128, 32, 8, 1024], [2, 0, 2]]
30+ for item in shape_list:
31+ cpu_input, npu_input = self.create_bool_tensor(item, 0, 1)
32+ cpu_output = self.cpu_op_exec(cpu_input)
33+ npu_output = self.npu_op_exec(npu_input)
34+ self.assertRtolEqual(
35+ cpu_output.astype(np.int32), npu_output.astype(np.int32)
36+ )
37+ 
38+ def cpu_op_dim_exec(self, input1, dim):
39+ output = input1.all(dim=dim)
40+ output = output.numpy()
41+ return output
42+ 
43+ def npu_op_dim_exec(self, input1, dim):
44+ output = input1.all(dim=dim)
45+ output = output.to("cpu").numpy()
46+ return output
47+ 
48+ def npu_op_out_exec(self, input1, dim, output):
49+ torch.all(input1, dim=dim, keepdim=False, out=output)
50+ output = output.to("cpu").numpy()
51+ return output
52+ 
53+ def test_alld_shape_format(self):
54+ shape_list = [[1024], [32, 1024], [32, 8, 1024], [128, 32, 8, 1024]]
55+ dtype_list = [
56+ np.float16,
57+ np.float32,
58+ np.float64,
59+ np.uint8,
60+ np.int16,
61+ np.int32,
62+ np.int64,
63+ np.bool_,
64+ ]
65+ format_list = [-1]
66+ for item in itertools.product(dtype_list, format_list, shape_list):
67+ cpu_input, npu_input = create_common_tensor(item, 0, 1)
68+ _, npu_output1 = self.create_bool_tensor(item[2], 0, 1)
69+ if item[0] == np.float16:
70+ cpu_input = cpu_input.to(torch.float32)
71+ cpu_output = self.cpu_op_dim_exec(cpu_input, 0)
72+ if item[0] == np.float16:
73+ cpu_output = cpu_output.astype(np.float16)
74+ npu_output0 = self.npu_op_dim_exec(npu_input, 0)
75+ npu_output1 = self.npu_op_out_exec(npu_input, 0, npu_output1)
76+ self.assertRtolEqual(
77+ cpu_output.astype(np.int32), npu_output0.astype(np.int32)
78+ )
79+ self.assertRtolEqual(
80+ cpu_output.astype(np.int32), npu_output1.astype(np.int32)
81+ )
82+ 
83+ def test_all_tensor_numel_0(self):
84+ ca = torch.rand(1, 2, 0, 3, 4).bool()
85+ na = ca.npu()
86+ cout = ca.all(2)
87+ nout = na.all(2)
88+ cout = cout.numpy()
89+ nout = nout.to("cpu").numpy()
90+ self.assertRtolEqual(cout, nout)
91+ 
92+ 
93+if __name__ == "__main__":
94+ run_tests()
Atest/test_base_ops/test_amp_foreach_non_finite_check_and_unscale_.py+55-0
@@ -0,0 +1,55 @@
1+import copy
2+import sys
3+ 
4+import torch
5+import numpy as np
6+ 
7+import torch_npu
8+ 
9+from torch_npu.testing.testcase import TestCase, run_tests
10+from torch_npu.testing.common_utils import create_common_tensor
11+ 
12+ 
13+class Test_AmpForeachNonFiniteCheckAndUnscale_(TestCase):
14+ def generate_data(self, min_d, max_d, shape, dtype, input3):
15+ input1 = np.random.uniform(min_d, max_d, shape).astype(dtype)
16+ input1 = torch.from_numpy(input1)
17+ input2 = np.array([0.0]).astype(dtype)
18+ input2 = torch.from_numpy(input2)
19+ input3 = np.array([input3]).astype(dtype)
20+ input3 = torch.from_numpy(input3)
21+ return input1, input2, input3
22+ 
23+ def cpu_op_exec(self, input1, input2, input3):
24+ input1 = input1.numpy()
25+ input2 = input2.numpy()
26+ input3 = input3.numpy()
27+ res = np.multiply(input1, input3)
28+ return res
29+ 
30+ def npu_op_exec(self, input1, input2, input3):
31+ input1 = input1.to("npu")
32+ input2 = input2.to("npu")
33+ input3 = input3.to("npu")
34+ torch._amp_foreach_non_finite_check_and_unscale_((input1,), input2, input3)
35+ input1 = input1.to("cpu")
36+ input1 = input1.numpy()
37+ return input1
38+ 
39+ def test_AmpForeachNonFiniteCheckAndUnscale_float32_case1(self, device="npu"):
40+ params = [
41+ (0, 100, (4, 3), np.float32, 1.5),
42+ (0, 100, (2, 5, 6), np.float32, 3.7),
43+ (0, 100, (5, 7), np.float32, 1.9),
44+ (0, 100, (2, 8, 1), np.float32, 3.2),
45+ ]
46+ torch_npu.npu.utils.clear_npu_overflow_flag()
47+ for param in params:
48+ input1, input2, input3 = self.generate_data(*param)
49+ cpu_output = self.cpu_op_exec(input1, input2, input3)
50+ npu_output = self.npu_op_exec(input1, input2, input3)
51+ self.assertRtolEqual(cpu_output, npu_output)
52+ 
53+ 
54+if __name__ == "__main__":
55+ run_tests()
Atest/test_base_ops/test_anchorresponseflags.py+55-0
@@ -0,0 +1,55 @@
1+import torch
2+import numpy as np
3+from torch.nn import functional as F
4+import torch_npu
5+ 
6+from torch_npu.testing.testcase import TestCase, run_tests
7+from torch_npu.testing.common_utils import create_common_tensor
8+ 
9+ 
10+class TestAnchorResponseFlags(TestCase):
11+ def cpu_op_exec(self, gt_bboxes, featmap_size, strides, num_base_anchors):
12+ feat_h, feat_w = featmap_size
13+ gt_bboxes_cx = (gt_bboxes[:, 0] + gt_bboxes[:, 2]) * 0.5
14+ gt_bboxes_cy = (gt_bboxes[:, 1] + gt_bboxes[:, 3]) * 0.5
15+ try:
16+ gt_bboxes_grid_x = torch.floor(gt_bboxes_cx / strides[0]).int()
17+ gt_bboxes_grid_y = torch.floor(gt_bboxes_cy / strides[1]).int()
18+ except ZeroDivisionError:
19+ print("There is 0 in strides.")
20+ gt_bboxes_grid_idx = gt_bboxes_grid_y * feat_w + gt_bboxes_grid_x
21+ responsible_grid = torch.zeros(feat_h * feat_w, dtype=torch.uint8)
22+ gt_bboxes_grid_idx = gt_bboxes_grid_idx.long()
23+ responsible_grid[gt_bboxes_grid_idx] = 1
24+ responsible_grid = (
25+ responsible_grid[:, None]
26+ .expand(responsible_grid.size(0), num_base_anchors)
27+ .contiguous()
28+ .view(-1)
29+ )
30+ return responsible_grid.numpy()
31+ 
32+ def npu_op_exec(self, input_npu, featmap_size, strides, num_base_anchors):
33+ out = torch_npu.npu_anchor_response_flags(
34+ input_npu, featmap_size, strides, num_base_anchors
35+ )
36+ out = out.to("cpu")
37+ return out.detach().numpy()
38+ 
39+ def test_anchor_response_flags(self, device="npu"):
40+ shape_format = [
41+ [[np.float32, -1, [100, 4]], [60, 60], [2, 2], 9],
42+ [[np.float16, -1, [200, 4]], [10, 10], [32, 32], 3],
43+ [[np.float16, -1, [500, 4]], [32, 32], [16, 16], 5],
44+ ]
45+ for item in shape_format:
46+ cpu_input, npu_input = create_common_tensor(item[0], 0, 100)
47+ if cpu_input.dtype == torch.float16:
48+ cpu_input = cpu_input.to(torch.float32)
49+ cpu_output = self.cpu_op_exec(cpu_input, *item[1:])
50+ npu_output = self.npu_op_exec(npu_input, *item[1:])
51+ self.assertRtolEqual(cpu_output, npu_output)
52+ 
53+ 
54+if __name__ == "__main__":
55+ run_tests()
Atest/test_base_ops/test_any.py+81-0
@@ -0,0 +1,81 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+ 
7+ 
8+class TestAny(TestCase):
9+ def create_bool_tensor(self, shape, minValue, maxValue):
10+ input1 = np.random.uniform(minValue, maxValue, shape)
11+ cpu_input = torch.from_numpy(input1) > 0.5
12+ npu_input = (torch.from_numpy(input1) > 0.5).to("npu")
13+ return cpu_input, npu_input
14+ 
15+ def cpu_op_exec(self, input1):
16+ output = input1.any()
17+ output = output.numpy()
18+ return output
19+ 
20+ def npu_op_exec(self, input1):
21+ output = input1.any()
22+ output = output.to("cpu")
23+ output = output.numpy()
24+ return output
25+ 
26+ def test_any_shape_format(self, device="npu"):
27+ shape_list = [[], [1024], [32, 1024], [32, 8, 1024], [128, 32, 8, 1024]]
28+ 
29+ for item in shape_list:
30+ cpu_input, npu_input = self.create_bool_tensor(item, 0, 1)
31+ cpu_output = self.cpu_op_exec(cpu_input)
32+ npu_output = self.npu_op_exec(npu_input)
33+ self.assertRtolEqual(
34+ cpu_output.astype(np.int32), npu_output.astype(np.int32)
35+ )
36+ 
37+ def cpu_op_exec1(self, input1, dim, keepdim):
38+ output = input1.any(dim=dim, keepdim=keepdim)
39+ output = output.numpy()
40+ return output
41+ 
42+ def npu_op_exec1(self, input1, dim, keepdim):
43+ output = input1.any(dim=dim, keepdim=keepdim)
44+ output = output.to("cpu")
45+ output = output.numpy()
46+ return output
47+ 
48+ def npu_op_out_exec1(self, input1, dim, keepdim):
49+ shape = list(input1.shape)
50+ output0 = torch.randn(shape) > 0
51+ output1 = torch.randn(shape.pop()) > 0
52+ output0 = output0.npu()
53+ output1 = output1.npu()
54+ torch.any(input1, dim=dim, keepdim=keepdim, out=output0)
55+ torch.any(input1, dim=dim, keepdim=keepdim, out=output1)
56+ output0 = output0.to("cpu").numpy()
57+ output1 = output1.to("cpu").numpy()
58+ return output0, output1
59+ 
60+ def test_anyd_shape_format(self, device="npu"):
61+ shape_list = [
62+ [[1024], 0, False],
63+ [[32, 1024], 1, False],
64+ [[32, 8, 1024], 2, True],
65+ [[128, 32, 8, 1024], 3, True],
66+ ]
67+ 
68+ for item in shape_list:
69+ cpu_input, npu_input = self.create_bool_tensor(item[0], 0, 1)
70+ cpu_output = self.cpu_op_exec1(cpu_input, item[1], item[2])
71+ npu_output = self.npu_op_exec1(npu_input, item[1], item[2])
72+ npu_out0, npu_out1 = self.npu_op_out_exec1(npu_input, item[1], item[2])
73+ self.assertRtolEqual(
74+ cpu_output.astype(np.int32), npu_output.astype(np.int32)
75+ )
76+ self.assertRtolEqual(cpu_output.astype(np.int32), npu_out0.astype(np.int32))
77+ self.assertRtolEqual(cpu_output.astype(np.int32), npu_out1.astype(np.int32))
78+ 
79+ 
80+if __name__ == "__main__":
81+ run_tests()
Atest/test_base_ops/test_api_common.py+191-0
@@ -0,0 +1,191 @@
1+import unittest
2+import torch
3+import numpy as np
4+ 
5+import torch_npu
6+from torch_npu.testing.testcase import TestCase, run_tests
7+from torch_npu.testing.common_utils import create_common_tensor, SupportedDevices
8+ 
9+ 
10+DEVICE_NAME = torch_npu.npu.get_device_name(0)[:10]
11+torch_npu.npu.set_compile_mode(jit_compile=False)
12+ 
13+ 
14+class TestApiCommon(TestCase):
15+ # test input tensor
16+ def cpu_op_out_exec_add(self, input1, input2, output):
17+ torch.add(input1, input2, alpha=1, out=output)
18+ output = output.numpy()
19+ return output
20+ 
21+ def npu_op_out_exec_add(self, input1, input2, output):
22+ torch.add(input1, input2, alpha=1, out=output)
23+ output = output.to("cpu").numpy()
24+ return output
25+ 
26+ def test_add_out_result(self):
27+ cpuout = torch.randn(18)
28+ npuout = torch.randn(18).to("npu")
29+ item = [np.float32, 0, [18]]
30+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 100)
31+ cpu_input2, npu_input2 = create_common_tensor(item, 0, 100)
32+ 
33+ cpu_output = self.cpu_op_out_exec_add(cpu_input1, cpu_input2, cpuout)
34+ npu_output = self.npu_op_out_exec_add(npu_input1, npu_input2, npuout)
35+ 
36+ self.assertRtolEqual(cpu_output, npu_output)
37+ 
38+ # test input scalar
39+ def cpu_op_scalar_exec_add(self, input1, scalar):
40+ output = torch.add(input1, scalar, alpha=1)
41+ output = output.numpy()
42+ return output
43+ 
44+ def npu_op_scalar_exec_add(self, input1, scalar):
45+ output = torch.add(input1, scalar, alpha=1)
46+ output = output.to("cpu")
47+ output = output.numpy()
48+ return output
49+ 
50+ def test_add_saclar_alpha_result(self):
51+ format_list = [0, 3]
52+ scalar_list = [0, 1]
53+ shape_format = [
54+ [[np.float16, i, [18]], k] for i in format_list for k in scalar_list
55+ ]
56+ for item in shape_format:
57+ cpu_input, npu_input = create_common_tensor(item[0], 0, 100)
58+ if cpu_input.dtype == torch.float16:
59+ cpu_input = cpu_input.to(torch.float32)
60+ cpu_output = self.cpu_op_scalar_exec_add(cpu_input, item[1])
61+ npu_output = self.npu_op_scalar_exec_add(npu_input, item[1])
62+ cpu_output = cpu_output.astype(npu_output.dtype)
63+ 
64+ self.assertRtolEqual(cpu_output, npu_output)
65+ 
66+ # test input IntArray
67+ def cpu_op_exec_AdaptiveAvgPool2d(self, input_x, input_grad):
68+ input_x.requires_grad_(True)
69+ m = torch.nn.AdaptiveAvgPool2d(input_grad)
70+ output = m(input_x)
71+ output.backward(output)
72+ out = output.detach(), input_x.grad
73+ return out
74+ 
75+ def npu_op_exec_AdaptiveAvgPool2d(self, input_x, input_grad):
76+ input_x.requires_grad_(True)
77+ m = torch.nn.AdaptiveAvgPool2d(input_grad)
78+ output = m(input_x)
79+ output.backward(output)
80+ out = output.detach().cpu(), input_x.grad.cpu()
81+ return out
82+ 
83+ def test_adaptiveAvgPool2d_backward(self):
84+ torch.manual_seed(123)
85+ cpu_input = torch.randn((1, 8, 9), dtype=torch.float32)
86+ npu_input = cpu_input.npu()
87+ output_size = np.array((2, 3))
88+ cpu_output = self.cpu_op_exec_AdaptiveAvgPool2d(cpu_input, output_size)
89+ npu_output = self.npu_op_exec_AdaptiveAvgPool2d(npu_input, output_size)
90+ self.assertRtolEqual(cpu_output[0], npu_output[0], prec=1e-3)
91+ self.assertRtolEqual(cpu_output[1], npu_output[1], prec=1e-3)
92+ 
93+ # test input TensorList
94+ @SupportedDevices(["Ascend910B"])
95+ def test_foreach_add(self, device="npu"):
96+ input1 = torch.randn((1, 8, 9), dtype=torch.float32).npu()
97+ input2 = torch.randn((1, 8, 9), dtype=torch.float32).npu()
98+ npu_input_list = (input1, input2)
99+ npu_input_list2 = (input1, input2)
100+ scalar1 = torch.tensor(0.5, dtype=torch.float32).npu()
101+ npu_output = torch._foreach_add(npu_input_list, scalar1)
102+ 
103+ # test input ScalarList
104+ # test input c10::ArrayRef<at::Scalar>
105+ @SupportedDevices(["Ascend910B"])
106+ def test_foreach_add_ScalarList(self, device="npu"):
107+ input1 = torch.randn((1, 8, 9), dtype=torch.float32).npu()
108+ input2 = torch.randn((1, 8, 9), dtype=torch.float32).npu()
109+ npu_input_list = (input1, input2)
110+ scalar1 = torch.tensor(0.5, dtype=torch.float32).npu()
111+ scalar2 = torch.tensor(0.5, dtype=torch.float32).npu()
112+ scalar_list = (scalar1, scalar2)
113+ npu_output = torch._foreach_add(npu_input_list, scalar_list)
114+ 
115+ # test c10::optional<at::Tensor>
116+ def test_batch_norm_backward_elemt_4d(self):
117+ grad_output = torch.ones([2, 3, 1, 4]).npu()
118+ input1 = torch.ones([2, 3, 1, 4]).npu()
119+ mean = torch.tensor([8.0, 5.0, 9.0]).npu()
120+ invstd = torch.tensor([2.0, 1.0, 2.0]).npu()
121+ weight = torch.tensor([1.0, 1.0, 4.0]).npu()
122+ mean_dy = torch.tensor([2.0, 2.0, 6.0]).npu()
123+ mean_dy_xmn = torch.tensor([2.0, 3.0, 11.0]).npu()
124+ count_tensor = torch.tensor([5, 5, 5], dtype=torch.int32).npu()
125+ 
126+ grad_input = torch.batch_norm_backward_elemt(
127+ grad_output,
128+ input1,
129+ mean,
130+ invstd,
131+ weight,
132+ mean_dy,
133+ mean_dy_xmn,
134+ count_tensor,
135+ )
136+ cuda_expect_out = torch.tensor(
137+ [
138+ [
139+ [[9.2000, 9.2000, 9.2000, 9.2000]],
140+ [[1.6667, 1.6667, 1.6667, 1.6667]],
141+ [[192.5333, 192.5333, 192.5333, 192.5333]],
142+ ],
143+ [
144+ [[9.2000, 9.2000, 9.2000, 9.2000]],
145+ [[1.6667, 1.6667, 1.6667, 1.6667]],
146+ [[192.5333, 192.5333, 192.5333, 192.5333]],
147+ ],
148+ ]
149+ )
150+ self.assertRtolEqual(grad_input.cpu(), cuda_expect_out)
151+ 
152+ # test c10::optional<at::IntArrayRef>、at::OptionalIntArrayRef
153+ def cpu_op_exec_mean(self, input1, dtype):
154+ output = torch.mean(input1, [2, 3], keepdim=True, dtype=dtype)
155+ output = output.numpy()
156+ return output
157+ 
158+ def npu_op_exec_mean(self, input1, dtype):
159+ input1 = input1.to("npu")
160+ output = torch.mean(input1, [2, 3], keepdim=True, dtype=dtype)
161+ output = output.to("cpu")
162+ output = output.numpy()
163+ return output
164+ 
165+ def test_mean_shape_format(self):
166+ item = [[np.float32, 3, (256, 1280, 7, 7)], torch.float32]
167+ cpu_input, npu_input = create_common_tensor(item[0], 0, 100)
168+ cpu_output = self.cpu_op_exec_mean(cpu_input, dtype=item[-1])
169+ npu_output = self.npu_op_exec_mean(npu_input, dtype=item[-1])
170+ self.assertRtolEqual(cpu_output, npu_output)
171+ 
172+ # test String
173+ # test c10::optional<at::Scalar>
174+ def test_clamp(self):
175+ item = [
176+ [np.float32, 0, (4, 3)],
177+ [np.float32, 0, (4, 3)],
178+ [np.float32, 0, (4, 3)],
179+ ]
180+ input_cpu, input_npu = create_common_tensor(item[0], 0, 10)
181+ min_cpu, min_npu = create_common_tensor(item[1], 1, 50)
182+ max_cpu, max_npu = create_common_tensor(item[2], 50, 100)
183+ _, out_npu = create_common_tensor(item[0], 1, 100)
184+ 
185+ cpu_output = torch.clamp(input_cpu, min_cpu, max_cpu).numpy()
186+ npu_output = torch.clamp(input_npu, min_npu, max_npu).cpu().numpy()
187+ self.assertRtolEqual(cpu_output, npu_output)
188+ 
189+ 
190+if __name__ == "__main__":
191+ run_tests()
Atest/test_base_ops/test_apply_adam.py+75-0
@@ -0,0 +1,75 @@
1+import torch
2+import torch_npu
3+ 
4+from torch_npu.testing.testcase import TestCase, run_tests
5+from torch_npu.testing.common_utils import create_common_tensor
6+ 
7+ 
8+class TestApplyAdam(TestCase):
9+ def test_apply_adam(self):
10+ var1 = torch.randn(2, 2, 2, 2, dtype=torch.float32).to("npu")
11+ m1 = torch.randn(2, 2, 2, 2, dtype=torch.float32).to("npu")
12+ v1 = torch.randn(2, 2, 2, 2, dtype=torch.float32).to("npu")
13+ grad1 = torch.randn(2, 2, 2, 2, dtype=torch.float32).to("npu")
14+ var2 = var1.to(torch.half)
15+ m2 = m1.to(torch.half)
16+ v2 = v1.to(torch.half)
17+ grad2 = grad1.to(torch.half)
18+ res1, _, v1_o = torch_npu.npu_apply_adam(1, 1, 0.2, 0.2, 0.2, 0.2, grad1, False, False, out=(var1, m1, v1))
19+ res2, _, v2_o = torch_npu.npu_apply_adam(1, 1, 0.2, 0.2, 0.2, 0.2, grad2, False, False, out=(var2, m2, v2))
20+ expect_vo = torch.tensor([[[[2.2156, -0.1393],
21+ [0.6441, 0.3087]],
22+ [[0.9008, -0.0295],
23+ [0.0776, 0.0773]]],
24+ [[[0.1105, 1.0725],
25+ [0.8731, 0.4582]],
26+ [[0.1653, 0.3091],
27+ [0.3175, 0.0998]]]], dtype=torch.float32)
28+ self.assertRtolEqual(expect_vo, v1_o.cpu())
29+ self.assertRtolEqual(expect_vo.to(torch.half), v2_o.cpu())
30+ 
31+ def test_apply_adam_out_fp32(self):
32+ var = torch.randn(2, 2, 2, 2, dtype=torch.float32).to("npu")
33+ m = torch.randn(2, 2, 2, 2, dtype=torch.float32).to("npu")
34+ v = torch.randn(2, 2, 2, 2, dtype=torch.float32).to("npu")
35+ grad = torch.randn(2, 2, 2, 2, dtype=torch.float32).to("npu")
36+ bt1p = 0.9
37+ bt2p = 0.9
38+ lr = 0.2
39+ bt1 = 0.2
40+ bt2 = 0.2
41+ ep = 0.2
42+ ul = False
43+ un = False
44+ var_o, m_o, v_o = torch_npu.npu_apply_adam(bt1p, bt2p, lr, bt1, bt2, ep, grad, ul, un, out=(var, m, v))
45+ expect_varo = torch.tensor([[[[-0.1842, 0.6028],
46+ [0.4803, -0.3156]],
47+ [[0.9466, -0.9984],
48+ [-0.1592, -0.1908]]],
49+ [[[-0.9448, 0.6290],
50+ [0.0694, 0.3411]],
51+ [[-0.0987, 0.5370],
52+ [-0.5744, 0.3317]]]])
53+ expect_mo = torch.tensor([[[[-1.4744, 0.1481],
54+ [-0.6954, 0.1557]],
55+ [[-0.6090, 0.4566],
56+ [-0.4863, 0.7218]]],
57+ [[[0.5437, -1.1527],
58+ [0.6547, -0.5491]],
59+ [[-0.2247, -0.7165],
60+ [0.7963, -0.1283]]]])
61+ expect_vo = torch.tensor([[[[2.2156, -0.1393],
62+ [0.6441, 0.3087]],
63+ [[0.9008, -0.0295],
64+ [0.0776, 0.0773]]],
65+ [[[0.1105, 1.0725],
66+ [0.8731, 0.4582]],
67+ [[0.1653, 0.3091],
68+ [0.3175, 0.0998]]]])
69+ self.assertRtolEqual(expect_varo, var_o.cpu())
70+ self.assertRtolEqual(expect_mo, m_o.cpu())
71+ self.assertRtolEqual(expect_vo, v_o.cpu())
72+ 
73+ 
74+if __name__ == "__main__":
75+ run_tests()
Atest/test_base_ops/test_apply_adam_w.py+220-0
@@ -0,0 +1,220 @@
1+import torch
2+import numpy as np
3+ 
4+import torch_npu
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestApplyAdam(TestCase):
10+ # pylint:disable = huawei-too-many-arguments
11+ def cpu_op_exec(
12+ self,
13+ var,
14+ m,
15+ v,
16+ beta1_power,
17+ beta2_power,
18+ lr,
19+ weight_decay,
20+ beta1,
21+ beta2,
22+ eps,
23+ grad,
24+ max_grad_norm,
25+ amsgrad,
26+ maximize,
27+ ):
28+ if amsgrad:
29+ max_grad_norm = np.random.uniform(-5.0, 5.0, var.shape)
30+ gt = -grad if maximize else grad
31+ m_out = m * beta1 - (beta1 + (-1)) * gt
32+ v_out = v * beta2 - (beta2 + (-1)) * gt * gt
33+ var_t = var * (1 + (-lr * weight_decay))
34+ beta1_power_out = beta1_power * beta1
35+ beta2_power_out = beta2_power * beta2
36+ if amsgrad:
37+ max_grad_norm_out = np.maximum(max_grad_norm, v_out)
38+ try:
39+ denom = np.sqrt(max_grad_norm_out / (1 - beta2_power_out)) + eps
40+ except ZeroDivisionError:
41+ print("Divide-by-Zero Error!")
42+ else:
43+ max_grad_norm_out = None
44+ try:
45+ denom = np.sqrt(v_out / (1 - beta2_power_out)) + eps
46+ except ZeroDivisionError:
47+ print("Divide-by-Zero Error!")
48+ try:
49+ var_out = var_t + (-lr * m_out / (1 - beta1_power_out)) / denom
50+ except ZeroDivisionError:
51+ print("Divide-by-Zero Error!")
52+ return var_out, m_out, v_out
53+ 
54+ # pylint:disable = huawei-too-many-arguments
55+ def npu_op_exec(
56+ self,
57+ var_tensor,
58+ m_tensor,
59+ v_tensor,
60+ beta1_power,
61+ beta2_power,
62+ lr,
63+ weight_decay,
64+ beta1,
65+ beta2,
66+ eps,
67+ grad,
68+ max_grad_norm,
69+ amsgrad,
70+ maximize,
71+ ):
72+ var_out_npu, m_out_npu, v_out_npu = torch_npu.npu_apply_adam_w(
73+ beta1_power[0],
74+ beta2_power[0],
75+ lr[0],
76+ weight_decay[0],
77+ beta1[0],
78+ beta2[0],
79+ eps[0],
80+ grad,
81+ max_grad_norm,
82+ amsgrad,
83+ maximize,
84+ out=(var_tensor, m_tensor, v_tensor),
85+ )
86+ return var_out_npu, m_out_npu, v_out_npu
87+ 
88+ def test_apply_adam_w_maximize_true(self):
89+ amsgrad = False # at present, the operator supports only false.
90+ maximize = True
91+ scalar_shape = [1]
92+ dtype = np.float32
93+ shape_format = [
94+ [np.float32, 2, (21130, 512)],
95+ ]
96+ var_cpu, var_npu = create_common_tensor(shape_format[0], 10.0, 20.0)
97+ m_cpu, m_npu = create_common_tensor(shape_format[0], 5.0, 10.0)
98+ v_cpu, v_npu = create_common_tensor(shape_format[0], 0.1, 5.0)
99+ grad_cpu, grad_npu = create_common_tensor(shape_format[0], -5.0, 5.0)
100+ 
101+ var_cpu = var_cpu.numpy()
102+ m_cpu = m_cpu.numpy()
103+ v_cpu = v_cpu.numpy()
104+ grad_cpu = grad_cpu.numpy()
105+ 
106+ beta1_power = np.random.uniform(0.0, 1.0, scalar_shape)
107+ beta2_power = np.random.uniform(0.0, 1.0, scalar_shape)
108+ lr = np.random.uniform(0.0001, 0.1, scalar_shape)
109+ weight_decay = np.random.uniform(0.001, 0.1, scalar_shape)
110+ beta1 = np.random.uniform(0.5, 1.0, scalar_shape)
111+ beta2 = np.random.uniform(0.5, 1.0, scalar_shape)
112+ eps = np.random.uniform(0.00001, 0.01, scalar_shape)
113+ max_grad_norm = None
114+ 
115+ var_ret_cpu, m_ret_cpu, v_ret_cpu = self.cpu_op_exec(
116+ var_cpu,
117+ m_cpu,
118+ v_cpu,
119+ beta1_power,
120+ beta2_power,
121+ lr,
122+ weight_decay,
123+ beta1,
124+ beta2,
125+ eps,
126+ grad_cpu,
127+ max_grad_norm,
128+ amsgrad,
129+ maximize,
130+ )
131+ 
132+ var_ret_npu, m_ret_npu, v_ret_npu = self.npu_op_exec(
133+ var_npu,
134+ m_npu,
135+ v_npu,
136+ beta1_power,
137+ beta2_power,
138+ lr,
139+ weight_decay,
140+ beta1,
141+ beta2,
142+ eps,
143+ grad_npu,
144+ max_grad_norm,
145+ amsgrad,
146+ maximize,
147+ )
148+ 
149+ self.assertRtolEqual(var_ret_cpu.astype(dtype), var_ret_npu.cpu().numpy())
150+ self.assertRtolEqual(m_ret_cpu.astype(dtype), m_ret_npu.cpu().numpy())
151+ self.assertRtolEqual(v_ret_cpu.astype(dtype), v_ret_npu.cpu().numpy())
152+ 
153+ def test_apply_adam_w_maximize_false(self):
154+ amsgrad = False # at present, the operator supports only false.
155+ maximize = False
156+ scalar_shape = [1]
157+ dtype = np.float32
158+ shape_format = [
159+ [np.float32, 2, (21130, 512)],
160+ ]
161+ var_cpu, var_npu = create_common_tensor(shape_format[0], 10.0, 20.0)
162+ m_cpu, m_npu = create_common_tensor(shape_format[0], 5.0, 10.0)
163+ v_cpu, v_npu = create_common_tensor(shape_format[0], 0.1, 5.0)
164+ grad_cpu, grad_npu = create_common_tensor(shape_format[0], -5.0, 5.0)
165+ 
166+ var_cpu = var_cpu.numpy()
167+ m_cpu = m_cpu.numpy()
168+ v_cpu = v_cpu.numpy()
169+ grad_cpu = grad_cpu.numpy()
170+ 
171+ beta1_power = np.random.uniform(0.0, 1.0, scalar_shape)
172+ beta2_power = np.random.uniform(0.0, 1.0, scalar_shape)
173+ lr = np.random.uniform(0.0001, 0.1, scalar_shape)
174+ weight_decay = np.random.uniform(0.001, 0.1, scalar_shape)
175+ beta1 = np.random.uniform(0.5, 1.0, scalar_shape)
176+ beta2 = np.random.uniform(0.5, 1.0, scalar_shape)
177+ eps = np.random.uniform(0.00001, 0.01, scalar_shape)
178+ max_grad_norm = None
179+ 
180+ var_ret_cpu, m_ret_cpu, v_ret_cpu = self.cpu_op_exec(
181+ var_cpu,
182+ m_cpu,
183+ v_cpu,
184+ beta1_power,
185+ beta2_power,
186+ lr,
187+ weight_decay,
188+ beta1,
189+ beta2,
190+ eps,
191+ grad_cpu,
192+ max_grad_norm,
193+ amsgrad,
194+ maximize,
195+ )
196+ 
197+ var_ret_npu, m_ret_npu, v_ret_npu = self.npu_op_exec(
198+ var_npu,
199+ m_npu,
200+ v_npu,
201+ beta1_power,
202+ beta2_power,
203+ lr,
204+ weight_decay,
205+ beta1,
206+ beta2,
207+ eps,
208+ grad_npu,
209+ max_grad_norm,
210+ amsgrad,
211+ maximize,
212+ )
213+ 
214+ self.assertRtolEqual(var_ret_cpu.astype(dtype), var_ret_npu.cpu().numpy())
215+ self.assertRtolEqual(m_ret_cpu.astype(dtype), m_ret_npu.cpu().numpy())
216+ self.assertRtolEqual(v_ret_cpu.astype(dtype), v_ret_npu.cpu().numpy())
217+ 
218+ 
219+if __name__ == "__main__":
220+ run_tests()
Atest/test_base_ops/test_arange.py+72-0
@@ -0,0 +1,72 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestArange(TestCase):
10+ def test_arange_default(self):
11+ shape_format = [
12+ [0, 100, 2],
13+ [1, 100, 1],
14+ [5, 100, 3],
15+ ]
16+ 
17+ for item in shape_format:
18+ cpu_output_default = torch.arange(
19+ item[0], item[1], item[2], device="cpu"
20+ ).numpy()
21+ npu_output_default = (
22+ torch.arange(item[0], item[1], item[2], device="npu").cpu().numpy()
23+ )
24+ self.assertRtolEqual(cpu_output_default, npu_output_default)
25+ 
26+ def test_arange(self):
27+ shape_format = [
28+ [0, 100, 2, torch.float32],
29+ [1, 100, 1, torch.int32],
30+ [5, 100, 3, torch.int64],
31+ ]
32+ 
33+ for item in shape_format:
34+ cpu_output = torch.arange(
35+ item[0], item[1], item[2], dtype=item[3], device="cpu"
36+ ).numpy()
37+ npu_output = (
38+ torch.arange(item[0], item[1], item[2], dtype=item[3], device="npu")
39+ .cpu()
40+ .numpy()
41+ )
42+ self.assertRtolEqual(cpu_output, npu_output)
43+ 
44+ def test_arange_out(self):
45+ shape_format = [
46+ [0, 100, 1, torch.float32, [np.float32, 0, [10]]],
47+ [1, 100, 2, torch.int32, [np.int32, 0, [20]]],
48+ [5, 100, 3, torch.int64, [np.int64, 0, [30]]],
49+ ]
50+ 
51+ for item in shape_format:
52+ cpu_input1, npu_input1 = create_common_tensor(item[4], 0, 10)
53+ cpu_output = torch.arange(
54+ item[0], item[1], item[2], dtype=item[3], device="cpu"
55+ ).numpy()
56+ npu_output = (
57+ torch.arange(
58+ item[0],
59+ item[1],
60+ item[2],
61+ out=npu_input1,
62+ dtype=item[3],
63+ device="npu",
64+ )
65+ .cpu()
66+ .numpy()
67+ )
68+ self.assertRtolEqual(cpu_output, npu_output)
69+ 
70+ 
71+if __name__ == "__main__":
72+ run_tests()
Atest/test_base_ops/test_arccosh.py+74-0
@@ -0,0 +1,74 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestArccosh(TestCase):
10+ def cpu_op_exec(self, input1):
11+ output = torch.arccosh(input1)
12+ output = output.numpy()
13+ return output
14+ 
15+ def npu_op_exec(self, input1):
16+ output = torch.arccosh(input1)
17+ output = output.to("cpu")
18+ output = output.numpy()
19+ return output
20+ 
21+ def npu_op_exec_out(self, input1, input2):
22+ torch.arccosh(input1, out=input2)
23+ output = input2.to("cpu")
24+ output = output.numpy()
25+ return output
26+ 
27+ def cpu_inp_op_exec(self, input1):
28+ output = torch.arccosh_(input1)
29+ output = output.numpy()
30+ return output
31+ 
32+ def npu_inp_op_exec(self, input1):
33+ output = torch.arccosh_(input1)
34+ output = output.to("cpu")
35+ output = output.numpy()
36+ return output
37+ 
38+ def test_arccosh_common_shape_format(self):
39+ shape_format = [
40+ [[np.float32, 0, (5, 3)]],
41+ ]
42+ for item in shape_format:
43+ cpu_input1, npu_input1 = create_common_tensor(item[0], -10, 10)
44+ cpu_output = self.cpu_op_exec(cpu_input1)
45+ npu_output = self.npu_op_exec(npu_input1)
46+ mask = ~(np.isnan(cpu_output) | np.isinf(cpu_output))
47+ self.assertRtolEqual(cpu_output[mask], npu_output[mask], 0.001)
48+ 
49+ def test_arccosh_out_common_shape_format(self):
50+ shape_format = [
51+ [[np.float32, 0, (4, 3)], [np.float32, 0, (4, 3)]],
52+ ]
53+ for item in shape_format:
54+ cpu_input1, npu_input1 = create_common_tensor(item[0], -10, 10)
55+ cpu_input2, npu_input2 = create_common_tensor(item[1], -10, 10)
56+ cpu_output = self.cpu_op_exec(cpu_input1)
57+ npu_output = self.npu_op_exec_out(npu_input1, npu_input2)
58+ mask = ~(np.isnan(cpu_output) | np.isinf(cpu_output))
59+ self.assertRtolEqual(cpu_output[mask], npu_output[mask], 0.001)
60+ 
61+ def test_arccosh_inp_common_shape_format(self):
62+ shape_format = [
63+ [[np.float32, 0, (5, 3)]],
64+ ]
65+ for item in shape_format:
66+ cpu_input1, npu_input1 = create_common_tensor(item[0], -10, 10)
67+ cpu_output = self.cpu_inp_op_exec(cpu_input1)
68+ npu_output = self.npu_inp_op_exec(npu_input1)
69+ mask = ~(np.isnan(cpu_output) | np.isinf(cpu_output))
70+ self.assertRtolEqual(cpu_output[mask], npu_output[mask], 0.001)
71+ 
72+ 
73+if __name__ == "__main__":
74+ run_tests()
Atest/test_base_ops/test_arcsin.py+71-0
@@ -0,0 +1,71 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestArcsin(TestCase):
10+ def cpu_op_exec(self, input1):
11+ output = torch.arcsin(input1)
12+ output = output.numpy()
13+ return output
14+ 
15+ def npu_op_exec(self, input1):
16+ output = torch.arcsin(input1)
17+ output = output.to("cpu")
18+ output = output.numpy()
19+ return output
20+ 
21+ def npu_op_exec_out(self, input1, input2):
22+ torch.arcsin(input1, out=input2)
23+ output = input2.to("cpu")
24+ output = output.numpy()
25+ return output
26+ 
27+ def cpu_inp_op_exec(self, input1):
28+ output = torch.arcsin_(input1)
29+ output = output.numpy()
30+ return output
31+ 
32+ def npu_inp_op_exec(self, input1):
33+ output = torch.arcsin_(input1)
34+ output = output.to("cpu")
35+ output = output.numpy()
36+ return output
37+ 
38+ def test_arcsin_common_shape_format(self):
39+ shape_format = [
40+ [[np.float32, 0, (5, 3)]],
41+ ]
42+ for item in shape_format:
43+ cpu_input1, npu_input1 = create_common_tensor(item[0], -1, 1)
44+ cpu_output = self.cpu_op_exec(cpu_input1)
45+ npu_output = self.npu_op_exec(npu_input1)
46+ self.assertRtolEqual(cpu_output, npu_output)
47+ 
48+ def test_arcsin_out_common_shape_format(self):
49+ shape_format = [
50+ [[np.float32, 0, (4, 3)], [np.float32, 0, (4, 3)]],
51+ ]
52+ for item in shape_format:
53+ cpu_input1, npu_input1 = create_common_tensor(item[0], -1, 1)
54+ cpu_input2, npu_input2 = create_common_tensor(item[1], -1, 1)
55+ cpu_output = self.cpu_op_exec(cpu_input1)
56+ npu_output = self.npu_op_exec_out(npu_input1, npu_input2)
57+ self.assertRtolEqual(cpu_output, npu_output)
58+ 
59+ def test_arcsin_inp_common_shape_format(self):
60+ shape_format = [
61+ [[np.float32, 0, (5, 3)]],
62+ ]
63+ for item in shape_format:
64+ cpu_input1, npu_input1 = create_common_tensor(item[0], -1, 1)
65+ cpu_output = self.cpu_inp_op_exec(cpu_input1)
66+ npu_output = self.npu_inp_op_exec(npu_input1)
67+ self.assertRtolEqual(cpu_output, npu_output)
68+ 
69+ 
70+if __name__ == "__main__":
71+ run_tests()
Atest/test_base_ops/test_arcsinh.py+71-0
@@ -0,0 +1,71 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestArcsinh(TestCase):
10+ def cpu_op_exec(self, input1):
11+ output = torch.arcsinh(input1)
12+ output = output.numpy()
13+ return output
14+ 
15+ def npu_op_exec(self, input1):
16+ output = torch.arcsinh(input1)
17+ output = output.to("cpu")
18+ output = output.numpy()
19+ return output
20+ 
21+ def npu_op_exec_out(self, input1, input2):
22+ torch.arcsinh(input1, out=input2)
23+ output = input2.to("cpu")
24+ output = output.numpy()
25+ return output
26+ 
27+ def cpu_inp_op_exec(self, input1):
28+ output = torch.arcsinh_(input1)
29+ output = output.numpy()
30+ return output
31+ 
32+ def npu_inp_op_exec(self, input1):
33+ output = torch.arcsinh_(input1)
34+ output = output.to("cpu")
35+ output = output.numpy()
36+ return output
37+ 
38+ def test_arcsinh_common_shape_format(self):
39+ shape_format = [
40+ [[np.float32, 0, (5, 3)]],
41+ ]
42+ for item in shape_format:
43+ cpu_input1, npu_input1 = create_common_tensor(item[0], -1, 1)
44+ cpu_output = self.cpu_op_exec(cpu_input1)
45+ npu_output = self.npu_op_exec(npu_input1)
46+ self.assertRtolEqual(cpu_output, npu_output)
47+ 
48+ def test_arcsinh_out_common_shape_format(self):
49+ shape_format = [
50+ [[np.float32, 0, (4, 3)], [np.float32, 0, (4, 3)]],
51+ ]
52+ for item in shape_format:
53+ cpu_input1, npu_input1 = create_common_tensor(item[0], -1, 1)
54+ cpu_input2, npu_input2 = create_common_tensor(item[1], -1, 1)
55+ cpu_output = self.cpu_op_exec(cpu_input1)
56+ npu_output = self.npu_op_exec_out(npu_input1, npu_input2)
57+ self.assertRtolEqual(cpu_output, npu_output)
58+ 
59+ def test_arcsinh_inp_common_shape_format(self):
60+ shape_format = [
61+ [[np.float32, 0, (5, 3)]],
62+ ]
63+ for item in shape_format:
64+ cpu_input1, npu_input1 = create_common_tensor(item[0], -1, 1)
65+ cpu_output = self.cpu_inp_op_exec(cpu_input1)
66+ npu_output = self.npu_inp_op_exec(npu_input1)
67+ self.assertRtolEqual(cpu_output, npu_output)
68+ 
69+ 
70+if __name__ == "__main__":
71+ run_tests()
Atest/test_base_ops/test_arctan.py+83-0
@@ -0,0 +1,83 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestArctan(TestCase):
10+ def cpu_op_exec(self, input1):
11+ output = torch.arctan(input1)
12+ output = output.numpy()
13+ return output
14+ 
15+ def npu_op_exec(self, input1):
16+ output = torch.arctan(input1)
17+ output = output.to("cpu")
18+ output = output.numpy()
19+ return output
20+ 
21+ def npu_op_exec_out(self, input1, input2):
22+ torch.arctan(input1, out=input2)
23+ output = input2.to("cpu")
24+ output = output.numpy()
25+ return output
26+ 
27+ def cpu_inp_op_exec(self, input1):
28+ output = torch.arctan_(input1)
29+ output = output.numpy()
30+ return output
31+ 
32+ def npu_inp_op_exec(self, input1):
33+ output = torch.arctan_(input1)
34+ output = output.to("cpu")
35+ output = output.numpy()
36+ return output
37+ 
38+ def test_arctan_shape_format(self):
39+ shape_format1 = [
40+ [[np.float32, 0, 1]],
41+ [[np.float32, 0, (64, 10)]],
42+ [[np.float32, 3, (256, 2048, 7, 7)]],
43+ [[np.float32, 4, (32, 1, 3, 3)]],
44+ [[np.float32, 29, (10, 128)]],
45+ ]
46+ for item in shape_format1:
47+ cpu_input1, npu_input1 = create_common_tensor(item[0], -1, 1)
48+ cpu_output = self.cpu_op_exec(cpu_input1)
49+ npu_output = self.npu_op_exec(npu_input1)
50+ self.assertRtolEqual(cpu_output, npu_output)
51+ 
52+ def test_arctan_out_shape_format(self):
53+ shape_format1 = [
54+ [[np.float32, 0, 1]],
55+ [[np.float32, 0, (64, 10)]],
56+ [[np.float32, 3, (256, 2048, 7, 7)]],
57+ [[np.float32, 4, (32, 1, 3, 3)]],
58+ [[np.float32, 29, (10, 128)]],
59+ ]
60+ for item in shape_format1:
61+ cpu_input1, npu_input1 = create_common_tensor(item[0], -1, 1)
62+ cpu_input2, npu_input2 = create_common_tensor(item[0], -1, 1)
63+ cpu_output1 = self.cpu_op_exec(cpu_input1)
64+ npu_output1 = self.npu_op_exec_out(npu_input1, npu_input2)
65+ self.assertRtolEqual(cpu_output1, npu_output1)
66+ 
67+ def test_arctan_inp_shape_format(self):
68+ shape_format1 = [
69+ [[np.float32, 0, 1]],
70+ [[np.float32, 0, (64, 10)]],
71+ [[np.float32, 3, (256, 2048, 7, 7)]],
72+ [[np.float32, 4, (32, 1, 3, 3)]],
73+ [[np.float32, 29, (10, 128)]],
74+ ]
75+ for item in shape_format1:
76+ cpu_input1, npu_input1 = create_common_tensor(item[0], -1, 1)
77+ cpu_output1 = self.cpu_inp_op_exec(cpu_input1)
78+ npu_output1 = self.npu_inp_op_exec(npu_input1)
79+ self.assertRtolEqual(cpu_output1, npu_output1)
80+ 
81+ 
82+if __name__ == "__main__":
83+ run_tests()
Atest/test_base_ops/test_arctanh.py+83-0
@@ -0,0 +1,83 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestArctanh(TestCase):
10+ def cpu_op_exec(self, input1):
11+ output = torch.arctanh(input1)
12+ output = output.numpy()
13+ return output
14+ 
15+ def npu_op_exec(self, input1):
16+ output = torch.arctanh(input1)
17+ output = output.to("cpu")
18+ output = output.numpy()
19+ return output
20+ 
21+ def npu_op_exec_out(self, input1, input2):
22+ torch.arctanh(input1, out=input2)
23+ output = input2.to("cpu")
24+ output = output.numpy()
25+ return output
26+ 
27+ def cpu_inp_op_exec(self, input1):
28+ output = torch.arctanh_(input1)
29+ output = output.numpy()
30+ return output
31+ 
32+ def npu_inp_op_exec(self, input1):
33+ output = torch.arctanh_(input1)
34+ output = output.to("cpu")
35+ output = output.numpy()
36+ return output
37+ 
38+ def test_arctan_shape_format(self):
39+ shape_format = [
40+ [[np.float32, 0, 1]],
41+ [[np.float32, 0, (64, 10)]],
42+ [[np.float32, 3, (256, 2048, 7, 7)]],
43+ [[np.float32, 4, (32, 1, 3, 3)]],
44+ [[np.float32, 29, (10, 128)]],
45+ ]
46+ for item in shape_format:
47+ cpu_input, npu_input = create_common_tensor(item[0], -1, 1)
48+ cpu_output = self.cpu_op_exec(cpu_input)
49+ npu_output = self.npu_op_exec(npu_input)
50+ self.assertRtolEqual(cpu_output, npu_output)
51+ 
52+ def test_arctan_out_shape_format(self):
53+ shape_format = [
54+ [[np.float32, 0, 1]],
55+ [[np.float32, 0, (64, 10)]],
56+ [[np.float32, 3, (256, 2048, 7, 7)]],
57+ [[np.float32, 4, (32, 1, 3, 3)]],
58+ [[np.float32, 29, (10, 128)]],
59+ ]
60+ for item in shape_format:
61+ cpu_input1, npu_input1 = create_common_tensor(item[0], -1, 1)
62+ cpu_input2, npu_input2 = create_common_tensor(item[0], -1, 1)
63+ cpu_output = self.cpu_op_exec(cpu_input1)
64+ npu_output = self.npu_op_exec_out(npu_input1, npu_input2)
65+ self.assertRtolEqual(cpu_output, npu_output)
66+ 
67+ def test_arctan_inp_shape_format(self):
68+ shape_format = [
69+ [[np.float32, 0, 1]],
70+ [[np.float32, 0, (64, 10)]],
71+ [[np.float32, 3, (256, 2048, 7, 7)]],
72+ [[np.float32, 4, (32, 1, 3, 3)]],
73+ [[np.float32, 29, (10, 128)]],
74+ ]
75+ for item in shape_format:
76+ cpu_input, npu_input = create_common_tensor(item[0], -1, 1)
77+ cpu_output = self.cpu_inp_op_exec(cpu_input)
78+ npu_output = self.npu_inp_op_exec(npu_input)
79+ self.assertRtolEqual(cpu_output, npu_output)
80+ 
81+ 
82+if __name__ == "__main__":
83+ run_tests()
Atest/test_base_ops/test_argmax.py+80-0
@@ -0,0 +1,80 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestArgmax(TestCase):
10+ def cpu_op_exec(self, input1):
11+ output = torch.argmax(input1)
12+ output = output.numpy()
13+ return output
14+ 
15+ def npu_op_exec(self, input1):
16+ output = torch.argmax(input1)
17+ output = output.to("cpu")
18+ output = output.numpy()
19+ return output
20+ 
21+ def test_argmax_shape_format_fp16(self, device="npu"):
22+ format_list = [0]
23+ shape_list = [[5], [2, 4], [2, 2, 4], [2, 3, 3, 4]]
24+ shape_format = [[np.float16, i, j] for i in format_list for j in shape_list]
25+ for item in shape_format:
26+ cpu_input, npu_input = create_common_tensor(item, -10, 10)
27+ cpu_input = cpu_input.to(torch.float32)
28+ cpu_output = self.cpu_op_exec(cpu_input)
29+ npu_output = self.npu_op_exec(npu_input)
30+ cpu_output = cpu_output.astype(npu_output.dtype)
31+ self.assertRtolEqual(cpu_output, npu_output)
32+ 
33+ def test_argmax_shape_format_fp32(self, device="npu"):
34+ format_list = [0]
35+ shape_list = [[5], [2, 4], [2, 2, 4], [2, 3, 3, 4]]
36+ shape_format = [[np.float32, i, j] for i in format_list for j in shape_list]
37+ for item in shape_format:
38+ cpu_input, npu_input = create_common_tensor(item, -10, 10)
39+ cpu_output = self.cpu_op_exec(cpu_input)
40+ npu_output = self.npu_op_exec(npu_input)
41+ cpu_output = cpu_output.astype(npu_output.dtype)
42+ self.assertRtolEqual(cpu_output, npu_output)
43+ 
44+ def cpu_op_exec1(self, input1, dim):
45+ output = torch.argmax(input1, dim)
46+ output = output.numpy()
47+ return output
48+ 
49+ def npu_op_exec1(self, input1, dim):
50+ output = torch.argmax(input1, dim)
51+ output = output.to("cpu")
52+ output = output.numpy()
53+ return output
54+ 
55+ def test_argmaxd_shape_format_fp16(self, device="npu"):
56+ format_list = [0]
57+ shape_list = [[5], [2, 4], [2, 2, 4], [2, 3, 3, 4]]
58+ shape_format = [[np.float16, i, j] for i in format_list for j in shape_list]
59+ for item in shape_format:
60+ cpu_input, npu_input = create_common_tensor(item, -10, 10)
61+ cpu_input = cpu_input.to(torch.float32)
62+ cpu_output = self.cpu_op_exec1(cpu_input, -1)
63+ npu_output = self.npu_op_exec1(npu_input, -1)
64+ cpu_output = cpu_output.astype(npu_output.dtype)
65+ self.assertRtolEqual(cpu_output, npu_output)
66+ 
67+ def test_argmaxd_shape_format_fp32(self, device="npu"):
68+ format_list = [0]
69+ shape_list = [[5], [2, 4], [2, 2, 4], [2, 3, 3, 4]]
70+ shape_format = [[np.float32, i, j] for i in format_list for j in shape_list]
71+ for item in shape_format:
72+ cpu_input, npu_input = create_common_tensor(item, -10, 10)
73+ cpu_output = self.cpu_op_exec1(cpu_input, -1)
74+ npu_output = self.npu_op_exec1(npu_input, -1)
75+ cpu_output = cpu_output.astype(npu_output.dtype)
76+ self.assertRtolEqual(cpu_output, npu_output)
77+ 
78+ 
79+if __name__ == "__main__":
80+ run_tests()
Atest/test_base_ops/test_argmin.py+62-0
@@ -0,0 +1,62 @@
1+# coding: utf-8
2+ 
3+import torch
4+import numpy as np
5+import torch_npu
6+ 
7+from torch_npu.testing.testcase import TestCase, run_tests
8+from torch_npu.testing.common_utils import create_common_tensor
9+from torch_npu.testing.decorator import Dtypes, instantiate_tests
10+ 
11+ 
12+@instantiate_tests
13+class TestArgmin(TestCase):
14+ @Dtypes(torch.float, torch.half)
15+ def test_argmin(self, device, dtype):
16+ inputValues = [-1000, -1, 0, 0.5, 1, 2, 1000]
17+ expectedOutput = [0.0000, 0.2689, 0.5, 0.6225, 0.7311, 0.8808, 1.000]
18+ precision_4dps = 0.0002
19+ a = torch.tensor(inputValues, dtype=dtype, device=device)
20+ self.assertRtolEqual(
21+ torch.tensor(inputValues, dtype=dtype, device=device).sigmoid().cpu(),
22+ torch.tensor(expectedOutput, dtype=dtype, device=device).cpu(),
23+ precision_4dps,
24+ )
25+ 
26+ def cpu_op_exec(self, input1, dims, keepdim=False):
27+ output = torch.argmin(input1, dim=dims, keepdim=keepdim)
28+ if output.dtype != torch.int32:
29+ output = output.to(torch.int32)
30+ output = output.numpy()
31+ return output
32+ 
33+ def npu_op_exec(self, input1, dims, keepdim=False):
34+ output = torch.argmin(input1, dim=dims, keepdim=keepdim)
35+ output = output.to("cpu")
36+ if output.dtype != torch.int32:
37+ output = output.to(torch.int32)
38+ output = output.numpy()
39+ return output
40+ 
41+ def test_argmin_shape_format(self):
42+ shape_format = [
43+ [[np.float32, 0, (6, 4)], 0, False],
44+ [[np.float32, 2, (6, 4)], 1, True],
45+ [[np.float32, 0, (2, 4, 5)], 2, True],
46+ [[np.float32, 0, (1, 2, 3, 3)], 2, False],
47+ [[np.float32, 0, (1, 2, 3, 3)], 3, True],
48+ [[np.float16, 0, (6, 4)], 0, False],
49+ [[np.float16, 2, (6, 4)], 1, True],
50+ [[np.float16, 0, (2, 4, 5)], 2, True],
51+ [[np.float16, 3, (1, 2, 3, 3)], 2, False],
52+ [[np.float16, 0, (1, 2, 3, 3)], 3, True],
53+ ]
54+ for item in shape_format:
55+ cpu_input, npu_input = create_common_tensor(item[0], 1, 100)
56+ cpu_output = self.cpu_op_exec(cpu_input, item[1], keepdim=item[2])
57+ npu_output = self.npu_op_exec(npu_input, item[1], keepdim=item[2])
58+ self.assertRtolEqual(cpu_output, npu_output)
59+ 
60+ 
61+if __name__ == "__main__":
62+ run_tests()
Atest/test_base_ops/test_argsort.py+67-0
@@ -0,0 +1,67 @@
1+import torch
2+import numpy as np
3+ 
4+import torch_npu
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestArgSort(TestCase):
10+ def cpu_op_exec(self, input1, dim, descending):
11+ output = torch.argsort(input1, dim=dim, descending=descending)
12+ return output.numpy()
13+ 
14+ def npu_op_exec(self, input1, dim, descending):
15+ output = torch.argsort(input1, dim=dim, descending=descending)
16+ 
17+ return output.cpu().numpy()
18+ 
19+ def cpu_default_op_exec(self, input1):
20+ output = torch.argsort(input1)
21+ return output.numpy()
22+ 
23+ def npu_default_op_exec(self, input1):
24+ output = torch.argsort(input1)
25+ return output.cpu().numpy()
26+ 
27+ def test_sort_shape_format_fp32(self):
28+ shape_format = [
29+ [[np.float32, 0, (8, 4, 3, 9)], 2, False],
30+ [[np.float32, 0, (2, 3)]],
31+ [[np.float32, 0, (1, 7)], 0, True],
32+ [[np.float32, 0, (1, 5, 6)], 1, False],
33+ ]
34+ 
35+ for item in shape_format:
36+ cpu_input1, npu_input1 = create_common_tensor(item[0], -100, 100)
37+ if len(item) > 1:
38+ cpu_output = self.cpu_op_exec(cpu_input1, item[1], item[2])
39+ npu_output = self.npu_op_exec(npu_input1, item[1], item[2])
40+ else:
41+ cpu_output = self.cpu_default_op_exec(cpu_input1)
42+ npu_output = self.npu_default_op_exec(npu_input1)
43+ self.assertRtolEqual(cpu_output, npu_output)
44+ 
45+ def test_sort_shape_format_fp16(self):
46+ shape_format = [
47+ [[np.float16, 0, (8, 4, 3, 9)], 2, False],
48+ [[np.float16, 0, (2, 3)]],
49+ [[np.float16, 0, (1, 7)], 0, True],
50+ [[np.float16, 0, (1, 5, 6)], 1, False],
51+ ]
52+ 
53+ for item in shape_format:
54+ cpu_input1, npu_input1 = create_common_tensor(item[0], -100, 100)
55+ if len(item) > 1:
56+ cpu_output = self.cpu_op_exec(
57+ cpu_input1.to(torch.float32), item[1], item[2]
58+ )
59+ npu_output = self.npu_op_exec(npu_input1, item[1], item[2])
60+ else:
61+ cpu_output = self.cpu_default_op_exec(cpu_input1.to(torch.float32))
62+ npu_output = self.npu_default_op_exec(npu_input1)
63+ self.assertRtolEqual(cpu_output, npu_output)
64+ 
65+ 
66+if __name__ == "__main__":
67+ run_tests()
Atest/test_base_ops/test_as_strided.py+38-0
@@ -0,0 +1,38 @@
1+import torch
2+import numpy as np
3+ 
4+import torch_npu
5+ 
6+from torch_npu.testing.testcase import TestCase, run_tests
7+from torch_npu.testing.common_utils import create_common_tensor
8+ 
9+ 
10+class TestAsStrided(TestCase):
11+ def cpu_op_exec(self, input1, size, stride, storage_offset):
12+ output = torch.as_strided(input1, size, stride, storage_offset)
13+ output = output.numpy()
14+ return output
15+ 
16+ def npu_op_exec(self, input1, size, stride, storage_offset):
17+ output = torch.as_strided(input1, size, stride, storage_offset)
18+ output = output.cpu().numpy()
19+ return output
20+ 
21+ def test_as_strided(self):
22+ shape_format = [
23+ [[np.float32, 0, [3, 3]], (2, 2), (1, 2), 0],
24+ [[np.float16, 0, [13, 23]], (10, 15), (1, 2), 1],
25+ [[np.int32, 0, [5, 5]], (3, 3), (1, 2), 1],
26+ [[np.float32, 2, [32, 8, 2]], (8, 6, 2), (5, 4, 1), 1],
27+ [[np.int32, 2, [8, 16]], (6, 3), (8, 2), 0],
28+ ]
29+ 
30+ for item in shape_format:
31+ cpu_input1, npu_input1 = create_common_tensor(item[0], -100, 100)
32+ cpu_output = self.cpu_op_exec(cpu_input1, item[1], item[2], item[3])
33+ npu_output = self.npu_op_exec(npu_input1, item[1], item[2], item[3])
34+ self.assertRtolEqual(cpu_output, npu_output)
35+ 
36+ 
37+if __name__ == "__main__":
38+ run_tests()
Atest/test_base_ops/test_asin.py+50-0
@@ -0,0 +1,50 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestAsin(TestCase):
10+ def cpu_op_exec(self, input1):
11+ output = torch.asin(input1)
12+ output = output.numpy()
13+ return output
14+ 
15+ def npu_op_exec(self, input1):
16+ output = torch.asin(input1)
17+ output = output.to("cpu")
18+ output = output.numpy()
19+ return output
20+ 
21+ def npu_op_exec_out(self, input1, input2):
22+ torch.asin(input1, out=input2)
23+ output = input2.to("cpu")
24+ output = output.numpy()
25+ return output
26+ 
27+ def test_asin_common_shape_format(self, device="npu"):
28+ shape_format = [
29+ [[np.float32, 0, (5, 3)]],
30+ ]
31+ for item in shape_format:
32+ cpu_input1, npu_input1 = create_common_tensor(item[0], -1, 1)
33+ cpu_output = self.cpu_op_exec(cpu_input1)
34+ npu_output = self.npu_op_exec(npu_input1)
35+ self.assertRtolEqual(cpu_output, npu_output)
36+ 
37+ def test_asin_out_common_shape_format(self, device="npu"):
38+ shape_format = [
39+ [[np.float32, 0, (4, 3)], [np.float32, 0, (4, 3)]],
40+ ]
41+ for item in shape_format:
42+ cpu_input1, npu_input1 = create_common_tensor(item[0], -1, 1)
43+ cpu_input2, npu_input2 = create_common_tensor(item[1], -1, 1)
44+ cpu_output = self.cpu_op_exec(cpu_input1)
45+ npu_output = self.npu_op_exec_out(npu_input1, npu_input2)
46+ self.assertRtolEqual(cpu_output, npu_output)
47+ 
48+ 
49+if __name__ == "__main__":
50+ run_tests()
Atest/test_base_ops/test_asinh.py+71-0
@@ -0,0 +1,71 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestAsinh(TestCase):
10+ def cpu_op_exec(self, input1):
11+ output = torch.asinh(input1)
12+ output = output.numpy()
13+ return output
14+ 
15+ def npu_op_exec(self, input1):
16+ output = torch.asinh(input1)
17+ output = output.to("cpu")
18+ output = output.numpy()
19+ return output
20+ 
21+ def npu_op_exec_out(self, input1, input2):
22+ torch.asinh(input1, out=input2)
23+ output = input2.to("cpu")
24+ output = output.numpy()
25+ return output
26+ 
27+ def cpu_inp_op_exec(self, input1):
28+ output = torch.asinh_(input1)
29+ output = output.numpy()
30+ return output
31+ 
32+ def npu_inp_op_exec(self, input1):
33+ output = torch.asinh_(input1)
34+ output = output.to("cpu")
35+ output = output.numpy()
36+ return output
37+ 
38+ def test_asinh_common_shape_format(self):
39+ shape_format1 = [
40+ [[np.float32, 0, (5, 3)]],
41+ ]
42+ for item in shape_format1:
43+ cpu_input1, npu_input1 = create_common_tensor(item[0], -1, 1)
44+ cpu_output = self.cpu_op_exec(cpu_input1)
45+ npu_output = self.npu_op_exec(npu_input1)
46+ self.assertRtolEqual(cpu_output, npu_output)
47+ 
48+ def test_asinh_out_common_shape_format(self):
49+ shape_format1 = [
50+ [[np.float32, 0, (4, 3)], [np.float32, 0, (4, 3)]],
51+ ]
52+ for item in shape_format1:
53+ cpu_input1, npu_input1 = create_common_tensor(item[0], -1, 1)
54+ cpu_input2, npu_input2 = create_common_tensor(item[1], -1, 1)
55+ cpu_output = self.cpu_op_exec(cpu_input1)
56+ npu_output = self.npu_op_exec_out(npu_input1, npu_input2)
57+ self.assertRtolEqual(cpu_output, npu_output)
58+ 
59+ def test_asinh_inp_common_shape_format(self):
60+ shape_format1 = [
61+ [[np.float32, 0, (5, 3)]],
62+ ]
63+ for item in shape_format1:
64+ cpu_input1, npu_input1 = create_common_tensor(item[0], -1, 1)
65+ cpu_output = self.cpu_inp_op_exec(cpu_input1)
66+ npu_output = self.npu_inp_op_exec(npu_input1)
67+ self.assertRtolEqual(cpu_output, npu_output)
68+ 
69+ 
70+if __name__ == "__main__":
71+ run_tests()
Atest/test_base_ops/test_atan2.py+62-0
@@ -0,0 +1,62 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestAtan2(TestCase):
10+ def cpu_op_exec(self, input1, input2):
11+ output = torch.atan2(input1, input2)
12+ output = output.numpy()
13+ return output
14+ 
15+ def npu_op_exec(self, input1, input2):
16+ output = torch.atan2(input1, input2)
17+ output = output.to("cpu")
18+ output = output.numpy()
19+ return output
20+ 
21+ def npu_op_exec_out(self, input1, input2, out):
22+ torch.atan2(input1, input2, out=out)
23+ output = out.to("cpu")
24+ output = output.numpy()
25+ return output
26+ 
27+ def test_atan2_common_shape_format(self):
28+ shape_format = [
29+ [[np.float16, 0, [4, 12, 12, 128]], [np.float16, 0, [4]]],
30+ [[np.float16, 0, [4, 128]], [np.float16, 0, [4, 256, 12]]],
31+ [[np.float32, 0, [4, 12, 12, 128]], [np.float32, 0, [4]]],
32+ [[np.float32, 0, [4, 128]], [np.float32, 0, [4, 256, 12]]],
33+ [[np.float16, 2, [4, 12, 12, 128]], [np.float16, 0, [4]]],
34+ [[np.float16, 3, [4, 128]], [np.float16, 0, [4, 256, 12]]],
35+ [[np.float32, 2, [4, 12, 12, 128]], [np.float32, 0, [4]]],
36+ [[np.float32, 3, [4, 128]], [np.float32, 0, [4, 256, 12]]],
37+ ]
38+ for item in shape_format:
39+ cpu_input1, npu_input1 = create_common_tensor(item[0], -1, 1)
40+ cpu_input2, npu_input2 = create_common_tensor(item[0], -1, 1)
41+ cpu_out, npu_out = create_common_tensor(item[1], -1, 1)
42+ if cpu_input1.dtype == torch.float16:
43+ cpu_input1 = cpu_input1.to(torch.float32)
44+ if cpu_input2.dtype == torch.float16:
45+ cpu_input2 = cpu_input2.to(torch.float32)
46+ cpu_output = self.cpu_op_exec(cpu_input1, cpu_input2)
47+ npu_output = self.npu_op_exec(npu_input1, npu_input2)
48+ npu_output_out = self.npu_op_exec_out(npu_input1, npu_input2, npu_out)
49+ cpu_output = cpu_output.astype(npu_output.dtype)
50+ self.assertRtolEqual(cpu_output, npu_output)
51+ self.assertRtolEqual(cpu_output, npu_output_out)
52+ 
53+ def test_atan2_mix_dtype(self):
54+ npu_input1, npu_input2 = create_common_tensor([np.float32, 0, (2, 3)], 1, 100)
55+ npu_input3, npu_input4 = create_common_tensor([np.float16, 0, (2, 3)], 1, 100)
56+ cpu_output = self.cpu_op_exec(npu_input1, npu_input3)
57+ npu_output = self.npu_op_exec(npu_input2, npu_input4)
58+ self.assertRtolEqual(cpu_output, npu_output)
59+ 
60+ 
61+if __name__ == "__main__":
62+ run_tests()
Atest/test_base_ops/test_atanh.py+83-0
@@ -0,0 +1,83 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestAtanh(TestCase):
10+ def cpu_op_exec(self, input1):
11+ output = torch.atanh(input1)
12+ output = output.numpy()
13+ return output
14+ 
15+ def npu_op_exec(self, input1):
16+ output = torch.atanh(input1)
17+ output = output.to("cpu")
18+ output = output.numpy()
19+ return output
20+ 
21+ def npu_op_exec_out(self, input1, input2):
22+ torch.atanh(input1, out=input2)
23+ output = input2.to("cpu")
24+ output = output.numpy()
25+ return output
26+ 
27+ def cpu_inp_op_exec(self, input1):
28+ output = torch.atanh_(input1)
29+ output = output.numpy()
30+ return output
31+ 
32+ def npu_inp_op_exec(self, input1):
33+ output = torch.atanh_(input1)
34+ output = output.to("cpu")
35+ output = output.numpy()
36+ return output
37+ 
38+ def test_atanh_shape_format(self):
39+ shape_format1 = [
40+ [[np.float32, 0, 1]],
41+ [[np.float32, 0, (64, 10)]],
42+ [[np.float32, 3, (256, 2048, 7, 7)]],
43+ [[np.float32, 4, (32, 1, 3, 3)]],
44+ [[np.float32, 29, (10, 128)]],
45+ ]
46+ for item in shape_format1:
47+ cpu_input1, npu_input1 = create_common_tensor(item[0], -1, 1)
48+ cpu_output1 = self.cpu_op_exec(cpu_input1)
49+ npu_output1 = self.npu_op_exec(npu_input1)
50+ self.assertRtolEqual(cpu_output1, npu_output1)
51+ 
52+ def test_atanh_out_shape_format(self):
53+ shape_format = [
54+ [[np.float32, 0, 1]],
55+ [[np.float32, 0, (64, 10)]],
56+ [[np.float32, 3, (256, 2048, 7, 7)]],
57+ [[np.float32, 4, (32, 1, 3, 3)]],
58+ [[np.float32, 29, (10, 128)]],
59+ ]
60+ for item in shape_format:
61+ cpu_input1, npu_input1 = create_common_tensor(item[0], -1, 1)
62+ cpu_input, npu_input = create_common_tensor(item[0], -1, 1)
63+ cpu_output = self.cpu_op_exec(cpu_input1)
64+ npu_output = self.npu_op_exec_out(npu_input1, npu_input)
65+ self.assertRtolEqual(cpu_output, npu_output)
66+ 
67+ def test_atanh_inp_shape_format(self):
68+ shape_format1 = [
69+ [[np.float32, 0, 1]],
70+ [[np.float32, 0, (64, 10)]],
71+ [[np.float32, 3, (256, 2048, 7, 7)]],
72+ [[np.float32, 4, (32, 1, 3, 3)]],
73+ [[np.float32, 29, (10, 128)]],
74+ ]
75+ for item in shape_format1:
76+ cpu_input, npu_input = create_common_tensor(item[0], -1, 1)
77+ cpu_output = self.cpu_inp_op_exec(cpu_input)
78+ npu_output = self.npu_inp_op_exec(npu_input)
79+ self.assertRtolEqual(cpu_output, npu_output)
80+ 
81+ 
82+if __name__ == "__main__":
83+ run_tests()
Atest/test_base_ops/test_avg_pool2d.py+78-0
@@ -0,0 +1,78 @@
1+import unittest
2+import torch
3+import torch.nn as nn
4+import numpy as np
5+import torch_npu
6+ 
7+from torch_npu.testing.testcase import TestCase, run_tests
8+from torch_npu.testing.common_utils import create_common_tensor
9+ 
10+ 
11+class TestAvgPool2d(TestCase):
12+ def cpu_op_exec(self, input1, ceil_mode):
13+ m = nn.AvgPool2d(3, stride=(6, 5), padding=0, ceil_mode=ceil_mode)
14+ output = m(input1)
15+ output = output.detach().numpy()
16+ return output
17+ 
18+ def npu_op_exec(self, input1, ceil_mode):
19+ m = nn.AvgPool2d(3, stride=(6, 5), padding=0, ceil_mode=ceil_mode).npu()
20+ output = m(input1)
21+ output = output.to("cpu")
22+ output = output.detach().numpy()
23+ return output
24+ 
25+ def test_avg_pool2d_backward_shape_format_fp16(self):
26+ shape_format = [
27+ [[np.float16, 0, (1, 3, 147, 147)], True],
28+ [[np.float16, 0, (1, 3, 147, 147)], True],
29+ ]
30+ 
31+ for item in shape_format:
32+ cpu_input, npu_input = create_common_tensor(item[0], 0, 1)
33+ cpu_input = cpu_input.to(torch.float32)
34+ cpu_output = self.cpu_op_exec(cpu_input.float(), item[1]).astype(np.float16)
35+ npu_output = self.npu_op_exec(npu_input, item[1])
36+ self.assertRtolEqual(cpu_output, npu_output, prec16=0.002)
37+ 
38+ @unittest.skip("skip test_avg_pool2d_backward_shape_format_fp32 now")
39+ def test_avg_pool2d_backward_shape_format_fp32(self):
40+ shape_format = [
41+ [[np.float32, 0, (1, 3, 147, 147)], True],
42+ [[np.float32, 0, (1, 3, 147, 147)], True],
43+ ]
44+ 
45+ for item in shape_format:
46+ cpu_input, npu_input = create_common_tensor(item[0], 0, 1)
47+ cpu_output = self.cpu_op_exec(cpu_input, item[1])
48+ npu_output = self.npu_op_exec(npu_input, item[1])
49+ self.assertRtolEqual(cpu_output, npu_output, 0.0009)
50+ 
51+ def test_avg_pool2d_3d_fp32(self):
52+ cinput = torch.randn(128, 32, 7)
53+ ninput = cinput.npu()
54+ cmodel = torch.nn.AvgPool2d((4, 5))
55+ nmodel = cmodel.npu()
56+ cpu_output = cmodel(cinput)
57+ npu_output = nmodel(ninput)
58+ self.assertRtolEqual(cpu_output.numpy(), npu_output.cpu().numpy(), 0.0009)
59+ 
60+ @unittest.skip("skip test_avg_pool2d_4d_fp32 now")
61+ def test_avg_pool2d_4d_fp32(self):
62+ cinput = torch.randn(18, 43, 12, 400)
63+ ninput = cinput.npu()
64+ kernel = 13
65+ padding = 6
66+ stride = 10
67+ ceil_mode = True
68+ cmodel = torch.nn.AvgPool2d(
69+ kernel, stride=stride, padding=padding, ceil_mode=ceil_mode
70+ )
71+ nmodel = cmodel.npu()
72+ cpu_output = cmodel(cinput)
73+ npu_output = nmodel(ninput)
74+ self.assertRtolEqual(cpu_output.numpy(), npu_output.cpu().numpy(), 0.0009)
75+ 
76+ 
77+if __name__ == "__main__":
78+ run_tests()
Atest/test_base_ops/test_avg_pool2d_backward.py+69-0
@@ -0,0 +1,69 @@
1+import torch
2+import torch.nn as nn
3+import numpy as np
4+import torch_npu
5+ 
6+from torch_npu.testing.testcase import TestCase, run_tests
7+from torch_npu.testing.common_utils import create_common_tensor
8+ 
9+ 
10+class TestAvgPool2dBackward(TestCase):
11+ def cpu_op_exec(self, input1):
12+ m = nn.AvgPool2d(kernel_size=2, stride=2)
13+ input1.requires_grad = True
14+ output = m(input1)
15+ output.backward(torch.ones_like(output))
16+ output_grad = input1.grad
17+ output_grad = output_grad.detach().numpy()
18+ output = output.detach().numpy()
19+ 
20+ return output_grad, output
21+ 
22+ def npu_op_exec(self, input1):
23+ m = nn.AvgPool2d(kernel_size=2, stride=2).npu()
24+ input1.requires_grad = True
25+ output = m(input1)
26+ output.backward(torch.ones_like(output))
27+ output_grad = input1.grad
28+ output_grad = output_grad.to("cpu")
29+ output_grad = output_grad.detach().numpy()
30+ output = output.to("cpu")
31+ output = output.detach().numpy()
32+ 
33+ return output_grad, output
34+ 
35+ def test_avg_pool2d_backward_shape_format_fp16(self):
36+ format_list = [0, 3]
37+ shape_list = [(5, 20, 8, 8)]
38+ shape_format = [[np.float16, i, j] for i in format_list for j in shape_list]
39+ for item in shape_format:
40+ cpu_input, npu_input = create_common_tensor(item, 0, 100)
41+ cpu_input = cpu_input.to(torch.float32)
42+ cpu_output_grad, cpu_output = self.cpu_op_exec(cpu_input)
43+ npu_output_grad, npu_output = self.npu_op_exec(npu_input)
44+ cpu_output = cpu_output.astype(npu_output.dtype)
45+ cpu_output_grad = cpu_output_grad.astype(npu_output_grad.dtype)
46+ 
47+ self.assertRtolEqual(cpu_output, npu_output)
48+ self.assertRtolEqual(cpu_output_grad, npu_output_grad)
49+ 
50+ def test_avg_pool2d_backward_shape_format_fp32(self):
51+ format_list = [0, 3]
52+ shape_list = [(5, 20, 8, 8)]
53+ shape_format = [[np.float32, i, j] for i in format_list for j in shape_list]
54+ for item in shape_format:
55+ cpu_input, npu_input = create_common_tensor(item, 0, 100)
56+ cpu_output_grad, cpu_output = self.cpu_op_exec(cpu_input)
57+ npu_output_grad, npu_output = self.npu_op_exec(npu_input)
58+ 
59+ cpu_output = cpu_output.astype(np.float16)
60+ cpu_output_grad = cpu_output_grad.astype(np.float16)
61+ npu_output = npu_output.astype(np.float16)
62+ npu_output_grad = npu_output_grad.astype(np.float16)
63+ 
64+ self.assertRtolEqual(cpu_output, npu_output)
65+ self.assertRtolEqual(cpu_output_grad, npu_output_grad)
66+ 
67+ 
68+if __name__ == "__main__":
69+ run_tests()
Atest/test_base_ops/test_avg_pool3d.py+55-0
@@ -0,0 +1,55 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestAvgPool3D(TestCase):
10+ def cpu_op_exec(self, kernel_size, stride, input1):
11+ m = torch.nn.AvgPool3d(kernel_size, stride)
12+ output_data = m(input1)
13+ return output_data
14+ 
15+ def cpu_op_exec_fp16(self, kernel_size, stride, input1):
16+ m = torch.nn.AvgPool3d(kernel_size, stride)
17+ output_data = m(input1.float())
18+ return output_data.half()
19+ 
20+ def npu_op_exec(self, kernel_size, stride, input1):
21+ m = torch.nn.AvgPool3d(kernel_size, stride).npu()
22+ output_data = m(input1)
23+ return output_data
24+ 
25+ def test_avg_pool_3d_fp32(self):
26+ shape_format = [
27+ [[np.float32, -1, (20, 16, 50, 44, 31)], (3, 2, 2), (2, 1, 2)],
28+ [[np.float32, -1, (2, 1, 4, 4, 4)], 3, 2],
29+ [[np.float32, -1, (2, 1, 4, 4, 4)], 2, 2],
30+ [[np.float32, -1, (2, 4, 4, 4)], 2, 2],
31+ ]
32+ 
33+ for item in shape_format:
34+ cpu_input1, npu_input1 = create_common_tensor(item[0], 1, 100)
35+ npu_output = self.npu_op_exec(item[1], item[2], npu_input1)
36+ cpu_output = self.cpu_op_exec(item[1], item[2], cpu_input1)
37+ self.assertRtolEqual(cpu_output, npu_output.cpu(), 1.0e-3)
38+ 
39+ def test_avg_pool_3d_fp16(self):
40+ shape_format = [
41+ [[np.float16, -1, (20, 16, 50, 44, 31)], (3, 2, 2), (2, 1, 2)],
42+ [[np.float16, -1, (2, 1, 4, 4, 4)], 3, 2],
43+ [[np.float16, -1, (2, 1, 4, 4, 4)], 2, 2],
44+ [[np.float16, -1, (2, 4, 4, 4)], 2, 2],
45+ ]
46+ 
47+ for item in shape_format:
48+ cpu_input1, npu_input1 = create_common_tensor(item[0], 1, 100)
49+ npu_output = self.npu_op_exec(item[1], item[2], npu_input1)
50+ cpu_output = self.cpu_op_exec_fp16(item[1], item[2], cpu_input1)
51+ self.assertRtolEqual(cpu_output, npu_output.cpu())
52+ 
53+ 
54+if __name__ == "__main__":
55+ run_tests()
Atest/test_base_ops/test_avg_pool3d_backward.py+77-0
@@ -0,0 +1,77 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestAvgPool3DBackward(TestCase):
10+ def cpu_op_exec(self, kernel_size, stride, input1):
11+ m = torch.nn.AvgPool3d(kernel_size, stride)
12+ input1.requires_grad = True
13+ output = m(input1)
14+ output.backward(torch.ones_like(output))
15+ output_grad = input1.grad
16+ output_grad = output_grad.detach().numpy()
17+ output = output.detach().numpy()
18+ return output_grad, output
19+ 
20+ def cpu_op_exec_fp16(self, kernel_size, stride, input1):
21+ m = torch.nn.AvgPool3d(kernel_size, stride)
22+ input1.requires_grad = True
23+ output = m(input1.float())
24+ output.backward(torch.ones_like(output))
25+ output_grad = input1.grad
26+ output_grad = output_grad.detach().numpy()
27+ output = output.half()
28+ output = output.detach().numpy()
29+ return output_grad, output
30+ 
31+ def npu_op_exec(self, kernel_size, stride, input1):
32+ m = torch.nn.AvgPool3d(kernel_size, stride).npu()
33+ input1.requires_grad = True
34+ output = m(input1)
35+ output.backward(torch.ones_like(output))
36+ output_grad = input1.grad
37+ output_grad = output_grad.to("cpu")
38+ output_grad = output_grad.detach().numpy()
39+ output = output.to("cpu")
40+ output = output.detach().numpy()
41+ return output_grad, output
42+ 
43+ def test_avg_pool_3d_fp32(self):
44+ shape_format = [
45+ [[np.float32, -1, (20, 16, 50, 44, 31)], (3, 2, 2), (2, 1, 2)],
46+ [[np.float32, -1, (2, 1, 4, 4, 4)], 3, 2],
47+ [[np.float32, -1, (2, 1, 4, 4, 4)], 2, 2],
48+ [[np.float32, -1, (2, 4, 4, 4)], 2, 2],
49+ ]
50+ 
51+ for item in shape_format:
52+ cpu_input1, npu_input1 = create_common_tensor(item[0], 1, 100)
53+ npu_output_grad, npu_output = self.npu_op_exec(item[1], item[2], npu_input1)
54+ cpu_output_grad, cpu_output = self.cpu_op_exec(item[1], item[2], cpu_input1)
55+ self.assertRtolEqual(cpu_output, npu_output, 1.0e-3)
56+ self.assertRtolEqual(cpu_output_grad, npu_output_grad, 1.0e-3)
57+ 
58+ def test_avg_pool_3d_fp16(self):
59+ shape_format = [
60+ [[np.float16, -1, (20, 16, 50, 44, 31)], (3, 2, 2), (2, 1, 2)],
61+ [[np.float16, -1, (2, 1, 4, 4, 4)], 3, 2],
62+ [[np.float16, -1, (2, 1, 4, 4, 4)], 2, 2],
63+ [[np.float16, -1, (2, 4, 4, 4)], 2, 2],
64+ ]
65+ 
66+ for item in shape_format:
67+ cpu_input1, npu_input1 = create_common_tensor(item[0], 1, 100)
68+ npu_output_grad, npu_output = self.npu_op_exec(item[1], item[2], npu_input1)
69+ cpu_output_grad, cpu_output = self.cpu_op_exec_fp16(
70+ item[1], item[2], cpu_input1
71+ )
72+ self.assertRtolEqual(cpu_output, npu_output)
73+ self.assertRtolEqual(cpu_output_grad, npu_output_grad)
74+ 
75+ 
76+if __name__ == "__main__":
77+ run_tests()
Atest/test_base_ops/test_baddbmm.py+160-0
@@ -0,0 +1,160 @@
1+import torch
2+import numpy as np
3+from torch.nn import functional as F
4+import torch_npu
5+ 
6+from torch_npu.testing.testcase import TestCase, run_tests
7+from torch_npu.testing.common_utils import create_common_tensor
8+ 
9+ 
10+class TestBaddBmm(TestCase):
11+ def generate_scalar(self, dtype, min1, max1):
12+ if dtype == "float32":
13+ scalar = np.random.uniform(min1, max1)
14+ if dtype == "float16":
15+ scalar = np.random.uniform(min1, max1)
16+ if dtype == "int32":
17+ scalar = np.random.randint(min1, max1)
18+ return scalar
19+ 
20+ def cpu_op_exec(self, input1, input2, input3, scalar1, scalar2):
21+ output = torch.baddbmm(input1, input2, input3, beta=scalar1, alpha=scalar2)
22+ output = output.numpy()
23+ return output
24+ 
25+ def cpu_op_exec_(self, input1, input2, input3, scalar1, scalar2):
26+ input1.baddbmm_(input2, input3, beta=scalar1, alpha=scalar2)
27+ input1 = input1.numpy()
28+ return input1
29+ 
30+ def npu_op_exec(self, input1, input2, input3, scalar1, scalar2):
31+ output = torch.baddbmm(input1, input2, input3, beta=scalar1, alpha=scalar2)
32+ output = output.to("cpu")
33+ output = output.numpy()
34+ return output
35+ 
36+ def npu_op_exec_(self, input1, input2, input3, scalar1, scalar2):
37+ input1.baddbmm_(input2, input3, beta=scalar1, alpha=scalar2)
38+ input1 = input1.to("cpu")
39+ input1 = input1.numpy()
40+ return input1
41+ 
42+ def test_baddbmm_common_shape_format(self):
43+ shape_format = [
44+ [
45+ [np.float16, -1, (1, 3, 5)],
46+ [np.float16, -1, (1, 3, 4)],
47+ [np.float16, -1, (1, 4, 5)],
48+ "float32",
49+ ],
50+ [
51+ [np.float16, -1, (6, 4, 3)],
52+ [np.float16, -1, (6, 4, 5)],
53+ [np.float16, -1, (6, 5, 3)],
54+ "float32",
55+ ],
56+ [
57+ [np.float16, -1, (175, 455, 22)],
58+ [np.float16, -1, (175, 455, 116)],
59+ [np.float16, -1, (175, 116, 22)],
60+ "float32",
61+ ],
62+ [
63+ [np.float16, -1, (25, 56, 12)],
64+ [np.float16, -1, (25, 56, 51)],
65+ [np.float16, -1, (25, 51, 12)],
66+ "float32",
67+ ],
68+ ]
69+ 
70+ for item in shape_format:
71+ cpu_input1, npu_input1 = create_common_tensor(item[0], 0, 1)
72+ cpu_input2, npu_input2 = create_common_tensor(item[1], 0, 1)
73+ cpu_input3, npu_input3 = create_common_tensor(item[2], 0, 1)
74+ scalar1 = self.generate_scalar(item[3], 0, 2)
75+ scalar2 = self.generate_scalar(item[3], 0, 2)
76+ cpu_output = self.cpu_op_exec(
77+ cpu_input1.float(),
78+ cpu_input2.float(),
79+ cpu_input3.float(),
80+ scalar1,
81+ scalar2,
82+ )
83+ npu_output = self.npu_op_exec(
84+ npu_input1.float(),
85+ npu_input2.float(),
86+ npu_input3.float(),
87+ scalar1,
88+ scalar2,
89+ )
90+ self.assertRtolEqual(cpu_output, npu_output, prec=1.0e-3, prec16=1.0e-3)
91+ cpu_output_ = self.cpu_op_exec_(
92+ cpu_input1.float(),
93+ cpu_input2.float(),
94+ cpu_input3.float(),
95+ scalar1,
96+ scalar2,
97+ )
98+ npu_output_ = self.npu_op_exec_(
99+ npu_input1.float(),
100+ npu_input2.float(),
101+ npu_input3.float(),
102+ scalar1,
103+ scalar2,
104+ )
105+ self.assertRtolEqual(cpu_output_, npu_output_, prec=1.0e-3, prec16=1.0e-3)
106+ 
107+ def test_baddbmm_float16_shape_format(self):
108+ def cpu_op_exec_fp16(input1, input2, input3, scalar1, scalar2):
109+ input1 = input1.to(torch.float32)
110+ input2 = input2.to(torch.float32)
111+ input3 = input3.to(torch.float32)
112+ output = torch.baddbmm(input1, input2, input3, beta=scalar1, alpha=scalar2)
113+ output = output.numpy()
114+ output = output.astype(np.float16)
115+ return output
116+ 
117+ shape_format = [
118+ [
119+ [np.float16, -1, (1, 3, 5)],
120+ [np.float16, -1, (1, 3, 4)],
121+ [np.float16, -1, (1, 4, 5)],
122+ "float16",
123+ ],
124+ [
125+ [np.float16, -1, (500, 40, 300)],
126+ [np.float16, -1, (500, 40, 500)],
127+ [np.float16, -1, (500, 500, 300)],
128+ "float16",
129+ ],
130+ [
131+ [np.float16, -1, (175, 455, 22)],
132+ [np.float16, -1, (175, 455, 116)],
133+ [np.float16, -1, (175, 116, 22)],
134+ "float16",
135+ ],
136+ [
137+ [np.float16, -1, (25, 21, 11)],
138+ [np.float16, -1, (25, 21, 34)],
139+ [np.float16, -1, (25, 34, 11)],
140+ "float16",
141+ ],
142+ ]
143+ 
144+ for item in shape_format:
145+ cpu_input1, npu_input1 = create_common_tensor(item[0], 0, 1)
146+ cpu_input2, npu_input2 = create_common_tensor(item[1], 0, 1)
147+ cpu_input3, npu_input3 = create_common_tensor(item[2], 0, 1)
148+ scalar1 = self.generate_scalar(item[3], 0, 2)
149+ scalar2 = self.generate_scalar(item[3], 0, 2)
150+ cpu_output = cpu_op_exec_fp16(
151+ cpu_input1, cpu_input2, cpu_input3, scalar1, scalar2
152+ )
153+ npu_output = self.npu_op_exec(
154+ npu_input1, npu_input2, npu_input3, scalar1, scalar2
155+ )
156+ self.assertRtolEqual(cpu_output, npu_output, prec=1.0e-3, prec16=1.0e-2)
157+ 
158+ 
159+if __name__ == "__main__":
160+ run_tests()
Atest/test_base_ops/test_batch_nms.py+38-0
@@ -0,0 +1,38 @@
1+import torch
2+import torch_npu
3+ 
4+from torch_npu.testing.testcase import TestCase, run_tests
5+from torch_npu.testing.common_utils import create_common_tensor
6+ 
7+ 
8+class TesBatchNms(TestCase):
9+ def test_batch_nms_shape_format(self):
10+ boxes = torch.randn(8, 4, 1, 4).npu()
11+ scores = torch.randn(8, 4, 1).npu()
12+ boxes_fp16 = boxes.half()
13+ scores_fp16 = scores.half()
14+ nmsed_boxes, nmsed_scores, nmsed_classes, nmsed_num = torch_npu.npu_batch_nms(
15+ boxes, scores, 0.3, 0.5, 4, 4
16+ )
17+ boxes1, scores1, classes1, num1 = torch_npu.npu_batch_nms(
18+ boxes_fp16, scores_fp16, 0.3, 0.5, 4, 4
19+ )
20+ expedt_nmsed_classes = torch.tensor(
21+ [
22+ [0.0000, 0.0000, 0.0000, 0.0000],
23+ [0.0000, 0.0000, 0.0000, 0.0000],
24+ [0.0000, 0.0000, 0.0000, 0.0000],
25+ [0.0000, 0.0000, 0.0000, 0.0000],
26+ [0.0000, 0.0000, 0.0000, 0.0000],
27+ [0.0000, 0.0000, 0.0000, 0.0000],
28+ [0.0000, 0.0000, 0.0000, 0.0000],
29+ [0.0000, 0.0000, 0.0000, 0.0000],
30+ ],
31+ dtype=torch.float32,
32+ )
33+ self.assertRtolEqual(expedt_nmsed_classes, nmsed_classes.cpu())
34+ self.assertRtolEqual(expedt_nmsed_classes.half(), classes1.cpu())
35+ 
36+ 
37+if __name__ == "__main__":
38+ run_tests()
Atest/test_base_ops/test_batch_norm.py+96-0
@@ -0,0 +1,96 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestBatchNorm(TestCase):
10+ def cpu_op_exec(self, input1, num_features, affine):
11+ flag = False
12+ if input1.dtype == torch.float16:
13+ input1 = input1.to(torch.float32)
14+ flag = True
15+ m = torch.nn.BatchNorm2d(num_features, affine=affine)
16+ output = m(input1)
17+ if flag:
18+ output = output.to(torch.float16)
19+ output_cpu = output.detach().numpy()
20+ return output_cpu
21+ 
22+ def npu_op_exec_new(self, input1, num_features, affine):
23+ m = torch.nn.BatchNorm2d(num_features, affine=affine)
24+ m = m.to("npu")
25+ output = m(input1)
26+ output = output.to("cpu").detach().numpy()
27+ return output
28+ 
29+ def test_batchnorm_shape_format(self):
30+ format_list = [-1, 3, 0]
31+ shape_list = [
32+ (10, 32, 35, 45),
33+ (256, 100, 7, 7),
34+ (256, 100, 14, 14),
35+ (10, 56, 28, 28),
36+ (10, 56, 56, 56),
37+ ]
38+ affine_list = [True]
39+ dtype_list = [np.float16, np.float32]
40+ # pylint:disable = complicate-comprehension
41+ shape_format = [
42+ [[z, i, j], h]
43+ for z in dtype_list
44+ for i in format_list
45+ for j in shape_list
46+ for h in affine_list
47+ ]
48+ 
49+ for item in shape_format:
50+ cpu_input1, npu_input1 = create_common_tensor(item[0], 0, 10)
51+ cpu_output = self.cpu_op_exec(cpu_input1, item[0][2][1], item[1])
52+ npu_output = self.npu_op_exec_new(npu_input1, item[0][2][1], item[1])
53+ self.assertRtolEqual(cpu_output, npu_output)
54+ 
55+ def cpu_op_exec_3d(self, input1, num_features, affine):
56+ flag = False
57+ if input1.dtype == torch.float16:
58+ input1 = input1.to(torch.float32)
59+ flag = True
60+ m = torch.nn.BatchNorm3d(num_features, affine=affine)
61+ output = m(input1)
62+ if flag:
63+ output = output.to(torch.float16)
64+ output_cpu = output.detach().numpy()
65+ return output_cpu
66+ 
67+ def npu_op_exec_new_3d(self, input1, num_features, affine):
68+ m = torch.nn.BatchNorm3d(num_features, affine=affine)
69+ m = m.to("npu")
70+ output = m(input1)
71+ output = output.to("cpu").detach().numpy()
72+ return output
73+ 
74+ def test_batchnorm_shape_format_3d(self):
75+ format_list = [-1]
76+ shape_list = [[8, 512, 4, 28, 28], [8, 256, 8, 56, 56]]
77+ affine_list = [True]
78+ dtype_list = [np.float16, np.float32]
79+ # pylint:disable = complicate-comprehension
80+ shape_format = [
81+ [[z, i, j], h]
82+ for z in dtype_list
83+ for i in format_list
84+ for j in shape_list
85+ for h in affine_list
86+ ]
87+ 
88+ for item in shape_format:
89+ cpu_input1, npu_input1 = create_common_tensor(item[0], 0, 10)
90+ cpu_output = self.cpu_op_exec_3d(cpu_input1, item[0][2][1], item[1])
91+ npu_output = self.npu_op_exec_new_3d(npu_input1, item[0][2][1], item[1])
92+ self.assertRtolEqual(cpu_output, npu_output)
93+ 
94+ 
95+if __name__ == "__main__":
96+ run_tests()
Atest/test_base_ops/test_batch_norm_elemt.py+33-0
@@ -0,0 +1,33 @@
1+import torch
2+import torch_npu
3+ 
4+from torch_npu.testing.testcase import TestCase, run_tests
5+ 
6+ 
7+class TestBatchNormElemt(TestCase):
8+ def test_batch_norm_elent(self):
9+ input1 = torch.tensor([[1.0], [2.0], [3.0]]).npu()
10+ weight = torch.tensor([1.0]).npu()
11+ bias = torch.tensor([10.0]).npu()
12+ mean = torch.tensor([2.0]).npu()
13+ invstd = torch.tensor([2.0]).npu()
14+ eps = 1e-5
15+ out = torch.batch_norm_elemt(input1, weight, bias, mean, invstd, eps)
16+ expect_out = torch.tensor([[8.0], [10.0], [12.0]])
17+ self.assertRtolEqual(expect_out, out.cpu())
18+ 
19+ def test_batch_norm_elent_out(self):
20+ input1 = torch.tensor([[1.0], [2.0], [3.0]]).npu()
21+ weight = torch.tensor([1.0]).npu()
22+ bias = torch.tensor([10.0]).npu()
23+ mean = torch.tensor([2.0]).npu()
24+ invstd = torch.tensor([2.0]).npu()
25+ eps = 1e-5
26+ out = torch.randn((3, 1), dtype=torch.float32).npu()
27+ torch.batch_norm_elemt(input1, weight, bias, mean, invstd, eps, out=out)
28+ expect_out = torch.tensor([[8.0], [10.0], [12.0]])
29+ self.assertRtolEqual(expect_out, out.cpu())
30+ 
31+ 
32+if __name__ == "__main__":
33+ run_tests()
Atest/test_base_ops/test_batch_norm_reduce.py+36-0
@@ -0,0 +1,36 @@
1+import torch
2+import numpy as np
3+ 
4+import torch_npu
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestBatchNormReduce(TestCase):
10+ def cuda_op_exec(self, input_data):
11+ cpu_sum = torch.sum(input_data, dim=[0, 2, 3])
12+ cpu_square_sum = torch.sum(input_data * input_data, dim=[0, 2, 3])
13+ return cpu_sum.numpy(), cpu_square_sum.numpy()
14+ 
15+ def npu_op_exec(self, *args):
16+ npu_sum, npu_square_sum = torch_npu.batch_norm_reduce(*args)
17+ out_sum = npu_sum.cpu().numpy()
18+ out_square_sum = npu_square_sum.cpu().numpy()
19+ return out_sum, out_square_sum
20+ 
21+ def test_batch_norm_reduce(self):
22+ np.random.seed(1234)
23+ shape_format = [
24+ [[np.float32, -1, [2, 3, 12, 12]], 1e-5],
25+ ]
26+ for item in shape_format:
27+ cpu_input1, npu_inputfp32 = create_common_tensor(item[0], 1, 10)
28+ cpu_output = self.cuda_op_exec(cpu_input1)
29+ npu_outputfp32 = self.npu_op_exec(npu_inputfp32, item[-1])
30+ 
31+ self.assertRtolEqual(cpu_output[0], npu_outputfp32[0])
32+ self.assertRtolEqual(cpu_output[1], npu_outputfp32[1], 1e-2)
33+ 
34+ 
35+if __name__ == "__main__":
36+ run_tests()
Atest/test_base_ops/test_batch_norm_stats.py+48-0
@@ -0,0 +1,48 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestBatchNormStats(TestCase):
10+ def cuda_op_exec(self, *args):
11+ cpu_mean, cpu_invstd = torch.batch_norm_stats(*args)
12+ return cpu_mean.numpy(), cpu_invstd.numpy()
13+ 
14+ def cuda_expect_result(self):
15+ cpu_output0 = np.array([5.401827, 5.444219, 5.7656665], dtype=np.float32)
16+ cpu_output1 = np.array([0.37123242, 0.38706362, 0.37435925], dtype=np.float32)
17+ return cpu_output0, cpu_output1
18+ 
19+ def npu_op_exec(self, *args):
20+ npu_mean, npu_invstd = torch.batch_norm_stats(*args)
21+ out_mean = npu_mean.cpu().numpy()
22+ out_invstd = npu_invstd.cpu().numpy()
23+ return out_mean, out_invstd
24+ 
25+ def test_batch_norm_stats(self):
26+ np.random.seed(1234)
27+ shape_format = [
28+ [[np.float16, -1, [2, 3, 12, 12]], 1e-5],
29+ ]
30+ for item in shape_format:
31+ cpu_input1, npu_inputfp16 = create_common_tensor(item[0], 1, 10)
32+ npu_input1fp32 = npu_inputfp16.float()
33+ if torch.cuda.is_available():
34+ cpu_output = self.cuda_op_exec(cpu_input1.cuda(), item[-1])
35+ else:
36+ cpu_output = self.cuda_expect_result()
37+ npu_outputfp16 = self.npu_op_exec(npu_inputfp16, item[-1])
38+ npu_outputfp32 = self.npu_op_exec(npu_inputfp16, item[-1])
39+ 
40+ self.assertRtolEqual(cpu_output[0], npu_outputfp16[0])
41+ self.assertRtolEqual(cpu_output[1], npu_outputfp16[1], 1e-2)
42+ 
43+ self.assertRtolEqual(cpu_output[0], npu_outputfp32[0])
44+ self.assertRtolEqual(cpu_output[1], npu_outputfp32[1], 1e-2)
45+ 
46+ 
47+if __name__ == "__main__":
48+ run_tests()
Atest/test_base_ops/test_batchnorm_backward_elemt.py+95-0
@@ -0,0 +1,95 @@
1+import torch
2+import torch_npu
3+from torch_npu.testing.testcase import TestCase, run_tests
4+ 
5+ 
6+class TestBatchNormBackwardElemt(TestCase):
7+ def test_batch_norm_backward_elemt_4d(self):
8+ grad_output = torch.ones([2, 3, 1, 4]).npu()
9+ input1 = torch.ones([2, 3, 1, 4]).npu()
10+ mean = torch.tensor([8.0, 5.0, 9.0]).npu()
11+ invstd = torch.tensor([2.0, 1.0, 2.0]).npu()
12+ weight = torch.tensor([1.0, 1.0, 4.0]).npu()
13+ mean_dy = torch.tensor([2.0, 2.0, 6.0]).npu()
14+ mean_dy_xmn = torch.tensor([2.0, 3.0, 11.0]).npu()
15+ count_tensor = torch.tensor([5, 5, 5], dtype=torch.int32).npu()
16+ 
17+ grad_input = torch.batch_norm_backward_elemt(
18+ grad_output,
19+ input1,
20+ mean,
21+ invstd,
22+ weight,
23+ mean_dy,
24+ mean_dy_xmn,
25+ count_tensor,
26+ )
27+ cuda_expect_out = torch.tensor(
28+ [
29+ [
30+ [[9.2000, 9.2000, 9.2000, 9.2000]],
31+ [[1.6667, 1.6667, 1.6667, 1.6667]],
32+ [[192.5333, 192.5333, 192.5333, 192.5333]],
33+ ],
34+ [
35+ [[9.2000, 9.2000, 9.2000, 9.2000]],
36+ [[1.6667, 1.6667, 1.6667, 1.6667]],
37+ [[192.5333, 192.5333, 192.5333, 192.5333]],
38+ ],
39+ ]
40+ )
41+ self.assertRtolEqual(grad_input.cpu(), cuda_expect_out)
42+ 
43+ def test_batch_norm_backward_elemt_2d(self):
44+ grad_output = torch.ones([2, 3]).npu()
45+ input1 = torch.ones([2, 3]).npu()
46+ mean = torch.tensor([8.0, 5.0, 9.0]).npu()
47+ invstd = torch.tensor([2.0, 1.0, 2.0]).npu()
48+ weight = torch.tensor([1.0, 1.0, 4.0]).npu()
49+ mean_dy = torch.tensor([2.0, 2.0, 6.0]).npu()
50+ mean_dy_xmn = torch.tensor([2.0, 3.0, 11.0]).npu()
51+ count_tensor = torch.tensor([5, 5, 5], dtype=torch.int32).npu()
52+ 
53+ grad_input = torch.batch_norm_backward_elemt(
54+ grad_output,
55+ input1,
56+ mean,
57+ invstd,
58+ weight,
59+ mean_dy,
60+ mean_dy_xmn,
61+ count_tensor,
62+ )
63+ cuda_expect_out = torch.tensor(
64+ [[9.2000, 1.6667, 192.5333], [9.2000, 1.6667, 192.5333]]
65+ )
66+ self.assertRtolEqual(grad_input.cpu(), cuda_expect_out)
67+ 
68+ def test_batch_norm_backward_elemt_2d_fp(self):
69+ grad_output = torch.ones([2, 3]).npu()
70+ input1 = torch.ones([2, 3]).npu()
71+ mean = torch.tensor([8.123456, 5.147125, 9.365778]).npu()
72+ invstd = torch.tensor([2.65485, 1.36541, 2.25879]).npu()
73+ weight = torch.tensor([1.36987, 1.36944, 4.25774]).npu()
74+ mean_dy = torch.tensor([2.0, 2.0, 6.0]).npu()
75+ mean_dy_xmn = torch.tensor([2.0, 3.0, 11.0]).npu()
76+ count_tensor = torch.tensor([5, 5, 5], dtype=torch.int32).npu()
77+ 
78+ grad_input = torch.batch_norm_backward_elemt(
79+ grad_output,
80+ input1,
81+ mean,
82+ invstd,
83+ weight,
84+ mean_dy,
85+ mean_dy_xmn,
86+ count_tensor,
87+ )
88+ cuda_expect_out = torch.tensor(
89+ [[27.4980, 4.5119, 306.8037], [27.4980, 4.5119, 306.8037]]
90+ )
91+ self.assertRtolEqual(grad_input.cpu(), cuda_expect_out)
92+ 
93+ 
94+if __name__ == "__main__":
95+ run_tests()
Atest/test_base_ops/test_batchnorm_backward_eval.py+64-0
@@ -0,0 +1,64 @@
1+import torch
2+import torch.nn as nn
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+ 
7+ 
8+class Model(nn.Module):
9+ def __init__(self, in_channels):
10+ super(Model, self).__init__()
11+ self.op1 = nn.Conv2d(in_channels, in_channels, 1)
12+ self.op2 = nn.BatchNorm2d(in_channels)
13+ self.op2.running_mean = torch.tensor([i / 1000 for i in range(in_channels)])
14+ self.op2.running_var = torch.tensor([i / 1000 for i in range(in_channels)])
15+ self.op3 = nn.Conv2d(in_channels, in_channels, 1)
16+ 
17+ def forward(self, x):
18+ self.op2.eval()
19+ x = self.op1(x)
20+ x = self.op2(x)
21+ x = self.op3(x)
22+ return x
23+ 
24+ 
25+class TestBn2dEval(TestCase):
26+ def test_batchnorm_backward_eval(self, device="npu"):
27+ model = Model(in_channels=64)
28+ cpu_tensor = torch.randn(32, 64, 14, 14)
29+ npu_tensor = cpu_tensor.npu()
30+ cpu_tensor.requires_grad = True
31+ npu_tensor.requires_grad = True
32+ 
33+ for i in range(1):
34+ out = model(cpu_tensor)
35+ loss = out.sum()
36+ loss.backward()
37+ cpuout = out
38+ cpu_grad_list = []
39+ for name, module in model.named_parameters():
40+ cpu_grad_list.append(module.grad)
41+ module.grad = None
42+ 
43+ model = model.npu()
44+ out = model(npu_tensor)
45+ loss = out.sum()
46+ loss.backward()
47+ npu_grad_list = []
48+ for name, module in model.named_parameters():
49+ npu_grad_list.append(module.grad.cpu())
50+ 
51+ cpu_grad = cpu_tensor.grad
52+ npu_grad = npu_tensor.grad
53+ # TODO(ascend): Insufficient precision
54+ # 精度未满足 self.assertRtolEqual(cpu_grad.numpy(), npu_grad.cpu().numpy())
55+ self.assertRtolEqual(cpu_grad.numpy(), npu_grad.cpu().numpy(), 0.01)
56+ 
57+ for cpu_grad, npu_grad in zip(cpu_grad_list, npu_grad_list):
58+ # TODO(ascend): Insufficient precision
59+ # 精度未满足 self.assertRtolEqual(cpu_grad.numpy(), npu_grad.numpy())
60+ self.assertRtolEqual(cpu_grad.numpy(), npu_grad.numpy(), 0.1)
61+ 
62+ 
63+if __name__ == "__main__":
64+ run_tests()
Atest/test_base_ops/test_batchnorm_backward_reduce.py+95-0
@@ -0,0 +1,95 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestBatchNormBackwardReduce(TestCase):
10+ def expect_result(self):
11+ cpu_output0 = np.array([449.18185, 464.78906, 471.87485], dtype=np.float32)
12+ cpu_output1 = np.array([831.08484, 2112.0908, 259.91568], dtype=np.float32)
13+ cpu_output2 = np.array([6091.88, 3367.45, 1824.8948], dtype=np.float32)
14+ cpu_output3 = np.array([449.18185, 464.78906, 471.87485], dtype=np.float32)
15+ list1 = [cpu_output0, cpu_output1, cpu_output2, cpu_output3]
16+ return list1
17+ 
18+ def npu_op_exec(self, *args):
19+ (
20+ npu_sum_dy,
21+ npu_sum_dy_xmu,
22+ npu_grad_weight,
23+ npu_grad_bias,
24+ ) = torch.batch_norm_backward_reduce(*args)
25+ list2 = [
26+ npu_sum_dy.cpu().numpy(),
27+ npu_sum_dy_xmu.cpu().numpy(),
28+ npu_grad_weight.cpu().numpy(),
29+ npu_grad_bias.cpu().numpy(),
30+ ]
31+ return list2
32+ 
33+ def test_batch_norm_backward_reduce_mix_precision(self):
34+ np.random.seed(1234)
35+ shape_format = [
36+ [[np.float16, -1, [1, 3, 9, 9]], [np.float32, -1, [3]], True, True, True],
37+ ]
38+ for item in shape_format:
39+ _, npu_grad_output_fp16 = create_common_tensor(item[0], 1, 10)
40+ _, npu_input1_fp16 = create_common_tensor(item[0], 1, 10)
41+ _, npu_mean = create_common_tensor(item[1], 1, 10)
42+ _, npu_invstd = create_common_tensor(item[1], 1, 10)
43+ _, npu_weight = create_common_tensor(item[1], 1, 10)
44+ npu_grad_output_fp32 = npu_grad_output_fp16.float()
45+ npu_input1_fp32 = npu_input1_fp16.float()
46+ 
47+ npu_output_fp16 = self.npu_op_exec(
48+ npu_grad_output_fp16,
49+ npu_input1_fp16,
50+ npu_mean,
51+ npu_invstd,
52+ npu_weight,
53+ *item[-3:]
54+ )
55+ npu_output_fp32 = self.npu_op_exec(
56+ npu_grad_output_fp32,
57+ npu_input1_fp32,
58+ npu_mean,
59+ npu_invstd,
60+ npu_weight,
61+ *item[-3:]
62+ )
63+ for out16, out32 in zip(npu_output_fp16, npu_output_fp32):
64+ self.assertRtolEqual(out16, out32)
65+ 
66+ def test_batch_norm_backward_reduce(self):
67+ np.random.seed(1234)
68+ shape_format = [
69+ [[np.float32, -1, [1, 3, 9, 9]], [np.float32, -1, [3]], True, True, True],
70+ ]
71+ for item in shape_format:
72+ _, npu_grad_output = create_common_tensor(item[0], 1, 10)
73+ _, npu_input1 = create_common_tensor(item[0], 1, 10)
74+ _, npu_mean = create_common_tensor(item[1], 1, 10)
75+ _, npu_invstd = create_common_tensor(item[1], 1, 10)
76+ _, npu_weight = create_common_tensor(item[1], 1, 10)
77+ 
78+ list1 = self.expect_result()
79+ list2 = self.npu_op_exec(
80+ npu_grad_output,
81+ npu_input1,
82+ npu_mean,
83+ npu_invstd,
84+ npu_weight,
85+ *item[-3:]
86+ )
87+ 
88+ self.assertRtolEqual(list1[0], list2[0])
89+ self.assertRtolEqual(list1[1], list2[1])
90+ self.assertRtolEqual(list1[2], list2[2])
91+ self.assertRtolEqual(list1[3], list2[3])
92+ 
93+ 
94+if __name__ == "__main__":
95+ run_tests()
Atest/test_v1r11_ops/test_add.py+465-0
@@ -0,0 +1,465 @@
1+# Copyright (c) 2020, Huawei Technologies.All rights reserved.
2+#
3+# Licensed under the BSD 3-Clause License (the "License");
4+# you may not use this file except in compliance with the License.
5+# You may obtain a copy of the License at
6+#
7+# https://opensource.org/licenses/BSD-3-Clause
8+#
9+# Unless required by applicable law or agreed to in writing, software
10+# distributed under the License is distributed on an "AS IS" BASIS,
11+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+# See the License for the specific language governing permissions and
13+# limitations under the License.
14+ 
15+ 
16+import torch
17+import numpy as np
18+ 
19+import torch_npu
20+from torch_npu.testing.testcase import TestCase, run_tests
21+from torch_npu.testing.common_utils import create_common_tensor
22+ 
23+ 
24+class TestAdd(TestCase):
25+ 
26+ def cpu_op_out_exec(self, input1, input2, output):
27+ torch.add(input1, input2, alpha=1, out=output)
28+ output = output.numpy()
29+ return output
30+ 
31+ def npu_op_out_exec_new(self, input1, input2, output):
32+ torch.add(input1, input2, alpha=1, out=output)
33+ output = output.to("cpu")
34+ output = output.numpy()
35+ return output
36+ 
37+ def cpu_op_exec(self, input1, input2):
38+ output = torch.add(input1, input2, alpha=1)
39+ output = output.numpy()
40+ return output
41+ 
42+ def npu_op_exec_new(self, input1, input2):
43+ output = torch.add(input1, input2, alpha=1)
44+ output = output.to("cpu")
45+ output = output.numpy()
46+ return output
47+ 
48+ def cpu_op_exec_alpha(self, input1, input2):
49+ output = torch.add(input1, input2, alpha=3)
50+ output = output.numpy()
51+ return output
52+ 
53+ def npu_op_exec_new_alpha(self, input1, input2):
54+ output = torch.add(input1, input2, alpha=3)
55+ output = output.to("cpu")
56+ output = output.numpy()
57+ return output
58+ 
59+ def cpu_op_scalar_exec(self, input1, scalar):
60+ output = torch.add(input1, scalar, alpha=1)
61+ output = output.numpy()
62+ return output
63+ 
64+ def npu_op_scalar_exec_new(self, input1, scalar):
65+ output = torch.add(input1, scalar, alpha=1)
66+ output = output.to("cpu")
67+ output = output.numpy()
68+ return output
69+ 
70+ def cpu_op_scalar_exec_alpha(self, input1, scalar):
71+ output = torch.add(input1, scalar, alpha=3)
72+ output = output.numpy()
73+ return output
74+ 
75+ def npu_op_scalar_exec_new_alpha(self, input1, scalar):
76+ output = torch.add(input1, scalar, alpha=3)
77+ output = output.to("cpu")
78+ output = output.numpy()
79+ return output
80+ 
81+ def add_scalar_result(self, shape_format):
82+ for item in shape_format:
83+ cpu_input, npu_input = create_common_tensor(item[0], 0, 100)
84+ if cpu_input.dtype == torch.float16:
85+ cpu_input = cpu_input.to(torch.float32)
86+ cpu_output = self.cpu_op_scalar_exec(cpu_input, item[1])
87+ npu_output = self.npu_op_exec_new(npu_input, item[1])
88+ cpu_output = cpu_output.astype(npu_output.dtype)
89+ 
90+ self.assertRtolEqual(cpu_output, npu_output)
91+ 
92+ def add_scalar_alpha_result(self, shape_format):
93+ for item in shape_format:
94+ cpu_input, npu_input = create_common_tensor(item[0], 0, 100)
95+ if cpu_input.dtype == torch.float16:
96+ cpu_input = cpu_input.to(torch.float32)
97+ cpu_output = self.cpu_op_scalar_exec_alpha(cpu_input, item[1])
98+ npu_output = self.npu_op_scalar_exec_new_alpha(npu_input, item[1])
99+ cpu_output = cpu_output.astype(npu_output.dtype)
100+ 
101+ self.assertRtolEqual(cpu_output, npu_output)
102+ 
103+ def add_result(self, shape_format):
104+ for item in shape_format:
105+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 100)
106+ cpu_input2, npu_input2 = create_common_tensor(item, 0, 100)
107+ if cpu_input1.dtype == torch.float16:
108+ cpu_input1 = cpu_input1.to(torch.float32)
109+ cpu_input2 = cpu_input2.to(torch.float32)
110+ 
111+ cpu_output = self.cpu_op_exec(cpu_input1, cpu_input2)
112+ npu_output = self.npu_op_exec_new(npu_input1, npu_input2)
113+ cpu_output = cpu_output.astype(npu_output.dtype)
114+ 
115+ self.assertRtolEqual(cpu_output, npu_output)
116+ 
117+ def add_out_result(self, shape_format):
118+ for item in shape_format:
119+ cpuout = torch.randn(3)
120+ npuout = torch.randn(3).to("npu")
121+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 100)
122+ cpu_input2, npu_input2 = create_common_tensor(item, 0, 100)
123+ if cpu_input1.dtype == torch.float16:
124+ cpu_input1 = cpu_input1.to(torch.float32)
125+ cpu_input2 = cpu_input2.to(torch.float32)
126+ 
127+ cpu_output = self.cpu_op_out_exec(cpu_input1, cpu_input2, cpuout)
128+ npu_output = self.npu_op_out_exec_new(npu_input1, npu_input2, npuout)
129+ cpu_output = cpu_output.astype(npu_output.dtype)
130+ 
131+ self.assertRtolEqual(cpu_output, npu_output)
132+ 
133+ def add_alpha_result(self, shape_format):
134+ for item in shape_format:
135+ cpu_input1, npu_input1 = create_common_tensor(item, 0, 100)
136+ cpu_input2, npu_input2 = create_common_tensor(item, 0, 100)
137+ if cpu_input1.dtype == torch.float16:
138+ cpu_input1 = cpu_input1.to(torch.float32)
139+ cpu_input2 = cpu_input2.to(torch.float32)
140+ 
141+ cpu_output = self.cpu_op_exec_alpha(cpu_input1, cpu_input2)
142+ npu_output = self.npu_op_exec_new_alpha(npu_input1, npu_input2)
143+ cpu_output = cpu_output.astype(npu_output.dtype)
144+ 
145+ self.assertRtolEqual(cpu_output, npu_output)
146+ 
147+ def test_add_scalar_shape_format_fp16_1d(self):
148+ format_list = [0, 3]
149+ scalar_list = [0, 1]
150+ shape_format = [
151+ [[np.float16, i, [18]], k] for i in format_list for k in scalar_list
152+ ]
153+ self.add_scalar_result(shape_format)
154+ 
155+ def test_add_scalar_shape_format_fp32_1d(self):
156+ format_list = [0, 3]
157+ scalar_list = [0, 1]
158+ shape_format = [
159+ [[np.float32, i, [18]], k] for i in format_list for k in scalar_list
160+ ]
161+ self.add_scalar_result(shape_format)
162+ 
163+ def test_add_scalar_shape_format_fp16_2d(self):
164+ format_list = [0, 3, 29]
165+ scalar_list = [0, 1]
166+ shape_format = [
167+ [[np.float16, i, [5, 256]], k] for i in format_list for k in scalar_list
168+ ]
169+ self.add_scalar_result(shape_format)
170+ 
171+ def test_add_scalar_shape_format_fp32_2d(self):
172+ format_list = [0, 3, 29]
173+ scalar_list = [0, 1]
174+ shape_format = [
175+ [[np.float32, i, [5, 256]], k] for i in format_list for k in scalar_list
176+ ]
177+ self.add_scalar_result(shape_format)
178+ 
179+ def test_add_scalar_shape_format_fp16_3d(self):
180+ format_list = [0, 3, 29]
181+ scalar_list = [0, 1]
182+ shape_format = [
183+ [[np.float16, i, [32, 3, 3]], k] for i in format_list for k in scalar_list
184+ ]
185+ self.add_scalar_result(shape_format)
186+ 
187+ def test_add_scalar_shape_format_fp32_3d(self):
188+ format_list = [0, 3, 29]
189+ scalar_list = [0, 1]
190+ shape_format = [
191+ [[np.float32, i, [32, 3, 3]], k] for i in format_list for k in scalar_list
192+ ]
193+ self.add_scalar_result(shape_format)
194+ 
195+ def test_add_scalar_shape_format_fp16_4d(self):
196+ format_list = [0, 3, 29]
197+ scalar_list = [0, 1]
198+ shape_format = [
199+ [[np.float16, i, [64, 112, 7, 7]], k] for i in format_list for k in scalar_list
200+ ]
201+ self.add_scalar_result(shape_format)
202+ 
203+ def test_add_scalar_shape_format_fp32_4d(self):
204+ format_list = [0, 3, 29]
205+ scalar_list = [0, 1]
206+ shape_format = [
207+ [[np.float32, i, [64, 112, 7, 7]], k] for i in format_list for k in scalar_list
208+ ]
209+ self.add_scalar_result(shape_format)
210+ 
211+ def test_add_scalar_shape_format_fp16_1d(self):
212+ format_list = [0, 3]
213+ scalar_list = [0, 1]
214+ shape_format = [
215+ [[np.float16, i, [18]], k] for i in format_list for k in scalar_list
216+ ]
217+ self.add_scalar_alpha_result(shape_format)
218+ 
219+ def test_add_scalar_shape_format_fp32_1d(self):
220+ format_list = [0, 3]
221+ scalar_list = [0, 1]
222+ shape_format = [
223+ [[np.float32, i, [18]], k] for i in format_list for k in scalar_list
224+ ]
225+ self.add_scalar_alpha_result(shape_format)
226+ 
227+ def test_add_scalar_shape_format_fp16_2d(self):
228+ format_list = [0, 3, 29]
229+ scalar_list = [0, 1]
230+ shape_format = [
231+ [[np.float16, i, [5, 256]], k] for i in format_list for k in scalar_list
232+ ]
233+ self.add_scalar_alpha_result(shape_format)
234+ 
235+ def test_add_scalar_shape_format_fp32_2d(self):
236+ format_list = [0, 3, 29]
237+ scalar_list = [0, 1]
238+ shape_format = [
239+ [[np.float32, i, [5, 256]], k] for i in format_list for k in scalar_list
240+ ]
241+ self.add_scalar_alpha_result(shape_format)
242+ 
243+ def test_add_scalar_shape_format_fp16_3d(self):
244+ format_list = [0, 3, 29]
245+ scalar_list = [0, 1]
246+ shape_format = [
247+ [[np.float16, i, [32, 3, 3]], k] for i in format_list for k in scalar_list
248+ ]
249+ self.add_scalar_alpha_result(shape_format)
250+ 
251+ def test_add_scalar_shape_format_fp32_3d(self):
252+ format_list = [0, 3, 29]
253+ scalar_list = [0, 1]
254+ shape_format = [
255+ [[np.float32, i, [32, 3, 3]], k] for i in format_list for k in scalar_list
256+ ]
257+ self.add_scalar_alpha_result(shape_format)
258+ 
259+ def test_add_scalar_shape_format_fp16_4d(self):
260+ format_list = [0, 3, 29]
261+ scalar_list = [0, 1]
262+ shape_format = [
263+ [[np.float16, i, [64, 112, 7, 7]], k] for i in format_list for k in scalar_list
264+ ]
265+ self.add_scalar_alpha_result(shape_format)
266+ 
267+ def test_add_scalar_shape_format_fp32_4d(self):
268+ format_list = [0, 3, 29]
269+ scalar_list = [0, 1]
270+ shape_format = [
271+ [[np.float32, i, [64, 112, 7, 7]], k] for i in format_list for k in scalar_list
272+ ]
273+ self.add_scalar_alpha_result(shape_format)
274+ 
275+ def test_add_shape_format_fp16_1d(self):
276+ format_list = [0, 3]
277+ shape_format = [
278+ [np.float16, i, [64]] for i in format_list
279+ ]
280+ self.add_result(shape_format)
281+ 
282+ def test_add_shape_format_fp32_1d(self):
283+ format_list = [0, 3]
284+ shape_format = [
285+ [np.float32, i, [64]] for i in format_list
286+ ]
287+ self.add_result(shape_format)
288+ 
289+ def test_add_shape_format_fp16_2d(self):
290+ format_list = [0, 3, 29]
291+ shape_format = [
292+ [np.float16, i, [5, 256]] for i in format_list
293+ ]
294+ self.add_result(shape_format)
295+ 
296+ def test_add_shape_format_fp32_2d(self):
297+ format_list = [0, 3, 29]
298+ shape_format = [
299+ [np.float32, i, [5, 256]] for i in format_list
300+ ]
301+ self.add_result(shape_format)
302+ 
303+ def test_add_shape_format_fp16_3d(self):
304+ format_list = [0, 3, 29]
305+ shape_format = [
306+ [np.float16, i, [32, 3, 3]] for i in format_list
307+ ]
308+ self.add_result(shape_format)
309+ 
310+ def test_add_shape_format_fp32_3d(self):
311+ format_list = [0, 3, 29]
312+ shape_format = [
313+ [np.float32, i, [32, 3, 3]] for i in format_list
314+ ]
315+ self.add_result(shape_format)
316+ 
317+ def test_add_shape_format_fp16_4d(self):
318+ format_list = [0, 3, 29]
319+ shape_format = [
320+ [np.float16, i, [64, 112, 7, 7]] for i in format_list
321+ ]
322+ self.add_result(shape_format)
323+ 
324+ def test_add_shape_format_fp32_4d(self):
325+ format_list = [0, 3, 29]
326+ shape_format = [
327+ [np.float32, i, [64, 112, 7, 7]] for i in format_list
328+ ]
329+ self.add_result(shape_format)
330+ 
331+ def test_add_shape_format_fp16_1d(self):
332+ format_list = [0, 3]
333+ shape_format = [
334+ [np.float16, i, [64]] for i in format_list
335+ ]
336+ self.add_alpha_result(shape_format)
337+ 
338+ def test_add_shape_format_fp32_1d(self):
339+ format_list = [0, 3]
340+ shape_format = [
341+ [np.float32, i, [64]] for i in format_list
342+ ]
343+ self.add_alpha_result(shape_format)
344+ 
345+ def test_add_shape_format_fp16_2d(self):
346+ format_list = [0, 3, 29]
347+ shape_format = [
348+ [np.float16, i, [5, 256]] for i in format_list
349+ ]
350+ self.add_alpha_result(shape_format)
351+ 
352+ def test_add_shape_format_fp32_2d(self):
353+ format_list = [0, 3, 29]
354+ shape_format = [
355+ [np.float32, i, [5, 256]] for i in format_list
356+ ]
357+ self.add_alpha_result(shape_format)
358+ 
359+ def test_add_shape_format_fp16_3d(self):
360+ format_list = [0, 3, 29]
361+ shape_format = [
362+ [np.float16, i, [32, 3, 3]] for i in format_list
363+ ]
364+ self.add_alpha_result(shape_format)
365+ 
366+ def test_add_shape_format_fp32_3d(self):
367+ format_list = [0, 3, 29]
368+ shape_format = [
369+ [np.float32, i, [32, 3, 3]] for i in format_list
370+ ]
371+ self.add_alpha_result(shape_format)
372+ 
373+ def test_add_shape_format_fp16_4d(self):
374+ format_list = [0, 3, 29]
375+ shape_format = [
376+ [np.float16, i, [64, 112, 7, 7]] for i in format_list
377+ ]
378+ self.add_alpha_result(shape_format)
379+ 
380+ def test_add_shape_format_fp32_4d(self):
381+ format_list = [0, 3, 29]
382+ shape_format = [
383+ [np.float32, i, [64, 112, 7, 7]] for i in format_list
384+ ]
385+ self.add_alpha_result(shape_format)
386+ 
387+ def test_add_mix_dtype(self):
388+ cpu_input1, npu_input1 = create_common_tensor([np.int32, 0, (2, 3)], 1, 100)
389+ cpu_input2, npu_input2 = create_common_tensor([np.float32, 0, (2, 3)], 1, 100)
390+ cpu_output = torch.add(cpu_input1, cpu_input2)
391+ npu_output = torch.add(npu_input1, npu_input2)
392+ npu_output = npu_output.to("cpu")
393+ self.assertRtolEqual(cpu_output, npu_output)
394+ 
395+ def test_add_scalar_check_5d_5d_match(self):
396+ ca = torch.randn(4)
397+ cb = ca.view(2, 2).transpose(1, 0)
398+ na = ca.npu()
399+ nb = cb.npu()
400+ caout = torch.add(ca, 1)
401+ cbout = torch.add(cb, 1)
402+ naout = torch.add(na, 1)
403+ nbout = torch.add(nb, 1)
404+ naout = naout.to("cpu")
405+ nbout = nbout.to("cpu")
406+ self.assertRtolEqual(caout, naout)
407+ self.assertRtolEqual(cbout, nbout)
408+ 
409+ def test_add_different_dtype(self):
410+ cpu_x1 = torch.rand(2, 3, 4)
411+ cpu_other1 = torch.rand(2, 3, 4).uniform_(1, 10).long()
412+ npu_x1 = cpu_x1.npu()
413+ npu_other1 = cpu_other1.npu()
414+ cpu_out1 = cpu_x1 + cpu_other1
415+ npu_out1 = npu_x1 + npu_other1
416+ 
417+ cpu_x2 = 1.5
418+ cpu_other2 = torch.rand(2, 3, 4).uniform_(1, 10).long()
419+ npu_x2 = 1.5
420+ npu_other2 = cpu_other2.npu()
421+ cpu_out2 = cpu_x2 + cpu_other2
422+ npu_out2 = npu_x2 + npu_other2
423+ 
424+ cpu_x3 = torch.rand(2, 3, 4).int()
425+ cpu_other3 = 3
426+ npu_x3 = cpu_x3.npu()
427+ npu_other3 = 3
428+ cpu_out3 = cpu_x3 + cpu_other3
429+ npu_out3 = npu_x3 + npu_other3
430+ 
431+ self.assertRtolEqual(cpu_out1, npu_out1.cpu())
432+ self.assertRtolEqual(cpu_out2, npu_out2.cpu())
433+ self.assertRtolEqual(cpu_out3, npu_out3.cpu())
434+ 
435+ def test_add_inplace_and_out_mix_dtype(self):
436+ dtype_list = [
437+ [np.int32, np.int64, np.int64],
438+ [np.int64, np.int32, np.int64],
439+ [np.float32, np.float16, np.float32],
440+ [np.float16, np.float32, np.float32],
441+ [np.int64, np.float32, np.float32]
442+ ]
443+ for item in dtype_list:
444+ cpu_input1, npu_input1 = create_common_tensor([item[0], 0, (2, 3, 4)], -100, 100)
445+ cpu_input2, npu_input2 = create_common_tensor([item[1], 0, (2, 3, 4)], -100, 100)
446+ _, npu_output = create_common_tensor([item[2], 0, (2, 3, 4)], 1, 100)
447+ 
448+ if item[0] == np.int64 and item[1] == np.float32:
449+ try:
450+ npu_input1.add_(npu_input2)
451+ except RuntimeError as e:
452+ self.assertRegex(
453+ str(e), "result type Float can't be cast to the desired output type Long")
454+ else:
455+ cpu_input1.add_(cpu_input2)
456+ npu_input1.add_(npu_input2)
457+ self.assertRtolEqual(cpu_input1, npu_input1.cpu())
458+ 
459+ cpu_output = torch.add(cpu_input1, cpu_input2)
460+ torch.add(npu_input1, npu_input2, out=npu_output)
461+ self.assertRtolEqual(cpu_output, npu_output.cpu())
462+ 
463+ 
464+if __name__ == "__main__":
465+ run_tests()
Atest/test_v1r11_ops/test_addbmm.py+120-0
@@ -0,0 +1,120 @@
1+# Copyright (c) 2020 Huawei Technologies Co., Ltd
2+# All rights reserved.
3+#
4+# Licensed under the BSD 3-Clause License (the "License");
5+# you may not use this file except in compliance with the License.
6+# You may obtain a copy of the License at
7+#
8+# https://opensource.org/licenses/BSD-3-Clause
9+#
10+# Unless required by applicable law or agreed to in writing, software
11+# distributed under the License is distributed on an "AS IS" BASIS,
12+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+# See the License for the specific language governing permissions and
14+# limitations under the License.
15+ 
16+ 
17+import torch
18+import numpy as np
19+import torch_npu
20+ 
21+from torch_npu.testing.testcase import TestCase, run_tests
22+from torch_npu.testing.common_utils import create_common_tensor
23+ 
24+ 
25+torch.npu.set_compile_mode(jit_compile=False)
26+torch.npu.config.allow_internal_format = False
27+ 
28+ 
29+class TestAddbmm(TestCase):
30+ 
31+ def cpu_op_exec(self, input1, input2, input3, scalar1, scalar2):
32+ output = torch.addbmm(input1, input2, input3, beta=scalar1, alpha=scalar2)
33+ output = output.numpy()
34+ return output
35+ 
36+ def npu_op_exec(self, input1, input2, input3, scalar1, scalar2):
37+ output = torch.addbmm(input1, input2, input3, beta=scalar1, alpha=scalar2)
38+ output = output.to("cpu")
39+ output = output.numpy()
40+ return output
41+ 
42+ def npu_op_exec_out(self, input1, input2, input3, scalar1, scalar2):
43+ output = torch.ones_like(input1)
44+ torch.addbmm(input1, input2, input3, beta=scalar1, alpha=scalar2, out=output)
45+ output = output.to("cpu")
46+ output = output.numpy()
47+ return output
48+ 
49+ def npu_op_exec_inplace(self, input1, input2, input3, scalar1, scalar2):
50+ input1.addbmm_(input2, input3, beta=scalar1, alpha=scalar2)
51+ output = input1.to("cpu")
52+ output = output.numpy()
53+ return output
54+ 
55+ def cpu_op_transpose_exec(self, input1, input2, input3, scalar1, scalar2):
56+ input3_t = input3.permute(0, 2, 1)
57+ output = torch.addbmm(input1, input2, input3_t, beta=scalar1, alpha=scalar2)
58+ output = output.numpy()
59+ return output
60+ 
61+ def npu_op_transpose_exec(self, input1, input2, input3, scalar1, scalar2):
62+ input3_t = input3.permute(0, 2, 1)
63+ output = torch.addbmm(input1, input2, input3_t, beta=scalar1, alpha=scalar2)
64+ output = output.to("cpu")
65+ output = output.numpy()
66+ return output
67+ 
68+ def test_addbmm(self):
69+ shape_format = [
70+ [[np.float16, 0, [3, 5]], [np.float16, 0, [10, 3, 4]], [np.float16, 0, [10, 4, 5]]],
71+ ]
72+ 
73+ for item in shape_format:
74+ cpu_input1, npu_input1 = create_common_tensor(item[0], 0, 100)
75+ cpu_input2, npu_input2 = create_common_tensor(item[1], 0, 100)
76+ cpu_input3, npu_input3 = create_common_tensor(item[2], 0, 100)
77+ 
78+ scalar1 = np.random.uniform(0, 10)
79+ scalar2 = np.random.uniform(0, 10)
80+ 
81+ cpu_input1 = cpu_input1.float()
82+ cpu_input2 = cpu_input2.float()
83+ cpu_input3 = cpu_input3.float()
84+ npu_input1 = npu_input1.float()
85+ npu_input2 = npu_input2.float()
86+ npu_input3 = npu_input3.float()
87+ 
88+ cpu_output = self.cpu_op_exec(cpu_input1, cpu_input2, cpu_input3, scalar1, scalar2)
89+ npu_output = self.npu_op_exec(npu_input1, npu_input2, npu_input3, scalar1, scalar2)
90+ 
91+ npu_output1 = self.npu_op_exec_out(npu_input1, npu_input2, npu_input3, scalar1, scalar2)
92+ npu_output2 = self.npu_op_exec_inplace(npu_input1, npu_input2, npu_input3, scalar1, scalar2)
93+ 
94+ self.assertRtolEqual(cpu_output, npu_output, prec=1.e-3)
95+ self.assertRtolEqual(cpu_output, npu_output1, prec=1.e-3)
96+ self.assertRtolEqual(cpu_output, npu_output2, prec=1.e-3)
97+ 
98+ def test_addbmm_transpose(self):
99+ shape_format = [
100+ [[np.float16, 0, [4, 5]], [np.float16, 0, [10, 4, 7]], [np.float16, 0, [10, 5, 7]]],
101+ ]
102+ 
103+ for item in shape_format:
104+ cpu_input1, npu_input1 = create_common_tensor(item[0], 0, 100)
105+ cpu_input2, npu_input2 = create_common_tensor(item[1], 0, 100)
106+ cpu_input3, npu_input3 = create_common_tensor(item[2], 0, 100)
107+ 
108+ scalar1 = np.random.uniform(0, 10)
109+ scalar2 = np.random.uniform(0, 10)
110+ 
111+ cpu_transpose_output = self.cpu_op_transpose_exec(
112+ cpu_input1.float(), cpu_input2.float(), cpu_input3.float(), scalar1, scalar2)
113+ npu_transpose_output = self.npu_op_transpose_exec(
114+ npu_input1.float(), npu_input2.float(), npu_input3.float(), scalar1, scalar2)
115+ 
116+ self.assertRtolEqual(cpu_transpose_output, npu_transpose_output, prec=1.e-3)
117+ 
118+ 
119+if __name__ == "__main__":
120+ run_tests()
Atest/test_v1r11_ops/test_addcdiv.py+263-0
@@ -0,0 +1,263 @@
1+# Copyright (c) 2020 Huawei Technologies Co., Ltd
2+# Copyright (c) 2019, Facebook CORPORATION.
3+# All rights reserved.
4+#
5+# Licensed under the BSD 3-Clause License (the "License");
6+# you may not use this file except in compliance with the License.
7+# You may obtain a copy of the License at
8+#
9+# https://opensource.org/licenses/BSD-3-Clause
10+#
11+# Unless required by applicable law or agreed to in writing, software
12+# distributed under the License is distributed on an "AS IS" BASIS,
13+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14+# See the License for the specific language governing permissions and
15+# limitations under the License.
16+ 
17+ 
18+import copy
19+import torch
20+import numpy as np
21+ 
22+from torch_npu.testing.testcase import TestCase, run_tests
23+ 
24+ 
25+class TestAddcdiv(TestCase):
26+ 
27+ def cpu_op_inp_input3_noncontiguous_exec(self, input1, input2, input3, scalar):
28+ input3_strided = input3.as_strided([2, 2], [1, 2], 2)
29+ input1.addcdiv_(input2, input3_strided, value=scalar)
30+ output = input1.numpy()
31+ return output
32+ 
33+ def npu_op_inp_input3_noncontiguous_exec(self, input1, input2, input3, scalar):
34+ input1 = input1.to("npu")
35+ input2 = input2.to("npu")
36+ input3 = input3.to("npu")
37+ input3_as_strided = input3.as_strided([2, 2], [1, 2], 2)
38+ input1.addcdiv_(input2, input3_as_strided, value=scalar)
39+ output = input1.to("cpu")
40+ output = output.numpy()
41+ return output
42+ 
43+ def non_zero_rand(self, size, dtype, device="npu"):
44+ if dtype.is_floating_point:
45+ a = torch.rand(size=size, dtype=dtype, device="cpu")
46+ a = a.to("npu")
47+ elif dtype == torch.uint8:
48+ a = torch.randint(1, 5, size=size, dtype=dtype, device="cpu").to(device)
49+ else:
50+ a = torch.randint(-5, 5, size=size, dtype=dtype, device="cpu").to(device)
51+ return a.type(dtype)
52+ 
53+ def cpu_op_exec(self, input1, input2, input3, scalar):
54+ output = torch.addcdiv(input1, input2, input3, value=scalar)
55+ return output
56+ 
57+ def npu_op_exec(self, input1, input2, input3, scalar):
58+ input1 = input1.to("npu")
59+ input2 = input2.to("npu")
60+ input3 = input3.to("npu")
61+ output = torch.addcdiv(input1, input2, input3, value=scalar)
62+ output = output.to("cpu")
63+ return output
64+ 
65+ def cpu_op_exec_out(self, input1, input2, input3, scalar, output):
66+ torch.addcdiv(input1, input2, input3, value=scalar, out=output)
67+ output = output.numpy()
68+ return output
69+ 
70+ def npu_op_exec_out(self, input1, input2, input3, scalar, output):
71+ input1 = input1.to("npu")
72+ input2 = input2.to("npu")
73+ input3 = input3.to("npu")
74+ output = output.to("npu")
75+ torch.addcdiv(input1, input2, input3, value=scalar, out=output)
76+ output = output.to("cpu").numpy()
77+ return output
78+ 
79+ def cpu_op_inp_contiguous_exec(self, input1, input2, input3, scalar):
80+ input1.addcdiv_(input2, input3, value=scalar)
81+ output = input1.numpy()
82+ return output
83+ 
84+ def npu_op_inp_contiguous_exec(self, input1, input2, input3, scalar):
85+ input1 = input1.to("npu")
86+ input2 = input2.to("npu")
87+ input3 = input3.to("npu")
88+ input1.addcdiv_(input2, input3, value=scalar)
89+ output = input1.to("cpu")
90+ output = output.numpy()
91+ return output
92+ 
93+ def cpu_op_inp_input1_noncontiguous_exec(self, input1, input2, input3, scalar):
94+ input1_strided = input1.as_strided([2, 2], [1, 2], 2)
95+ input1_strided.addcdiv_(input2, input3, value=scalar)
96+ output = input1.numpy()
97+ return output
98+ 
99+ def npu_op_inp_input1_noncontiguous_exec(self, input1, input2, input3, scalar):
100+ input1 = input1.to("npu")
101+ input2 = input2.to("npu")
102+ input3 = input3.to("npu")
103+ input1_as_strided = input1.as_strided([2, 2], [1, 2], 2)
104+ input1_as_strided.addcdiv_(input2, input3, value=scalar)
105+ output = input1.to("cpu")
106+ output = output.numpy()
107+ return output
108+ 
109+ def cpu_op_inp_input2_noncontiguous_exec(self, input1, input2, input3, scalar):
110+ input2_strided = input2.as_strided([2, 2], [1, 2], 2)
111+ input1.addcdiv_(input2_strided, input3, value=scalar)
112+ output = input1.numpy()
113+ return output
114+ 
115+ def npu_op_inp_input2_noncontiguous_exec(self, input1, input2, input3, scalar):
116+ input1 = input1.to("npu")
117+ input3 = input3.to("npu")
118+ input2 = input2.to("npu")
119+ input2_as_strided = input2.as_strided([2, 2], [1, 2], 2)
120+ input1.addcdiv_(input2_as_strided, input3, value=scalar)
121+ output = input1.to("cpu")
122+ output = output.numpy()
123+ return output
124+ 
125+ def generate_data(self, min1, max1, shape, dtype):
126+ input1 = np.random.uniform(min1, max1, shape).astype(dtype)
127+ input2 = np.random.uniform(min1, max1, shape).astype(dtype)
128+ input3 = np.random.uniform(min1, max1, shape).astype(dtype)
129+ npu_input1 = torch.from_numpy(input1)
130+ npu_input2 = torch.from_numpy(input2)
131+ npu_input3 = torch.from_numpy(input3)
132+ return npu_input1, npu_input2, npu_input3
133+ 
134+ def generate_single_data(self, min1, max1, shape, dtype):
135+ inputs = np.random.uniform(min1, max1, shape).astype(dtype)
136+ npu_input = torch.from_numpy(inputs)
137+ return npu_input
138+ 
139+ def generate_scalar(self, min1, max1):
140+ scalar = np.random.uniform(min1, max1)
141+ return scalar
142+ 
143+ def generate_int_scalar(self, min1, max1):
144+ scalar = np.random.randint(min1, max1)
145+ return scalar
146+ 
147+ def _test_addcdiv(self, a, alpha, b, c):
148+ actual = torch.addcdiv(a, b, c, value=alpha)
149+ if not actual.dtype.is_floating_point:
150+ alpha = int(alpha)
151+ try:
152+ expected = a + (alpha * b) / c
153+ except ZeroDivisionError:
154+ print("Divide-by-Zero Error!!")
155+ self.assertTrue(torch.allclose(expected.to("cpu"), actual.to("cpu"), equal_nan=True))
156+ self.assertRtolEqual(actual.to("cpu"), torch.addcdiv(a, alpha, b, c).to("cpu"))
157+ 
158+ def test_addcdiv(self, device="npu"):
159+ """NPU does not support numpy.bool.
160+ 
161+ with self.maybeWarnsRegex(UserWarning, "This overload of addcdiv is deprecated"):
162+ self.assertRtolEqual(actual.to("cpu"), torch.addcdiv(a, alpha, b, c).to("cpu"))
163+ 
164+ """
165+ dtype_list = [torch.uint8, torch.int8, torch.int16, torch.int32, torch.int64,
166+ torch.float64, torch.complex64, torch.complex128]
167+ for dtype in torch.testing.get_all_math_dtypes(device):
168+ if dtype in dtype_list:
169+ continue
170+ self._test_addcdiv(
171+ self.non_zero_rand((2, 2), dtype=dtype, device=device),
172+ 0.5,
173+ self.non_zero_rand((2, 2), dtype=dtype, device=device),
174+ self.non_zero_rand((2, 2), dtype=dtype, device=device))
175+ 
176+ def test_addcdiv_float32(self):
177+ npu_input1, npu_input2, npu_input3 = self.generate_data(1, 100, (5, 3), np.float32)
178+ scalar = self.generate_scalar(1, 10)
179+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2, npu_input3, scalar)
180+ npu_output = self.npu_op_exec(npu_input1, npu_input2, npu_input3, scalar)
181+ self.assertRtolEqual(cpu_output, npu_output)
182+ 
183+ def test_addcdiv_float32_out(self):
184+ npu_input1, npu_input2, npu_input3 = self.generate_data(1, 100, (5, 3), np.float32)
185+ scalar = self.generate_scalar(1, 10)
186+ npu_input4 = self.generate_single_data(1, 100, (5, 3), np.float32)
187+ cpu_output = self.cpu_op_exec_out(npu_input1, npu_input2, npu_input3, scalar, npu_input4)
188+ npu_output = self.npu_op_exec_out(npu_input1, npu_input2, npu_input3, scalar, npu_input4)
189+ self.assertRtolEqual(cpu_output, npu_output)
190+ 
191+ def test_addcdiv_float32_broadcast(self):
192+ npu_input1 = self.generate_single_data(1, 100, (5, 3, 1), np.float32)
193+ npu_input2 = self.generate_single_data(1, 100, (5, 1, 5), np.float32)
194+ npu_input3 = self.generate_single_data(1, 100, (1, 1, 5), np.float32)
195+ scalar = self.generate_scalar(1, 10)
196+ cpu_output = self.cpu_op_exec(npu_input1, npu_input2, npu_input3, scalar)
197+ npu_output = self.npu_op_exec(npu_input1, npu_input2, npu_input3, scalar)
198+ self.assertRtolEqual(cpu_output, npu_output)
199+ 
200+ def test_addcdiv_inp_contiguous_float32(self):
201+ npu_input1, npu_input2, npu_input3 = self.generate_data(1, 100, (5, 3), np.float32)
202+ cpu_input1 = copy.deepcopy(npu_input1)
203+ cpu_input2 = copy.deepcopy(npu_input2)
204+ cpu_input3 = copy.deepcopy(npu_input3)
205+ scalar = self.generate_int_scalar(1, 10)
206+ cpu_output = self.cpu_op_inp_contiguous_exec(cpu_input1, cpu_input2, cpu_input3, scalar)
207+ npu_output = self.npu_op_inp_contiguous_exec(npu_input1, npu_input2, npu_input3, scalar)
208+ self.assertRtolEqual(cpu_output, npu_output)
209+ 
210+ def test_addcdiv_inp_input1_noncontiguous_float32(self):
211+ npu_input1 = self.generate_single_data(1, 100, (4, 3), np.float32)
212+ npu_input2 = self.generate_single_data(1, 100, (2, 2), np.float32)
213+ npu_input3 = self.generate_single_data(1, 100, (2, 2), np.float32)
214+ cpu_input1 = copy.deepcopy(npu_input1)
215+ cpu_input2 = copy.deepcopy(npu_input2)
216+ cpu_input3 = copy.deepcopy(npu_input3)
217+ scalar = self.generate_int_scalar(1, 10)
218+ cpu_output = self.cpu_op_inp_input1_noncontiguous_exec(cpu_input1, cpu_input2, cpu_input3, scalar)
219+ npu_output = self.npu_op_inp_input1_noncontiguous_exec(npu_input1, npu_input2, npu_input3, scalar)
220+ self.assertRtolEqual(cpu_output, npu_output)
221+ 
222+ def test_addcdiv_inp_input2_noncontiguous_float32(self):
223+ npu_input1 = self.generate_single_data(1, 100, (2, 2), np.float32)
224+ npu_input2 = self.generate_single_data(1, 100, (4, 3), np.float32)
225+ npu_input3 = self.generate_single_data(1, 100, (2, 2), np.float32)
226+ cpu_input1 = copy.deepcopy(npu_input1)
227+ cpu_input2 = copy.deepcopy(npu_input2)
228+ cpu_input3 = copy.deepcopy(npu_input3)
229+ scalar = self.generate_int_scalar(1, 10)
230+ cpu_output = self.cpu_op_inp_input2_noncontiguous_exec(cpu_input1, cpu_input2, cpu_input3, scalar)
231+ npu_output = self.npu_op_inp_input2_noncontiguous_exec(npu_input1, npu_input2, npu_input3, scalar)
232+ self.assertRtolEqual(cpu_output, npu_output)
233+ 
234+ def test_addcdiv_inp_input3_noncontiguous_float32(self):
235+ npu_input1 = self.generate_single_data(1, 100, (2, 2), np.float32)
236+ npu_input2 = self.generate_single_data(1, 100, (2, 2), np.float32)
237+ npu_input3 = self.generate_single_data(1, 100, (4, 3), np.float32)
238+ cpu_input1 = copy.deepcopy(npu_input1)
239+ cpu_input2 = copy.deepcopy(npu_input2)
240+ cpu_input3 = copy.deepcopy(npu_input3)
241+ scalar = self.generate_int_scalar(1, 10)
242+ cpu_output = self.cpu_op_inp_input3_noncontiguous_exec(cpu_input1, cpu_input2, cpu_input3, scalar)
243+ npu_output = self.npu_op_inp_input3_noncontiguous_exec(npu_input1, npu_input2, npu_input3, scalar)
244+ self.assertRtolEqual(cpu_output, npu_output)
245+ 
246+ def test_addcdiv_float64(self):
247+ cpu_input1, cpu_input2, cpu_input3 = self.generate_data(1, 100, (5, 3), np.float64)
248+ scalar = self.generate_scalar(1, 10)
249+ cpu_output = self.cpu_op_exec(cpu_input1, cpu_input2, cpu_input3, scalar)
250+ npu_output = self.npu_op_exec(cpu_input1, cpu_input2, cpu_input3, scalar)
251+ self.assertRtolEqual(cpu_output, npu_output)
252+ 
253+ def test_addcdiv_float16(self):
254+ cpu_input1, cpu_input2, cpu_input3 = self.generate_data(1, 100, (5, 3), np.float16)
255+ scalar = self.generate_scalar(1, 10)
256+ cpu_output = self.cpu_op_exec(cpu_input1.float(), cpu_input2.float(), cpu_input3.float(), scalar)
257+ npu_output = self.npu_op_exec(cpu_input1, cpu_input2, cpu_input3, scalar)
258+ cpu_output = cpu_output.to(npu_output.dtype)
259+ self.assertRtolEqual(cpu_output, npu_output)
260+ 
261+ 
262+if __name__ == "__main__":
263+ run_tests()
Atest/test_v1r11_ops/test_addcmul.py+110-0
@@ -0,0 +1,110 @@
1+# Copyright (c) 2020, Huawei Technologies.All rights reserved.
2+#
3+# Licensed under the BSD 3-Clause License (the "License");
4+# you may not use this file except in compliance with the License.
5+# You may obtain a copy of the License at
6+#
7+# https://opensource.org/licenses/BSD-3-Clause
8+#
9+# Unless required by applicable law or agreed to in writing, software
10+# distributed under the License is distributed on an "AS IS" BASIS,
11+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+# See the License for the specific language governing permissions and
13+# limitations under the License.
14+ 
15+import sys
16+ 
17+import torch
18+import numpy as np
19+ 
20+import torch_npu
21+ 
22+from torch_npu.testing.testcase import TestCase, run_tests
23+from torch_npu.testing.common_utils import create_common_tensor
24+ 
25+ 
26+class TestAddCMul(TestCase):
27+ def generate_data(self, min_d, max_d, shape, dtype):
28+ input1 = np.random.uniform(min_d, max_d, shape).astype(dtype)
29+ input2 = np.random.uniform(min_d, max_d, shape).astype(dtype)
30+ input3 = np.random.uniform(min_d, max_d, shape).astype(dtype)
31+ npu_input1 = torch.from_numpy(input1)
32+ npu_input2 = torch.from_numpy(input2)
33+ npu_input3 = torch.from_numpy(input3)
34+ 
35+ return npu_input1, npu_input2, npu_input3
36+ 
37+ def generate_output_data(self, min_d, max_d, shape, dtype):
38+ output_y = np.random.uniform(min_d, max_d, shape).astype(dtype)
39+ npu_output_y = torch.from_numpy(output_y)
40+ return npu_output_y
41+ 
42+ def cpu_op_exec(self, input1, input2, input3, scalar):
43+ output = torch.addcmul(input1, input2, input3, value=scalar)
44+ output = output.numpy()
45+ return output
46+ 
47+ def cpu_op_exec_out(self, input1, input2, input3, scalar, output_y):
48+ output = output_y
49+ torch.addcmul(input1, input2, input3, value=scalar, out=output_y)
50+ output = output.numpy()
51+ return output
52+ 
53+ def npu_op_exec(self, input1, input2, input3, scalar):
54+ input1 = input1.to("npu")
55+ input2 = input2.to("npu")
56+ input3 = input3.to("npu")
57+ output = torch.addcmul(input1, input2, input3, value=scalar)
58+ output = output.to("cpu")
59+ output = output.numpy()
60+ return output
61+ 
62+ def npu_op_exec_out(self, input1, input2, input3, scalar, output_y):
63+ input1 = input1.to("npu")
64+ input2 = input2.to("npu")
65+ input3 = input3.to("npu")
66+ output = output_y.to("npu")
67+ torch.addcmul(input1, input2, input3, value=scalar, out=output)
68+ output = output.to("cpu")
69+ output = output.numpy()
70+ return output
71+ 
72+ def test_addcmul_3_3_float32(self, device="npu"):
73+ input1, input2, input3 = self.generate_data(0, 100, (3, 3), np.float32)
74+ cpu_output = self.cpu_op_exec(input1, input2, input3, 0.5)
75+ npu_output = self.npu_op_exec(input1, input2, input3, 0.5)
76+ self.assertRtolEqual(cpu_output, npu_output)
77+ 
78+ def test_addcmul_10_10_float32(self, device="npu"):
79+ input1, input2, input3 = self.generate_data(0, 100, (10, 10), np.float32)
80+ cpu_output = self.cpu_op_exec(input1, input2, input3, 0.5)
81+ npu_output = self.npu_op_exec(input1, input2, input3, 0.5)
82+ self.assertRtolEqual(cpu_output, npu_output)
83+ 
84+ def test_addcmul_3_3_float16(self, device="npu"):
85+ input1, input2, input3 = self.generate_data(0, 100, (3, 3), np.float16)
86+ input1_cpu = input1.float()
87+ input2_cpu = input2.float()
88+ input3_cpu = input3.float()
89+ cpu_output = self.cpu_op_exec(input1_cpu, input2_cpu, input3_cpu, 0.5).astype(np.float16)
90+ npu_output = self.npu_op_exec(input1, input2, input3, 0.5)
91+ self.assertRtolEqual(cpu_output, npu_output)
92+ 
93+ def test_addcmul_10_10_float16(self, device="npu"):
94+ input1, input2, input3 = self.generate_data(0, 100, (10, 10), np.float16)
95+ input1_cpu = input1.float()
96+ input2_cpu = input2.float()
97+ input3_cpu = input3.float()
98+ cpu_output = self.cpu_op_exec(input1_cpu, input2_cpu, input3_cpu, 0.5).astype(np.float16)
99+ npu_output = self.npu_op_exec(input1, input2, input3, 0.5)
100+ self.assertRtolEqual(cpu_output, npu_output)
101+ 
102+ def test_addcmul_10_23_float32(self, device="npu"):
103+ input1, input2, input3 = self.generate_data(0, 100, (10, 23), np.float32)
104+ cpu_output = self.cpu_op_exec(input1, input2, input3, 0.5)
105+ npu_output = self.npu_op_exec(input1, input2, input3, 0.5)
106+ self.assertRtolEqual(cpu_output, npu_output)
107+ 
108+ 
109+if __name__ == "__main__":
110+ run_tests()
Atest/test_v1r11_ops/test_addmv.py+103-0
@@ -0,0 +1,103 @@
1+# Copyright (c) 2020, Huawei Technologies.All rights reserved.
2+#
3+# Licensed under the BSD 3-Clause License (the "License");
4+# you may not use this file except in compliance with the License.
5+# You may obtain a copy of the License at
6+#
7+# https://opensource.org/licenses/BSD-3-Clause
8+#
9+# Unless required by applicable law or agreed to in writing, software
10+# distributed under the License is distributed on an "AS IS" BASIS,
11+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+# See the License for the specific language governing permissions and
13+# limitations under the License.
14+ 
15+ 
16+import torch
17+import numpy as np
18+import torch_npu
19+ 
20+from torch_npu.testing.testcase import TestCase, run_tests
21+from torch_npu.testing.common_utils import create_common_tensor
22+ 
23+ 
24+torch.npu.set_compile_mode(jit_compile=False)
25+torch.npu.config.allow_internal_format = False
26+ 
27+ 
28+class TestAddmv(TestCase):
29+ def cpu_op_exec(self, a, b, c, alpha, beta):
30+ output = torch.addmv(c, a, b, alpha=alpha, beta=beta)
31+ output = output.numpy()
32+ return output
33+ 
34+ def npu_op_exec(self, a, b, c, alpha, beta):
35+ output = torch.addmv(c, a, b, alpha=alpha, beta=beta)
36+ output = output.to('cpu')
37+ output = output.numpy()
38+ return output
39+ 
40+ # pylint:disable = huawei-too-many-arguments
41+ def npu_op_exec_out(self, a, b, c, beta, alpha, input1):
42+ torch.addmv(c, a, b, alpha=alpha, beta=beta, out=input1)
43+ output = input1.to("cpu")
44+ output = output.numpy()
45+ return output
46+ 
47+ def test_addmv_fp16(self):
48+ shape_format = [
49+ [[np.float16, 3, (2, 3)], [np.float16, 3, (3,)], [np.float16, 3, (2,)]]
50+ ]
51+ for item in shape_format:
52+ input_a, npu_input_a = create_common_tensor(item[0], -2, 2)
53+ input_b, npu_input_b = create_common_tensor(item[1], -2, 2)
54+ input_c, npu_input_c = create_common_tensor(item[2], -2, 2)
55+ 
56+ input_a = input_a.to(torch.float32)
57+ input_b = input_b.to(torch.float32)
58+ input_c = input_c.to(torch.float32)
59+ 
60+ cpu_output = self.cpu_op_exec(input_a, input_b, input_c, 1, 1)
61+ npu_output = self.npu_op_exec(npu_input_a, npu_input_b, npu_input_c, 1, 1)
62+ 
63+ cpu_output = cpu_output.astype(np.float16)
64+ self.assertRtolEqual(cpu_output, npu_output)
65+ 
66+ def test_addmv_out_fp16(self):
67+ shape_format = [
68+ [[np.float16, 3, (2, 3)], [np.float16, 3, (3,)], [np.float16, 3, (2,)], [np.float16, 3, (10,)]]
69+ ]
70+ for item in shape_format:
71+ input_a, npu_input_a = create_common_tensor(item[0], -2, 2)
72+ input_b, npu_input_b = create_common_tensor(item[1], -2, 2)
73+ input_c, npu_input_c = create_common_tensor(item[2], -2, 2)
74+ _, npu_input = create_common_tensor(item[3], -2, 2)
75+ 
76+ input_a = input_a.to(torch.float32)
77+ input_b = input_b.to(torch.float32)
78+ input_c = input_c.to(torch.float32)
79+ 
80+ cpu_output = self.cpu_op_exec(input_a, input_b, input_c, 1, 1)
81+ npu_output = self.npu_op_exec_out(npu_input_a, npu_input_b, npu_input_c, 1, 1, npu_input)
82+ cpu_output = cpu_output.astype(np.float16)
83+ 
84+ self.assertRtolEqual(cpu_output, npu_output)
85+ 
86+ def test_addmv_fp32(self):
87+ shape_format = [
88+ [[np.float16, 0, (2, 3)], [np.float16, 0, (3,)], [np.float16, 0, (2,)]],
89+ [[np.float16, 0, (3168, 320)], [np.float16, 0, (320,)], [np.float16, 0, (3168,)]],
90+ ]
91+ for item in shape_format:
92+ input_a, npu_input_a = create_common_tensor(item[0], -2, 2)
93+ input_b, npu_input_b = create_common_tensor(item[1], -2, 2)
94+ input_c, npu_input_c = create_common_tensor(item[2], -2, 2)
95+ 
96+ cpu_output = self.cpu_op_exec(input_a.float(), input_b.float(), input_c.float(), 1, 1)
97+ npu_output = self.npu_op_exec(npu_input_a.float(), npu_input_b.float(), npu_input_c.float(), 1, 1)
98+ 
99+ self.assertRtolEqual(cpu_output, npu_output, prec=1.e-3)
100+ 
101+ 
102+if __name__ == "__main__":
103+ run_tests()
Atest/test_v1r11_ops/test_apply_adam.py+89-0
@@ -0,0 +1,89 @@
1+# Copyright (c) 2020, Huawei Technologies.All rights reserved.
2+#
3+# Licensed under the BSD 3-Clause License (the "License");
4+# you may not use this file except in compliance with the License.
5+# You may obtain a copy of the License at
6+#
7+# https://opensource.org/licenses/BSD-3-Clause
8+#
9+# Unless required by applicable law or agreed to in writing, software
10+# distributed under the License is distributed on an "AS IS" BASIS,
11+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+# See the License for the specific language governing permissions and
13+# limitations under the License.
14+ 
15+import torch
16+import torch_npu
17+ 
18+from torch_npu.testing.testcase import TestCase, run_tests
19+from torch_npu.testing.common_utils import create_common_tensor
20+ 
21+ 
22+class TestApplyAdam(TestCase):
23+ def test_apply_adam(self):
24+ var1 = torch.randn(2, 2, 2, 2, dtype=torch.float32).to("npu")
25+ m1 = torch.randn(2, 2, 2, 2, dtype=torch.float32).to("npu")
26+ v1 = torch.randn(2, 2, 2, 2, dtype=torch.float32).to("npu")
27+ grad1 = torch.randn(2, 2, 2, 2, dtype=torch.float32).to("npu")
28+ var2 = var1.to(torch.half)
29+ m2 = m1.to(torch.half)
30+ v2 = v1.to(torch.half)
31+ grad2 = grad1.to(torch.half)
32+ res1, _, v1_o = torch_npu.npu_apply_adam(1, 1, 0.2, 0.2, 0.2, 0.2, grad1, False, False, out=(var1, m1, v1))
33+ res2, _, v2_o = torch_npu.npu_apply_adam(1, 1, 0.2, 0.2, 0.2, 0.2, grad2, False, False, out=(var2, m2, v2))
34+ expect_vo = torch.tensor([[[[2.2156, -0.1393],
35+ [0.6441, 0.3087]],
36+ [[0.9008, -0.0295],
37+ [0.0776, 0.0773]]],
38+ [[[0.1105, 1.0725],
39+ [0.8731, 0.4582]],
40+ [[0.1653, 0.3091],
41+ [0.3175, 0.0998]]]], dtype=torch.float32)
42+ self.assertRtolEqual(expect_vo, v1_o.cpu())
43+ self.assertRtolEqual(expect_vo.to(torch.half), v2_o.cpu())
44+ 
45+ def test_apply_adam_out_fp32(self):
46+ var = torch.randn(2, 2, 2, 2, dtype=torch.float32).to("npu")
47+ m = torch.randn(2, 2, 2, 2, dtype=torch.float32).to("npu")
48+ v = torch.randn(2, 2, 2, 2, dtype=torch.float32).to("npu")
49+ grad = torch.randn(2, 2, 2, 2, dtype=torch.float32).to("npu")
50+ bt1p = 0.9
51+ bt2p = 0.9
52+ lr = 0.2
53+ bt1 = 0.2
54+ bt2 = 0.2
55+ ep = 0.2
56+ ul = False
57+ un = False
58+ var_o, m_o, v_o = torch.npu_apply_adam(bt1p, bt2p, lr, bt1, bt2, ep, grad, ul, un, out=(var, m, v))
59+ expect_varo = torch.tensor([[[[-0.1842, 0.6028],
60+ [0.4803, -0.3156]],
61+ [[0.9466, -0.9984],
62+ [-0.1592, -0.1908]]],
63+ [[[-0.9448, 0.6290],
64+ [0.0694, 0.3411]],
65+ [[-0.0987, 0.5370],
66+ [-0.5744, 0.3317]]]])
67+ expect_mo = torch.tensor([[[[-1.4744, 0.1481],
68+ [-0.6954, 0.1557]],
69+ [[-0.6090, 0.4566],
70+ [-0.4863, 0.7218]]],
71+ [[[0.5437, -1.1527],
72+ [0.6547, -0.5491]],
73+ [[-0.2247, -0.7165],
74+ [0.7963, -0.1283]]]])
75+ expect_vo = torch.tensor([[[[2.2156, -0.1393],
76+ [0.6441, 0.3087]],
77+ [[0.9008, -0.0295],
78+ [0.0776, 0.0773]]],
79+ [[[0.1105, 1.0725],
80+ [0.8731, 0.4582]],
81+ [[0.1653, 0.3091],
82+ [0.3175, 0.0998]]]])
83+ self.assertRtolEqual(expect_varo, var_o.cpu())
84+ self.assertRtolEqual(expect_mo, m_o.cpu())
85+ self.assertRtolEqual(expect_vo, v_o.cpu())
86+ 
87+ 
88+if __name__ == "__main__":
89+ run_tests()
Atest/test_v1r11_ops/test_apply_adam_w.py+145-0
@@ -0,0 +1,145 @@
1+# Copyright (c) 2023, Huawei Technologies.All rights reserved.
2+#
3+# Licensed under the BSD 3-Clause License (the "License");
4+# you may not use this file except in compliance with the License.
5+# You may obtain a copy of the License at
6+#
7+# https://opensource.org/licenses/BSD-3-Clause
8+#
9+# Unless required by applicable law or agreed to in writing, software
10+# distributed under the License is distributed on an "AS IS" BASIS,
11+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+# See the License for the specific language governing permissions and
13+# limitations under the License.
14+ 
15+ 
16+import torch
17+import numpy as np
18+ 
19+import torch_npu
20+from torch_npu.testing.testcase import TestCase, run_tests
21+from torch_npu.testing.common_utils import create_common_tensor
22+ 
23+ 
24+class TestApplyAdam(TestCase):
25+ 
26+ # pylint:disable = huawei-too-many-arguments
27+ def cpu_op_exec(self, var, m, v, beta1_power, beta2_power, lr, weight_decay,
28+ beta1, beta2, eps, grad, max_grad_norm, amsgrad, maximize):
29+ if amsgrad:
30+ max_grad_norm = np.random.uniform(-5.0, 5.0, var_shape).astype(dtype)
31+ gt = -grad if maximize else grad
32+ m_out = m * beta1 - (beta1 + (-1)) * gt
33+ v_out = v * beta2 - (beta2 + (-1)) * gt * gt
34+ var_t = var * (1 + (-lr * weight_decay))
35+ beta1_power_out = beta1_power * beta1
36+ beta2_power_out = beta2_power * beta2
37+ if amsgrad:
38+ max_grad_norm_out = np.maximum(max_grad_norm, v_out)
39+ try:
40+ denom = np.sqrt(max_grad_norm_out / (1 - beta2_power_out)) + eps
41+ except ZeroDivisionError:
42+ print("Divide-by-Zero Error!")
43+ else:
44+ max_grad_norm_out = None
45+ try:
46+ denom = np.sqrt(v_out / (1 - beta2_power_out)) + eps
47+ except ZeroDivisionError:
48+ print("Divide-by-Zero Error!")
49+ try:
50+ var_out = var_t + (-lr * m_out / (1 - beta1_power_out)) / denom
51+ except ZeroDivisionError:
52+ print("Divide-by-Zero Error!")
53+ return var_out, m_out, v_out
54+ 
55+ # pylint:disable = huawei-too-many-arguments
56+ def npu_op_exec(self, var_tensor, m_tensor, v_tensor, beta1_power, beta2_power, lr, weight_decay,
57+ beta1, beta2, eps, grad, max_grad_norm, amsgrad, maximize):
58+ var_out_npu, m_out_npu, v_out_npu = torch_npu.npu_apply_adam_w(beta1_power[0],
59+ beta2_power[0], lr[0], weight_decay[0], beta1[0],
60+ beta2[0], eps[0], grad, max_grad_norm,
61+ amsgrad, maximize,
62+ out=(var_tensor, m_tensor, v_tensor))
63+ return var_out_npu, m_out_npu, v_out_npu
64+ 
65+ def test_apply_adam_w_maximize_true(self):
66+ amsgrad = False # at present, the operator supports only false.
67+ maximize = True
68+ scalar_shape = [1]
69+ dtype = np.float32
70+ shape_format = [
71+ [np.float32, 2, (21130, 512)],
72+ ]
73+ var_cpu, var_npu = create_common_tensor(shape_format[0], 10.0, 20.0)
74+ m_cpu, m_npu = create_common_tensor(shape_format[0], 5.0, 10.0)
75+ v_cpu, v_npu = create_common_tensor(shape_format[0], 0.1, 5.0)
76+ grad_cpu, grad_npu = create_common_tensor(shape_format[0], -5.0, 5.0)
77+ 
78+ var_cpu = var_cpu.numpy()
79+ m_cpu = m_cpu.numpy()
80+ v_cpu = v_cpu.numpy()
81+ grad_cpu = grad_cpu.numpy()
82+ 
83+ beta1_power = np.random.uniform(0.0, 1.0, scalar_shape).astype(dtype)
84+ beta2_power = np.random.uniform(0.0, 1.0, scalar_shape).astype(dtype)
85+ lr = np.random.uniform(0.0001, 0.1, scalar_shape).astype(dtype)
86+ weight_decay = np.random.uniform(0.001, 0.1, scalar_shape).astype(dtype)
87+ beta1 = np.random.uniform(0.5, 1.0, scalar_shape).astype(dtype)
88+ beta2 = np.random.uniform(0.5, 1.0, scalar_shape).astype(dtype)
89+ eps = np.random.uniform(0.00001, 0.01, scalar_shape).astype(dtype)
90+ max_grad_norm = None
91+ 
92+ var_ret_cpu, m_ret_cpu, v_ret_cpu = self.cpu_op_exec(var_cpu, m_cpu, v_cpu, beta1_power, beta2_power, lr,
93+ weight_decay, beta1, beta2, eps, grad_cpu, max_grad_norm,
94+ amsgrad, maximize)
95+ 
96+ var_ret_npu, m_ret_npu, v_ret_npu = self.npu_op_exec(var_npu, m_npu, v_npu, beta1_power,
97+ beta2_power, lr, weight_decay, beta1, beta2, eps, grad_npu,
98+ max_grad_norm, amsgrad, maximize)
99+ 
100+ self.assertRtolEqual(var_ret_cpu, var_ret_npu.cpu().numpy())
101+ self.assertRtolEqual(m_ret_cpu, m_ret_npu.cpu().numpy())
102+ self.assertRtolEqual(v_ret_cpu, v_ret_npu.cpu().numpy())
103+ 
104+ def test_apply_adam_w_maximize_false(self):
105+ amsgrad = False # at present, the operator supports only false.
106+ maximize = False
107+ scalar_shape = [1]
108+ dtype = np.float32
109+ shape_format = [
110+ [np.float32, 2, (21130, 512)],
111+ ]
112+ var_cpu, var_npu = create_common_tensor(shape_format[0], 10.0, 20.0)
113+ m_cpu, m_npu = create_common_tensor(shape_format[0], 5.0, 10.0)
114+ v_cpu, v_npu = create_common_tensor(shape_format[0], 0.1, 5.0)
115+ grad_cpu, grad_npu = create_common_tensor(shape_format[0], -5.0, 5.0)
116+ 
117+ var_cpu = var_cpu.numpy()
118+ m_cpu = m_cpu.numpy()
119+ v_cpu = v_cpu.numpy()
120+ grad_cpu = grad_cpu.numpy()
121+ 
122+ beta1_power = np.random.uniform(0.0, 1.0, scalar_shape).astype(dtype)
123+ beta2_power = np.random.uniform(0.0, 1.0, scalar_shape).astype(dtype)
124+ lr = np.random.uniform(0.0001, 0.1, scalar_shape).astype(dtype)
125+ weight_decay = np.random.uniform(0.001, 0.1, scalar_shape).astype(dtype)
126+ beta1 = np.random.uniform(0.5, 1.0, scalar_shape).astype(dtype)
127+ beta2 = np.random.uniform(0.5, 1.0, scalar_shape).astype(dtype)
128+ eps = np.random.uniform(0.00001, 0.01, scalar_shape).astype(dtype)
129+ max_grad_norm = None
130+ 
131+ var_ret_cpu, m_ret_cpu, v_ret_cpu = self.cpu_op_exec(var_cpu, m_cpu, v_cpu, beta1_power, beta2_power, lr,
132+ weight_decay, beta1, beta2, eps, grad_cpu, max_grad_norm,
133+ amsgrad, maximize)
134+ 
135+ var_ret_npu, m_ret_npu, v_ret_npu = self.npu_op_exec(var_npu, m_npu, v_npu, beta1_power,
136+ beta2_power, lr, weight_decay, beta1, beta2, eps, grad_npu,
137+ max_grad_norm, amsgrad, maximize)
138+ 
139+ self.assertRtolEqual(var_ret_cpu, var_ret_npu.cpu().numpy())
140+ self.assertRtolEqual(m_ret_cpu, m_ret_npu.cpu().numpy())
141+ self.assertRtolEqual(v_ret_cpu, v_ret_npu.cpu().numpy())
142+ 
143+ 
144+if __name__ == "__main__":
145+ run_tests()
Atest/test_v1r11_ops/test_asarray.py+38-0
@@ -0,0 +1,38 @@
1+# Copyright (c) 2020, Huawei Technologies.All rights reserved.
2+#
3+# Licensed under the BSD 3-Clause License (the "License");
4+# you may not use this file except in compliance with the License.
5+# You may obtain a copy of the License at
6+#
7+# https://opensource.org/licenses/BSD-3-Clause
8+#
9+# Unless required by applicable law or agreed to in writing, software
10+# distributed under the License is distributed on an "AS IS" BASIS,
11+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+# See the License for the specific language governing permissions and
13+# limitations under the License.
14+import torch
15+import numpy as np
16+import torch_npu
17+ 
18+from torch_npu.testing.testcase import TestCase, run_tests
19+from torch_npu.testing.common_utils import create_common_tensor
20+ 
21+ 
22+class TestAsarray(TestCase):
23+ def test_asarray_default(self):
24+ np_input = np.random.randn(1)
25+ cpu_output_default = torch.asarray(np_input, device="cpu").numpy()
26+ npu_output_default = torch.asarray(np_input, device="npu").cpu().numpy()
27+ self.assertRtolEqual(cpu_output_default, npu_output_default)
28+ 
29+ def test_asarray_device_none(self):
30+ npu_input = torch.tensor([1, 2, 3]).npu()
31+ npu_input_device = npu_input.device
32+ npu_output = torch.asarray(npu_input)
33+ npu_output_device = npu_output.device
34+ if npu_input_device != npu_output_device:
35+ raise ValueError("The device of input and output must be the same")
36+ 
37+if __name__ == "__main__":
38+ run_tests()
Atest/test_v1r11_ops/test_avg_pool2d_backward.py+103-0
@@ -0,0 +1,103 @@
1+# Copyright (c) 2020, Huawei Technologies.All rights reserved.
2+#
3+# Licensed under the BSD 3-Clause License (the "License");
4+# you may not use this file except in compliance with the License.
5+# You may obtain a copy of the License at
6+#
7+# https://opensource.org/licenses/BSD-3-Clause
8+#
9+# Unless required by applicable law or agreed to in writing, software
10+# distributed under the License is distributed on an "AS IS" BASIS,
11+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+# See the License for the specific language governing permissions and
13+# limitations under the License.
14+ 
15+ 
16+import torch
17+import torch.nn as nn
18+import numpy as np
19+import torch_npu
20+ 
21+from torch_npu.testing.testcase import TestCase, run_tests
22+from torch_npu.testing.common_utils import create_common_tensor
23+ 
24+torch.npu.set_compile_mode(jit_compile=False)
25+torch.npu.config.allow_internal_format = False
26+ 
27+ 
28+class TestAvgPool2dBackward(TestCase):
29+ def cpu_op_exec(self, input1):
30+ m = nn.AvgPool2d(kernel_size=2, stride=2)
31+ input1.requires_grad = True
32+ output = m(input1)
33+ output.backward(torch.ones_like(output))
34+ output_grad = input1.grad
35+ output_grad = output_grad.detach().numpy()
36+ output = output.detach().numpy()
37+ 
38+ return output_grad, output
39+ 
40+ def npu_op_exec(self, input1):
41+ m = nn.AvgPool2d(kernel_size=2, stride=2).npu()
42+ input1.requires_grad = True
43+ output = m(input1)
44+ output.backward(torch.ones_like(output))
45+ output_grad = input1.grad
46+ output_grad = output_grad.to("cpu")
47+ output_grad = output_grad.detach().numpy()
48+ output = output.to("cpu")
49+ output = output.detach().numpy()
50+ 
51+ return output_grad, output
52+ 
53+ def test_avg_pool2d_backward_shape_format_fp16(self):
54+ format_list = [0, 3]
55+ shape_list = [(5, 20, 8, 8)]
56+ shape_format = [
57+ [np.float16, i, j] for i in format_list for j in shape_list
58+ ]
59+ for item in shape_format:
60+ cpu_input, npu_input = create_common_tensor(item, 0, 100)
61+ cpu_input = cpu_input.to(torch.float32)
62+ cpu_output_grad, cpu_output = self.cpu_op_exec(cpu_input)
63+ npu_output_grad, npu_output = self.npu_op_exec(npu_input)
64+ cpu_output = cpu_output.astype(npu_output.dtype)
65+ cpu_output_grad = cpu_output_grad.astype(npu_output_grad.dtype)
66+ 
67+ self.assertRtolEqual(cpu_output, npu_output)
68+ self.assertRtolEqual(cpu_output_grad, npu_output_grad)
69+ 
70+ def test_avg_pool2d_backward_shape_format_fp32(self):
71+ format_list = [0, 3]
72+ shape_list = [(5, 20, 8, 8)]
73+ shape_format = [
74+ [np.float32, i, j] for i in format_list for j in shape_list
75+ ]
76+ for item in shape_format:
77+ cpu_input, npu_input = create_common_tensor(item, 0, 100)
78+ cpu_output_grad, cpu_output = self.cpu_op_exec(cpu_input)
79+ npu_output_grad, npu_output = self.npu_op_exec(npu_input)
80+ 
81+ cpu_output = cpu_output.astype(np.float16)
82+ cpu_output_grad = cpu_output_grad.astype(np.float16)
83+ npu_output = npu_output.astype(np.float16)
84+ npu_output_grad = npu_output_grad.astype(np.float16)
85+ 
86+ self.assertRtolEqual(cpu_output, npu_output)
87+ self.assertRtolEqual(cpu_output_grad, npu_output_grad)
88+ 
89+ def test_avg_pool2d_backward_3d_fp32(self):
90+ cpu_input, npu_input = create_common_tensor([np.float32, 0, (1, 13, 13)], 0, 1)
91+ cpu_output_grad, _ = self.cpu_op_exec(cpu_input)
92+ npu_output_grad, _ = self.npu_op_exec(npu_input)
93+ self.assertRtolEqual(cpu_output_grad, npu_output_grad, 0.0009)
94+ 
95+ def test_avg_pool2d_backward_4d_fp32(self):
96+ cpu_input, npu_input = create_common_tensor([np.float32, 0, (5, 1, 8, 8)], 0, 1)
97+ cpu_output_grad, _ = self.cpu_op_exec(cpu_input)
98+ npu_output_grad, _ = self.npu_op_exec(npu_input)
99+ self.assertRtolEqual(cpu_output_grad, npu_output_grad, 0.0009)
100+ 
101+ 
102+if __name__ == "__main__":
103+ run_tests()
Atest/test_v1r11_ops/test_avg_pool3d.py+94-0
@@ -0,0 +1,94 @@
1+# Copyright (c) 2020 Huawei Technologies Co., Ltd
2+# Copyright (c) 2019, Facebook CORPORATION.
3+# All rights reserved.
4+#
5+# Licensed under the BSD 3-Clause License (the "License");
6+# you may not use this file except in compliance with the License.
7+# You may obtain a copy of the License at
8+#
9+# https://opensource.org/licenses/BSD-3-Clause
10+#
11+# Unless required by applicable law or agreed to in writing, software
12+# distributed under the License is distributed on an "AS IS" BASIS,
13+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14+# See the License for the specific language governing permissions and
15+# limitations under the License.
16+ 
17+ 
18+import copy
19+import torch
20+import numpy as np
21+ 
22+import torch_npu
23+from torch_npu.testing.testcase import TestCase, run_tests
24+from torch_npu.testing.common_utils import create_common_tensor
25+ 
26+ 
27+class TestAvgPool3D(TestCase):
28+ 
29+ def cpu_op_exec(self, kernel_size, stride, input1):
30+ m = torch.nn.AvgPool3d(kernel_size, stride)
31+ output_data = m(input1)
32+ return output_data
33+ 
34+ def cpu_op_exec_fp16(self, kernel_size, stride, input1):
35+ m = torch.nn.AvgPool3d(kernel_size, stride)
36+ output_data = m(input1.float())
37+ return output_data.half()
38+ 
39+ def npu_op_exec(self, kernel_size, stride, input1):
40+ m = torch.nn.AvgPool3d(kernel_size, stride).npu()
41+ output_data = m(input1)
42+ return output_data
43+ 
44+ def test_avg_pool_3d_fp32(self):
45+ shape_format = [
46+ [[np.float32, -1, (20, 16, 50, 44, 31)], (3, 2, 2), (2, 1, 2)],
47+ [[np.float32, -1, (2, 1, 4, 4, 4)], 3, 2],
48+ [[np.float32, -1, (2, 1, 4, 4, 4)], 2, 2],
49+ [[np.float32, -1, (2, 4, 4, 4)], 2, 2]
50+ ]
51+ 
52+ for item in shape_format:
53+ cpu_input1, npu_input1 = create_common_tensor(item[0], 1, 100)
54+ npu_output = self.npu_op_exec(item[1], item[2], npu_input1)
55+ cpu_output = self.cpu_op_exec(item[1], item[2], cpu_input1)
56+ self.assertRtolEqual(cpu_output, npu_output.cpu(), 1.e-3)
57+ 
58+ def test_avg_pool_3d_fp16(self):
59+ shape_format = [
60+ [[np.float16, -1, (20, 16, 50, 44, 31)], (3, 2, 2), (2, 1, 2)],
61+ [[np.float16, -1, (2, 1, 4, 4, 4)], 3, 2],
62+ [[np.float16, -1, (2, 1, 4, 4, 4)], 2, 2],
63+ [[np.float16, -1, (2, 4, 4, 4)], 2, 2]
64+ ]
65+ 
66+ for item in shape_format:
67+ cpu_input1, npu_input1 = create_common_tensor(item[0], 1, 100)
68+ npu_output = self.npu_op_exec(item[1], item[2], npu_input1)
69+ cpu_output = self.cpu_op_exec_fp16(item[1], item[2], cpu_input1)
70+ self.assertRtolEqual(cpu_output, npu_output.cpu())
71+ 
72+ def test_avg_pool_3d(self):
73+ shape_format = [
74+ [np.float16, -1, (512, 88, 64, 31)],
75+ [np.float16, -1, (2, 1, 4, 4, 6)],
76+ [np.float32, -1, (512, 88, 64, 31)],
77+ [np.float16, -1, (2, 1, 4, 4, 6)]
78+ ]
79+ cmodel = torch.nn.AvgPool3d((3, 3, 5), (6, 9, 3), (1, 1, 2), True)
80+ nmodel = copy.deepcopy(cmodel).npu()
81+ for item in shape_format:
82+ np.random.seed(123)
83+ cpu_input1, npu_input1 = create_common_tensor(item, 1, 100)
84+ if item[0] == np.float16:
85+ cpu_input1 = cpu_input1.to(torch.float32)
86+ cpu_output = cmodel(cpu_input1)
87+ npu_output = nmodel(npu_input1)
88+ if item[0] == np.float16:
89+ cpu_output = cpu_output.to(torch.float16)
90+ self.assertRtolEqual(cpu_output, npu_output.cpu(), 0.001, 0.0015)
91+ 
92+ 
93+if __name__ == "__main__":
94+ run_tests()
Atest/test_v1r11_ops/test_baddbmm.py+113-0
@@ -0,0 +1,113 @@
1+# Copyright (c) 2020 Huawei Technologies Co., Ltd
2+#
3+# Licensed under the BSD 3-Clause License (the "License");
4+# you may not use this file except in compliance with the License.
5+# You may obtain a copy of the License at
6+#
7+# https://opensource.org/licenses/BSD-3-Clause
8+#
9+# Unless required by applicable law or agreed to in writing, software
10+# distributed under the License is distributed on an "AS IS" BASIS,
11+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+# See the License for the specific language governing permissions and
13+# limitations under the License.
14+import torch
15+import numpy as np
16+from torch.nn import functional as F
17+import torch_npu
18+ 
19+from torch_npu.testing.testcase import TestCase, run_tests
20+from torch_npu.testing.common_utils import create_common_tensor
21+ 
22+ 
23+class TestBaddBmm(TestCase):
24+ def generate_scalar(self, dtype, min1, max1):
25+ if dtype == "float32":
26+ scalar = np.random.uniform(min1, max1)
27+ if dtype == "float16":
28+ scalar = np.random.uniform(min1, max1)
29+ if dtype == "int32":
30+ scalar = np.random.randint(min1, max1)
31+ return scalar
32+ 
33+ def cpu_op_exec(self, input1, input2, input3, scalar1, scalar2):
34+ output = torch.baddbmm(input1, input2, input3, beta=scalar1, alpha=scalar2)
35+ output = output.numpy()
36+ return output
37+ 
38+ def cpu_op_exec_(self, input1, input2, input3, scalar1, scalar2):
39+ input1.baddbmm_(input2, input3, beta=scalar1, alpha=scalar2)
40+ input1 = input1.numpy()
41+ return input1
42+ 
43+ def npu_op_exec(self, input1, input2, input3, scalar1, scalar2):
44+ output = torch.baddbmm(input1, input2, input3, beta=scalar1, alpha=scalar2)
45+ output = output.to("cpu")
46+ output = output.numpy()
47+ return output
48+ 
49+ def npu_op_exec_(self, input1, input2, input3, scalar1, scalar2):
50+ input1.baddbmm_(input2, input3, beta=scalar1, alpha=scalar2)
51+ input1 = input1.to("cpu")
52+ input1 = input1.numpy()
53+ return input1
54+ 
55+ def test_baddbmm_common_shape_format(self):
56+ shape_format = [
57+ [[np.float16, -1, (1, 3, 5)], [np.float16, -1, (1, 3, 4)],
58+ [np.float16, -1, (1, 4, 5)], "float32"],
59+ [[np.float16, -1, (6, 4, 3)], [np.float16, -1, (6, 4, 5)],
60+ [np.float16, -1, (6, 5, 3)], "float32"],
61+ [[np.float16, -1, (175, 455, 22)], [np.float16, -1, (175, 455, 116)],
62+ [np.float16, -1, (175, 116, 22)], "float32"],
63+ [[np.float16, -1, (25, 56, 12)], [np.float16, -1, (25, 56, 51)],
64+ [np.float16, -1, (25, 51, 12)], "float32"]
65+ ]
66+ 
67+ for item in shape_format:
68+ cpu_input1, npu_input1 = create_common_tensor(item[0], 1, 10)
69+ cpu_input2, npu_input2 = create_common_tensor(item[1], 1, 10)
70+ cpu_input3, npu_input3 = create_common_tensor(item[2], 1, 10)
71+ scalar1 = self.generate_scalar(item[3], 0, 10)
72+ scalar2 = self.generate_scalar(item[3], 0, 10)
73+ cpu_output = self.cpu_op_exec(cpu_input1.float(), cpu_input2.float(), cpu_input3.float(), scalar1, scalar2)
74+ npu_output = self.npu_op_exec(npu_input1.float(), npu_input2.float(), npu_input3.float(), scalar1, scalar2)
75+ self.assertRtolEqual(cpu_output, npu_output, prec=1.e-3, prec16=1.e-3)
76+ cpu_output_ = self.cpu_op_exec_(cpu_input1.float(), cpu_input2.float(), cpu_input3.float(), scalar1, scalar2)
77+ npu_output_ = self.npu_op_exec_(npu_input1.float(), npu_input2.float(), npu_input3.float(), scalar1, scalar2)
78+ self.assertRtolEqual(cpu_output_, npu_output_, prec=1.e-3, prec16=1.e-3)
79+ 
80+ def test_baddbmm_float16_shape_format(self):
81+ def cpu_op_exec_fp16(input1, input2, input3, scalar1, scalar2):
82+ input1 = input1.to(torch.float32)
83+ input2 = input2.to(torch.float32)
84+ input3 = input3.to(torch.float32)
85+ output = torch.baddbmm(input1, input2, input3, beta=scalar1, alpha=scalar2)
86+ output = output.numpy()
87+ output = output.astype(np.float16)
88+ return output
89+ 
90+ shape_format = [
91+ [[np.float16, -1, (1, 3, 5)], [np.float16, -1, (1, 3, 4)],
92+ [np.float16, -1, (1, 4, 5)], "float16"],
93+ [[np.float16, -1, (500, 40, 300)], [np.float16, -1, (500, 40, 500)],
94+ [np.float16, -1, (500, 500, 300)], "float16"],
95+ [[np.float16, -1, (175, 455, 22)], [np.float16, -1, (175, 455, 116)],
96+ [np.float16, -1, (175, 116, 22)], "float16"],
97+ [[np.float16, -1, (25, 21, 11)], [np.float16, -1, (25, 21, 34)],
98+ [np.float16, -1, (25, 34, 11)], "float16"],
99+ ]
100+ 
101+ for item in shape_format:
102+ cpu_input1, npu_input1 = create_common_tensor(item[0], 1, 1)
103+ cpu_input2, npu_input2 = create_common_tensor(item[1], 1, 1)
104+ cpu_input3, npu_input3 = create_common_tensor(item[2], 1, 1)
105+ scalar1 = self.generate_scalar(item[3], 0, 2)
106+ scalar2 = self.generate_scalar(item[3], 0, 2)
107+ cpu_output = cpu_op_exec_fp16(cpu_input1, cpu_input2, cpu_input3, scalar1, scalar2)
108+ npu_output = self.npu_op_exec(npu_input1, npu_input2, npu_input3, scalar1, scalar2)
109+ self.assertRtolEqual(cpu_output, npu_output, prec=1.e-3, prec16=1.e-3)
110+ 
111+ 
112+if __name__ == "__main__":
113+ run_tests()
Atest/test_v1r11_ops/test_batch_norm_reduce.py+50-0
@@ -0,0 +1,50 @@
1+# Copyright (c) 2020, Huawei Technologies.All rights reserved.
2+#
3+# Licensed under the BSD 3-Clause License (the "License");
4+# you may not use this file except in compliance with the License.
5+# You may obtain a copy of the License at
6+#
7+# https://opensource.org/licenses/BSD-3-Clause
8+#
9+# Unless required by applicable law or agreed to in writing, software
10+# distributed under the License is distributed on an "AS IS" BASIS,
11+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+# See the License for the specific language governing permissions and
13+# limitations under the License.
14+ 
15+import torch
16+import numpy as np
17+ 
18+import torch_npu
19+from torch_npu.testing.testcase import TestCase, run_tests
20+from torch_npu.testing.common_utils import create_common_tensor
21+ 
22+ 
23+class TestBatchNormReduce(TestCase):
24+ def cuda_op_exec(self, input_data):
25+ cpu_sum = torch.sum(input_data, dim=[0, 2, 3])
26+ cpu_square_sum = torch.sum(input_data * input_data, dim=[0, 2, 3])
27+ return cpu_sum.numpy(), cpu_square_sum.numpy()
28+ 
29+ def npu_op_exec(self, *args):
30+ npu_sum, npu_square_sum = torch.batch_norm_reduce(*args)
31+ out_sum = npu_sum.cpu().numpy()
32+ out_square_sum = npu_square_sum.cpu().numpy()
33+ return out_sum, out_square_sum
34+ 
35+ def test_batch_norm_reduce(self):
36+ np.random.seed(1234)
37+ shape_format = [
38+ [[np.float32, -1, [2, 3, 12, 12]], 1e-5],
39+ ]
40+ for item in shape_format:
41+ cpu_input1, npu_inputfp32 = create_common_tensor(item[0], 1, 10)
42+ cpu_output = self.cuda_op_exec(cpu_input1)
43+ npu_outputfp32 = self.npu_op_exec(npu_inputfp32, item[-1])
44+ 
45+ self.assertRtolEqual(cpu_output[0], npu_outputfp32[0])
46+ self.assertRtolEqual(cpu_output[1], npu_outputfp32[1], 1e-2)
47+ 
48+ 
49+if __name__ == "__main__":
50+ run_tests()
Atest/test_v2r1_ops/test_adaptive_max_pool2d.py+54-0
@@ -0,0 +1,54 @@
1+import torch
2+import torch.nn as nn
3+import torch.nn.functional as F
4+import numpy as np
5+ 
6+from torch_npu.testing.testcase import TestCase, run_tests
7+from torch_npu.testing.common_utils import create_common_tensor
8+ 
9+ 
10+class TestAdaptiveMaxPool2d(TestCase):
11+ def cpu_op_exec(self, input1, output_size):
12+ m = nn.AdaptiveMaxPool2d(output_size)
13+ output = m(input1)
14+ return output.numpy()
15+ 
16+ def npu_op_exec(self, input1, output_size):
17+ m = nn.AdaptiveMaxPool2d(output_size).npu()
18+ output = m(input1)
19+ return output.cpu().numpy()
20+ 
21+ def test_adaptiveMaxPool2d_shape_format_fp32_6(self):
22+ np.random.seed(1234)
23+ format_list = [-1]
24+ # (1, 8, 9) IndexError
25+ shape_list = [(1, 5, 9, 9)]
26+ shape_format = [
27+ [np.float32, i, j] for i in format_list for j in shape_list
28+ ]
29+ output_list = [(3, 3)]
30+ for item in shape_format:
31+ cpu_input, npu_input = create_common_tensor(item, 0, 100)
32+ for output_size in output_list:
33+ cpu_output = self.cpu_op_exec(cpu_input, output_size)
34+ npu_output = self.npu_op_exec(npu_input, output_size)
35+ 
36+ self.assertRtolEqual(cpu_output, npu_output, 0.0004)
37+ 
38+ def test_adaptiveMaxPool2d_case_in_photo2cartoon(self):
39+ cpu_x = torch.rand(1, 256, 31, 31)
40+ npu_x = cpu_x.npu()
41+ cpu_out = F.adaptive_max_pool2d(cpu_x, 1)
42+ npu_out = F.adaptive_max_pool2d(npu_x, 1)
43+ self.assertRtolEqual(cpu_out, npu_out.cpu(), 0.0003)
44+ 
45+ def test_adaptiveMaxPool2d_case_in_photo2cartoon_fp16(self):
46+ cpu_x = torch.rand(1, 256, 31, 31).half()
47+ npu_x = cpu_x.npu()
48+ cpu_out = F.adaptive_max_pool2d(cpu_x.float(), 1).half()
49+ npu_out = F.adaptive_max_pool2d(npu_x, 1)
50+ self.assertRtolEqual(cpu_out, npu_out.cpu())
51+ 
52+ 
53+if __name__ == "__main__":
54+ run_tests()
Atest/test_v2r1_ops/test_argsort.py+65-0
@@ -0,0 +1,65 @@
1+import torch
2+import numpy as np
3+import torch_npu
4+ 
5+from torch_npu.testing.testcase import TestCase, run_tests
6+from torch_npu.testing.common_utils import create_common_tensor
7+ 
8+ 
9+class TestArgSort(TestCase):
10+ def cpu_op_exec(self, input1, dim, descending):
11+ output = torch.argsort(input1, dim=dim, descending=descending)
12+ return output.numpy()
13+ 
14+ def npu_op_exec(self, input1, dim, descending):
15+ output = torch.argsort(input1, dim=dim, descending=descending)
16+ 
17+ return output.cpu().numpy()
18+ 
19+ def cpu_default_op_exec(self, input1):
20+ output = torch.argsort(input1)
21+ return output.numpy()
22+ 
23+ def npu_default_op_exec(self, input1):
24+ output = torch.argsort(input1)
25+ return output.cpu().numpy()
26+ 
27+ def test_sort_shape_format_fp32(self, device="npu"):
28+ shape_format = [
29+ [[np.float32, 0, (8, 4, 3, 9)], 2, False],
30+ [[np.float32, 0, (2, 3)]],
31+ [[np.float32, 0, (1, 7)], 0, True],
32+ [[np.float32, 0, (1, 5, 6)], 1, False],
33+ ]
34+ 
35+ for item in shape_format:
36+ cpu_input1, npu_input1 = create_common_tensor(item[0], -100, 100)
37+ if len(item) > 1:
38+ cpu_output = self.cpu_op_exec(cpu_input1, item[1], item[2])
39+ npu_output = self.npu_op_exec(npu_input1, item[1], item[2])
40+ else:
41+ cpu_output = self.cpu_default_op_exec(cpu_input1)
42+ npu_output = self.npu_default_op_exec(npu_input1)
43+ self.assertRtolEqual(cpu_output, npu_output)
44+ 
45+ def test_sort_shape_format_fp16(self, device="npu"):
46+ shape_format = [
47+ [[np.float16, 0, (8, 4, 3, 9)], 2, False],
48+ [[np.float16, 0, (2, 3)]],
49+ [[np.float16, 0, (1, 7)], 0, True],
50+ [[np.float16, 0, (1, 5, 6)], 1, False],
51+ ]
52+ 
53+ for item in shape_format:
54+ cpu_input1, npu_input1 = create_common_tensor(item[0], -100, 100)
55+ if len(item) > 1:
56+ cpu_output = self.cpu_op_exec(cpu_input1.to(torch.float32), item[1], item[2])
57+ npu_output = self.npu_op_exec(npu_input1, item[1], item[2])
58+ else:
59+ cpu_output = self.cpu_default_op_exec(cpu_input1.to(torch.float32))
60+ npu_output = self.npu_default_op_exec(npu_input1)
61+ self.assertRtolEqual(cpu_output, npu_output)
62+ 
63+ 
64+if __name__ == "__main__":
65+ run_tests()