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

296 lines
13 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 checking for some ops"""

  16. import functools

  17. import logging

  18. import numpy as np

  19. 

  20. import mindspore.context as context

  21. from mindspore import Tensor

  22. from mindspore import nn

  23. from mindspore.common.api import _executor

  24. from mindspore.ops import operations as P

  25. from ..ut_filter import non_graph_engine

  26. from ....mindspore_test_framework.mindspore_test import mindspore_test

  27. from ....mindspore_test_framework.pipeline.forward.compile_forward \

  28.     import pipeline_for_compile_forward_ge_graph_for_case_by_case_config

  29. from ....mindspore_test_framework.pipeline.forward.verify_exception \

  30.     import pipeline_for_verify_exception_for_case_by_case_config

  31. 

  32. logging.basicConfig(level=logging.WARNING)

  33. 

  34. 

  35. # pylint: disable=abstract-method

  36. class NetMissConstruct(nn.Cell):

  37.     """ NetMissConstruct definition """

  38. 

  39.     def __init__(self):

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

  41.         self.conv1 = nn.Conv2d(1, 6, 5, pad_mode='valid')

  42.         self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid')

  43.         self.fc1 = nn.Dense(16 * 5 * 5, 120)

  44.         self.fc2 = nn.Dense(120, 84)

  45.         self.fc3 = nn.Dense(84, 10)

  46.         self.relu = nn.ReLU()

  47.         self.max_pool2d = nn.MaxPool2d(kernel_size=2)

  48.         self.flatten = P.Flatten()

  49. 

  50.     # TestCase: Mis-spelled 'construct' to 'construtc'

  51.     def construtc(self, x):

  52.         x = self.max_pool2d(self.relu(self.conv1(x)))

  53.         x = self.max_pool2d(self.relu(self.conv2(x)))

  54.         x = self.flatten(x)

  55.         x = self.relu(self.fc1(x))

  56.         x = self.relu(self.fc2(x))

  57.         x = self.fc3(x)

  58.         return x

  59. 

  60. 

  61. def test_net_without_construct():

  62.     """ test_net_without_construct """

  63.     net = NetMissConstruct()

  64.     inp = Tensor(np.ones([1, 1, 32, 32]).astype(np.float32))

  65.     try:

  66.         _executor.compile(net, inp)

  67.     except RuntimeError as err:

  68.         if str(err).find("Unsupported syntax 'Raise' at ") >= 0:

  69.             print(str(err))

  70.         else:

  71.             raise err

  72. 

  73. 

  74. class NetWithRaise(nn.Cell):

  75.     """ NetWithRaise definition """

  76. 

  77.     def __init__(self):

  78.         super(NetWithRaise, self).__init__()

  79.         self.conv1 = nn.Conv2d(1, 6, 5, pad_mode='valid')

  80. 

  81.     # raise exception in method 'construct'

  82.     def construct(self, x):

  83.         raise 'exception in construct'

  84. 

  85. 

  86. def test_net_with_raise():

  87.     """ test_net_with_raise """

  88.     net = NetWithRaise()

  89.     inp = Tensor(np.ones([1, 1, 32, 32]).astype(np.float32))

  90.     try:

  91.         _executor.compile(net, inp)

  92.     except RuntimeError as err:

  93.         if str(err).find("Unsupported syntax 'Raise' at ") >= 0:

  94.             print(str(err))

  95.         else:

  96.             raise err

  97. 

  98. 

  99. class NetAddN(nn.Cell):

  100.     """net for test AddN"""

  101. 

  102.     def __init__(self):

  103.         super(NetAddN, self).__init__()

  104.         self.net = P.AddN()

  105. 

  106.     def construct(self, x):

  107.         return self.net(x)

  108. 

  109. 

  110. class NetSplit(nn.Cell):

  111.     "net for test Split"

  112. 

  113.     def __init__(self):

  114.         super(NetSplit, self).__init__()

  115.         self.net = P.Split(1, 2)

  116. 

  117.     def construct(self, x):

  118.         return self.net(x)

  119. 

  120. 

  121. class NetBatchMatMul(nn.Cell):

  122.     """net for test BatchMatMul"""

  123. 

  124.     def __init__(self):

  125.         super(NetBatchMatMul, self).__init__()

  126.         self.op = P.BatchMatMul()

  127. 

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

  129.         return self.op(x, y)

  130. 

  131. 

  132. test_case_check_ops = [

  133.     ('Conv_Padding_1', {

  134.         'block': nn.Conv2d(1, 6, 5, pad_mode='same', padding=0),

  135.         'desc_inputs': [Tensor(np.ones(shape=[1, 1, 6, 5]).astype(np.float32))]}),

  136.     ('Conv_Padding_2', {

  137.         'block': nn.Conv2d(1, 6, 5, pad_mode='valid', padding=0),

  138.         'desc_inputs': [Tensor(np.ones(shape=[1, 1, 6, 5]).astype(np.float32))]}),

  139.     ('Conv_Padding_3', {

  140.         'block': nn.Conv2d(1, 6, 5, pad_mode='pad', padding=0),

  141.         'desc_inputs': [Tensor(np.ones(shape=[1, 1, 6, 5]).astype(np.float32))]}),

  142.     ('Conv_Padding_4', {

  143.         'block': nn.Conv2d(1, 6, 5, pad_mode='pad', padding=7),

  144.         'desc_inputs': [Tensor(np.ones(shape=[1, 1, 6, 5]).astype(np.float32))]}),

  145.     ('Conv_Bias_1', {

  146.         'block': nn.Conv2d(1, 6, 5, has_bias=True, bias_init=Tensor(np.ones([6]).astype(np.float32))),

  147.         'desc_inputs': [Tensor(np.ones(shape=[1, 1, 6, 5]).astype(np.float32))]}),

  148.     ('Conv_Bias_2', {

  149.         'block': nn.Conv2d(1, 6, 5, has_bias=True, bias_init='zeros'),

  150.         'desc_inputs': [Tensor(np.ones(shape=[1, 1, 6, 5]).astype(np.float32))]}),

  151.     ('Conv_Bias_3', {

  152.         'block': nn.Conv2d(1, 6, 5, has_bias=False, bias_init='zeros'),

  153.         'desc_inputs': [Tensor(np.ones(shape=[1, 1, 6, 5]).astype(np.float32))]}),

  154.     ('Conv_Bias_4', {

  155.         'block': nn.Conv2d(1, 6, 5, has_bias=False, bias_init=Tensor(np.ones([6]).astype(np.float32))),

  156.         'desc_inputs': [Tensor(np.ones(shape=[1, 1, 6, 5]).astype(np.float32))]}),

  157.     ('Dense_Bias_1', {

  158.         'block': nn.Dense(1, 6, has_bias=True, bias_init=Tensor(np.ones([6]).astype(np.float32))),

  159.         'desc_inputs': [Tensor(np.ones(shape=[6, 1]).astype(np.float32))]}),

  160.     ('Dense_Bias_2', {

  161.         'block': nn.Dense(1, 6, has_bias=True, bias_init='zeros'),

  162.         'desc_inputs': [Tensor(np.ones(shape=[6, 1]).astype(np.float32))]}),

  163.     ('Dense_Bias_3', {

  164.         'block': nn.Dense(1, 6, has_bias=False, bias_init='zeros'),

  165.         'desc_inputs': [Tensor(np.ones(shape=[6, 1]).astype(np.float32))]}),

  166.     ('Dense_Bias_4', {

  167.         'block': nn.Dense(1, 6, has_bias=False, bias_init=Tensor(np.ones([6]).astype(np.float32))),

  168.         'desc_inputs': [Tensor(np.ones(shape=[6, 1]).astype(np.float32))]}),

  169.     ('MaxPool2d_1', {

  170.         'block': nn.MaxPool2d(5, pad_mode='same'),

  171.         'desc_inputs': [Tensor(np.ones(shape=[5, 5, 8, 8]).astype(np.float32))]}),

  172.     ('MaxPool2d_2', {

  173.         'block': nn.MaxPool2d(5, pad_mode='valid'),

  174.         'desc_inputs': [Tensor(np.ones(shape=[5, 5, 8, 8]).astype(np.float32))]}),

  175.     ('AvgPool2d_1', {

  176.         'block': nn.AvgPool2d(5, pad_mode='same'),

  177.         'desc_inputs': [Tensor(np.ones(shape=[5, 5, 8, 8]).astype(np.float32))]}),

  178.     ('AvgPool2d_2', {

  179.         'block': nn.AvgPool2d(5, pad_mode='valid'),

  180.         'desc_inputs': [Tensor(np.ones(shape=[5, 5, 8, 8]).astype(np.float32))]}),

  181.     ('Conv2D_1', {

  182.         'block': P.Conv2D(1, 6, pad_mode='same', pad=0),

  183.         'desc_inputs': [Tensor(np.ones(shape=[5, 5, 8, 8]).astype(np.float32)),

  184.                         Tensor(np.ones(shape=[1, 5, 6, 6]).astype(np.float32))]}),

  185.     ('Conv2D_2', {

  186.         'block': P.Conv2D(1, 6, pad_mode='valid', pad=0),

  187.         'desc_inputs': [Tensor(np.ones(shape=[5, 5, 8, 8]).astype(np.float32)),

  188.                         Tensor(np.ones(shape=[1, 5, 6, 6]).astype(np.float32))]}),

  189.     ('Conv2D_3', {

  190.         'block': P.Conv2D(1, 6, pad_mode='pad', pad=0),

  191.         'desc_inputs': [Tensor(np.ones(shape=[5, 5, 8, 8]).astype(np.float32)),

  192.                         Tensor(np.ones(shape=[1, 5, 6, 6]).astype(np.float32))]}),

  193.     ('Conv2D_4', {

  194.         'block': P.Conv2D(1, 6, pad_mode='pad', pad=7),

  195.         'desc_inputs': [Tensor(np.ones(shape=[5, 5, 8, 8]).astype(np.float32)),

  196.                         Tensor(np.ones(shape=[1, 5, 6, 6]).astype(np.float32))]}),

  197.     ('MatMul_1', {

  198.         'block': P.MatMul(),

  199.         'desc_inputs': [Tensor(np.ones(shape=[1, 3])), Tensor(np.ones(shape=[3, 4]))]}),

  200.     ('MatMul_2', {

  201.         'block': P.BatchMatMul(),

  202.         'desc_inputs': [Tensor(np.ones(shape=[5, 1, 5])), Tensor(np.ones(shape=[5, 5, 4]))]}),

  203.     ('MatMul_Transpose_1', {

  204.         'block': P.MatMul(transpose_a=True),

  205.         'desc_inputs': [Tensor(np.ones(shape=[3, 1])), Tensor(np.ones(shape=[3, 4]))]}),

  206.     ('MatMul_Transpose_2', {

  207.         'block': P.MatMul(transpose_b=True),

  208.         'desc_inputs': [Tensor(np.ones(shape=[3, 2])), Tensor(np.ones(shape=[5, 2]))]}),

  209.     ('MatMul_Transpose_3', {

  210.         'block': P.MatMul(transpose_a=True, transpose_b=True),

  211.         'desc_inputs': [Tensor(np.ones(shape=[3, 2])), Tensor(np.ones(shape=[5, 3]))]}),

  212.     ('BatchMatMul', {

  213.         'block': NetBatchMatMul(),

  214.         'desc_inputs': [Tensor(np.ones(shape=[3, 1, 5])), Tensor(np.ones(shape=[3, 5, 4]))]}),

  215. ]

  216. 

  217. test_case_lists = [test_case_check_ops]

  218. test_exec_case = functools.reduce(lambda x, y: x + y, test_case_lists)

  219. # use -k to select certain testcast

  220. # pytest tests/python/ops/test_ops.py::test_backward -k LayerNorm

  221. 

  222. 

  223. 

  224. @non_graph_engine

  225. @mindspore_test(pipeline_for_compile_forward_ge_graph_for_case_by_case_config)

  226. def test_exec():

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

  228.     return test_exec_case

  229. 

  230. 

  231. raise_set = [

  232.     ('Conv_Padding_1_Error', {

  233.         'block': (lambda x: nn.Conv2d(1, 6, 5, pad_mode='same', padding=7), {'exception': ValueError}),

  234.         'desc_inputs': [Tensor(np.ones(shape=[1, 1, 6, 5]).astype(np.float32))]}),

  235.     ('Conv_Padding_2_Error', {

  236.         'block': (lambda x: nn.Conv2d(1, 6, 5, pad_mode='same', padding=7), {'exception': ValueError}),

  237.         'desc_inputs': [Tensor(np.ones(shape=[1, 1, 6, 5]).astype(np.float32))]}),

  238.     ('Conv2D_1_Error', {

  239.         'block': (lambda x, y: P.Conv2D(1, 6, pad_mode='same', pad=7), {'exception': ValueError}),

  240.         'desc_inputs': [Tensor(np.ones(shape=[5, 5, 8, 8]).astype(np.float32)),

  241.                         Tensor(np.ones(shape=[1, 5, 6, 6]).astype(np.float32))]}),

  242.     ('Conv2D_2_Error', {

  243.         'block': (lambda x, y: P.Conv2D(1, 6, pad_mode='valid', pad=7), {'exception': ValueError}),

  244.         'desc_inputs': [Tensor(np.ones(shape=[5, 5, 8, 8]).astype(np.float32)),

  245.                         Tensor(np.ones(shape=[1, 5, 6, 6]).astype(np.float32))]}),

  246.     ('NetAddN_Error', {

  247.         'block': (NetAddN(), {'exception': TypeError}),

  248.         'desc_inputs': [(np.random.randn(1, 2, 3, 4).astype(np.float32),

  249.                          np.random.randn(1, 2, 3, 4).astype(np.float32))]}),

  250.     ('AddN_Error', {

  251.         'block': (P.AddN(), {'exception': TypeError}),

  252.         'desc_inputs': [(np.random.randn(1, 2, 3, 4).astype(np.float32),

  253.                          np.random.randn(1, 2, 3, 4).astype(np.float32))]}),

  254.     ('Splite_Error', {

  255.         'block': (NetSplit(), {'exception': TypeError}),

  256.         'desc_inputs': [None]}),

  257.     ('MatMul_1_Error', {

  258.         'block': (P.MatMul(), {'exception': ValueError}),

  259.         'desc_inputs': [Tensor(np.ones(shape=[5])), Tensor(np.ones(shape=[4]))]}),

  260.     ('MatMul_2_Error', {

  261.         'block': (P.MatMul(), {'exception': ValueError}),

  262.         'desc_inputs': [Tensor(np.ones(shape=[1, 5])), Tensor(np.ones(shape=[3, 4]))]}),

  263.     ('MatMul_3_Error', {

  264.         'block': (P.MatMul(), {'exception': ValueError}),

  265.         'desc_inputs': [Tensor(np.ones(shape=[1, 5])), Tensor(np.ones(shape=[5, 5, 4]))]}),

  266.     ('MatMul_Transpose_1_Error', {

  267.         'block': (P.MatMul(transpose_a=True), {'exception': ValueError}),

  268.         'desc_inputs': [Tensor(np.ones(shape=[1, 3])), Tensor(np.ones(shape=[3, 4]))]}),

  269.     ('MatMul_Transpose_2_Error', {

  270.         'block': (P.MatMul(transpose_b=True), {'exception': ValueError}),

  271.         'desc_inputs': [Tensor(np.ones(shape=[3, 2])), Tensor(np.ones(shape=[2, 5]))]}),

  272.     ('MatMul_Transpose_3_Error', {

  273.         'block': (P.MatMul(transpose_a=True, transpose_b=True), {'exception': ValueError}),

  274.         'desc_inputs': [Tensor(np.ones(shape=[3, 2])), Tensor(np.ones(shape=[3, 5]))]}),

  275.     ('BatchMatMul_1_Error', {

  276.         'block': (P.BatchMatMul(), {'exception': ValueError}),

  277.         'desc_inputs': [Tensor(np.ones(shape=[5])), Tensor(np.ones(shape=[4]))]}),

  278.     ('BatchMatMul_2_Error', {

  279.         'block': (P.BatchMatMul(), {'exception': ValueError}),

  280.         'desc_inputs': [Tensor(np.ones(shape=[1, 5])), Tensor(np.ones(shape=[3, 4]))]}),

  281.     ('BatchMatMul_3_Error', {

  282.         'block': (P.BatchMatMul(), {'exception': ValueError}),

  283.         'desc_inputs': [Tensor(np.ones(shape=[3, 1, 5])), Tensor(np.ones(shape=[3, 3, 4]))]}),

  284.     ('BatchMatMul_4_Error', {

  285.         'block': (P.BatchMatMul(), {'exception': ValueError}),

  286.         'desc_inputs': [Tensor(np.ones(shape=[3, 1, 5])), Tensor(np.ones(shape=[1, 3, 5, 4]))]}),

  287.     ('BatchMatMul_5_Error', {

  288.         'block': (P.BatchMatMul(), {'exception': ValueError}),

  289.         'desc_inputs': [Tensor(np.ones(shape=[3, 1, 5])), Tensor(np.ones(shape=[2, 5, 4]))]}),

  290. ]

  291. 

  292. 

  293. @mindspore_test(pipeline_for_verify_exception_for_case_by_case_config)

  294. def test_check_exception():

  295.     return raise_set