mindspore 2.6.0rc1__cp310-cp310-win_amd64.whl → 2.7.0rc1__cp310-cp310-win_amd64.whl

mindspore/nn/learning_rate_schedule.py

@@ -19,7 +19,7 @@ from __future__ import division
 import math
 
 from mindspore.common import dtype as mstype
-from mindspore.ops import operations as P
+from mindspore import ops
 from mindspore.nn.cell import Cell
 from mindspore import _checkparam as validator
 
@@ -119,13 +119,13 @@ class ExponentialDecayLR(LearningRateSchedule):
         self.decay_rate = decay_rate
         self.decay_steps = decay_steps
         self.is_stair = is_stair
-        self.pow = P.Pow()
-        self.cast = P.Cast()
+        self.pow = ops.Pow()
+        self.cast = ops.Cast()
 
     def construct(self, global_step):
         p = self.cast(global_step, mstype.float32) / self.decay_steps
         if self.is_stair:
-            p = P.Floor()(p)
+            p = ops.Floor()(p)
         return self.learning_rate * self.pow(self.decay_rate, p)
 
 
@@ -191,13 +191,13 @@ class NaturalExpDecayLR(LearningRateSchedule):
         self.decay_steps = decay_steps
         self.is_stair = is_stair
         self.math_e = math.e
-        self.pow = P.Pow()
-        self.cast = P.Cast()
+        self.pow = ops.Pow()
+        self.cast = ops.Cast()
 
     def construct(self, global_step):
         p = self.cast(global_step, mstype.float32)
         if self.is_stair:
-            p = P.FloorDiv()(p, self.decay_steps) * self.decay_steps
+            p = ops.FloorDiv()(p, self.decay_steps) * self.decay_steps
         return self.learning_rate * self.pow(self.math_e, -self.decay_rate * p)
 
 
@@ -264,12 +264,12 @@ class InverseDecayLR(LearningRateSchedule):
         self.decay_rate = decay_rate
         self.decay_steps = decay_steps
         self.is_stair = is_stair
-        self.cast = P.Cast()
+        self.cast = ops.Cast()
 
     def construct(self, global_step):
         p = self.cast(global_step, mstype.float32) / self.decay_steps
         if self.is_stair:
-            p = P.Floor()(p)
+            p = ops.Floor()(p)
         return self.learning_rate / (1 + self.decay_rate * p)
 
 
@@ -334,10 +334,10 @@ class CosineDecayLR(LearningRateSchedule):
         self.decay_steps = decay_steps
         self.math_pi = math.pi
         self.delta = 0.5 * (max_lr - min_lr)
-        self.cos = P.Cos()
-        self.sin = P.Sin()
-        self.min = P.Minimum()
-        self.cast = P.Cast()
+        self.cos = ops.Cos()
+        self.sin = ops.Sin()
+        self.min = ops.Minimum()
+        self.cast = ops.Cast()
 
     def construct(self, global_step):
         p = self.cast(self.min(global_step, self.decay_steps), mstype.float32)
@@ -425,13 +425,13 @@ class PolynomialDecayLR(LearningRateSchedule):
         self.diff_learning_rate = learning_rate - end_learning_rate
         self.power = power
         self.update_decay_steps = update_decay_steps
-        self.pow = P.Pow()
-        self.ceil = P.Ceil()
-        self.min = P.Minimum()
-        self.max = P.Maximum()
+        self.pow = ops.Pow()
+        self.ceil = ops.Ceil()
+        self.min = ops.Minimum()
+        self.max = ops.Maximum()
 
     def construct(self, global_step):
-        tmp_global_step = P.Cast()(global_step, mstype.float32)
+        tmp_global_step = ops.Cast()(global_step, mstype.float32)
         tmp_decay_step = self.decay_steps
         if self.update_decay_steps:
             tmp_decay_step = tmp_decay_step * self.max(self.ceil(tmp_global_step / tmp_decay_step), 1)
