Rollback to Normal on D

mindspore/nn/distribution/bernoulli.py

@@ -14,7 +14,6 @@
 # ============================================================================
 """Bernoulli Distribution"""
 from mindspore.ops import operations as P
-from mindspore.ops import composite as C
 from .distribution import Distribution
 from ._utils.utils import cast_to_tensor, check_prob
 from ...common import dtype as mstype
@@ -54,7 +53,6 @@ class Bernoulli(Distribution):
             check_prob(self._probs)
         else:
             self._probs = probs
-        self.seed = seed
 
         # ops needed for the class
         self.log = P.Log()
@@ -66,6 +64,7 @@ class Bernoulli(Distribution):
         self.const = P.ScalarToArray()
         self.less = P.Less()
         self.cast = P.Cast()
+        self.normal = P.Normal(seed=seed)
         self.erf = P.Erf()
         self.sqrt = P.Sqrt()
 
@@ -160,7 +159,7 @@ class Bernoulli(Distribution):
             mean_zero = self.const(0.0)
             sd_one = self.const(1.0)
             sqrt_two = self.sqrt(self.const(2.0))
-            sample_norm = C.normal(sample_shape, mean_zero, sd_one, self.seed)
+            sample_norm = self.normal(sample_shape, mean_zero, sd_one)
             sample_uniform = 0.5 * (1 + self.erf(self.realdiv(sample_norm, sqrt_two)))
             sample = self.less(sample_uniform, probs1)
             sample = self.cast(sample, self._dtype)

mindspore/nn/distribution/normal.py

@@ -15,7 +15,6 @@
 """Normal Distribution"""
 import numpy as np
 from mindspore.ops import operations as P
-from mindspore.ops import composite as C
 from .distribution import Distribution
 from ._utils.utils import convert_to_batch, check_greater_equal_zero
 from ...common import dtype as mstype
@@ -61,7 +60,6 @@ class Normal(Distribution):
         else:
             self._mean_value = mean
             self._sd_value = sd
-        self.seed = seed
 
         #ops needed for the class
         self.exp = P.Exp()
@@ -72,6 +70,7 @@ class Normal(Distribution):
         self.sqrt = P.Sqrt()
         self.realdiv = P.RealDiv()
         self.expm1 = P.Expm1() if get_context('device_target') == 'Ascend' else self._expm1_by_step
+        self.normal = P.Normal(seed=seed)
         self.shape = P.Shape()
         self.zeroslike = P.ZerosLike()
         self.const = P.ScalarToArray()
@@ -164,7 +163,7 @@ class Normal(Distribution):
             sample_shape = shape + batch_shape
             mean_zero = self.const(0.0)
             sd_one = self.const(1.0)
-            sample_norm = C.normal(sample_shape, mean_zero, sd_one, self.seed)
+            sample_norm = self.normal(sample_shape, mean_zero, sd_one)
             sample = self.add(mean, self.mul(sample_norm, sd))
             return sample
         return None

mindspore/ops/composite/__init__.py

@@ -27,7 +27,6 @@ from .clip_ops import clip_by_value
 from .multitype_ops.add_impl import hyper_add
 from .multitype_ops.ones_like_impl import ones_like
 from .multitype_ops.zeros_like_impl import zeros_like
