diff --git a/mindspore/_akg/gpu/__init__.py b/mindspore/_akg/gpu/__init__.py index 08961d3989f..f9db48c634f 100644 --- a/mindspore/_akg/gpu/__init__.py +++ b/mindspore/_akg/gpu/__init__.py @@ -30,3 +30,8 @@ from .hsigmoid import HSigmoid, gpu_schedule_HSigmoid from .hsigmoid_grad import HSigmoidGrad, gpu_schedule_HSigmoidGrad from .hswish import HSwish, gpu_schedule_HSwish from .hswish_grad import HSwishGrad, gpu_schedule_HSwishGrad +from .logical_or import LogicalOr, gpu_schedule_LogicalOr +from .logical_not import LogicalNot, gpu_schedule_LogicalNot +from .logical_and import LogicalAnd, gpu_schedule_LogicalAnd +from .sub import Sub, gpu_schedule_Sub +from .less_equal import LessEqual, gpu_schedule_LessEqual diff --git a/mindspore/nn/wrap/loss_scale.py b/mindspore/nn/wrap/loss_scale.py index ba8e6cbb7c8..65d66f0150f 100644 --- a/mindspore/nn/wrap/loss_scale.py +++ b/mindspore/nn/wrap/loss_scale.py @@ -209,6 +209,7 @@ class TrainOneStepWithLossScaleCell(Cell): self.gpu_target = True self.float_status = P.FloatStatus() self.addn = P.AddN() + self.reshape = P.Reshape() else: self.gpu_target = False self.alloc_status = NPUAllocFloatStatus() @@ -260,6 +261,8 @@ class TrainOneStepWithLossScaleCell(Cell): else: flag_sum = self.hyper_map(F.partial(_grad_overflow), grads) flag_sum = self.addn(flag_sum) + # convert flag_sum to scalar + flag_sum = self.reshape(flag_sum, (())) if self.is_distributed: # sum overflow flag over devices flag_reduce = self.allreduce(flag_sum) diff --git a/mindspore/ops/_op_impl/akg/gpu/__init__.py b/mindspore/ops/_op_impl/akg/gpu/__init__.py index 8ffc796ae32..08beb44340b 100644 --- a/mindspore/ops/_op_impl/akg/gpu/__init__.py +++ b/mindspore/ops/_op_impl/akg/gpu/__init__.py @@ -27,3 +27,8 @@ from .hsigmoid import _hsigmoid_akg from .hsigmoid_grad import _hsigmoid_grad_akg from .hswish import _hswish_akg from .hswish_grad import _hswish_grad_akg +from .sub import _sub_akg +from .logical_and import _logical_and_akg +from .logical_not import _logical_not_akg +from .logical_or import _logical_or_akg +from .lessequal import _lessequal_akg diff --git a/mindspore/ops/operations/math_ops.py b/mindspore/ops/operations/math_ops.py index a3df6b7fbab..78d813b9cca 100644 --- a/mindspore/ops/operations/math_ops.py +++ b/mindspore/ops/operations/math_ops.py @@ -1495,6 +1495,7 @@ class LogicalNot(PrimitiveWithInfer): @prim_attr_register def __init__(self): """init LogicalNot""" + self.init_prim_io_names(inputs=['x'], outputs=['output']) def infer_shape(self, x_shape): return x_shape diff --git a/tests/st/ops/gpu/test_lessequal_op.py b/tests/st/ops/gpu/test_lessequal_op.py new file mode 100644 index 00000000000..08bb28b0afa --- /dev/null +++ b/tests/st/ops/gpu/test_lessequal_op.py @@ -0,0 +1,49 @@ +# Copyright 2020 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ + +import pytest +from mindspore.ops import operations as P +from mindspore.nn import Cell +from mindspore.common.tensor import Tensor +import mindspore.context as context +import numpy as np + + +class Net(Cell): + def __init__(self): + super(Net, self).__init__() + self.lessequal = P.LessEqual() + + def construct(self, x, y): + return self.lessequal(x, y) + + +@pytest.mark.level0 +@pytest.mark.platform_x86_gpu_training +@pytest.mark.env_onecard +def test_lessequal(): + x = Tensor(np.array([[1, 2, 3]]).astype(np.float32)) + y = Tensor(np.array([[2]]).astype(np.float32)) + expect = [[True, True, False]] + context.set_context(mode=context.PYNATIVE_MODE, device_target="GPU") + lessequal = Net() + output = lessequal(x, y) + assert np.all(output.asnumpy() == expect) + + context.set_context(mode=context.GRAPH_MODE, device_target="GPU") + lessequal = Net() + output = lessequal(x, y) + assert np.all(output.asnumpy() == expect) + diff --git a/tests/st/ops/gpu/test_logical_op.py b/tests/st/ops/gpu/test_logical_op.py new file mode 100644 index 00000000000..ab95aa8f3fc --- /dev/null +++ b/tests/st/ops/gpu/test_logical_op.py @@ -0,0 +1,92 @@ +# Copyright 2020 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ + +import pytest +from mindspore.ops import operations as P +from mindspore.nn import Cell +from mindspore.common.tensor import Tensor +import mindspore.context as context +import numpy as np + + +class NetAnd(Cell): + def __init__(self): + super(NetAnd, self).__init__() + self.logicaland = P.LogicalAnd() + + def construct(self, x, y): + return self.logicaland(x, y) + +class NetOr(Cell): + def __init__(self): + super(NetOr, self).__init__() + self.logicalor = P.LogicalOr() + + def construct(self, x, y): + return self.logicalor(x, y) + +class NetNot(Cell): + def __init__(self): + super(NetNot, self).__init__() + self.logicalnot = P.LogicalNot() + + def construct(self, x): + return self.logicalnot(x) + +x = np.array([True, False, False]).astype(np.bool) +y = np.array([False]).astype(np.bool) + +@pytest.mark.level0 +@pytest.mark.platform_x86_gpu_training +@pytest.mark.env_onecard +def test_logicaland(): + context.set_context(mode=context.PYNATIVE_MODE, device_target="GPU") + logicaland = NetAnd() + output = logicaland(Tensor(x), Tensor(y)) + assert np.all(output.asnumpy() == np.logical_and(x, y)) + + context.set_context(mode=context.GRAPH_MODE, device_target="GPU") + logicaland = NetAnd() + output = logicaland(Tensor(x), Tensor(y)) + assert np.all(output.asnumpy() == np.logical_and(x, y)) + +@pytest.mark.level0 +@pytest.mark.platform_x86_gpu_training +@pytest.mark.env_onecard +def test_logicalor(): + context.set_context(mode=context.PYNATIVE_MODE, device_target="GPU") + logicalor = NetOr() + output = logicalor(Tensor(x), Tensor(y)) + assert np.all(output.asnumpy() == np.logical_or(x, y)) + + context.set_context(mode=context.GRAPH_MODE, device_target="GPU") + logicalor = NetOr() + output = logicalor(Tensor(x), Tensor(y)) + assert np.all(output.asnumpy() == np.logical_or(x, y)) + +@pytest.mark.level0 +@pytest.mark.platform_x86_gpu_training +@pytest.mark.env_onecard +def test_logicalnot(): + context.set_context(mode=context.PYNATIVE_MODE, device_target="GPU") + logicalnot = NetNot() + output = logicalnot(Tensor(x)) + assert np.all(output.asnumpy() == np.logical_not(x)) + + context.set_context(mode=context.GRAPH_MODE, device_target="GPU") + logicalnot = NetNot() + output = logicalnot(Tensor(x)) + assert np.all(output.asnumpy() == np.logical_not(x)) + diff --git a/tests/st/ops/gpu/test_maximum_op.py b/tests/st/ops/gpu/test_maximum_op.py new file mode 100644 index 00000000000..3193dafa61f --- /dev/null +++ b/tests/st/ops/gpu/test_maximum_op.py @@ -0,0 +1,55 @@ +# Copyright 2020 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ + +import pytest +from mindspore.ops import operations as P +from mindspore.nn import Cell +from mindspore.common.tensor import Tensor +import mindspore.context as context +import numpy as np + + +class Net(Cell): + def __init__(self): + super(Net, self).__init__() + self.max = P.Maximum() + + def construct(self, x, y): + return self.max(x, y) + + +@pytest.mark.level0 +@pytest.mark.platform_x86_gpu_training +@pytest.mark.env_onecard +def test_max(): + x = Tensor(np.array([[1, 2, 3]]).astype(np.float32)) + y = Tensor(np.array([[2]]).astype(np.float32)) + expect = [[2, 2, 3]] + error = np.ones(shape=[1, 3]) * 1.0e-5 + + context.set_context(mode=context.PYNATIVE_MODE, device_target="GPU") + max = Net() + output = max(x, y) + diff = output.asnumpy() - expect + assert np.all(diff < error) + assert np.all(-diff < error) + + context.set_context(mode=context.GRAPH_MODE, device_target="GPU") + max = Net() + output = max(x, y) + diff = output.asnumpy() - expect + assert np.all(diff < error) + assert np.all(-diff < error) +