@@ -498,8 +498,8 @@ class WarmUpLR(LearningRateSchedule):
         validator.check_positive_int(warmup_steps, 'warmup_steps', self.cls_name)
         self.warmup_steps = warmup_steps
         self.learning_rate = learning_rate
-        self.min = P.Minimum()
-        self.cast = P.Cast()
+        self.min = ops.Minimum()
+        self.cast = ops.Cast()
 
     def construct(self, global_step):
         warmup_percent = self.cast(self.min(global_step, self.warmup_steps), mstype.float32) / self.warmup_steps

mindspore/nn/loss/loss.py

@@ -22,9 +22,7 @@ import mindspore.ops as ops
 from mindspore import log
 from mindspore.common.tensor import Tensor
 from mindspore.common.parameter import Parameter
-from mindspore.ops import operations as P
 from mindspore.ops.operations import _inner_ops as inner
-from mindspore.ops import functional as F
 from mindspore import nn
 from mindspore.ops.primitive import constexpr, _primexpr
 from mindspore.nn.cell import Cell
@@ -103,10 +101,10 @@ class LossBase(Cell):
         if reduction == 'none':
             self.reduce = False
 
-        self.reduce_mean = P.ReduceMean()
-        self.reduce_sum = P.ReduceSum()
-        self.mul = P.Mul()
-        self.cast = P.Cast()
+        self.reduce_mean = ops.ReduceMean()
+        self.reduce_sum = ops.ReduceSum()
+        self.mul = ops.Mul()
+        self.cast = ops.Cast()
 
     def get_axis(self, x):
         """
@@ -115,9 +113,9 @@ class LossBase(Cell):
         Args:
             x (Tensor): Tensor of any shape.
         """
-        shape = F.shape(x)
-        length = F.tuple_len(shape)
-        perm = F.make_range(0, length)
+        shape = ops.shape(x)
+        length = ops.tuple_len(shape)
+        perm = ops.make_range(0, length)
         return perm
 
     def get_loss(self, x, weights=1.0):
@@ -168,9 +166,9 @@ class _Loss(LossBase):
 @constexpr(check=False)
 def _check_is_tensor(param_name, input_data, cls_name):
     """Internal function, used to check whether the input data is Tensor."""
-    if input_data is not None and not isinstance(F.typeof(input_data), mstype.TensorType):
+    if input_data is not None and not isinstance(ops.typeof(input_data), mstype.TensorType):
         raise TypeError(f"For '{cls_name}', the '{param_name}' must be '{mstype.TensorType}', "
-                        f"but got '{F.typeof(input_data)}'")
+                        f"but got '{ops.typeof(input_data)}'")
 
 
 class L1Loss(LossBase):
@@ -243,7 +241,7 @@ class L1Loss(LossBase):
         self.reduction = reduction
 
     def construct(self, logits, labels):
-        return F.l1_loss(logits, labels, self.reduction)
+        return ops.l1_loss(logits, labels, self.reduction)
 
 
 class L1LossExt(LossBase):
@@ -389,7 +387,7 @@ class MSELoss(LossBase):
     def construct(self, logits, labels):
         _check_is_tensor('logits', logits, self.cls_name)
         _check_is_tensor('labels', labels, self.cls_name)
-        x = F.square(logits - labels)
+        x = ops.square(logits - labels)
         return self.get_loss(x)
 
 
@@ -448,7 +446,7 @@ class RMSELoss(LossBase):
     def __init__(self):
         """Initialize RMSELoss."""
         super(RMSELoss, self).__init__()
-        self.dtype = P.DType()
+        self.dtype = ops.DType()
         self.MSELoss = MSELoss()
 
     def construct(self, logits, label):
@@ -458,7 +456,7 @@ class RMSELoss(LossBase):
         _check_rmseloss_dtype(logits_dtype, not_supported_dtype, 'RMSELoss')
         _check_rmseloss_dtype(label_dtype, not_supported_dtype, "RMSELoss")
 
-        rmse_loss = F.sqrt(self.MSELoss(logits, label))
+        rmse_loss = ops.sqrt(self.MSELoss(logits, label))
 
         return rmse_loss
 
