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: 693b4cfdc8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '693b4cfdc8'
${ noResults }
mindspore2022/tests/st/ops/gpu/test_batchnorm_op.py

204 lines
8.9 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 BatchNorm2d

  22. from mindspore.nn import Cell

  23. from mindspore.ops import composite as C

  24. 

  25. 

  26. class Batchnorm_Net(Cell):

  27.     def __init__(self, c, weight, bias, moving_mean, moving_var_init, use_batch_statistics=None):

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

  29.         self.bn = BatchNorm2d(c, eps=0.00001, momentum=0.1, beta_init=bias, gamma_init=weight,

  30.                               moving_mean_init=moving_mean, moving_var_init=moving_var_init,

  31.                               use_batch_statistics=use_batch_statistics)

  32. 

  33.     def construct(self, input_data):

  34.         x = self.bn(input_data)

  35.         return x

  36. 

  37. 

  38. class Grad(Cell):

  39.     def __init__(self, network):

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

  41.         self.grad = C.GradOperation(get_all=True, sens_param=True)

  42.         self.network = network

  43. 

  44.     def construct(self, input_data, sens):

  45.         gout = self.grad(self.network)(input_data, sens)

  46.         return gout

  47. 

  48. 

  49. @pytest.mark.level0

  50. @pytest.mark.platform_x86_gpu_training

  51. @pytest.mark.env_onecard

  52. def test_train_forward():

  53.     x = np.array([[

  54.         [[1, 3, 3, 5], [2, 4, 6, 8], [3, 6, 7, 7], [4, 3, 8, 2]],

  55.         [[5, 7, 6, 3], [3, 5, 6, 7], [9, 4, 2, 5], [7, 5, 8, 1]]]]).astype(np.float32)

  56.     expect_output = np.array([[[[-0.6059, 0.3118, 0.3118, 1.2294],

  57.                                 [-0.1471, 0.7706, 1.6882, 2.6059],

  58.                                 [0.3118, 1.6882, 2.1471, 2.1471],

  59.                                 [0.7706, 0.3118, 2.6059, -0.1471]],

  60. 

  61.                                [[0.9119, 1.8518, 1.3819, -0.0281],

  62.                                 [-0.0281, 0.9119, 1.3819, 1.8518],

  63.                                 [2.7918, 0.4419, -0.4981, 0.9119],

  64.                                 [1.8518, 0.9119, 2.3218, -0.9680]]]]).astype(np.float32)

  65. 

  66.     weight = np.ones(2).astype(np.float32)

  67.     bias = np.ones(2).astype(np.float32)

  68.     moving_mean = np.ones(2).astype(np.float32)

  69.     moving_var_init = np.ones(2).astype(np.float32)

  70.     error = np.ones(shape=[1, 2, 4, 4]) * 1.0e-4

  71. 

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

  73.     bn_net = Batchnorm_Net(2, Tensor(weight), Tensor(bias),

  74.                            Tensor(moving_mean), Tensor(moving_var_init))

  75.     bn_net.set_train()

  76.     output = bn_net(Tensor(x))

  77.     diff = output.asnumpy() - expect_output

  78.     assert np.all(diff < error)

  79.     assert np.all(-diff < error)

  80. 

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

  82.     bn_net = Batchnorm_Net(2, Tensor(weight), Tensor(bias),

  83.                            Tensor(moving_mean), Tensor(moving_var_init))

  84.     bn_net.set_train()

  85.     output = bn_net(Tensor(x))

  86.     diff = output.asnumpy() - expect_output

  87.     assert np.all(diff < error)

  88.     assert np.all(-diff < error)

  89. 

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

  91.     bn_net = Batchnorm_Net(2, Tensor(weight), Tensor(bias),

  92.                            Tensor(moving_mean), Tensor(moving_var_init))

  93.     bn_net.set_train(False)

  94.     output = bn_net(Tensor(x))

  95. 

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

  97.     bn_net = Batchnorm_Net(2, Tensor(weight), Tensor(bias),

  98.                            Tensor(moving_mean), Tensor(moving_var_init))

  99.     bn_net.set_train(False)

  100.     output = bn_net(Tensor(x))

  101. 

  102. 

  103. @pytest.mark.level0

  104. @pytest.mark.platform_x86_gpu_training

  105. @pytest.mark.env_onecard

  106. def test_train_backward():

  107.     x = np.array([[

  108.         [[1, 3, 3, 5], [2, 4, 6, 8], [3, 6, 7, 7], [4, 3, 8, 2]],

  109.         [[5, 7, 6, 3], [3, 5, 6, 7], [9, 4, 2, 5], [7, 5, 8, 1]]]]).astype(np.float32)

  110.     grad = np.array([[

  111.         [[1, 2, 7, 1], [4, 2, 1, 3], [1, 6, 5, 2], [2, 4, 3, 2]],

  112.         [[9, 4, 3, 5], [1, 3, 7, 6], [5, 7, 9, 9], [1, 4, 6, 8]]]]).astype(np.float32)

  113.     expect_output = np.array([[[[-0.69126546, -0.32903028, 1.9651246, -0.88445705],

  114.                                 [0.6369296, -0.37732816, -0.93275493, -0.11168876],

  115.                                 [-0.7878612, 1.3614, 0.8542711, -0.52222186],

  116.                                 [-0.37732816, 0.5886317, -0.11168876, -0.28073236]],

  117. 

  118.                                [[1.6447213, -0.38968924, -1.0174079, -0.55067265],

  119.                                 [-2.4305856, -1.1751484, 0.86250514, 0.5502673],

  120.                                 [0.39576983, 0.5470243, 1.1715001, 1.6447213],

  121.                                 [-1.7996241, -0.7051701, 0.7080077, 0.5437813]]]]).astype(np.float32)

  122. 

  123.     weight = Tensor(np.ones(2).astype(np.float32))

  124.     bias = Tensor(np.ones(2).astype(np.float32))

  125.     moving_mean = Tensor(np.ones(2).astype(np.float32))

  126.     moving_var_init = Tensor(np.ones(2).astype(np.float32))

  127.     error = np.ones(shape=[1, 2, 4, 4]) * 1.0e-6

  128. 

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

  130.     bn_net = Batchnorm_Net(2, weight, bias, moving_mean, moving_var_init)

  131.     bn_net.set_train()

  132.     bn_grad = Grad(bn_net)

  133.     output = bn_grad(Tensor(x), Tensor(grad))

  134.     diff = output[0].asnumpy() - expect_output

  135.     assert np.all(diff < error)

  136.     assert np.all(-diff < error)

  137. 

  138. 

  139. @pytest.mark.level0

  140. @pytest.mark.platform_x86_gpu_training

  141. @pytest.mark.env_onecard

  142. def test_train_stats_false_forward():

  143.     x = np.array([[

  144.         [[1, 3, 3, 5], [2, 4, 6, 8], [3, 6, 7, 7], [4, 3, 8, 2]],

  145.         [[5, 7, 6, 3], [3, 5, 6, 7], [9, 4, 2, 5], [7, 5, 8, 1]]]]).astype(np.float32)

  146. 

  147.     expect_output = np.array([[[[3.707105, 5.121315, 5.121315, 6.535525],

  148.                                 [4.41421, 5.8284197, 7.24263, 8.656839],

  149.                                 [5.121315, 7.24263, 7.9497347, 7.9497347],

  150.                                 [5.8284197, 5.121315, 8.656839, 4.41421]],

  151. 

  152.                                [[6.535525, 7.9497347, 7.24263, 5.121315],

  153.                                 [5.121315, 6.535525, 7.24263, 7.9497347],

  154.                                 [9.363945, 5.8284197, 4.41421, 6.535525],

  155.                                 [7.9497347, 6.535525, 8.656839, 3.707105]]]]).astype(np.float32)

  156. 

  157.     weight = np.ones(2).astype(np.float32)

  158.     bias = np.ones(2).astype(np.float32) * 3

  159.     moving_mean = np.zeros(2).astype(np.float32)

  160.     moving_var_init = np.ones(2).astype(np.float32) * 2

  161.     error = np.ones(shape=[1, 2, 4, 4]) * 1.0e-4

  162.     use_batch_statistics = False

  163. 

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

  165.     bn_net = Batchnorm_Net(2, Tensor(weight), Tensor(bias), Tensor(moving_mean),

  166.                            Tensor(moving_var_init), use_batch_statistics)

  167.     bn_net.set_train()

  168.     output = bn_net(Tensor(x))

  169.     diff = output.asnumpy() - expect_output

  170.     assert np.all(diff < error)

  171.     assert np.all(-diff < error)

  172. 

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

  174.     bn_net = Batchnorm_Net(2, Tensor(weight), Tensor(bias), Tensor(moving_mean),

  175.                            Tensor(moving_var_init), use_batch_statistics)

  176.     bn_net.set_train()

  177.     output = bn_net(Tensor(x))

  178.     diff = output.asnumpy() - expect_output

  179.     assert np.all(diff < error)

  180.     assert np.all(-diff < error)

  181. 

  182. 

  183. @pytest.mark.level0

  184. @pytest.mark.platform_x86_gpu_training

  185. @pytest.mark.env_onecard

  186. def test_infer_backward():

  187.     expect_output = np.array([[[[-0.3224156, -0.3840524], [1.1337637, -1.0998858]],

  188.                                [[-0.1724273, -0.877854], [0.0422135, 0.5828123]],

  189.                                [[-1.1006137, 1.1447179], [0.9015862, 0.5024918]]]]).astype(np.float32)

  190.     np.random.seed(1)

  191.     x_np = np.random.randn(1, 3, 2, 2).astype(np.float32)

  192.     input_grad_np = np.random.randn(1, 3, 2, 2).astype(np.float32)

  193.     ms_input = Tensor(x_np)

  194.     weight = Tensor(np.ones(3).astype(np.float32))

  195.     bias = Tensor(np.zeros(3).astype(np.float32))

  196.     moving_mean = Tensor(np.zeros(3).astype(np.float32))

  197.     moving_var_init = Tensor(np.ones(3).astype(np.float32))

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

  199.     ms_net = Batchnorm_Net(3, weight, bias, moving_mean, moving_var_init)

  200.     ms_net.set_train(False)

  201.     ms_grad = Grad(ms_net)

  202.     ms_out_grad_np = ms_grad(ms_input, Tensor(input_grad_np))

  203.     assert np.allclose(ms_out_grad_np[0].asnumpy(), expect_output)