mindspore 2.6.0__cp310-cp310-win_amd64.whl → 2.7.0__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

@@ -909,9 +909,7 @@ class AdamWeightDecay(Optimizer):
     Note:
         There is usually no connection between a optimizer and mixed precision. But when `FixedLossScaleManager` is used
         and `drop_overflow_update` in `FixedLossScaleManager` is set to False, optimizer needs to set the 'loss_scale'.
-        As this optimizer has no argument of `loss_scale`, so `loss_scale` needs to be processed by other means, refer
-        document `LossScale <https://www.mindspore.cn/tutorials/en/master/beginner/mixed_precision.html>`_ to
-        process `loss_scale` correctly.
+        As this optimizer has no argument of `loss_scale`, so `loss_scale` needs to be processed by other means.
 
         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
@@ -1014,7 +1012,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):

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/lamb.py

@@ -131,9 +131,7 @@ class Lamb(Optimizer):
     Note:
         There is usually no connection between a optimizer and mixed precision. But when `FixedLossScaleManager` is used
         and `drop_overflow_update` in `FixedLossScaleManager` is set to False, optimizer needs to set the 'loss_scale'.
-        As this optimizer has no argument of `loss_scale`, so `loss_scale` needs to be processed by other means. Refer
-        document `LossScale <https://www.mindspore.cn/tutorials/en/master/beginner/mixed_precision.html>`_ to
-        process `loss_scale` correctly.
+        As this optimizer has no argument of `loss_scale`, so `loss_scale` needs to be processed by other means.
 
         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/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/tft_wrapper.py

@@ -69,10 +69,9 @@ class OptTFTWrapper(Optimizer):
         tft_env = os.getenv("MS_ENABLE_TFT", "")
         if ("TTP:1" not in tft_env) and ("UCE:1" not in tft_env) and ("ARF:1" not in tft_env):
             raise ValueError("MindIO TFT regitster need custom switch on[MS_ENABLE_TFT='{TTP:1,UCE:1,ARF:1}']!")
-        mode = context.get_context("mode")
         device_target = context.get_context("device_target")
-        if device_target != "Ascend" or mode != context.GRAPH_MODE:
-            raise ValueError("MindIO adataper only support on Ascend device with GRAPH Mode!")
+        if device_target != "Ascend":
+            raise ValueError("MindIO adataper only support on Ascend device!")
         self.opt = opt
         self.report = TensorReport()
         self.report_end = TensorReport()

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/_utils/utils.py

@@ -298,7 +298,7 @@ class CheckTuple(PrimitiveWithInfer):
         # The op is not used in a cell
         if isinstance(x, tuple):
             return x
-        if context.get_context("mode") == 0:
+        if context.get_context("mode") == context.GRAPH_MODE:
             return x["value"]
         raise TypeError(f"For {name}, input type must be a tuple.")
 
@@ -349,7 +349,7 @@ def set_param_type(args, hint_type):
     for name, arg in args.items():
         if hasattr(arg, 'dtype'):
             if isinstance(arg, np.ndarray):
-                cur_dtype = mstype.pytype_to_dtype(arg.dtype)
+                cur_dtype = mstype._pytype_to_dtype(arg.dtype)  # pylint:disable=protected-access
             else:
                 cur_dtype = arg.dtype
             if common_dtype is None:

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'`` .