@@ -532,7 +530,7 @@ class MAELoss(LossBase):
     def __init__(self, reduction='mean'):
         """Initialize MAELoss."""
         super(MAELoss, self).__init__(reduction)
-        self.abs = P.Abs()
+        self.abs = ops.Abs()
 
     def construct(self, logits, label):
         _check_is_tensor('logits', logits, self.cls_name)
@@ -708,7 +706,7 @@ class SmoothL1Loss(LossBase):
         super(SmoothL1Loss, self).__init__(reduction)
         self.beta = beta
         self.reduction = reduction
-        self.smooth_l1_loss = P.SmoothL1Loss(self.beta, self.reduction)
+        self.smooth_l1_loss = ops.SmoothL1Loss(self.beta, self.reduction)
 
     def construct(self, logits, labels):
         return self.smooth_l1_loss(logits, labels)
@@ -772,7 +770,7 @@ class SoftMarginLoss(LossBase):
         self.reduction = reduction
 
     def construct(self, logits, labels):
-        return F.soft_margin_loss(logits, labels, self.reduction)
+        return ops.soft_margin_loss(logits, labels, self.reduction)
 
 
 class SoftmaxCrossEntropyWithLogits(LossBase):
@@ -856,12 +854,12 @@ class SoftmaxCrossEntropyWithLogits(LossBase):
         super(SoftmaxCrossEntropyWithLogits, self).__init__(reduction)
         self.sparse = validator.check_bool(sparse, "sparse", self.cls_name)
         self.reduction = reduction
-        self.softmax_cross_entropy = P.SoftmaxCrossEntropyWithLogits()
-        self.one_hot = P.OneHot()
+        self.softmax_cross_entropy = ops.SoftmaxCrossEntropyWithLogits()
+        self.one_hot = ops.OneHot()
         self.on_value = Tensor(1.0, mstype.float32)
         self.off_value = Tensor(0., mstype.float32)
         self.is_cpugpu = context.get_context('device_target') in ["CPU", "GPU"]
-        self.sparse_softmax_cross_entropy = P.SparseSoftmaxCrossEntropyWithLogits()
+        self.sparse_softmax_cross_entropy = ops.SparseSoftmaxCrossEntropyWithLogits()
 
     def construct(self, logits, labels):
         _check_is_tensor('logits', logits, self.cls_name)
@@ -870,7 +868,7 @@ class SoftmaxCrossEntropyWithLogits(LossBase):
             if self.reduction == 'mean':
                 x = self.sparse_softmax_cross_entropy(logits, labels)
                 return x
-            labels = self.one_hot(labels, F.shape(logits)[-1], self.on_value, self.off_value)
+            labels = self.one_hot(labels, ops.shape(logits)[-1], self.on_value, self.off_value)
         x = self.softmax_cross_entropy(logits, labels)[0]
         return self.get_loss(x)
 
@@ -934,7 +932,7 @@ class DiceLoss(LossBase):
         """Initialize DiceLoss."""
         super(DiceLoss, self).__init__()
         self.smooth = validator.check_positive_float(smooth, "smooth")
-        self.reshape = P.Reshape()
+        self.reshape = ops.Reshape()
 
     def construct(self, logits, label):
         _check_is_tensor('logits', logits, self.cls_name)
@@ -1049,7 +1047,7 @@ class MultiClassDiceLoss(LossBase):
         if self.activation is not None and not isinstance(self.activation, Cell):
             raise TypeError(f"For '{self.cls_name}', the 'activation' must be str or Cell, "
                             f"but got {type(self.activation)}.")
-        self.reshape = P.Reshape()
+        self.reshape = ops.Reshape()
 
     def construct(self, logits, label):
         _check_is_tensor('logits', logits, self.cls_name)
@@ -1161,31 +1159,31 @@ class SampledSoftmaxLoss(LossBase):
         self.sampled_values = sampled_values
         self.remove_accidental_hits = remove_accidental_hits
         self.seed = seed
