Huawei_Technology
/
mindspore
Not watched
1
0
Fork 0
Code
Releases 13 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: 11f5f88021
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '11f5f88021'
${ noResults }
mindspore/tests/st/pynative/test_tensor_index.py

742 lines
26 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. """ test_tensor_slice """

  16. import numpy as np

  17. import pytest

  18. 

  19. from mindspore import Tensor, Parameter

  20. from mindspore import context

  21. from mindspore import dtype as mstype

  22. from mindspore.nn import Cell

  23. 

  24. def setup_module():

  25.     context.set_context(mode=context.PYNATIVE_MODE, device_target="Ascend")

  26. 

  27. class NetWorkSlicePositive(Cell):

  28.     def __init__(self):

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

  30.         self.tensor_ret0 = Tensor(np.ones([1, 2, 3], np.int32))

  31.         self.tensor_ret1 = Tensor(np.ones([4, 8, 10], np.int32))

  32.         self.tensor_ret2 = Tensor(np.ones([6, 8, 10], np.int32))

  33.         self.tensor_ret3 = Tensor(np.ones([3, 8, 10], np.int32))

  34. 

  35.     def construct(self, tensor):

  36.         ret0 = tensor[3:4:1, 1:5:2, 3:6:1] + self.tensor_ret0

  37.         ret1 = tensor[-6:4:1, 0:8:1, ::1] + self.tensor_ret1

  38.         ret2 = tensor[::, ::, ::] + self.tensor_ret2

  39.         ret3 = tensor[::2] + self.tensor_ret3

  40.         return ret0, ret1, ret2, ret3

  41. 

  42. 

  43. def test_slice_positive():

  44.     net = NetWorkSlicePositive()

  45.     input_np = np.arange(6*8*10).reshape(6, 8, 10).astype(np.int32)

  46.     input_0 = Tensor(input_np)

  47.     output0, output1, output2, output3 = net(input_0)

  48.     assert np.all(output0.asnumpy() == input_np[3:4:1, 1:5:2, 3:6:1] + np.ones([1, 2, 3]))

  49.     assert np.all(output1.asnumpy() == input_np[-6:4:1, 0:8:1, ::1] + np.ones([4, 8, 10]))

  50.     assert np.all(output2.asnumpy() == input_np[::, ::, ::] + np.ones([6, 8, 10]))

  51.     assert np.all(output3.asnumpy() == input_np[::2] + np.ones([3, 8, 10]))

  52. 

  53. 

  54. class NetWorkSliceEllipsis(Cell):

  55.     def __init__(self):

  56.         super(NetWorkSliceEllipsis, self).__init__()

  57.         self.tensor_ret0 = Tensor(np.ones([2, 7, 8], np.int32))

  58.         self.tensor_ret1 = Tensor(np.ones([6, 7, 8, 9], np.int32))

  59.         self.tensor_ret2 = Tensor(np.ones([1, 6, 7, 8, 9], np.int32))

  60. 

  61.     def construct(self, tensor):

  62.         ret0 = tensor[0:4:2, ..., 1] + self.tensor_ret0

  63.         ret1 = tensor[...] + self.tensor_ret1

  64.         ret2 = tensor[None] + self.tensor_ret2

  65.         ret3 = tensor[True] + self.tensor_ret2

  66.         return ret0, ret1, ret2, ret3

  67. 

  68. 

  69. def Xtest_slice_ellipsis():

  70.     net = NetWorkSliceEllipsis()

  71.     input_np = np.arange(6*7*8*9).reshape(6, 7, 8, 9).astype(np.int32)

  72.     input_0 = Tensor(input_np)

  73.     output0, output1, output2, output3 = net(input_0)

  74.     assert np.all(output0.asnumpy() == input_np[0:4:2, ..., 1] + np.ones([1, 2, 3]))

  75.     assert np.all(output1.asnumpy() == input_np[...] + np.ones([6, 7, 8, 9]))

  76.     assert np.all(output2.asnumpy() == input_np[None] + np.ones([6, 7, 8, 9]))

  77.     assert np.all(output3.asnumpy() == input_np[True] + np.ones([1, 6, 7, 8, 9]))

  78. 

  79. 

  80. class NetWorkReduceDimension(Cell):

  81.     def __init__(self):

  82.         super(NetWorkReduceDimension, self).__init__()

  83.         self.tensor_ret1 = Tensor(np.ones([3, 10], np.int32))

  84.         self.tensor_ret2 = Tensor(np.ones([6, 8], np.int32))

  85.         self.tensor_ret3 = Tensor(np.array(8, np.int32))

  86.         self.tensor_ret4 = Tensor(np.ones([8, 10], np.int32))

  87. 

  88.     def construct(self, tensor):

  89.         ret1 = tensor[::2, 1, ::1] + self.tensor_ret1

  90.         ret2 = tensor[::, ::, 0] + self.tensor_ret2

  91.         ret3 = tensor[3, 2, 5] + self.tensor_ret3

  92.         ret4 = tensor[1] + self.tensor_ret4

  93.         return ret1, ret2, ret3, ret4

  94. 

  95. 

  96. def Xtest_reduce_dimension():

  97.     net = NetWorkReduceDimension()

  98.     input_np = np.arange(6*8*10).reshape(6, 8, 10).astype(np.int32)

  99.     input_0 = Tensor(input_np)

  100.     output1, output2, output3, output4 = net(input_0)

  101.     assert np.all(output1.asnumpy() == input_np[::2, 1, ::1] + np.ones([3, 10]))

  102.     assert np.all(output2.asnumpy() == input_np[::, ::, 0] + np.ones([6, 8]))

  103.     assert np.all(output3.asnumpy() == input_np[3, 2, 5] + np.array(8, np.int32))

  104.     assert np.all(output4.asnumpy() == input_np[1] + np.ones([8, 10]))

  105. 

  106. 

  107. class NetWorkSliceStep(Cell):

  108.     def __init__(self):

  109.         super(NetWorkSliceStep, self).__init__()

  110.         self.tensor_ret1 = Tensor(np.ones([6, 5, 10], np.int32))

  111.         self.tensor_ret2 = Tensor(np.ones([3, 5, 5], np.int32))

  112. 

  113.     def construct(self, tensor):

  114.         ret1 = tensor[::1, -5::, ::-1] + self.tensor_ret1

  115.         ret2 = tensor[::2, -5::, ::2] + self.tensor_ret2

  116.         return ret1, ret2

  117. 

  118. 

  119. def Xtest_step_negative():

  120.     net = NetWorkSliceEllipsis()

  121.     input_np = np.arange(6*8*10).reshape(6, 8, 10).astype(np.int32)

  122.     input_0 = Tensor(input_np)

  123.     output1, output2 = net(input_0)

  124.     assert np.all(output1.asnumpy() == input_np[::1, -5::, ::-1] + np.ones([6, 8, 10]))

  125.     assert np.all(output2.asnumpy() == input_np[::2, -5::, ::2] + np.ones([3, 5, 5]))

  126. 

  127. 

  128. class TensorGetItemByThreeTensors(Cell):

  129.     def __init__(self):

  130.         super(TensorGetItemByThreeTensors, self).__init__()

  131.         self.const0 = Tensor(np.ones((4, 5, 8, 10)), mstype.int32)

  132.         self.const1 = Tensor(np.ones((3, 4, 5, 10)), mstype.int32)

  133.         self.const2 = Tensor(np.ones((5, 3, 4, 5)), mstype.int32)

  134. 

  135.     def construct(self, x, index_0, index_1, index_2):

  136.         ret0 = x[index_0] + self.const0

  137.         ret1 = x[index_0, index_1] + self.const1

  138.         ret2 = x[index_0, index_1, index_2] + self.const2

  139.         return ret0, ret1, ret2

  140. 

  141. 

  142. def Xtest_getitem_by_tensors():

  143.     net = TensorGetItemByThreeTensors()

  144.     input_x = np.arange(6*8*10).reshape(6, 8, 10).astype(np.int32)

  145.     index_0 = np.random.randint(6, size=(3, 4, 5)).astype(np.int32)

  146.     index_1 = np.random.randint(6, size=(4, 5)).astype(np.int32)

  147.     index_2 = np.random.randint(6, size=(5, 3, 4, 5)).astype(np.int32)

  148.     input_x_ms = Tensor(input_x)

  149.     index_0_ms = Tensor(index_0)

  150.     index_1_ms = Tensor(index_1)

  151.     input_2_ms = Tensor(index_2)

  152.     output0, output1, output2 = net(input_x_ms, index_0_ms, index_1_ms, input_2_ms)

  153.     assert np.all(output0.asnumpy() == input_x[index_0] + np.ones([4, 5, 8, 10]))

  154.     assert np.all(output1.asnumpy() == input_x[index_0, index_1] + np.ones([3, 4, 5, 10]))

  155.     assert np.all(output2.asnumpy() == input_x[index_0, index_1, index_2] + np.ones([5, 3, 4, 5]))

  156. 

  157. 

  158. class TensorGetItemByMixedTensors_0(Cell):

  159.     def __init__(self):

  160.         super(TensorGetItemByMixedTensors_0, self).__init__()

  161.         self.const = Tensor(np.ones((3, 4, 5, 3, 6, 5), np.float32))

  162. 

  163.     def construct(self, tensor, index_0, index_1):

  164.         ret = tensor[index_0, index_1, 0:3, ..., 0:5, 3] + self.const

  165.         return ret

  166. 

  167. 

  168. class TensorGetItemByMixedTensors_1(Cell):

  169.     def __init__(self):

  170.         super(TensorGetItemByMixedTensors_1, self).__init__()

  171.         self.const = Tensor(np.ones((3, 4, 5, 3, 5, 5), np.float32))

  172. 

  173.     def construct(self, tensor, index_0, index_1):

  174.         ret = tensor[0:3, index_0, ..., index_1, 3, 0:5] + self.const

  175.         return ret

  176. 

  177. 

  178. class TensorGetItemByMixedTensors_2(Cell):

  179.     def __init__(self):

  180.         super(TensorGetItemByMixedTensors_2, self).__init__()

  181.         self.const = Tensor(np.ones((3, 4, 5, 6, 7), np.float32))

  182. 

  183.     def construct(self, tensor, index_0, index_1):

  184.         ret = tensor[0, index_0, index_1, ..., 3] + self.const

  185.         return ret

  186. 

  187. 

  188. class TensorGetItemByMixedTensors_3(Cell):

  189.     def __init__(self):

  190.         super(TensorGetItemByMixedTensors_3, self).__init__()

  191.         self.const = Tensor(np.ones((3, 4, 5, 3, 4, 3, 5), np.float32))

  192. 

  193.     def construct(self, tensor, index_0, index_1):

  194.         ret = tensor[..., index_0, 0:3, index_1, 0:5] + self.const

  195.         return ret

  196. 

  197. 

  198. class TensorGetItemByMixedTensors_4(Cell):

  199.     def __init__(self):

  200.         super(TensorGetItemByMixedTensors_4, self).__init__()

  201.         self.const = Tensor(np.ones((2, 2, 3, 4, 5, 3, 9), np.float32))

  202. 

  203.     def construct(self, tensor, index_0, index_1, index_2):

  204.         ret = tensor[0:2, index_0, index_1, 2, index_2, 0:3, ...] + self.const

  205.         return ret

  206. 

  207. 

  208. class TensorGetItemByMixedTensors_5(Cell):

  209.     def __init__(self):

  210.         super(TensorGetItemByMixedTensors_5, self).__init__()

  211.         self.const = Tensor(np.ones((2, 3, 4, 5, 2, 6), np.float32))

  212. 

  213.     def construct(self, tensor, index_0, index_1, index_2):

  214.         ret = tensor[0:2, index_0, index_1, ..., index_2, 2] + self.const

  215.         return ret

  216. 

  217. 

  218. class TensorGetItemByMixedTensors_6(Cell):

  219.     def __init__(self):

  220.         super(TensorGetItemByMixedTensors_6, self).__init__()

  221.         self.const = Tensor(np.ones((3, 4, 2, 3, 4, 5), np.float32))

  222. 

  223.     def construct(self, tensor, index_0, index_1, index_2):

  224.         ret = tensor[..., index_0, index_1, index_2, 3] + self.const

  225.         return ret

  226. 

  227. 

  228. class TensorSetItemByMixedTensors_0(Cell):

  229.     def __init__(self, value):

  230.         super(TensorSetItemByMixedTensors_0, self).__init__()

  231.         self.const = Tensor(np.ones((3, 4, 5, 6, 7, 8, 9), np.float32))

  232.         self.param = Parameter(Tensor(np.arange(3 * 4 * 5 * 6 * 7 * 8 * 9).reshape((3, 4, 5, 6, 7, 8, 9)),

  233.                                       mstype.float32),

  234.                                name="x")

  235.         self.value = value

  236. 

  237.     def construct(self, index_0, index_1, index_2):

  238.         self.param[0:2, index_0, index_1, 2, index_2, 0:3, ...] = self.value

  239.         ret = self.param + self.const

  240.         return ret

  241. 

  242. 

  243. class TensorSetItemByMixedTensors_1(Cell):

  244.     def __init__(self, value):

  245.         super(TensorSetItemByMixedTensors_1, self).__init__()

  246.         self.const = Tensor(np.ones((3, 4, 5, 6, 7, 8), np.float32))

  247.         self.param = Parameter(Tensor(np.arange(3 * 4 * 5 * 6 * 7 * 8).reshape((3, 4, 5, 6, 7, 8)), mstype.float32),

  248.                                name="x")

  249.         self.value = value

  250. 

  251.     def construct(self, index_0, index_1, index_2):

  252.         self.param[0:2, index_0, index_1, ..., index_2, 2] = self.value

  253.         ret = self.param + self.const

  254.         return ret

  255. 

  256. 

  257. class TensorSetItemByMixedTensors_2(Cell):

  258.     def __init__(self, value):

  259.         super(TensorSetItemByMixedTensors_2, self).__init__()

  260.         self.const = Tensor(np.ones((3, 4, 5, 6, 7, 8), np.float16))

  261.         self.param = Parameter(Tensor(np.arange(3 * 4 * 5 * 6 * 7 * 8).reshape((3, 4, 5, 6, 7, 8)), mstype.float16),

  262.                                name="x")

  263.         self.value = value

  264. 

  265.     def construct(self, index_0, index_1, index_2):

  266.         self.param[..., index_0, index_1, index_2, 3] = self.value

  267.         ret = self.param + self.const

  268.         return ret

  269. 

  270. 

  271. class TensorGetItemByMixedTensorsTypeError(Cell):

  272.     def __init__(self):

  273.         super(TensorGetItemByMixedTensorsTypeError, self).__init__()

  274. 

  275.     def construct(self, x, index_0, index_1):

  276.         ret = x[index_0, index_1, 0:3, ..., 0:5, [1, 2, 3, 4]]

  277.         return ret

  278. 

  279. 

  280. class TensorGetItemByMixedTensorsNumberError(Cell):

  281.     def __init__(self):

  282.         super(TensorGetItemByMixedTensorsNumberError, self).__init__()

  283. 

  284.     def construct(self, x, index_0, index_1):

  285.         ret = x[index_0, index_1, 0:3, ..., index_1, index_0]

  286.         return ret

  287. 

  288. 

  289. class TensorSetItemByOneTensorWithNumber(Cell):

  290.     def __init__(self, value):

  291.         super(TensorSetItemByOneTensorWithNumber, self).__init__()

  292.         self.const = Tensor(np.ones((6, 7, 8)), mstype.float32)

  293.         self.param = Parameter(Tensor(np.arange(6 * 7 * 8).reshape((6, 7, 8)), mstype.float32), name="x")

  294.         self.value = value

  295. 

  296.     def construct(self, index):

  297.         self.param[index] = self.value

  298.         ret = self.param + self.const

  299.         return ret

  300. 

  301. 

  302. class TensorSetItemByOneTensorWithTensor(Cell):

  303.     def __init__(self):

  304.         super(TensorSetItemByOneTensorWithTensor, self).__init__()

  305.         self.const = Tensor(np.ones((6, 7, 8)), mstype.float32)

  306.         self.param = Parameter(Tensor(np.arange(6 * 7 * 8).reshape((6, 7, 8)), mstype.float32), name="x")

  307. 

  308.     def construct(self, index, value):

  309.         self.param[index] = value

  310.         ret = self.param + self.const

  311.         return ret

  312. 

  313. 

  314. class TensorSetItemByOneTensorWithTupleOfNumber(Cell):

  315.     def __init__(self, value):

  316.         super(TensorSetItemByOneTensorWithTupleOfNumber, self).__init__()

  317.         self.const = Tensor(np.ones((6, 7, 8)), mstype.float32)

  318.         self.param = Parameter(Tensor(np.arange(6 * 7 * 8).reshape((6, 7, 8)), mstype.float32), name="x")

  319.         self.value = value

  320. 

  321.     def construct(self, index):

  322.         self.param[index] = self.value

  323.         ret = self.param + self.const

  324.         return ret

  325. 

  326. 

  327. class TensorSetItemByOneTensorWithTupleOfTensor(Cell):

  328.     def __init__(self):

  329.         super(TensorSetItemByOneTensorWithTupleOfTensor, self).__init__()

  330.         self.const = Tensor(np.ones((6, 3, 8)), mstype.float32)

  331.         self.param = Parameter(Tensor(np.arange(6 * 3 * 8).reshape((6, 3, 8)), mstype.float32), name="x")

  332. 

  333.     def construct(self, index, value_0, value_1, value_2):

  334.         self.param[index] = (value_0, value_1, value_2)

  335.         ret = self.param + self.const

  336.         return ret

  337. 

  338. 

  339. class TensorSetItemByTensorsWithNumber(Cell):

  340.     def __init__(self, value):

  341.         super(TensorSetItemByTensorsWithNumber, self).__init__()

  342.         self.const = Tensor(np.ones((6, 7, 8)), mstype.float32)

  343.         self.param = Parameter(Tensor(np.arange(6 * 7 * 8).reshape((6, 7, 8)), mstype.float32), name="x")

  344.         self.value = value

  345. 

  346.     def construct(self, index_0, index_1, index_2):

  347.         self.param[index_0, index_1, index_2] = self.value

  348.         ret = self.param + self.const

  349.         return ret

  350. 

  351. 

  352. class TensorSetItemByTensorsWithTensor(Cell):

  353.     def __init__(self):

  354.         super(TensorSetItemByTensorsWithTensor, self).__init__()

  355.         self.const = Tensor(np.ones((6, 7, 8)), mstype.float32)

  356.         self.param = Parameter(Tensor(np.arange(6 * 7 * 8).reshape((6, 7, 8)), mstype.float32), name="x")

  357. 

  358.     def construct(self, index_0, index_1, index_2, value):

  359.         self.param[index_0, index_1, index_2] = value

  360.         ret = self.param + self.const

  361.         return ret

  362. 

  363. 

  364. class TensorSetItemByTensorsWithTensorNumberError(Cell):

  365.     def __init__(self):

  366.         super(TensorSetItemByTensorsWithTensorNumberError, self).__init__()

  367.         self.const = Tensor(np.ones((6, 7, 8)), mstype.float32)

  368.         self.param = Parameter(Tensor(np.arange(6 * 7 * 8).reshape((6, 7, 8)), mstype.float32), name="x")

  369. 

  370.     def construct(self, index_0, index_1, index_2, index_3, value):

  371.         self.param[index_0, index_1, index_2, index_3] = value

  372.         ret = self.param + self.const

  373.         return ret

  374. 

  375. 

  376. class TensorSetItemByTensorsWithTupleOfNumber(Cell):

  377.     def __init__(self, value):

  378.         super(TensorSetItemByTensorsWithTupleOfNumber, self).__init__()

  379.         self.const = Tensor(np.ones((6, 7, 8)), mstype.float32)

  380.         self.param = Parameter(Tensor(np.arange(6 * 7 * 8).reshape((6, 7, 8)), mstype.float32), name="x")

  381.         self.value = value

  382. 

  383.     def construct(self, index_0, index_1, index_2):

  384.         self.param[index_0, index_1, index_2] = self.value

  385.         ret = self.param + self.const

  386.         return ret

  387. 

  388. 

  389. class TensorSetItemByTensorsWithTupleOfTensor(Cell):

  390.     def __init__(self):

  391.         super(TensorSetItemByTensorsWithTupleOfTensor, self).__init__()

  392.         self.const = Tensor(np.ones((6, 7, 8)), mstype.float32)

  393.         self.param = Parameter(Tensor(np.arange(6 * 7 * 8).reshape((6, 7, 8)), mstype.float32), name="x")

  394. 

  395.     def construct(self, index_0, index_1, index_2, value_0, value_1, value_2):

  396.         self.param[index_0, index_1, index_2] = (value_0, value_1, value_2)

  397.         ret = self.param + self.const

  398.         return ret

  399. 

  400. 

  401. class TensorSetItemByTensorsWithTupleOfTensorNumberError(Cell):

  402.     def __init__(self):

  403.         super(TensorSetItemByTensorsWithTupleOfTensorNumberError, self).__init__()

  404.         self.const = Tensor(np.ones((6, 7, 8)), mstype.float32)

  405.         self.param = Parameter(Tensor(np.arange(6 * 7 * 8).reshape((6, 7, 8)), mstype.float32), name="x")

  406. 

  407.     def construct(self, index_0, index_1, index_2, value_0, value_1):

  408.         self.param[index_0, index_1, index_2] = (value_0, value_1)

  409.         ret = self.param + self.const

  410.         return ret

  411. 

  412. 

  413. class TensorSetItemByMixedTensors(Cell):

  414.     def __init__(self):

  415.         super(TensorSetItemByMixedTensors, self).__init__()

  416.         self.const = Tensor(np.ones((6, 7, 8)), mstype.float32)

  417.         self.param = Parameter(Tensor(np.arange(6 * 7 * 8).reshape((6, 7, 8)), mstype.float32), name="x")

  418.         self.value = 99.0

  419. 

  420.     def construct(self, index_0, index_1):

  421.         self.param[index_0, index_1, 0:6] = self.value

  422.         ret = self.param + self.const

  423.         return ret

  424. 

  425. 

  426. class TensorAssignWithSliceError1(Cell):

  427.     def __init__(self):

  428.         super(TensorAssignWithSliceError1, self).__init__()

  429. 

  430.     def construct(self, a, b):

  431.         a[1:3:-1, ::] = b

  432.         return a

  433. 

  434. 

  435. class TensorAssignWithSliceError2(Cell):

  436.     def __init__(self):

  437.         super(TensorAssignWithSliceError2, self).__init__()

  438. 

  439.     def construct(self, a, b):

  440.         a[1:3:-1] = b

  441.         return a

  442. 

  443. 

  444. class TensorAssignWithSlice2(Cell):

  445.     def __init__(self):

  446.         super(TensorAssignWithSlice2, self).__init__()

  447. 

  448.     def construct(self, a, b, ck):

  449.         a[1:5] = b

  450.         a[3:4] = 5

  451.         a[-1:1:-1] = b

  452.         a[-1:3:-1] = 5

  453.         a[::] = b

  454.         a[::] = 9

  455.         z = a + ck

  456.         return z

  457. 

  458. 

  459. class TensorAssignWithSlice(Cell):

  460.     def __init__(self):

  461.         super(TensorAssignWithSlice, self).__init__()

  462.         self.c = 2

  463. 

  464.     def construct(self, a, b, ck):

  465.         a[1:3, ::] = b

  466.         a[2:3:, 3:] = b

  467.         a[::] = b

  468.         a[::] = self.c

  469.         a[::, ::] = b

  470.         a[::, ::] = self.c

  471.         a[2:3:, 0:, 4:1:-1] = b

  472.         a[2:3:, 0:, 4:1:-1] = self.c

  473.         z = a + ck

  474.         return z

  475. 

  476. 

  477. def test_tensor_assign():

  478.     context.set_context(mode=context.GRAPH_MODE, save_graphs=True)

  479.     net = TensorAssignWithSlice()

  480.     net2 = TensorAssignWithSlice2()

  481.     net_e1 = TensorAssignWithSliceError1()

  482.     net_e2 = TensorAssignWithSliceError2()

  483.     a = np.arange(60).reshape(3, 4, 5)

  484.     ck = np.arange(60).reshape(3, 4, 5)

  485.     b = Tensor([1], dtype=mstype.float32)

  486.     Ta = Tensor(a, dtype=mstype.float32)

  487.     Tck = Tensor(ck, dtype=mstype.float32)

  488.     Ta4d = Tensor(a.reshape(1, 3, 4, 5), dtype=mstype.float32)

  489.     Ta4d_ck = Tensor(ck.reshape(1, 3, 4, 5), dtype=mstype.float32)

  490.     Tb = Tensor([1, 3], dtype=mstype.float32)

  491.     Tc = Tensor([], dtype=mstype.float32)

  492.     t = Tensor([1, 2, 3, 4, 5, 6, 7, 8], dtype=mstype.float32)

  493.     tck = Tensor([1, 2, 3, 4, 5, 6, 7, 8], dtype=mstype.float32)

  494.     net(Ta, b, Tck)

  495.     net2(t, b, tck)

  496.     # Error for A[Slice] = Number

  497.     # 1. A[Slice] = Number,  Slice error

  498.     with pytest.raises(IndexError):

  499.         net_e2(t, 2)

  500. 

  501.     # Error for A[Slice] = U, U is a Tensor

  502.     # 1. A[Slice] = U,  u.size is error

  503.     with pytest.raises(ValueError):

  504.         net2(t, Tb, tck)

  505.     # 2. A[Slice] = U, U is empty

  506.     with pytest.raises(ValueError):

  507.         net2(t, Tc, tck)

  508.     # 3. A[Slice] = U, U.size error

  509.     with pytest.raises(ValueError):

  510.         net2(t, Tb, tck)

  511. 

  512.     # Error for A[Tuple(Slice...)] = Tensor

  513.     # 1. A[Tuple(Slice...)] = U, U is empty

  514.     with pytest.raises(ValueError):

  515.         net(Ta, Tc, Tck)

  516.     # 2. A[Tuple(Slice...)] = U, U.size error

  517.     with pytest.raises(ValueError):

  518.         net(Ta, Tb, Tck)

  519.     # 3. A[Tuple(Slice...)] = U,  Slice error

  520.     with pytest.raises(IndexError):

  521.         net_e1(Ta, b)

  522. 

  523.     # Error for A[Tuple(Slice...)] = Number

  524.     # 1. A[Tuple(Slice...)] = Number,  Slice error

  525.     with pytest.raises(IndexError):

  526.         net_e1(Ta, 2)

  527. 

  528.     net = TensorAssignWithInteger()

  529.     # Error for A[Number] = scalar/Tensor

  530.     # 1. A[Number] = U, U is a Tensor, u.size not match

  531.     with pytest.raises(ValueError):

  532.         net(Ta, Tb, Tck)

  533.     with pytest.raises(ValueError):

  534.         net(Ta, Tc, Tck)

  535.     # 2. A[Number] = U, the number index error

  536.     with pytest.raises(IndexError):

  537.         net(Ta4d, b, Ta4d_ck)

  538. 

  539.     # Error for A[(n,m)] = scalar/Tensor

  540.     # 1. A[(n,m)] = U, U is a tensor. u.size not match

  541.     net = TensorAssignWithTupleInteger()

  542.     with pytest.raises(ValueError):

  543.         net(Ta, Tc, Tck)

  544.     with pytest.raises(ValueError):

  545.         net(Ta, Tb, Tck)

  546.     # 2. A[(n,m)] = U, the number index error

  547.     with pytest.raises(IndexError):

  548.         net(Ta4d, b, Ta4d_ck)

  549. 

  550.     # Error for  A[...] = U or A[1:, ...] = u

  551.     # 1. A[...] = scalar/tensor

  552.     net = TensorAssignWithEllipsis()

  553.     net(Ta, Ta4d)

  554.     with pytest.raises(ValueError):

  555.         net(Ta, Tc)

  556.     with pytest.raises(ValueError):

  557.         net(Ta, Tb)

  558.     # 2. A[::, 1:, ...] = scalar/tensor

  559.     net = TensorAssignWithTupleEllipsis()

  560.     net(Ta, b)

  561.     Tc = Tensor(1, mstype.float32)

  562.     with pytest.raises(ValueError):

  563.         net(Ta, Tc)

  564.     with pytest.raises(ValueError):

  565.         net(Ta, Tb)

  566. 

  567. 

  568. class TensorAssignWithTupleEllipsis2(Cell):

  569.     def __init__(self):

  570.         super(TensorAssignWithTupleEllipsis2, self).__init__()

  571. 

  572.     def construct(self, a, b):

  573.         a[1:, ..., ::] = b

  574.         return a

  575. 

  576. 

  577. class TensorAssignWithTupleEllipsis(Cell):

  578.     def __init__(self):

  579.         super(TensorAssignWithTupleEllipsis, self).__init__()

  580. 

  581.     def construct(self, a, b):

  582.         a[:2, ...] = 1

  583.         a[1:, ...] = b

  584.         return a

  585. 

  586. 

  587. class TensorAssignWithEllipsis(Cell):

  588.     def __init__(self):

  589.         super(TensorAssignWithEllipsis, self).__init__()

  590. 

  591.     def construct(self, a, b):

  592.         a[...] = 1

  593.         a[...] = b

  594.         return a

  595. 

  596. 

  597. class TensorAssignWithInteger(Cell):

  598.     def __init__(self):

  599.         super(TensorAssignWithInteger, self).__init__()

  600. 

  601.     def construct(self, a, b, ck):

  602.         a[1] = 1

  603.         a[0] = b

  604.         z = a + ck

  605.         return z

  606. 

  607. 

  608. class TensorAssignWithTupleInteger(Cell):

  609.     def __init__(self):

  610.         super(TensorAssignWithTupleInteger, self).__init__()

  611. 

  612.     def construct(self, a, b, ck):

  613.         a[(1)] = 1

  614.         a[(1)] = b

  615.         a[(1, 1)] = b

  616.         a[(1, 1)] = 1

  617.         z = a + ck

  618.         return z

  619. 

  620. 

  621. class TensorAssignWithBoolTensorIndex(Cell):

  622.     def __init__(self):

  623.         super(TensorAssignWithBoolTensorIndex, self).__init__()

  624.         self.t = Tensor(np.arange(60).reshape([3, 4, 5]), dtype=mstype.float32)

  625.         self.u_scalar = 5

  626. 

  627.     def construct(self, a, b, c, u_tensor):

  628.         a[c] = self.u_scalar

  629.         a[b] = u_tensor

  630.         z = a + self.t

  631.         return z

  632. 

  633. 

  634. class TensorAssignWithBoolTensorIndexError(Cell):

  635.     def __init__(self):

  636.         super(TensorAssignWithBoolTensorIndexError, self).__init__()

  637. 

  638.     def construct(self, a, b, c, u_tensor):

  639.         a[b][c] = u_tensor

  640.         return a

  641. 

  642. 

  643. class TensorAssignWithBoolTensorIndex2(Cell):

  644.     def __init__(self):

  645.         super(TensorAssignWithBoolTensorIndex2, self).__init__()

  646.         self.t = Tensor(np.arange(6).reshape([2, 3]), dtype=mstype.float32)

  647.         self.t = Tensor(np.arange(60).reshape([3, 4, 5]), dtype=mstype.float32)

  648.         self.u_scalar = 5

  649. 

  650.     def construct(self, a, u_tensor):

  651.         a[a > 8] = u_tensor

  652.         a[a >= 6] = self.u_scalar

  653.         a[a < 3] = self.u_scalar

  654.         a[a <= 5] = u_tensor

  655.         a[a == 5] = self.u_scalar

  656.         z = a + self.t

  657.         return z

  658. 

  659. 

  660. class TensorAssignWithBoolTensorIndex2Error(Cell):

  661.     def __init__(self):

  662.         super(TensorAssignWithBoolTensorIndex2Error, self).__init__()

  663. 

  664.     def construct(self, a, u_tensor):

  665.         a[a > 8][a > 5] = u_tensor

  666.         return a

  667. 

  668. 

  669. def Xtest_tensor_assign_bool_index():

  670.     a = np.arange(60).reshape(3, 4, 5)

  671.     b = a > 5

  672.     c = a < 3

  673.     Ta = Tensor(a, dtype=mstype.float32)

  674.     Tb = Tensor(b)

  675.     Tc = Tensor(c)

  676.     Td = Tensor([True, True])

  677.     u_tensor = Tensor([1], dtype=mstype.float32)

  678.     u_tensor_error = Tensor([1, 2], dtype=mstype.float32)

  679.     u_scalar = 5

  680.     net1 = TensorAssignWithBoolTensorIndex()

  681.     net2 = TensorAssignWithBoolTensorIndex2()

  682.     net1(Ta, Tb, Tc, u_tensor)

  683.     net1(Ta, Tb, Tc, u_tensor)

  684.     with pytest.raises(ValueError):

  685.         net1(Ta, Td, Tc, u_tensor)

  686.     with pytest.raises(IndexError):

  687.         net1(Ta, u_tensor, Tc, u_tensor)

  688.     with pytest.raises(ValueError):

  689.         net1(Ta, Tb, Td, u_tensor)

  690.     with pytest.raises(IndexError):

  691.         net1(Ta, Tb, Ta, u_tensor)

  692.     with pytest.raises(ValueError):

  693.         net1(Ta, Tb, Tc, u_tensor_error)

  694.     # net1(Ta, u_tensor, Tc, u_tensor_error, u_scalar)

  695.     with pytest.raises(ValueError):

  696.         net2(Ta, u_tensor_error)

  697.     net3 = TensorAssignWithBoolTensorIndexError()

  698.     with pytest.raises(AttributeError):

  699.         net3(Ta, Tb, Tc, u_tensor)

  700.     with pytest.raises(AttributeError):

  701.         net3(Ta, Tb, Tc, u_scalar)

  702.     net4 = TensorAssignWithBoolTensorIndex2Error()

  703.     with pytest.raises(AttributeError):

  704.         net4(Ta, u_tensor)

  705.     with pytest.raises(AttributeError):

  706.         net4(Ta, u_scalar)

  707. 

  708. 

  709. def Xtest_tensor_slice_reduce_out_of_bounds_neg():

  710.     class NetWork(Cell):

  711.         def __init__(self):

  712.             super(NetWork, self).__init__()

  713.             self.tensor_ret = Tensor(np.array(9, np.int32))

  714. 

  715.         def construct(self, tensor):

  716.             ret = tensor[-7, 3, 4]

  717.             return ret

  718. 

  719.     input_tensor = Tensor(np.ones([6, 8, 10], np.int32))

  720.     net = NetWork()

  721.     with pytest.raises(ValueError) as ex:

  722.         net(input_tensor)

  723.     assert "For 'StridedSlice' the `begin[0]` should be an int and must greater or equal to -6, but got `-7`" in str(

  724.         ex.value)

  725. 

  726. 

  727. def Xtest_tensor_slice_reduce_out_of_bounds_positive():

  728.     class NetWork(Cell):

  729.         def __init__(self):

  730.             super(NetWork, self).__init__()

  731.             self.tensor_ret = Tensor(np.array(9, np.int32))

  732. 

  733.         def construct(self, tensor):

  734.             ret = tensor[6, 3, 4]

  735.             return ret

  736. 

  737.     input_tensor = Tensor(np.ones([6, 8, 10], np.int32))

  738.     net = NetWork()

  739.     with pytest.raises(ValueError) as ex:

  740.         net(input_tensor)

  741.     assert "For 'StridedSlice' the `begin[0]` should be an int and must less than 6, but got `6`" in str(ex.value)