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: c005dfd803
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c005dfd803'
${ noResults }
mindspore2022/tests/ut/python/parallel/test_element_wise_function.py

307 lines
11 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. import numpy as np

  16. 

  17. import mindspore as ms

  18. import mindspore.nn as nn

  19. from mindspore import Tensor

  20. from mindspore import context

  21. from mindspore.common.api import _executor

  22. from mindspore.ops import composite as C

  23. from mindspore.ops import operations as P

  24. from tests.ut.python.ops.test_math_ops import VirtualLoss

  25. 

  26. 

  27. class NetWithLoss(nn.Cell):

  28.     def __init__(self, network):

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

  30.         self.loss = VirtualLoss()

  31.         self.network = network

  32. 

  33.     def construct(self, x, y, b):

  34.         predict = self.network(x, y, b)

  35.         return self.loss(predict)

  36. 

  37. 

  38. class GradWrap(nn.Cell):

  39.     def __init__(self, network):

  40.         super(GradWrap, self).__init__()

  41.         self.network = network

  42. 

  43.     def construct(self, x, y, b):

  44.         return C.grad_all(self.network)(x, y, b)

  45. 

  46. 

  47. def compile_net(net, x, y, b):

  48.     net.set_auto_parallel()

  49.     _executor.compile(net, x, y, b)

  50. 

  51. 

  52. def test_matmul_pow():

  53.     class Net(nn.Cell):

  54.         def __init__(self, strategy1, strategy2):

  55.             super().__init__()

  56.             self.matmul = P.MatMul().set_strategy(strategy1)

  57.             self.pow = P.Pow().set_strategy(strategy2)

  58.             self.matmul2 = P.MatMul().set_strategy(strategy1)

  59. 

  60.         def construct(self, x, y, b):

  61.             out = self.matmul(x, y)

  62.             out = self.pow(out, 2.0)

  63.             out = self.matmul2(out, b)

  64.             return out

  65. 

  66.     context.set_auto_parallel_context(device_num=8, global_rank=0)

  67.     strategy1 = ((2, 2), (2, 2))

  68.     strategy2 = ((4, 2), ())

  69.     net = GradWrap(NetWithLoss(Net(strategy1, strategy2)))

  70.     context.set_auto_parallel_context(parallel_mode="semi_auto_parallel")

  71. 

  72.     x = Tensor(np.ones([128, 32]), dtype=ms.float32)

  73.     y = Tensor(np.ones([32, 64]), dtype=ms.float32)

  74.     b = Tensor(np.ones([64, 64]), dtype=ms.float32)

  75.     compile_net(net, x, y, b)

  76. 

  77. 

  78. def test_matmul_exp():

  79.     class Net(nn.Cell):

  80.         def __init__(self, strategy1, strategy2):

  81.             super().__init__()

  82.             self.matmul = P.MatMul().set_strategy(strategy1)

  83.             self.exp = P.Exp().set_strategy(strategy2)

  84.             self.matmul2 = P.MatMul().set_strategy(strategy1)

  85. 

  86.         def construct(self, x, y, b):

  87.             out = self.matmul(x, y)

  88.             out = self.exp(out)

  89.             out = self.matmul2(out, b)

  90.             return out

  91. 

  92.     context.set_auto_parallel_context(device_num=8, global_rank=0)

  93.     strategy1 = ((2, 2), (2, 2))

  94.     strategy2 = ((4, 2),)

  95.     net = GradWrap(NetWithLoss(Net(strategy1, strategy2)))

  96.     context.set_auto_parallel_context(parallel_mode="semi_auto_parallel")

  97. 

  98.     x = Tensor(np.ones([128, 32]), dtype=ms.float32)

  99.     y = Tensor(np.ones([32, 64]), dtype=ms.float32)

  100.     b = Tensor(np.ones([64, 64]), dtype=ms.float32)

  101.     compile_net(net, x, y, b)

  102. 

  103. 

  104. def test_matmul_log():

  105.     class Net(nn.Cell):

  106.         def __init__(self, strategy1, strategy2):

  107.             super().__init__()

  108.             self.matmul = P.MatMul().set_strategy(strategy1)

  109.             self.log = P.Log().set_strategy(strategy2)

  110.             self.matmul2 = P.MatMul().set_strategy(strategy1)

  111. 

  112.         def construct(self, x, y, b):

  113.             out = self.matmul(x, y)

  114.             out = self.log(out)

  115.             out = self.matmul2(out, b)

  116.             return out

  117. 

  118.     context.set_auto_parallel_context(device_num=8, global_rank=0)

  119.     strategy1 = ((2, 2), (2, 2))

  120.     strategy2 = ((4, 2),)

  121.     net = GradWrap(NetWithLoss(Net(strategy1, strategy2)))

  122.     context.set_auto_parallel_context(parallel_mode="semi_auto_parallel")

  123. 

  124.     x = Tensor(np.ones([128, 32]), dtype=ms.float32)

  125.     y = Tensor(np.ones([32, 64]), dtype=ms.float32)

  126.     b = Tensor(np.ones([64, 64]), dtype=ms.float32)

  127.     compile_net(net, x, y, b)

  128. 

  129. 

  130. def test_matmul_logical_not():

  131.     class Net(nn.Cell):

  132.         def __init__(self, strategy1, strategy2, strategy3):

  133.             super().__init__()

  134.             self.matmul = P.MatMul().set_strategy(strategy1)

  135.             self.logicalnot = P.LogicalNot().set_strategy(strategy2)

  136.             self.equal = P.Equal().set_strategy(strategy3)

  137. 

  138.         def construct(self, x, y, b):

  139.             out = self.matmul(x, y)

  140.             out = self.equal(out, b)

  141.             out = self.logicalnot(out)

  142.             return out

  143. 

  144.     context.set_auto_parallel_context(device_num=8, global_rank=0)

  145.     strategy1 = ((2, 2), (2, 2))

  146.     strategy2 = ((4, 2),)

  147.     strategy3 = ((4, 2), (4, 2))

  148.     net = GradWrap(NetWithLoss(Net(strategy1, strategy2, strategy3)))

  149.     context.set_auto_parallel_context(parallel_mode="semi_auto_parallel")

  150. 

  151.     x = Tensor(np.ones([128, 32]), dtype=ms.float32)

  152.     y = Tensor(np.ones([32, 64]), dtype=ms.float32)

  153.     b = Tensor(np.ones([128, 64]), dtype=ms.float32)

  154.     compile_net(net, x, y, b)

  155. 

  156. 

  157. def test_matmul_cast():

  158.     class Net(nn.Cell):

  159.         def __init__(self, strategy1, strategy2, strategy3):

  160.             super().__init__()

  161.             self.matmul = P.MatMul().set_strategy(strategy1)

  162.             self.cast = P.Cast().set_strategy(strategy2)

  163.             self.matmul2 = P.MatMul().set_strategy(strategy3)

  164. 

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

  166.             out = self.matmul(x, y)

  167.             b = self.cast(b, ms.float32)

  168.             out = self.matmul2(out, b)

  169.             return out

  170. 

  171.     context.set_auto_parallel_context(device_num=8, global_rank=0)

  172.     strategy1 = ((2, 2), (2, 2))

  173.     strategy2 = ((4, 2),)

  174.     strategy3 = ((1, 4), (4, 2))

  175.     net = GradWrap(NetWithLoss(Net(strategy1, strategy2, strategy3)))

  176.     context.set_auto_parallel_context(parallel_mode="semi_auto_parallel")

  177. 

  178.     x = Tensor(np.ones([128, 32]), dtype=ms.float32)

  179.     y = Tensor(np.ones([32, 64]), dtype=ms.float32)

  180.     b = Tensor(np.ones([64, 64]), dtype=ms.int32)

  181.     compile_net(net, x, y, b)

  182. 

  183. 

  184. def test_cast_before_mirror():

  185.     class Net(nn.Cell):

  186.         def __init__(self, strategy1):

  187.             super().__init__()

  188.             self.matmul = P.MatMul().set_strategy(strategy1)

  189.             self.cast = P.Cast()

  190. 

  191.         def construct(self, x, y, b):

  192.             out = self.matmul(x, y)

  193.             b = self.cast(b, ms.float32)

  194.             out = self.matmul(out, b)

  195.             return out

  196. 

  197.     context.set_auto_parallel_context(device_num=8, global_rank=0, cast_before_mirror=True)

  198.     strategy1 = ((2, 2), (2, 2))

  199.     net = GradWrap(NetWithLoss(Net(strategy1)))

  200.     context.set_auto_parallel_context(parallel_mode="semi_auto_parallel")

  201. 

  202.     x = Tensor(np.ones([128, 32]), dtype=ms.float32)

  203.     y = Tensor(np.ones([32, 64]), dtype=ms.float32)

  204.     b = Tensor(np.ones([64, 64]), dtype=ms.float16)

  205.     compile_net(net, x, y, b)

  206. 

  207. 

  208. def test_cast_before_mirror1():

  209.     class Net(nn.Cell):

  210.         def __init__(self, strategy1):

  211.             super().__init__()

  212.             self.matmul = P.MatMul().set_strategy(strategy1)

  213.             self.cast = P.Cast()

  214. 

  215.         def construct(self, x, y, b):

  216.             out = self.matmul(x, y)

  217.             b = self.cast(b, ms.float16)

  218.             out = self.matmul(out, b)

  219.             return out

  220. 

  221.     context.set_auto_parallel_context(device_num=8, global_rank=0, cast_before_mirror=True)

  222.     strategy1 = ((2, 2), (2, 2))

  223.     net = GradWrap(NetWithLoss(Net(strategy1)))

  224.     context.set_auto_parallel_context(parallel_mode="semi_auto_parallel")

  225. 

  226.     x = Tensor(np.ones([128, 32]), dtype=ms.float16)

  227.     y = Tensor(np.ones([32, 64]), dtype=ms.float16)

  228.     b = Tensor(np.ones([64, 64]), dtype=ms.float32)

  229.     compile_net(net, x, y, b)

  230. 

  231. 

  232. def test_cast_before_mirror2():

  233.     class Net(nn.Cell):

  234.         def __init__(self, strategy1):

  235.             super().__init__()

  236.             self.matmul = P.MatMul().set_strategy(strategy1)

  237.             self.cast = P.Cast()

  238. 

  239.         def construct(self, x, y, b):

  240.             out = self.matmul(x, y)

  241.             b = self.cast(b, ms.float16)

  242.             out = self.matmul(out, b)

  243.             return out

  244. 

  245.     context.set_auto_parallel_context(device_num=8, global_rank=0, cast_before_mirror=False)

  246.     strategy1 = ((2, 2), (2, 2))

  247.     net = GradWrap(NetWithLoss(Net(strategy1)))

  248.     context.set_auto_parallel_context(parallel_mode="semi_auto_parallel")

  249. 

  250.     x = Tensor(np.ones([128, 32]), dtype=ms.float16)

  251.     y = Tensor(np.ones([32, 64]), dtype=ms.float16)

  252.     b = Tensor(np.ones([64, 64]), dtype=ms.float32)

  253.     compile_net(net, x, y, b)

  254. 

  255. 

  256. def test_cast_before_mirror3():

  257.     class Net(nn.Cell):

  258.         def __init__(self, strategy1):

  259.             super().__init__()

  260.             self.matmul = P.MatMul().set_strategy(strategy1)

  261.             self.cast = P.Cast()

  262. 

  263.         def construct(self, x, y, b):

  264.             out = self.matmul(x, y)

  265.             b = self.cast(b, ms.float16)

  266.             out = self.matmul(out, b)

  267.             return out

  268. 

  269.     context.set_auto_parallel_context(device_num=8, global_rank=0)

  270.     strategy1 = ((2, 2), (2, 2))

  271.     net = GradWrap(NetWithLoss(Net(strategy1)))

  272.     context.set_auto_parallel_context(parallel_mode="semi_auto_parallel")

  273. 

  274.     x = Tensor(np.ones([128, 32]), dtype=ms.float16)

  275.     y = Tensor(np.ones([32, 64]), dtype=ms.float16)

  276.     b = Tensor(np.ones([64, 64]), dtype=ms.float32)

  277.     compile_net(net, x, y, b)

  278. 

  279. 

  280. def test_mul_two_cast():

  281.     class Net(nn.Cell):

  282.         def __init__(self, strategy1, strategy2, strategy3):

  283.             super().__init__()

  284.             self.mul = P.Mul().set_strategy(strategy1)

  285.             self.mul2 = P.Mul().set_strategy(strategy2)

  286.             self.cast = P.Cast().set_strategy(strategy3)

  287.             self.cast2 = P.Cast().set_strategy(strategy3)

  288. 

  289.         def construct(self, x, y, b):

  290.             out = self.mul(x, y)

  291.             out = self.mul2(out, b)

  292.             out = self.cast(out, ms.int32)

  293.             out = self.cast2(out, ms.bool_)

  294.             return out

  295. 

  296.     context.set_auto_parallel_context(device_num=8, global_rank=0)

  297.     strategy1 = ((2, 2), (2, 2))

  298.     strategy2 = ((8, 1), (8, 1))

  299.     strategy3 = ((8, 1),)

  300.     net = GradWrap(Net(strategy1, strategy2, strategy3))

  301.     context.set_auto_parallel_context(parallel_mode="semi_auto_parallel")

  302. 

  303.     x = Tensor(np.ones([128, 32]), dtype=ms.float32)

  304.     y = Tensor(np.ones([128, 32]), dtype=ms.float32)

  305.     b = Tensor(np.ones([128, 32]), dtype=ms.float32)

  306.     compile_net(net, x, y, b)