-        self.sampler = P.UniformCandidateSampler(
+        self.sampler = ops.UniformCandidateSampler(
             num_true,
             num_sampled,
             True,
             num_classes,
             seed,
             remove_accidental_hits)
-        self.cast = P.Cast()
-        self.reshape = P.Reshape()
-        self.shape = P.Shape()
-        self.exp = P.Exp()
-        self.log = P.Log()
-        self.slice_op = P.Slice()
-        self.matmul = P.MatMul(False, True)
-        self.gather_v2 = P.Gather()
-        self.reduce_max_true = P.ReduceMax(True)
-        self.reduce_sum = P.ReduceSum()
-        self.reduce_sum_true = P.ReduceSum(True)
-        self.concat_dim0 = P.Concat(0)
-        self.concat_dim1 = P.Concat(1)
-        self.ones_like = P.OnesLike()
-        self.zeros_like = P.ZerosLike()
-        self.mul = P.Mul()
-        self.expand_dims = P.ExpandDims()
-        self.dtype = P.DType()
+        self.cast = ops.Cast()
+        self.reshape = ops.Reshape()
+        self.shape = ops.Shape()
+        self.exp = ops.Exp()
+        self.log = ops.Log()
+        self.slice_op = ops.Slice()
+        self.matmul = ops.MatMul(False, True)
+        self.gather_v2 = ops.Gather()
+        self.reduce_max_true = ops.ReduceMax(True)
+        self.reduce_sum = ops.ReduceSum()
+        self.reduce_sum_true = ops.ReduceSum(True)
+        self.concat_dim0 = ops.Concat(0)
+        self.concat_dim1 = ops.Concat(1)
+        self.ones_like = ops.OnesLike()
+        self.zeros_like = ops.ZerosLike()
+        self.mul = ops.Mul()
+        self.expand_dims = ops.ExpandDims()
+        self.dtype = ops.DType()
 
     def construct(self, weights, biases, labels, logits):
         _check_is_tensor('weights', weights, self.cls_name)
@@ -1393,7 +1391,7 @@ class TripletMarginWithDistanceLoss(LossBase):
                         "'ndim' of the input must be positive, "
                         f"but got {d.ndim}"
                     )
-                return P.LpNorm(axis=1, p=2)(d)
+                return ops.LpNorm(axis=1, p=2)(d)
 
             self.distance_function = pairwise_distance
         else:
@@ -1401,8 +1399,8 @@ class TripletMarginWithDistanceLoss(LossBase):
         self.swap = swap
         self.reduction = reduction
         self.margin = margin
-        self.minimum = P.Minimum()
-        self.maximum = P.Maximum()
+        self.minimum = ops.Minimum()
+        self.maximum = ops.Maximum()
 
     def construct(self, x, positive, negative):
         _check_is_tensor("x", x, self.cls_name)
@@ -1486,8 +1484,8 @@ class PoissonNLLLoss(LossBase):
         self.log_input = log_input
         self.full = full
         self.eps = eps
-        self.maximum = P.Maximum()
-        self.cast = P.Cast()
+        self.maximum = ops.Maximum()
+        self.cast = ops.Cast()
 
     def construct(self, input, target):
         _check_is_tensor('input', input, self.cls_name)
@@ -1500,7 +1498,7 @@ class PoissonNLLLoss(LossBase):
         if self.full:
             target = self.maximum(target, self.eps)
             stirling_term = (target > 1) * ((target + 0.5) * target.log() - target + get_half_ln_2_pi())
-            loss += F.masked_fill(stirling_term, target <= 1, F.cast(0, stirling_term.dtype))
+            loss += ops.masked_fill(stirling_term, target <= 1, ops.cast(0, stirling_term.dtype))
         out = self.get_loss(loss)
         return out
 
@@ -1570,7 +1568,7 @@ class MultiLabelSoftMarginLoss(LossBase):
         self.reduction = reduction
 
     def construct(self, x, target):