-from .random_ops import normal
 
 
 __all__ = [
@@ -48,5 +47,4 @@ __all__ = [
     'zeros_like',
     'ones_like',
     'zip_operation',
-    'normal',
     'clip_by_value',]

mindspore/ops/composite/random_ops.py

@@ -1,63 +0,0 @@
-# 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.
-# ============================================================================
-
-"""Operations for random number generatos."""
-
-from mindspore.ops.primitive import constexpr
-from .. import operations as P
-
-# set graph-level RNG seed
-_GRAPH_SEED = 0
-
-@constexpr
-def set_seed(seed):
-    global _GRAPH_SEED
-    _GRAPH_SEED = seed
-
-@constexpr
-def get_seed():
-    return _GRAPH_SEED
-
-
-def normal(shape, mean, stddev, seed):
-    """
-    Generates random numbers according to the Normal (or Gaussian) random number distribution.
-    It is defined as:
-
-    Args:
-        - **shape** (tuple) - The shape of random tensor to be generated.
-        - **mean** (Tensor) - The mean μ distribution parameter, which specifies the location of the peak.
-          With float32 data type.
-        - **stddev** (Tensor) - The deviation σ distribution parameter. With float32 data type.
-        - **seed** (int): Seed is used as entropy source for Random number engines generating pseudo-random numbers.
-          Default: 0.
-
-    Returns:
-        Tensor. The shape should be the broadcasted shape of Input "shape" and shapes of mean and stddev.
-        The dtype is float32.
-
-    Examples:
-        >>> shape = (4, 16)
-        >>> mean = Tensor(1.0, mstype.float32)
-        >>> stddev = Tensor(1.0, mstype.float32)
-        >>> output = C.normal(shape, mean, stddev, seed=5)
-    """
-    set_seed(10)
-    seed1 = get_seed()
-    seed2 = seed
-    stdnormal = P.StandardNormal(seed1, seed2)
-    rnd = stdnormal(shape)
-    value = rnd * stddev + mean
-    return value

mindspore/ops/operations/__init__.py

@@ -55,7 +55,7 @@ from .math_ops import (Abs, ACos, Asin, Asinh, AddN, AccumulateNV2, AssignAdd, A
                        Sin, Sqrt, Rsqrt, BesselI0e, BesselI1e,
                        Square, Sub, TensorAdd, Sign, Round, SquareSumAll, Atan, Atanh, Cosh, Sinh, Eps)
 
-from .random_ops import (RandomChoiceWithMask, StandardNormal)
+from .random_ops import (RandomChoiceWithMask, Normal)
 from .nn_ops import (LSTM, SGD, Adam, SparseApplyAdam, SparseApplyLazyAdam, ApplyMomentum, BatchNorm,
                      BiasAdd, Conv2D,
                      DepthwiseConv2dNative,
@@ -170,7 +170,7 @@ __all__ = [
     'HSigmoid',
     'Tanh',
     'RandomChoiceWithMask',
-    'StandardNormal',
+    'Normal',
     'ResizeBilinear',
     'ScalarSummary',
     'ImageSummary',

mindspore/ops/operations/random_ops.py

@@ -21,48 +21,6 @@ from ...common import dtype as mstype
 from ..primitive import PrimitiveWithInfer, prim_attr_register
 
 
-class StandardNormal(PrimitiveWithInfer):
-    r"""
-    Generates random numbers according to the standard Normal (or Gaussian) random number distribution.
-
-    Args:
-        seed (int): Random seed. Default: 0.
-        seed2 (int): Random seed2. Default: 0.
-
-    Inputs:
-        - **shape** (tuple) - The shape of random tensor to be generated. Only constant value is allowed.
-
-    Outputs:
-        Tensor. The shape should be the broadcasted shape of Input "shape" and shapes of mean and stddev.
-        The dtype is float32.
-
-    Examples:
-        >>> shape = (4, 16)
-        >>> stdnormal = P.StandardNormal(seed=2)
-        >>> output = stdnormal(shape)
-    """
-
-    @prim_attr_register
-    def __init__(self, seed=0, seed2=0):
-        """Init StandardNormal"""
-        self.init_prim_io_names(inputs=['shape'], outputs=['output'])
-        validator.check_value_type('seed', seed, [int], self.name)
-        validator.check_value_type('seed2', seed2, [int], self.name)
-
-    def __infer__(self, shape):
-        shape_v = shape["value"]
-        if shape_v is None:
-            raise ValueError(f"For {self.name}, shape must be const.")
-        validator.check_value_type("shape", shape_v, [tuple], self.name)
-        for i, shape_i in enumerate(shape_v):
-            validator.check_integer("shape[%d]" % i, shape_i, 0, Rel.GT, self.name)
-        out = {
-            'shape': shape_v,
-            'dtype': mstype.float32,
-            'value': None}
-        return out
-
-
 class RandomChoiceWithMask(PrimitiveWithInfer):
     """
     Generates a random samply as index tensor with a mask tensor from a given tensor.
@@ -106,3 +64,47 @@ class RandomChoiceWithMask(PrimitiveWithInfer):
     def infer_dtype(self, x_dtype):
         validator.check_tensor_type_same({'x': x_dtype}, [mstype.bool_], self.name)
         return (mstype.int32, mstype.bool_)
+
+
+class Normal(PrimitiveWithInfer):
+    """
+    Generates random samples from a normal(Gaussian) distribution.
+
+    Args:
+        seed (int): Random seed. Default: 0.
+
+    Inputs:
+        - **shape** (tuple[int]) - The shape of output tensor. Only constant value is allowed.
+        - **mean** (Tensor) - The mean of the distribution, with float32 data type.
+        - **stddev** (Tensor) - The standard deviation of the distribution, with float32 data type.
+
+    Outputs:
+        Tensor, with the given shape from the specific distribution and float32 data type.
+
+    Examples:
+        >>> normal = P.Normal()
+        >>> mean = Tensor(0., mstype.float32)
+        >>> stddev = Tensor(1., mstype.float32)
+        >>> out = normal((32, 3, 3), mean, stddev)
+    """
+
+    @prim_attr_register
+    def __init__(self, seed=0):
+        """Init Normal"""
+        validator.check_value_type("seed", seed, [int], self.name)
+
+    def __infer__(self, shape, mean, stddev):
+        shape_value = shape["value"]
+        if shape_value is None:
+            raise ValueError(f"For {self.name}, shape must be const.")
+        validator.check_value_type("shape", shape_value, [tuple], self.name)
+        for i, shape_i in enumerate(shape_value):
+            validator.check_integer("shape[%d]" % i, shape_i, 0, Rel.GE, self.name)
+
+        validator.check_tensor_type_same({"mean": mean["dtype"]}, [mstype.float32], self.name)
+        validator.check_tensor_type_same({"stddev": stddev["dtype"]}, [mstype.float32], self.name)
+
+        out = {"shape": shape_value,
+               "dtype": mstype.float32,
+               "value": None}
+        return out

tests/st/ops/gpu/test_normal.py

@@ -1,56 +0,0 @@
-# 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 numpy as np
-
-import mindspore.context as context
-import mindspore.nn as nn
-from mindspore import Tensor
-from mindspore.common import dtype as mstype
-from mindspore.ops import composite as C
-
-context.set_context(mode=context.GRAPH_MODE, device_target="GPU")
-
-
-class Net(nn.Cell):
-    def __init__(self, shape, seed=0):
-        super(Net, self).__init__()
-        self.shape = shape
-        self.seed = seed
-
-    def construct(self, mean, stddev):
-        return C.normal(self.shape, mean, stddev, self.seed)
-
-
-def test_net_1D():
-    seed = 10
-    shape = (3, 2, 4)
-    mean = 1.0
-    stddev = 1.0
-    net = Net(shape, seed)
-    tmean, tstddev = Tensor(mean, mstype.float32), Tensor(stddev, mstype.float32)
-    output = net(tmean, tstddev)
-    assert output.shape == (3, 2, 4)
-
-
-def test_net_ND():
-    seed = 10
-    shape = (3, 1, 2)
-    mean = np.array([[[1], [2]], [[3], [4]], [[5], [6]]]).astype(np.float32)
-    stddev = np.array([1.0]).astype(np.float32)
-    net = Net(shape, seed)
-    tmean, tstddev = Tensor(mean, mstype.float32), Tensor(stddev, mstype.float32)
-    output = net(tmean, tstddev)
-    assert output.shape == (3, 2, 2)

tests/ut/python/ops/test_ops.py

@@ -533,10 +533,10 @@ class NormalNet(nn.Cell):
     def __init__(self, shape=None, seed=0):
         super(NormalNet, self).__init__()
         self.shape = shape
-        self.seed = seed
+        self.normal = P.Normal(seed=seed)
 
     def construct(self, mean, stddev):
-        out = C.normal(self.shape, mean, stddev, self.seed)
+        out = self.normal(self.shape, mean, stddev)
         return out