zzy34407230
/
mindspore2022
Not watched
1
0
Fork 0
Code
Releases 22 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 6fcd6cab68
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6fcd6cab68'
${ noResults }
mindspore2022/tests/st/ops/gpu/test_scatter_update_op.py

360 lines
16 kB
Raw Blame History 

  1. # Copyright 2020 Huawei Technologies Co., Ltd

  2. #

  3. # Licensed under the Apache License, Version 2.0 (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. # http://www.apache.org/licenses/LICENSE-2.0

  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 numpy as np

  17. import pytest

  18. import mindspore.context as context

  19. import mindspore.nn as nn

  20. from mindspore import Tensor, Parameter

  21. from mindspore.ops import operations as P

  22. from mindspore.ops.operations import _inner_ops as inner

  23. 

  24. context.set_context(mode=context.GRAPH_MODE, device_target="GPU")

  25. # all cases tested against dchip

  26. 

  27. class TestScatterUpdateNet(nn.Cell):

  28.     def __init__(self, inputx, indices, updates):

  29.         super(TestScatterUpdateNet, self).__init__()

  30.         self.scatter_update = P.ScatterUpdate()

  31.         self.inputx = Parameter(inputx, name="inputx")

  32.         self.indices = Parameter(indices, name="indices")

  33.         self.updates = Parameter(updates, name="updates")

  34. 

  35.     def construct(self):

  36.         out = self.scatter_update(self.inputx, self.indices, self.updates)

  37.         return out

  38. 

  39. def scatter_update_net(inputx, indices, updates):

  40.     net = TestScatterUpdateNet(inputx, indices, updates)

  41.     return net()

  42. 

  43. class TestScatterUpdateDynamicNet(nn.Cell):

  44.     def __init__(self, inputx, indices, updates):

  45.         super(TestScatterUpdateDynamicNet, self).__init__()

  46.         self.scatter_update = P.ScatterUpdate()

  47.         self.test_dynamic = inner.GpuConvertToDynamicShape()

  48.         self.inputx = Parameter(inputx, name="inputx")

  49.         self.indices = Parameter(indices, name="indices")

  50.         self.updates = Parameter(updates, name="updates")

  51. 

  52.     def construct(self):

  53.         indices = self.test_dynamic(self.indices)

  54.         updates = self.test_dynamic(self.updates)

  55.         out = self.scatter_update(self.inputx, indices, updates)

  56.         return out

  57. 

  58. def scatter_update_d_net(inputx, indices, updates):

  59.     context.set_context(mode=context.GRAPH_MODE, device_target="GPU")

  60.     net = TestScatterUpdateDynamicNet(inputx, indices, updates)

  61.     return net()

  62. 

  63. class TestScatterUpdateDynamicNet2(nn.Cell):

  64.     def __init__(self, inputx):

  65.         super(TestScatterUpdateDynamicNet2, self).__init__()

  66.         self.scatter_update = P.ScatterUpdate()

  67.         self.test_dynamic = inner.GpuConvertToDynamicShape()

  68.         self.inputx = Parameter(inputx, name="inputx")

  69. 

  70.     def construct(self, indices, updates):

  71.         indices = self.test_dynamic(indices)

  72.         updates = self.test_dynamic(updates)

  73.         out = self.scatter_update(self.inputx, indices, updates)

  74.         return out

  75. 

  76. def scatter_update_d2_net(inputx, indices_1, updates_1,

  77.                           indices_2, updates_2):

  78.     context.set_context(mode=context.GRAPH_MODE, device_target="GPU")

  79.     net = TestScatterUpdateDynamicNet2(inputx)

  80.     out1 = net(indices_1, updates_1)

  81.     out2 = net(indices_2, updates_2)

  82.     return (out1, out2)

  83. 

  84. @pytest.mark.level0

  85. @pytest.mark.platform_x86_gpu_training

  86. @pytest.mark.env_onecard

  87. def test_scatter_update_small_float32():

  88.     inputx = Tensor(np.zeros((2, 3)).astype(np.float32))

  89.     indices = Tensor(np.array([0, 1]).astype(np.int32))

  90.     updates = Tensor(np.arange(6).reshape((2, 3)).astype(np.float32))

  91.     output = scatter_update_net(inputx, indices, updates)

  92.     expected = np.array([[0., 1., 2.],

  93.                          [3., 4., 5.]])

  94.     np.testing.assert_array_almost_equal(output.asnumpy(), expected)

  95. 

  96. @pytest.mark.level0

  97. @pytest.mark.platform_x86_gpu_training

  98. @pytest.mark.env_onecard

  99. def test_scatter_update_input_updated():

  100.     inputx = Tensor(np.zeros((2, 3)).astype(np.float32))

  101.     indices = Tensor(np.array([0, 1]).astype(np.int32))

  102.     updates = Tensor(np.arange(6).reshape((2, 3)).astype(np.float32))

  103.     net = TestScatterUpdateNet(inputx, indices, updates)

  104.     net()

  105.     expected = np.array([[0., 1., 2.],

  106.                          [3., 4., 5.]])

  107.     np.testing.assert_array_almost_equal(net.inputx.asnumpy(), expected)

  108. 

  109. @pytest.mark.level0

  110. @pytest.mark.platform_x86_gpu_training

  111. @pytest.mark.env_onecard

  112. def test_scatter_update_input_less_than_1_float32():

  113.     inputx = Tensor(np.array([[0.214141, 0.415151, 0.51516],

  114.                               [0.876542, 0.451611, 0.55112],

  115.                               [0.111244, 0.633333, 0.34444]]).astype(np.float32))

  116.     indices = Tensor(np.array([1, 0, 2]).astype(np.int32))

  117.     updates = Tensor(np.arange(34, 43).reshape((3, 3)).astype(np.float32))

  118.     output = scatter_update_net(inputx, indices, updates)

  119.     expected = np.array([[37., 38., 39.],

  120.                          [34., 35., 36.],

  121.                          [40., 41., 42.]], dtype=np.float32)

  122.     np.testing.assert_array_almost_equal(output.asnumpy(), expected)

  123. 

  124. @pytest.mark.level0

  125. @pytest.mark.platform_x86_gpu_training

  126. @pytest.mark.env_onecard

  127. def test_scatter_update_float16():

  128.     inputx = Tensor(np.zeros((2, 3)).astype(np.float16))

  129.     indices = Tensor(np.array([0, 1]).astype(np.int32))

  130.     updates = Tensor(np.arange(6).reshape((2, 3)).astype(np.float16))

  131.     output = scatter_update_net(inputx, indices, updates)

  132.     expected = np.array([[0., 1., 2.],

  133.                          [3., 4., 5.]]).astype(np.float16)

  134.     np.testing.assert_array_almost_equal(output.asnumpy(), expected)

  135. 

  136. @pytest.mark.level0

  137. @pytest.mark.platform_x86_gpu_training

  138. @pytest.mark.env_onecard

  139. def test_scatter_update_int32():

  140.     inputx = Tensor(np.zeros((2, 3)).astype(np.int32))

  141.     indices = Tensor(np.array([0, 1]).astype(np.int32))

  142.     updates = Tensor(np.arange(6).reshape((2, 3)).astype(np.int32))

  143.     output = scatter_update_net(inputx, indices, updates)

  144.     expected = np.array([[0., 1., 2.],

  145.                          [3., 4., 5.]]).astype(np.int32)

  146.     np.testing.assert_array_almost_equal(output.asnumpy(), expected)

  147. 

  148. @pytest.mark.level0

  149. @pytest.mark.platform_x86_gpu_training

  150. @pytest.mark.env_onecard

  151. def test_scatter_update_large_float16():

  152.     inputx = Tensor(np.zeros((4, 3)).astype(np.float16))

  153.     indices = Tensor(np.array([[2, 1], [0, 3]]).astype(np.int32))

  154.     updates = Tensor(np.arange(63, 75).reshape((2, 2, 3)).astype(np.float16))

  155.     output = scatter_update_net(inputx, indices, updates)

  156.     expected = np.array([[69., 70., 71.],

  157.                          [66., 67., 68.],

  158.                          [63., 64., 65.],

  159.                          [72., 73., 74.]]).astype(np.float16)

  160.     np.testing.assert_array_almost_equal(output.asnumpy(), expected)

  161. 

  162. @pytest.mark.level0

  163. @pytest.mark.platform_x86_gpu_training

  164. @pytest.mark.env_onecard

  165. def test_scatter_update_disordered_float16():

  166.     inputx = Tensor(np.flip(np.arange(34, 46).reshape(3, 4).astype(np.float16)))

  167.     indices = Tensor(np.array([1, 2]).astype(np.int32))

  168.     updates = Tensor(np.arange(63, 71).reshape((2, 4)).astype(np.float16))

  169.     output = scatter_update_net(inputx, indices, updates)

  170.     expected = np.array([[45., 44., 43., 42.],

  171.                          [63., 64., 65., 66.],

  172.                          [67., 68., 69., 70.]]).astype(np.float16)

  173.     np.testing.assert_array_almost_equal(output.asnumpy(), expected)

  174. 

  175. @pytest.mark.level0

  176. @pytest.mark.platform_x86_gpu_training

  177. @pytest.mark.env_onecard

  178. def test_scatter_update_disordered_int32():

  179.     inputx = Tensor(np.flip(np.arange(34, 46).reshape(3, 4).astype(np.int32)))

  180.     indices = Tensor(np.array([1, 2]).astype(np.int32))

  181.     updates = Tensor(np.arange(63, 71).reshape((2, 4)).astype(np.int32))

  182.     output = scatter_update_net(inputx, indices, updates)

  183.     expected = np.array([[45., 44., 43., 42.],

  184.                          [63., 64., 65., 66.],

  185.                          [67., 68., 69., 70.]]).astype(np.int32)

  186.     np.testing.assert_array_almost_equal(output.asnumpy(), expected)

  187. 

  188. @pytest.mark.level0

  189. @pytest.mark.platform_x86_gpu_training

  190. @pytest.mark.env_onecard

  191. def test_scatter_update_large_shape_float16():

  192.     inputx = Tensor(np.arange(96).reshape((4, 2, 3, 4)).astype(np.float16))

  193.     indices = Tensor(np.array([1, 0]).astype(np.int32))

  194.     updates = Tensor(np.flip(np.arange(48).reshape((2, 2, 3, 4)).astype(np.float16)))

  195.     output = scatter_update_net(inputx, indices, updates)

  196.     expected = np.array([[[[23., 22., 21., 20.],

  197.                            [19., 18., 17., 16.],

  198.                            [15., 14., 13., 12.]],

  199.                           [[11., 10., 9., 8.],

  200.                            [7., 6., 5., 4.],

  201.                            [3., 2., 1., 0.]]],

  202.                          [[[47., 46., 45., 44.],

  203.                            [43., 42., 41., 40.],

  204.                            [39., 38., 37., 36.]],

  205.                           [[35., 34., 33., 32.],

  206.                            [31., 30., 29., 28.],

  207.                            [27., 26., 25., 24.]]],

  208.                          [[[48., 49., 50., 51.],

  209.                            [52., 53., 54., 55.],

  210.                            [56., 57., 58., 59.]],

  211.                           [[60., 61., 62., 63.],

  212.                            [64., 65., 66., 67.],

  213.                            [68., 69., 70., 71.]]],

  214.                          [[[72., 73., 74., 75.],

  215.                            [76., 77., 78., 79.],

  216.                            [80., 81., 82., 83.]],

  217.                           [[84., 85., 86., 87.],

  218.                            [88., 89., 90., 91.],

  219.                            [92., 93., 94., 95.]]]]).astype(np.float16)

  220.     np.testing.assert_array_almost_equal(output.asnumpy(), expected)

  221. 

  222. @pytest.mark.level0

  223. @pytest.mark.platform_x86_gpu_training

  224. @pytest.mark.env_onecard

  225. def test_scatter_update_disordered_int8():

  226.     inputx = Tensor(np.flip(np.arange(34, 46).reshape(3, 4).astype(np.int8)))

  227.     indices = Tensor(np.array([1, 2]).astype(np.int32))

  228.     updates = Tensor(np.arange(63, 71).reshape((2, 4)).astype(np.int8))

  229.     output = scatter_update_net(inputx, indices, updates)

  230.     expected = np.array([[45., 44., 43., 42.],

  231.                          [63., 64., 65., 66.],

  232.                          [67., 68., 69., 70.]]).astype(np.int8)

  233.     np.testing.assert_array_almost_equal(output.asnumpy(), expected)

  234. 

  235. @pytest.mark.level0

  236. @pytest.mark.platform_x86_gpu_training

  237. @pytest.mark.env_onecard

  238. def test_scatter_update_large_shape_int8():

  239.     inputx = Tensor(np.arange(96).reshape((4, 2, 3, 4)).astype(np.int8))

  240.     indices = Tensor(np.array([1, 0]).astype(np.int32))

  241.     updates = Tensor(np.flip(np.arange(48).reshape((2, 2, 3, 4)).astype(np.int8)))

  242.     output = scatter_update_net(inputx, indices, updates)

  243.     expected = np.array([[[[23., 22., 21., 20.],

  244.                            [19., 18., 17., 16.],

  245.                            [15., 14., 13., 12.]],

  246.                           [[11., 10., 9., 8.],

  247.                            [7., 6., 5., 4.],

  248.                            [3., 2., 1., 0.]]],

  249.                          [[[47., 46., 45., 44.],

  250.                            [43., 42., 41., 40.],

  251.                            [39., 38., 37., 36.]],

  252.                           [[35., 34., 33., 32.],

  253.                            [31., 30., 29., 28.],

  254.                            [27., 26., 25., 24.]]],

  255.                          [[[48., 49., 50., 51.],

  256.                            [52., 53., 54., 55.],

  257.                            [56., 57., 58., 59.]],

  258.                           [[60., 61., 62., 63.],

  259.                            [64., 65., 66., 67.],

  260.                            [68., 69., 70., 71.]]],

  261.                          [[[72., 73., 74., 75.],

  262.                            [76., 77., 78., 79.],

  263.                            [80., 81., 82., 83.]],

  264.                           [[84., 85., 86., 87.],

  265.                            [88., 89., 90., 91.],

  266.                            [92., 93., 94., 95.]]]]).astype(np.int8)

  267.     np.testing.assert_array_almost_equal(output.asnumpy(), expected)

  268. 

  269. @pytest.mark.level0

  270. @pytest.mark.platform_x86_gpu_training

  271. @pytest.mark.env_onecard

  272. def test_scatter_update_large_uint8():

  273.     inputx = Tensor(np.zeros((4, 3)).astype(np.uint8))

  274.     indices = Tensor(np.array([[2, 1], [0, 3]]).astype(np.int32))

  275.     updates = Tensor(np.arange(63, 75).reshape((2, 2, 3)).astype(np.uint8))

  276.     output = scatter_update_net(inputx, indices, updates)

  277.     expected = np.array([[69., 70., 71.],

  278.                          [66., 67., 68.],

  279.                          [63., 64., 65.],

  280.                          [72., 73., 74.]]).astype(np.uint8)

  281.     np.testing.assert_array_almost_equal(output.asnumpy(), expected)

  282. 

  283. @pytest.mark.level0

  284. @pytest.mark.platform_x86_gpu_training

  285. @pytest.mark.env_onecard

  286. def test_scatter_update_disordered_uint8():

  287.     inputx = Tensor(np.flip(np.arange(34, 46).reshape(3, 4).astype(np.uint8)))

  288.     indices = Tensor(np.array([1, 2]).astype(np.int32))

  289.     updates = Tensor(np.arange(63, 71).reshape((2, 4)).astype(np.uint8))

  290.     output = scatter_update_net(inputx, indices, updates)

  291.     expected = np.array([[45., 44., 43., 42.],

  292.                          [63., 64., 65., 66.],

  293.                          [67., 68., 69., 70.]]).astype(np.uint8)

  294.     np.testing.assert_array_almost_equal(output.asnumpy(), expected)

  295. 

  296. @pytest.mark.level0

  297. @pytest.mark.platform_x86_gpu_training

  298. @pytest.mark.env_onecard

  299. def test_scatter_update_large_shape_dynamic_int8():

  300.     inputx = Tensor(np.arange(96).reshape((4, 2, 3, 4)).astype(np.int8))

  301.     indices = Tensor(np.array([1, 0]).astype(np.int32))

  302.     updates = Tensor(np.flip(np.arange(48).reshape((2, 2, 3, 4)).astype(np.int8)))

  303.     output = scatter_update_d_net(inputx, indices, updates)

  304.     expected = np.array([[[[23., 22., 21., 20.],

  305.                            [19., 18., 17., 16.],

  306.                            [15., 14., 13., 12.]],

  307.                           [[11., 10., 9., 8.],

  308.                            [7., 6., 5., 4.],

  309.                            [3., 2., 1., 0.]]],

  310.                          [[[47., 46., 45., 44.],

  311.                            [43., 42., 41., 40.],

  312.                            [39., 38., 37., 36.]],

  313.                           [[35., 34., 33., 32.],

  314.                            [31., 30., 29., 28.],

  315.                            [27., 26., 25., 24.]]],

  316.                          [[[48., 49., 50., 51.],

  317.                            [52., 53., 54., 55.],

  318.                            [56., 57., 58., 59.]],

  319.                           [[60., 61., 62., 63.],

  320.                            [64., 65., 66., 67.],

  321.                            [68., 69., 70., 71.]]],

  322.                          [[[72., 73., 74., 75.],

  323.                            [76., 77., 78., 79.],

  324.                            [80., 81., 82., 83.]],

  325.                           [[84., 85., 86., 87.],

  326.                            [88., 89., 90., 91.],

  327.                            [92., 93., 94., 95.]]]]).astype(np.int8)

  328.     np.testing.assert_array_almost_equal(output.asnumpy(), expected)

  329. 

  330. @pytest.mark.level0

  331. @pytest.mark.platform_x86_gpu_training

  332. @pytest.mark.env_onecard

  333. def test_scatter_update_disordered_dynamic_int32():

  334.     inputx = Tensor(np.flip(np.arange(34, 46).reshape(3, 4).astype(np.int32)))

  335.     indices = Tensor(np.array([1, 2]).astype(np.int32))

  336.     updates = Tensor(np.arange(63, 71).reshape((2, 4)).astype(np.int32))

  337.     output = scatter_update_d_net(inputx, indices, updates)

  338.     expected = np.array([[45., 44., 43., 42.],

  339.                          [63., 64., 65., 66.],

  340.                          [67., 68., 69., 70.]]).astype(np.int32)

  341.     np.testing.assert_array_almost_equal(output.asnumpy(), expected)

  342. 

  343. @pytest.mark.level0

  344. @pytest.mark.platform_x86_gpu_training

  345. @pytest.mark.env_onecard

  346. def test_scatter_update_two_inputs():

  347.     inputx = Tensor(np.zeros((2, 3)).astype(np.float32))

  348.     indices_1 = Tensor(np.array([0, 1]).astype(np.int32))

  349.     updates_1 = Tensor(np.arange(6).reshape((2, 3)).astype(np.float32))

  350.     indices_2 = Tensor(np.array([1]).astype(np.int32))

  351.     updates_2 = Tensor(np.arange(34, 37).reshape((1, 3)).astype(np.float32))

  352.     output_1, output_2 = scatter_update_d2_net(inputx, indices_1, updates_1,

  353.                                                indices_2, updates_2)

  354.     expected_1 = np.array([[0., 1., 2.],

  355.                            [3., 4., 5.]], dtype=np.float32)

  356.     expected_2 = np.array([[0., 1., 2.],

  357.                            [34., 35., 36.]], dtype=np.float32)

  358.     np.testing.assert_array_almost_equal(output_1.asnumpy(), expected_1)

  359.     np.testing.assert_array_almost_equal(output_2.asnumpy(), expected_2)