-        return F.multilabel_soft_margin_loss(x, target, self.weight, self.reduction)
+        return ops.multilabel_soft_margin_loss(x, target, self.weight, self.reduction)
 
 
 class MultiMarginLoss(LossBase):
@@ -1655,7 +1653,7 @@ class MultiMarginLoss(LossBase):
         if not weight_one:
             _check_is_tensor('weight', weight, self.cls_name)
         else:
-            weight = F.fill(x.dtype, x.astype('float32')[0].shape, 1)
+            weight = ops.fill(x.dtype, x.astype('float32')[0].shape, 1)
         loss = self.multi_margin_loss(x, target, weight)
         return loss
 
@@ -1734,7 +1732,7 @@ class BCELoss(LossBase):
         self.weight = weight
 
     def construct(self, logits, labels):
-        return F.binary_cross_entropy(logits, labels, self.weight, self.reduction)
+        return ops.binary_cross_entropy(logits, labels, self.weight, self.reduction)
 
 
 class CosineEmbeddingLoss(LossBase):
@@ -1793,8 +1791,8 @@ class CosineEmbeddingLoss(LossBase):
     def __init__(self, margin=0.0, reduction="mean"):
         """Initialize CosineEmbeddingLoss."""
         super(CosineEmbeddingLoss, self).__init__(reduction)
-        self.reduce_sum = P.ReduceSum()
-        self.maximum = P.Maximum()
+        self.reduce_sum = ops.ReduceSum()
+        self.maximum = ops.Maximum()
         validator.check_value_type("margin", margin, [float], self.cls_name)
         self.margin = validator.check_float_range(margin, -1.0, 1.0, validator.INC_BOTH, "margin", self.cls_name)
 
@@ -1806,16 +1804,16 @@ class CosineEmbeddingLoss(LossBase):
         # if labels > 0, 1-cosine(logits_x1, logits_x2)
         # else, max(0, cosine(logits_x1, logits_x2)-margin)
         prod_sum = self.reduce_sum(logits_x1 * logits_x2, (1,))
-        square1 = self.reduce_sum(F.square(logits_x1), (1,))
-        square2 = self.reduce_sum(F.square(logits_x2), (1,))
-        denom = F.sqrt(square1) * F.sqrt(square2)
+        square1 = self.reduce_sum(ops.square(logits_x1), (1,))
+        square2 = self.reduce_sum(ops.square(logits_x2), (1,))
+        denom = ops.sqrt(square1) * ops.sqrt(square2)
         cosine = prod_sum / denom
 
         pos_value = 1.0 - cosine
         neg_value = self.maximum(cosine - self.margin, 0.0)
-        zeros = F.zeros_like(cosine)
-        pos_part = F.select(labels == 1, pos_value, zeros)
-        neg_part = F.select(labels == -1, neg_value, zeros)
+        zeros = ops.zeros_like(cosine)
+        pos_part = ops.select(labels == 1, pos_value, zeros)
+        neg_part = ops.select(labels == -1, neg_value, zeros)
         output_unreduced = pos_part + neg_part
 
         return self.get_loss(output_unreduced)
@@ -2089,12 +2087,12 @@ class FocalLoss(LossBase):
         if isinstance(weight, Tensor) and weight.ndim != 1:
             raise ValueError(f"For '{self.cls_name}', the dimension of 'weight' must be 1, but got {weight.ndim}.")
         self.weight = weight
-        self.expand_dims = P.ExpandDims()
-        self.gather_d = P.GatherD()
-        self.squeeze = P.Squeeze(axis=1)
-        self.tile = P.Tile()
-        self.cast = P.Cast()
-        self.dtype = P.DType()
+        self.expand_dims = ops.ExpandDims()
+        self.gather_d = ops.GatherD()
+        self.squeeze = ops.Squeeze(axis=1)
+        self.tile = ops.Tile()
+        self.cast = ops.Cast()
+        self.dtype = ops.DType()
         self.logsoftmax = nn.LogSoftmax(1)
 
     def construct(self, logits, labels):
