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: 2fa654e65c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2fa654e65c'
${ noResults }
mindspore/tests/ut/python/ops/test_control_ops.py

394 lines
10 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 control ops """

  16. import numpy as np

  17. import mindspore as ms

  18. from mindspore import nn

  19. from mindspore import Tensor

  20. from mindspore import context

  21. from mindspore.ops import operations as P

  22. from mindspore.ops import composite as C

  23. from mindspore.ops import functional as F

  24. from mindspore.common.parameter import Parameter, ParameterTuple

  25. 

  26. context.set_context(mode=context.GRAPH_MODE)

  27. 

  28. 

  29. def cond_data_test(x_init, y_init):

  30.     class Net(nn.Cell):

  31.         def __init__(self):

  32.             """"""

  33.             super(Net, self).__init__()

  34.             self.square = P.Square()

  35.             self.add = P.TensorAdd()

  36.             self.value = Tensor(np.full((1), 3, dtype=np.float32))

  37.             self.switch = P.GeSwitch()

  38.             self.merge = P.Merge()

  39.             self.less = P.Less()

  40. 

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

  42.             cond = self.less(x, y)

  43.             st1, sf1 = self.switch(x, cond)

  44.             st2, sf2 = self.switch(y, cond)

  45.             add_ret = self.add(st1, st2)

  46.             st3, sf3 = self.switch(self.value, cond)

  47.             sq_ret = self.square(sf3)

  48.             ret = self.merge((add_ret, sq_ret))

  49.             return ret[0]

  50. 

  51.     x = Tensor(x_init, dtype=ms.float32)

  52.     y = Tensor(y_init, dtype=ms.float32)

  53.     net = Net()

  54.     output = net(x, y)

  55.     return output

  56. 

  57. 

  58. def test_cond_data_true():

  59.     output = cond_data_test(3, 8)

  60.     print("test_cond_data_true:", output)

  61. 

  62. def test_cond_data_false():

  63.     output = cond_data_test(8, 3)

  64.     print("test_cond_data_false:", output)

  65. 

  66. def if_compile_test(x_init, y_init):

  67.     class Net(nn.Cell):

  68.         def __init__(self):

  69.             """"""

  70.             super(Net, self).__init__()

  71.             self.square = P.Square()

  72.             self.add = P.TensorAdd()

  73.             self.value = Tensor(3, dtype=ms.float32)

  74.             self.switch = P.GeSwitch()

  75.             self.merge = P.Merge()

  76.             self.less = P.Less()

  77. 

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

  79.             cond = self.less(x, y)

  80.             ret = self.value

  81.             if cond:

  82.                 ret = self.add(x, ret)

  83.                 ret = self.add(y, ret)

  84.             else:

  85.                 ret = self.square(self.value)

  86.             return ret

  87. 

  88.     x = Tensor(x_init, dtype=ms.float32)

  89.     y = Tensor(y_init, dtype=ms.float32)

  90.     net = Net()

  91.     output = net(x, y)

  92.     return output

  93. 

  94. 

  95. def test_if_none():

  96.     class Net(nn.Cell):

  97.         def __init__(self, z: None):

  98.             """"""

  99.             super(Net, self).__init__()

  100.             self.z = z

  101. 

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

  103.             if self.z:

  104.                 ret = x

  105.             else:

  106.                 ret = y

  107.             return ret

  108. 

  109.     x = Tensor(np.ones([6, 8, 10], np.int32))

  110.     y = Tensor(np.zeros([3, 4, 5], np.int32))

  111.     z = None

  112.     net = Net(z)

  113.     assert net(x, y) == y

  114. 

  115. 

  116. def test_if_str_is_not_none_right():

  117.     class Net(nn.Cell):

  118.         def __init__(self, z: str):

  119.             """"""

  120.             super(Net, self).__init__()

  121.             self.z = z

  122. 

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

  124.             if self.z == None:

  125.                 ret = x

  126.             else:

  127.                 ret = y

  128.             return ret

  129. 

  130.     x = Tensor(np.ones([6, 8, 10], np.int32))

  131.     y = Tensor(np.zeros([3, 4, 5], np.int32))

  132.     z = "ok"

  133.     net = Net(z)

  134.     assert net(x, y) == y

  135. 

  136. 

  137. def test_if_str_is_not_none_left():

  138.     class Net(nn.Cell):

  139.         def __init__(self, z: str):

  140.             """"""

  141.             super(Net, self).__init__()

  142.             self.z = z

  143. 

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

  145.             if None == self.z:

  146.                 ret = x

  147.             else:

  148.                 ret = y

  149.             return ret

  150. 

  151.     x = Tensor(np.ones([6, 8, 10], np.int32))

  152.     y = Tensor(np.zeros([3, 4, 5], np.int32))

  153.     z = "ok"

  154.     net = Net(z)

  155.     assert net(x, y) == y

  156. 

  157. 

  158. def test_if_none_equal_none():

  159.     class Net(nn.Cell):

  160.         def __init__(self, z: None):

  161.             """"""

  162.             super(Net, self).__init__()

  163.             self.z = z

  164. 

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

  166.             if self.z == None:

  167.                 ret = x

  168.             else:

  169.                 ret = y

  170.             return ret

  171. 

  172.     x = Tensor(np.ones([6, 8, 10], np.int32))

  173.     y = Tensor(np.zeros([3, 4, 5], np.int32))

  174.     z = None

  175.     net = Net(z)

  176.     assert net(x, y) == x

  177. 

  178. 

  179. def test_if_str_is_null():

  180.     class Net(nn.Cell):

  181.         def __init__(self, z: str):

  182.             """"""

  183.             super(Net, self).__init__()

  184.             self.z = z

  185. 

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

  187.             if self.z:

  188.                 ret = x

  189.             else:

  190.                 ret = y

  191.             return ret

  192. 

  193.     x = Tensor(np.ones([6, 8, 10], np.int32))

  194.     y = Tensor(np.zeros([3, 4, 5], np.int32))

  195.     z = ""

  196.     net = Net(z)

  197.     assert net(x, y) == y

  198. 

  199. 

  200. def test_if_str_is_true():

  201.     class Net(nn.Cell):

  202.         def __init__(self, z: str):

  203.             """"""

  204.             super(Net, self).__init__()

  205.             self.z = z

  206. 

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

  208.             if self.z:

  209.                 ret = x

  210.             else:

  211.                 ret = y

  212.             return ret

  213. 

  214.     x = Tensor(np.ones([6, 9, 10], np.int32))

  215.     y = Tensor(np.zeros([3, 4, 5], np.int32))

  216.     z = "ok"

  217.     net = Net(z)

  218.     assert net(x, y) == x

  219. 

  220. 

  221. def test_if_str_equal():

  222.     class Net(nn.Cell):

  223.         def __init__(self, z: str):

  224.             """"""

  225.             super(Net, self).__init__()

  226.             self.z = z

  227. 

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

  229.             if self.z == "ok":

  230.                 ret = x

  231.             else:

  232.                 ret = y

  233.             return ret

  234. 

  235.     x = Tensor(np.ones([6, 8, 10], np.int32))

  236.     y = Tensor(np.zeros([3, 4, 5], np.int32))

  237.     z = "ok"

  238.     net = Net(z)

  239.     assert net(x, y) == x

  240. 

  241. 

  242. def test_if_tuple_is_null():

  243.     class Net(nn.Cell):

  244.         def __init__(self, z: tuple):

  245.             """"""

  246.             super(Net, self).__init__()

  247.             self.z = z

  248. 

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

  250.             if self.z:

  251.                 ret = x

  252.             else:

  253.                 ret = y

  254.             return ret

  255. 

  256.     x = Tensor(np.ones([6, 8, 10], np.int32))

  257.     y = Tensor(np.zeros([3, 4, 5], np.int32))

  258.     z = ()

  259.     net = Net(z)

  260.     assert net(x, y) == y

  261. 

  262. 

  263. def test_if_tuple_is_not_null():

  264.     class Net(nn.Cell):

  265.         def __init__(self, z: tuple):

  266.             """"""

  267.             super(Net, self).__init__()

  268.             self.z = z

  269. 

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

  271.             if self.z:

  272.                 ret = x

  273.             else:

  274.                 ret = y

  275.             return ret

  276. 

  277.     x = Tensor(np.ones([6, 8, 10], np.int32))

  278.     y = Tensor(np.zeros([3, 4, 5], np.int32))

  279.     z = (1, 2, 3)

  280.     net = Net(z)

  281.     assert net(x, y) == x

  282. 

  283. 

  284. def test_if_dict_is_null():

  285.     class Net(nn.Cell):

  286.         def __init__(self, z: dict):

  287.             """"""

  288.             super(Net, self).__init__()

  289.             self.z = z

  290. 

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

  292.             if self.z:

  293.                 ret = x

  294.             else:

  295.                 ret = y

  296.             return ret

  297. 

  298.     x = Tensor(np.ones([6, 8, 10], np.int32))

  299.     y = Tensor(np.zeros([3, 4, 5], np.int32))

  300.     z = {}

  301.     net = Net(z)

  302.     assert net(x, y) == y

  303. 

  304. 

  305. def test_if_dict_is_not_null():

  306.     class Net(nn.Cell):

  307.         def __init__(self, z: dict):

  308.             """"""

  309.             super(Net, self).__init__()

  310.             self.z = z

  311. 

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

  313.             if self.z:

  314.                 ret = x

  315.             else:

  316.                 ret = y

  317.             return ret

  318. 

  319.     x = Tensor(np.ones([6, 8, 10], np.int32))

  320.     y = Tensor(np.zeros([3, 4, 5], np.int32))

  321.     z = {"one": 1, "two": 2}

  322.     net = Net(z)

  323.     assert net(x, y) == x

  324. 

  325. 

  326. def test_if_else_assign():

  327.     class Net(nn.Cell):

  328.         def __init__(self, m: list):

  329.             """"""

  330.             super(Net, self).__init__()

  331.             self.m = m

  332.             self.n = [4, 5, 6]

  333. 

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

  335.             exp_1 = self.m if self.m else self.n

  336.             exp_2 = self.m if exp_1 == self.n else self.n

  337.             if exp_2 == self.m:

  338.                 if self.m:

  339.                     ret = x

  340.                 else:

  341.                     ret = y

  342.             else:

  343.                 if self.m:

  344.                     ret = x

  345.                 else:

  346.                     ret = y

  347.             return ret

  348. 

  349.     x = Tensor(np.ones([6, 8, 10], np.int32))

  350.     y = Tensor(np.zeros([3, 4, 5], np.int32))

  351.     z = [1, 2]

  352.     net = Net(z)

  353.     assert net(x, y) == x

  354. 

  355. 

  356. def test_if_compile_true():

  357.     output = if_compile_test(3, 8)

  358.     print("test_if_compile_true:", output)

  359. 

  360. 

  361. def test_if_compile_false():

  362.     output = if_compile_test(8, 3)

  363.     print("test_if_compile_false:", output)

  364. 

  365. 

  366. def test_switch_layer():

  367.     class Layer1(nn.Cell):

  368.         def __init__(self):

  369.             super(Layer1, self).__init__()

  370.             self.z1 = Parameter(Tensor(np.full([128, 96], 0.6, dtype=np.float32)), name='z1')

  371.         def construct(self, x):

  372.             return x * self.z1

  373. 

  374.     class Layer2(nn.Cell):

  375.         def __init__(self):

  376.             super(Layer2, self).__init__()

  377.             self.z2 = Parameter(Tensor(np.full([128, 96], 0.6, dtype=np.float32)), name='z2')

  378.         def construct(self, x):

  379.             return x * self.z2

  380. 

  381.     class SwitchLayerCell(nn.Cell):

  382.         def __init__(self):

  383.             super(SwitchLayerCell, self).__init__()

  384.             self.layers = (Layer1(), Layer2())

  385.             self.z3 = Parameter(Tensor(np.full([128, 96], 0.6, dtype=np.float32)), name='z3')

  386.         def construct(self, index, x):

  387.             ret = F.switch_layer(index, self.layers)(x) * self.z3

  388.             return ret

  389. 

  390.     net = SwitchLayerCell()

  391.     net(1, Tensor(np.full([128, 96], 0.6, dtype=np.float32)))

  392.     C.grad_by_list(net, ParameterTuple(net.trainable_params()))(0, Tensor(np.full([128, 96], 0.6, dtype=np.float32)))

  393.     C.grad_all(net)(0, Tensor(np.full([128, 96], 0.6, dtype=np.float32)))