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: 9f62227f99
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '9f62227f99'
${ noResults }
mindspore/tests/st/ops/gpu/test_equal_op.py

267 lines
9.6 kB
Raw Blame History 

  1. # Copyright 2019 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. 

  19. import mindspore.context as context

  20. from mindspore.common.tensor import Tensor

  21. from mindspore.nn import Cell

  22. from mindspore.ops import operations as P

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

  24. 

  25. 

  26. class NetEqual(Cell):

  27.     def __init__(self):

  28.         super(NetEqual, self).__init__()

  29.         self.Equal = P.Equal()

  30. 

  31.     def construct(self, x, y):

  32.         return self.Equal(x, y)

  33. 

  34. class NetEqualDynamic(Cell):

  35.     def __init__(self):

  36.         super(NetEqualDynamic, self).__init__()

  37.         self.conv = inner.GpuConvertToDynamicShape()

  38.         self.Equal = P.Equal()

  39. 

  40.     def construct(self, x, y):

  41.         x_conv = self.conv(x)

  42.         y_conv = self.conv(y)

  43.         return self.Equal(x_conv, y_conv)

  44. 

  45. class NetNotEqual(Cell):

  46.     def __init__(self):

  47.         super(NetNotEqual, self).__init__()

  48.         self.NotEqual = P.NotEqual()

  49. 

  50.     def construct(self, x, y):

  51.         return self.NotEqual(x, y)

  52. 

  53. class NetGreaterEqual(Cell):

  54.     def __init__(self):

  55.         super(NetGreaterEqual, self).__init__()

  56.         self.GreaterEqual = P.GreaterEqual()

  57. 

  58.     def construct(self, x, y):

  59.         return self.GreaterEqual(x, y)

  60. 

  61. @pytest.mark.level0

  62. @pytest.mark.platform_x86_gpu_training

  63. @pytest.mark.env_onecard

  64. def test_equal():

  65.     x0_np = np.arange(24).reshape((4, 3, 2)).astype(np.float32)

  66.     x0 = Tensor(x0_np)

  67.     y0_np = np.arange(24).reshape((4, 3, 2)).astype(np.float32)

  68.     y0 = Tensor(y0_np)

  69.     expect0 = np.equal(x0_np, y0_np)

  70.     x1_np = np.array([0, 1, 3]).astype(np.float32)

  71.     x1 = Tensor(x1_np)

  72.     y1_np = np.array([0, 1, -3]).astype(np.float32)

  73.     y1 = Tensor(y1_np)

  74.     expect1 = np.equal(x1_np, y1_np)

  75.     x2_np = np.array([0, 1, 3]).astype(np.int32)

  76.     x2 = Tensor(x2_np)

  77.     y2_np = np.array([0, 1, -3]).astype(np.int32)

  78.     y2 = Tensor(y2_np)

  79.     expect2 = np.equal(x2_np, y2_np)

  80.     x3_np = np.array([0, 1, 3]).astype(np.int16)

  81.     x3 = Tensor(x3_np)

  82.     y3_np = np.array([0, 1, -3]).astype(np.int16)

  83.     y3 = Tensor(y3_np)

  84.     expect3 = np.equal(x3_np, y3_np)

  85.     x4_np = np.array([0, 1, 4]).astype(np.uint8)

  86.     x4 = Tensor(x4_np)

  87.     y4_np = np.array([0, 1, 3]).astype(np.uint8)

  88.     y4 = Tensor(y4_np)

  89.     expect4 = np.equal(x4_np, y4_np)

  90.     x5_np = np.array([True, False, True]).astype(bool)

  91.     x5 = Tensor(x5_np)

  92.     y5_np = np.array([True, False, False]).astype(bool)

  93.     y5 = Tensor(y5_np)

  94.     expect5 = np.equal(x5_np, y5_np)

  95.     x6_np = np.array([0, 1, 4]).astype(np.int8)

  96.     x6 = Tensor(x4_np)

  97.     y6_np = np.array([0, 1, 3]).astype(np.int8)

  98.     y6 = Tensor(y4_np)

  99.     expect6 = np.equal(x6_np, y6_np)

  100.     x7_np = np.array([0, 1, 4]).astype(np.int64)

  101.     x7 = Tensor(x4_np)

  102.     y7_np = np.array([0, 1, 3]).astype(np.int64)

  103.     y7 = Tensor(y4_np)

  104.     expect7 = np.equal(x7_np, y7_np)

  105.     x8_np = np.array([0, 1, 4]).astype(np.float16)

  106.     x8 = Tensor(x4_np)

  107.     y8_np = np.array([0, 1, 3]).astype(np.float16)

  108.     y8 = Tensor(y4_np)

  109.     expect8 = np.equal(x8_np, y8_np)

  110. 

  111.     context.set_context(mode=context.PYNATIVE_MODE, device_target="GPU")

  112.     equal = NetEqual()

  113.     output0 = equal(x0, y0)

  114.     assert np.all(output0.asnumpy() == expect0)

  115.     assert output0.shape == expect0.shape

  116.     output1 = equal(x1, y1)

  117.     assert np.all(output1.asnumpy() == expect1)

  118.     assert output1.shape == expect1.shape

  119.     output2 = equal(x2, y2)

  120.     assert np.all(output2.asnumpy() == expect2)

  121.     assert output2.shape == expect2.shape

  122.     output3 = equal(x3, y3)

  123.     assert np.all(output3.asnumpy() == expect3)

  124.     assert output3.shape == expect3.shape

  125.     output4 = equal(x4, y4)

  126.     assert np.all(output4.asnumpy() == expect4)

  127.     assert output4.shape == expect4.shape

  128.     output5 = equal(x5, y5)

  129.     assert np.all(output5.asnumpy() == expect5)

  130.     assert output5.shape == expect5.shape

  131. 

  132. 

  133. 

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

  135.     equal = NetEqual()

  136.     output0 = equal(x0, y0)

  137.     assert np.all(output0.asnumpy() == expect0)

  138.     assert output0.shape == expect0.shape

  139.     output1 = equal(x1, y1)

  140.     assert np.all(output1.asnumpy() == expect1)

  141.     assert output1.shape == expect1.shape

  142.     output2 = equal(x2, y2)

  143.     assert np.all(output2.asnumpy() == expect2)

  144.     assert output2.shape == expect2.shape

  145.     output3 = equal(x3, y3)

  146.     assert np.all(output3.asnumpy() == expect3)

  147.     assert output3.shape == expect3.shape

  148.     output4 = equal(x4, y4)

  149.     assert np.all(output4.asnumpy() == expect4)

  150.     assert output4.shape == expect4.shape

  151.     output5 = equal(x5, y5)

  152.     assert np.all(output5.asnumpy() == expect5)

  153.     assert output5.shape == expect5.shape

  154.     output6 = equal(x6, y6)

  155.     assert np.all(output6.asnumpy() == expect6)

  156.     assert output6.shape == expect6.shape

  157.     output7 = equal(x7, y7)

  158.     assert np.all(output7.asnumpy() == expect7)

  159.     assert output7.shape == expect7.shape

  160.     output8 = equal(x8, y8)

  161.     assert np.all(output8.asnumpy() == expect8)

  162.     assert output8.shape == expect8.shape

  163. 

  164. 

  165. @pytest.mark.level0

  166. @pytest.mark.platform_x86_gpu_training

  167. @pytest.mark.env_onecard

  168. def test_notequal():

  169.     x0 = Tensor(np.array([[1.2, 1], [1, 0]]).astype(np.float32))

  170.     y0 = Tensor(np.array([[1, 2]]).astype(np.float32))

  171.     expect0 = np.array([[True, True], [False, True]])

  172.     x1 = Tensor(np.array([[2, 1], [1, 1]]).astype(np.int16))

  173.     y1 = Tensor(np.array([[1, 2]]).astype(np.int16))

  174.     expect1 = np.array([[True, True], [False, True]])

  175.     x2 = Tensor(np.array([[2, 1], [1, 2]]).astype(np.uint8))

  176.     y2 = Tensor(np.array([[1, 2]]).astype(np.uint8))

  177.     expect2 = np.array([[True, True], [False, False]])

  178.     x3 = Tensor(np.array([[False, True], [True, False]]).astype(bool))

  179.     y3 = Tensor(np.array([[True, False]]).astype(bool))

  180.     expect3 = np.array([[True, True], [False, False]])

  181. 

  182.     context.set_context(mode=context.PYNATIVE_MODE, device_target="GPU")

  183.     notequal = NetNotEqual()

  184.     output0 = notequal(x0, y0)

  185.     assert np.all(output0.asnumpy() == expect0)

  186.     assert output0.shape == expect0.shape

  187.     output1 = notequal(x1, y1)

  188.     assert np.all(output1.asnumpy() == expect1)

  189.     assert output1.shape == expect1.shape

  190.     output2 = notequal(x2, y2)

  191.     assert np.all(output2.asnumpy() == expect2)

  192.     assert output2.shape == expect2.shape

  193.     output3 = notequal(x3, y3)

  194.     assert np.all(output3.asnumpy() == expect3)

  195.     assert output3.shape == expect3.shape

  196. 

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

  198.     notequal = NetNotEqual()

  199.     output0 = notequal(x0, y0)

  200.     assert np.all(output0.asnumpy() == expect0)

  201.     assert output0.shape == expect0.shape

  202.     output1 = notequal(x1, y1)

  203.     assert np.all(output1.asnumpy() == expect1)

  204.     assert output1.shape == expect1.shape

  205.     output2 = notequal(x2, y2)

  206.     assert np.all(output2.asnumpy() == expect2)

  207.     assert output2.shape == expect2.shape

  208.     output3 = notequal(x3, y3)

  209.     assert np.all(output3.asnumpy() == expect3)

  210.     assert output3.shape == expect3.shape

  211. 

  212. 

  213. @pytest.mark.level0

  214. @pytest.mark.platform_x86_gpu_training

  215. @pytest.mark.env_onecard

  216. def test_greaterqual():

  217.     x0 = Tensor(np.array([[1.2, 1], [1, 0]]).astype(np.float32))

  218.     y0 = Tensor(np.array([[1, 2]]).astype(np.float32))

  219.     expect0 = np.array([[True, False], [True, False]])

  220.     x1 = Tensor(np.array([[2, 1], [1, 1]]).astype(np.int16))

  221.     y1 = Tensor(np.array([[1, 2]]).astype(np.int16))

  222.     expect1 = np.array([[True, False], [True, False]])

  223.     x2 = Tensor(np.array([[2, 1], [1, 2]]).astype(np.uint8))

  224.     y2 = Tensor(np.array([[1, 2]]).astype(np.uint8))

  225.     expect2 = np.array([[True, False], [True, True]])

  226. 

  227.     context.set_context(mode=context.PYNATIVE_MODE, device_target="GPU")

  228.     gequal = NetGreaterEqual()

  229.     output0 = gequal(x0, y0)

  230.     assert np.all(output0.asnumpy() == expect0)

  231.     assert output0.shape == expect0.shape

  232.     output1 = gequal(x1, y1)

  233.     assert np.all(output1.asnumpy() == expect1)

  234.     assert output1.shape == expect1.shape

  235.     output2 = gequal(x2, y2)

  236.     assert np.all(output2.asnumpy() == expect2)

  237.     assert output2.shape == expect2.shape

  238. 

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

  240.     gequal = NetGreaterEqual()

  241.     output0 = gequal(x0, y0)

  242.     assert np.all(output0.asnumpy() == expect0)

  243.     assert output0.shape == expect0.shape

  244.     output1 = gequal(x1, y1)

  245.     assert np.all(output1.asnumpy() == expect1)

  246.     assert output1.shape == expect1.shape

  247.     output2 = gequal(x2, y2)

  248.     assert np.all(output2.asnumpy() == expect2)

  249.     assert output2.shape == expect2.shape

  250. 

  251. 

  252. @pytest.mark.level0

  253. @pytest.mark.platform_x86_gpu_training

  254. @pytest.mark.env_onecard

  255. def test_equal_dynamic_shape():

  256.     x0_np = np.arange(24).reshape((4, 3, 2)).astype(np.float32)

  257.     x0 = Tensor(x0_np)

  258.     y0_np = np.arange(24).reshape((4, 3, 2)).astype(np.float32)

  259.     y0 = Tensor(y0_np)

  260.     expect0 = np.equal(x0_np, y0_np)

  261. 

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

  263.     equal = NetEqualDynamic()

  264.     output0 = equal(x0, y0)

  265.     assert np.all(output0.asnumpy() == expect0)

  266.     assert output0.shape == expect0.shape