@@ -2118,7 +2116,7 @@ class FocalLoss(LossBase):
             log_probability = self.gather_d(log_probability, 1, self.cast(labelss, mindspore.int32))
             log_probability = self.squeeze(log_probability)
 
-        probability = F.exp(log_probability)
+        probability = ops.exp(log_probability)
 
         if self.weight is not None:
             convert_weight = self.weight[None, :, None]
@@ -2128,7 +2126,7 @@ class FocalLoss(LossBase):
                 convert_weight = self.squeeze(convert_weight)
             log_probability = log_probability * convert_weight
 
-        weight = F.pows(-1 * probability + 1.0, self.gamma)
+        weight = ops.pows(-1 * probability + 1.0, self.gamma)
         if labels.shape[1] == 1:
             loss = (-1 * weight * log_probability).mean(axis=1)
         else:
@@ -2225,7 +2223,7 @@ class HuberLoss(LossBase):
         self.delta = delta
 
     def construct(self, logits, labels):
-        return F.huber_loss(logits, labels, self.reduction, self.delta)
+        return ops.huber_loss(logits, labels, self.reduction, self.delta)
 
 
 class TripletMarginLoss(LossBase):
@@ -2323,8 +2321,8 @@ class TripletMarginLoss(LossBase):
     def construct(self, x, positive, negative, margin=1.):
         if self.margin != 1.0:
             margin = self.margin
-        return F.triplet_margin_loss(x, positive, negative, margin=margin, p=self.p,
-                                     eps=self.eps, swap=self.swap, reduction=self.reduction)
+        return ops.triplet_margin_loss(x, positive, negative, margin=margin, p=self.p,
+                                       eps=self.eps, swap=self.swap, reduction=self.reduction)
 
 
 class NLLLoss(LossBase):
@@ -2352,9 +2350,9 @@ class NLLLoss(LossBase):
         \end{array}\right.
 
     Args:
-        weight (Tensor): The rescaling weight to each class. If the value is not None, the shape is :math:`(C,)`.
-            The data type only supports float32 or float16. Default: ``None`` .
-        ignore_index (int): Specifies a target value that is ignored (typically for padding value)
+        weight (Tensor, optional): The rescaling weight to each class. If the value is not None,
+            the shape is :math:`(C,)`. The data type only supports float32 or float16. Default: ``None`` .
+        ignore_index (int, optional): Specifies a target value that is ignored (typically for padding value)
             and does not contribute to the gradient. Default: ``-100`` .
         reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
             ``'sum'`` . Default: ``'mean'`` .
@@ -2406,7 +2404,7 @@ class NLLLoss(LossBase):
         self.reduction = reduction
 
     def construct(self, logits, labels):
-        return F.nll_loss(logits, labels, self.weight, self.ignore_index, self.reduction)
+        return ops.nll_loss(logits, labels, self.weight, self.ignore_index, self.reduction)
 
 
 @constexpr
@@ -2568,7 +2566,7 @@ class CrossEntropyLoss(LossBase):
                                     logits.dtype, labels.dtype,
                                     self.cls_name)
 
-        return F.cross_entropy(logits, labels, self.weight, self.ignore_index, self.reduction, self.label_smoothing)
+        return ops.cross_entropy(logits, labels, self.weight, self.ignore_index, self.reduction, self.label_smoothing)
 
 
 class KLDivLoss(LossBase):
@@ -2644,7 +2642,7 @@ class KLDivLoss(LossBase):
     def construct(self, logits, labels):
         _check_is_tensor('logits', logits, self.cls_name)
         _check_is_tensor('labels', labels, self.cls_name)
-        return F.kl_div(logits, labels, self.reduction)
+        return ops.kl_div(logits, labels, self.reduction)
 
 
 @_primexpr
@@ -2753,11 +2751,11 @@ class CTCLoss(LossBase):
             if targets.ndim == 1:
                 targets = targets.expand_dims(0)
             log_probs = log_probs.expand_dims(-2)
-            neg_log_hood, _ = F.ctc_loss(log_probs, targets, input_lengths, target_lengths, self.blank, self.reduction,
-                                         self.zero_infinity)
+            neg_log_hood, _ = ops.ctc_loss(log_probs, targets, input_lengths, target_lengths, self.blank,
+                                           self.reduction, self.zero_infinity)
             return neg_log_hood.squeeze(axis=0)
-        neg_log_hood, _ = F.ctc_loss(log_probs, targets, input_lengths, target_lengths, self.blank, self.reduction,
-                                     self.zero_infinity)
+        neg_log_hood, _ = ops.ctc_loss(log_probs, targets, input_lengths, target_lengths, self.blank, self.reduction,
+                                       self.zero_infinity)
         return neg_log_hood
 
 

mindspore/nn/optim/adam.py

@@ -537,7 +537,7 @@ class Adam(Optimizer):
 
         When using Adam with use_offload=True:
 
-        This optimizer only supports `GRAPH_MODE`.
+        This optimizer only supports `GRAPH_MODE` and don't support GE backend.
 
     Args:
         params (Union[list[Parameter], list[dict]]): Must be list of `Parameter` or list of `dict`. When the
@@ -1014,7 +1014,7 @@ class AdamWeightDecay(Optimizer):
         >>>
         >>> loss = nn.SoftmaxCrossEntropyWithLogits()
         >>> model = ms.Model(net, loss_fn=loss, optimizer=optim)
-   """
+    """
     _support_parallel_optimizer = True
 
     def __init__(self, params, learning_rate=1e-3, beta1=0.9, beta2=0.999, eps=1e-6, weight_decay=0.0):
@@ -1111,7 +1111,7 @@ class AdamOffload(Optimizer):
     :math:`\epsilon` represents `eps`.
 
     Note:
-        This optimizer only supports `GRAPH_MODE` currently.
+        This optimizer only supports `GRAPH_MODE` currently and don't support GE backend.
 
         If parameters are not grouped, the `weight_decay` in optimizer will be applied on the network parameters without
         'beta' or 'gamma' in their names. Users can group parameters to change the strategy of decaying weight. When

mindspore/nn/optim/adasum.py

@@ -202,7 +202,7 @@ class _AdaSum(Cell):
     @staticmethod
     def _hash(step, target, weights_index):
         target = "tag" + str(step) + str(target) + str(weights_index)
-        target_hash = hashlib.sha1(target.encode()).hexdigest()
+        target_hash = hashlib.sha256(target.encode()).hexdigest()
         hash_res = int(int(target_hash, 16) % MAX_NUM_HASH)
         return hash_res
 
@@ -430,7 +430,7 @@ class AdaSumByGradWrapCell(Cell):
             requires only one input.
 
     Inputs:
-        - **grads** (Tuple[Tensor]) - Tuple of gradients, same with the input of passed optimizer.
+        - **grads** (tuple[Tensor]) - Tuple of gradients, same with the input of passed optimizer.
 
     Raises:
         RuntimeError: If `parallel_mode` uses `stand_alone` mode, AdaSum only supports use in distributed scenarios.

mindspore/nn/optim/asgd.py

@@ -50,6 +50,8 @@ class ASGD(Optimizer):
     :math:`w` represents `params`.
 
     Note:
+        This optimizer don't support GE backend.
+
         If parameters are not grouped, the `weight_decay` in optimizer will be applied on the parameters without 'beta'
         or 'gamma' in their names. Users can group parameters to change the strategy of decaying weight. When parameters
         are grouped, each group can set `weight_decay`, if not, the `weight_decay` in optimizer will be applied.

mindspore/nn/optim/optimizer.py

@@ -514,7 +514,7 @@ class Optimizer(Cell):
             raise ValueError("For 'Optimizer', the property 'target' cannot be set to 'Ascend' "
                              "in the 'GPU' environment.")
 
-        self._is_device = (value != 'CPU')
+        self._is_device = value != 'CPU'
         self._target = value
 
     def _grad_sparse_indices_deduplicate(self, gradients):

mindspore/nn/optim/thor.py

@@ -445,7 +445,7 @@ class ThorGpu(Optimizer):
     def _define_gpu_reducer(self, split_indices):
         """define gpu reducer"""
         self.parallel_mode = context.get_auto_parallel_context("parallel_mode")
-        self.is_distributed = (self.parallel_mode != ParallelMode.STAND_ALONE)
+        self.is_distributed = self.parallel_mode != ParallelMode.STAND_ALONE
         if self.is_distributed:
             mean = _get_gradients_mean()
             degree = _get_device_num()
@@ -764,7 +764,7 @@ class ThorAscend(Optimizer):
     def _define_ascend_reducer(self, split_indices):
         """define ascend reducer"""
         self.parallel_mode = context.get_auto_parallel_context("parallel_mode")
-        self.is_distributed = (self.parallel_mode != ParallelMode.STAND_ALONE)
+        self.is_distributed = self.parallel_mode != ParallelMode.STAND_ALONE
         if self.is_distributed:
             mean = _get_gradients_mean()
             degree = _get_device_num()

mindspore/nn/probability/distribution/exponential.py

@@ -35,7 +35,8 @@ class Exponential(Distribution):
     where :math:`\lambda` is the rate of the distribution.
 
     Args:
-        rate (int, float, list, numpy.ndarray, Tensor, optional): The inverse scale. :math:`\lambda` in the formula. Default: ``None`` .
+        rate (int, float, list, numpy.ndarray, Tensor, optional): The inverse scale.
+            :math:`\lambda` in the formula. Default: ``None`` .
         seed (int, optional): The seed used in sampling. The global seed is used if it is None. Default: ``None`` .
         dtype (mindspore.dtype, optional): The type of the event samples. Default: ``mstype.float32`` .
         name (str, optional): The name of the distribution. Default: ``'Exponential'`` .

mindspore/nn/probability/distribution/poisson.py

@@ -36,7 +36,8 @@ class Poisson(Distribution):
     where :math:`\lambda` is the rate of the distribution.
 
     Args:
-        rate (list, numpy.ndarray, Tensor): The rate of the Poisson distribution. :math:`\lambda` in the formula. Default: ``None`` .
+        rate (list, numpy.ndarray, Tensor): The rate of the Poisson distribution.
+            :math:`\lambda` in the formula. Default: ``None`` .
         seed (int): The seed used in sampling. The global seed is used if it is ``None`` . Default: ``None`` .
         dtype (mindspore.dtype): The type of the event samples. Default: ``mstype.float32`` .
         name (str): The name of the distribution. Default: ``'Poisson'`` .

mindspore/nn/sparse/sparse.py

@@ -15,8 +15,8 @@
 """Sparse related tools."""
 from __future__ import absolute_import
 
+from mindspore import ops
 from mindspore import log as logger
-from mindspore.ops import operations as P
 from mindspore.nn.cell import Cell
 
 
@@ -76,7 +76,7 @@ class SparseToDense(Cell):
         logger.warning("'nn.SparseToDense' is deprecated from version 2.0 and will be removed in a future version. " +
                        "Please use 'COOTensor.to_dense()' instead.")
         super(SparseToDense, self).__init__()
-        self.sparse_to_dense = P.SparseToDense()
+        self.sparse_to_dense = ops.SparseToDense()
 
     def construct(self, sparse_tensor):
         return self.sparse_to_dense(sparse_tensor.indices,
@@ -141,7 +141,7 @@ class SparseTensorDenseMatmul(Cell):
         super(SparseTensorDenseMatmul, self).__init__()
         self.adj_st = adjoint_st
         self.adj_dt = adjoint_dt
-        self.sparse_dense_matmul = P.SparseTensorDenseMatmul(adjoint_st=self.adj_st, adjoint_dt=self.adj_dt)
+        self.sparse_dense_matmul = ops.SparseTensorDenseMatmul(adjoint_st=self.adj_st, adjoint_dt=self.adj_dt)
 
     def construct(self, indices, values, sparse_shape, dense):
         return self.sparse_dense_matmul(indices, values, sparse_shape, dense)