mindspore 2.4.10__cp39-cp39-manylinux1_x86_64.whl → 2.5.0__cp39-cp39-manylinux1_x86_64.whl

mindspore/ops/operations/__init__.py

@@ -49,7 +49,7 @@ from .array_ops import (ArgMaxWithValue, ArgMinWithValue, Argmax, Argmin, BatchT
                         FillDiagonal, Fills, ResizeNearestNeighborV2, RightShift, ScatterAddWithAxis,
                         ScatterNdMul, SegmentMean, SegmentProd, SegmentSum, SegmentMax, SegmentMin, Tril, Triu,
                         UniqueConsecutive, UnravelIndex, FillV2, CountNonZero, TensorScatterElements, IndexPut,
-                        MaskedScatter)
+                        MaskedScatter, TypeAs)
 from .comm_ops import (AllGather, AllReduce, Reduce, NeighborExchange, NeighborExchangeV2, AlltoAll, _AllSwap,
                        Broadcast, CollectiveGather, CollectiveScatter, Barrier, Send, Receive, BatchISendIRecv,
                        _MirrorOperator, _MirrorMiniStepOperator, _MiniStepAllGather, ReduceOp, _VirtualDataset,
@@ -88,7 +88,7 @@ from .math_ops import (Abs, ACos, Asin, Asinh, AddN, AccumulateNV2, AssignAdd, A
                        NextAfter, Orgqr, Qr, RaggedRange, Digamma, Eig, EuclideanNorm, CompareAndBitpack, ComplexAbs,
                        CumulativeLogsumexp, Gcd, Polygamma, Trace, TridiagonalMatMul, TrilIndices, TriuIndices, Zeta,
                        Roll, Lgamma, Logit, MatrixSolveLs, Polar, Fmax, Fmin, Quantile, Sinc, Angle, Bernoulli,
-                       NanToNum, Igamma, BesselI0, BesselI1, InplaceIndexAdd, Igammac, Ormqr)
+                       NanToNum, Igamma, BesselI0, BesselI1, InplaceIndexAdd, Igammac, Ormqr, LerpScalar)
 from .nn_ops import (LSTM, SGD, Adam, AdamWeightDecay, FusedSparseAdam, FusedSparseLazyAdam, AdamNoUpdateParam,
                      ApplyMomentum, BatchNorm, BiasAdd, Conv2D, Conv3D, Conv2DTranspose, Conv3DTranspose,
                      DepthwiseConv2dNative,
@@ -250,6 +250,7 @@ __all__ = [
     'LayerNorm',
     'Rank',
     'Lerp',
+    'LerpScalar',
     'Less',
     'LessEqual',
     'LowerBound',

mindspore/ops/operations/_embedding_cache_ops.py

@@ -27,7 +27,7 @@ class UpdateCache(PrimitiveWithCheck):
     The difference is that UpdateCache will not update when indices < 0 or indices >= max_num.
 
     Inputs:
-        - **input_x** (Parameter) - Parameter which is going to be updated.
+        - **input_x** (Union[Parameter, Tensor]) - Parameter or Tensor which is going to be updated.
         - **indices** (Tensor) - Update indices of input_x.
         - **updates** (Tensor) - The update values.
 
@@ -148,7 +148,7 @@ class CacheSwapTable(PrimitiveWithCheck):
     Delete a hashmap entry,and insert a new key to hashmap, return the key and value of delete entry.
 
     Inputs:
-        - **cache_table** (Parameter) - The cache table which is on device.
+        - **cache_table** (Union[Parameter, Tensor]) - The cache table which is on device.
         - **swap_cache_idx** (Tensor) - The index of table which need to swap. -1 is skipped.
         - **miss_value** (int) - The values which arg going to swap into cache table.
 
@@ -227,10 +227,10 @@ class MapCacheIdx(PrimitiveWithCheck):
 
 class DynamicAssign(PrimitiveWithCheck):
     """
-    Assigns `Parameter` with a value, the `value` can have a dynamic shape.
+    Assigns `Parameter` or `Tensor` with a value, the `value` can have a dynamic shape.
 
     Inputs:
-        - **variable** (Parameter) - The `Parameter`.
+        - **variable** (Union[Parameter, Tensor]) - The `Parameter` or `Tensor`.
         - **value** (Tensor) - The value to be assigned.
 
     Outputs:

mindspore/ops/operations/_grad_ops.py

@@ -30,13 +30,13 @@ from mindspore.communication.management import GlobalComm
 from mindspore.common._utils import is_shape_unknown, is_dim_unknown
 from ..auto_generate import (AbsGrad, ACosGrad, LogitGrad, AcoshGrad, AsinGrad, AsinhGrad, ReciprocalGrad, RsqrtGrad,
                              SqrtGrad, BatchNormGrad, BatchNormGradGrad, BiasAddGrad, GeLUGrad, FastGeLUGrad,
-                             AvgPoolGrad, MinimumGrad, LogSoftmaxGrad, PReLUGrad, ReluGrad, ReLU6Grad, EluGrad,
+                             AvgPoolGrad, MinimumGrad, LogSoftmaxGrad, GluGrad, PReLUGrad, ReluGrad, ReLU6Grad, EluGrad,
                              GatherDGradV2, ResizeBilinearGrad, ResizeLinear1DGrad, ResizeNearestNeighborV2Grad,
                              SigmoidGrad, HSwishGrad, NLLLossGrad, AtanGrad, GridSampler3DGrad, GridSampler2DGrad,
                              ResizeBicubicGrad, HSigmoidGrad, CholeskyGrad, ResizeNearestNeighborGrad, LayerNormGrad,
                              HShrinkGrad, LayerNormGradGrad, SiLUGrad, MaximumGrad, MaximumGradGrad, RmsNormGrad,
                              FlashAttentionScoreGrad, UpsampleTrilinear3DGrad, UpsampleNearest3DGrad, MaskedSelectGrad,
-                             BinaryCrossEntropyGrad, SoftShrinkGrad, SeluGrad)
+                             BinaryCrossEntropyGrad, SoftShrinkGrad, SeluGrad, SmoothL1LossGrad)
 
 
 class SparseFillEmptyRowsGrad(Primitive):
@@ -1639,16 +1639,6 @@ class SliceGrad(PrimitiveWithInfer):
                 'value': None}
 
 
-class SmoothL1LossGrad(Primitive):
-    """Computes gradient for prediction on SmoothL1Loss."""
-
-    @prim_attr_register
-    def __init__(self, beta=1.0, reduction='none'):
-        self.add_prim_attr('sigma', self.beta)
-        self.reduction = validator.check_string(
-            reduction, ['none', 'sum', 'mean'], 'reduction', self.name)
-
-
 class SoftMarginLossGrad(Primitive):
     """Computes gradient for prediction on SoftMarginLoss."""
 
@@ -1962,15 +1952,6 @@ class MvlgammaGrad(Primitive):
         self.p = validator.check_value_type('p', p, [int], self.name)
 
 
-class CdistGrad(Primitive):
-    """Computes gradient for Cdist."""
-
-    @prim_attr_register
-    def __init__(self, p=2.0):
-        validator.check_value_type("p", p, [float], self.name)
-        self.init_prim_io_names(inputs=['grad', 'input_x', 'input_y', 'cdist'], outputs=['output'])
-
-
 class PdistGrad(Primitive):
     """Computes gradient for Pdist operation.
 
@@ -2908,19 +2889,6 @@ class AffineGridGrad(Primitive):
         self.init_prim_io_names(inputs=['y_grad', 'x_size'], outputs=['x_grad'])
 
 
-
-class GluGrad(Primitive):
-    """
-    Computes grad for Glu operation.
-    """
-
-    @prim_attr_register
-    def __init__(self, axis):
-        self.add_prim_attr("cust_aicpu", self.name)
-        self.init_prim_io_names(inputs=["grads", "x"], outputs=["y"])
-        validator.check_value_type("axis", axis, [int], self.name)
-
-
 class MapTensorGetGrad(Primitive):
     """
     Computes gradients for MapTensorGet operation.

mindspore/ops/operations/_infer_ops.py

@@ -16,4 +16,5 @@
 """Operator of infer net"""
 # pylint: disable=unused-import
 from ..auto_generate import (QuantV2, DynamicQuantExt, QuantBatchMatmul, WeightQuantBatchMatmul, KVCacheScatterUpdate,
-                             FusedInferAttentionScore, GroupedMatmul, MoeFinalizeRouting, QuantLinearSparse)
+                             FusedInferAttentionScore, GroupedMatmul, MoeFinalizeRouting, QuantLinearSparse,
+                             MatmulAllReduceAddRmsNorm, MoeGatingTopKSoftmax)

mindspore/ops/operations/_inner_ops.py

@@ -31,9 +31,11 @@ from mindspore.ops.primitive import PrimitiveWithCheck, PrimitiveWithInfer, prim
     _run_op, _check_contains_variable
 from mindspore._c_expression import Tensor as Tensor_
 from mindspore._c_expression import typing, HookType
+from mindspore._c_expression import pyboost_generator
 from mindspore import _checkparam as validator
 from mindspore.common import dtype as mstype
 from mindspore.common.parameter import Parameter
+from mindspore.common._stub_tensor import _convert_stub
 from mindspore.communication.management import GlobalComm, get_rank, _get_group, get_group_size
 from mindspore.common.api import _pynative_executor
 from mindspore.common._register_for_adapter import ms_adapter_registry
@@ -79,7 +81,7 @@ class Generator(Primitive):
     def __call__(self, cmd, inputs):
         if cmd == 0:  # step cmd
             return inputs[0], inputs[1]
-        return super().__call__(cmd, inputs)
+        return _convert_stub(pyboost_generator(self, [cmd, inputs]))
 
 
 class Quant(PrimitiveWithInfer):
@@ -534,7 +536,8 @@ class ConvertToDynamic(PrimitiveWithCheck):
           >>>         dynamic_input = self.convert_to_dynamic(input)
           >>>         reshaped_input = self.reshape(dynamic_input, new_shape)
           >>>
-          >>> ms.set_context(mode=ms.GRAPH_MODE, device_target="CPU")
+          >>> ms.set_context(mode=ms.GRAPH_MODE)
+          >>> ms.set_device(device_target="CPU")
           >>> input = Tensor(np.array([0, 1, 2, 3])
           >>> new_shape = (2, 2)
           >>> net = TestDynamicNet()
@@ -585,7 +588,8 @@ class GpuConvertToDynamicShape(PrimitiveWithCheck):
           >>>         dynamic_shape_input = self.convert_to_dynamic_shape(input)
           >>>         reshaped_input = self.reshape(input, new_shape)
           >>>
-          >>> ms.set_context(mode=ms.GRAPH_MODE, device_target="GPU")
+          >>> ms.set_context(mode=ms.GRAPH_MODE)
+          >>> ms.set_device(device_target="GPU")
           >>> input = Tensor(np.array([0, 1, 2, 3])
           >>> new_shape = (2, 2)
           >>> net = TestDynamicShapeReshapeNet()
@@ -632,7 +636,8 @@ class ErrorOnDynamicShapeInput(PrimitiveWithInfer):
           >>>         dynamic_shape_input = self.convert_to_dynamic_shape(input)
           >>>         self.error_on_dynamic_shape_input(dynamic_shape_input)
           >>>
-          >>> ms.set_context(mode=ms.GRAPH_MODE, device_target="GPU")
+          >>> ms.set_context(mode=ms.GRAPH_MODE)
+          >>> ms.set_device(device_target="GPU")
           >>> input = Tensor(np.array([0])
           >>> net = TestDynamicShapeReshapeNet()
           >>> output = net(input, new_shape)
@@ -1407,9 +1412,9 @@ class PsROIPooling(PrimitiveWithInfer):
         >>>                                  group_size=7)
         >>> out, channel_map = psRoIPooling(features, rois)
         >>> print(out.shape)
-            [4, 21, 7, 7]
+        [4, 21, 7, 7]
         >>> print(channel_map.shape)
-            [4, 21, 7, 7]
+        [4, 21, 7, 7]
     """
 
     @prim_attr_register
@@ -1570,7 +1575,29 @@ class CellBackwardHook(PrimitiveWithInfer):
         # If args is empty, just return.
         if not args:
             return args
-        return _run_op(self, self.name, args)
+
+        # Collect the indices and values of arguments that are instances of Tensor
+        tensors_idx = []
+        tensors = []
+        for i, arg in enumerate(args):
+            if isinstance(arg, Tensor):
+                tensors_idx.append(i)
+                tensors.append(arg)
+
+        # If there are no Tensor arguments, return the single argument or the original tuple
+        if not tensors:
+            return args[0] if len(args) == 1 else args
+
+        new_tensors = _run_op(self, self.name, tensors)
+        if not isinstance(new_tensors, tuple):
+            new_tensors = (new_tensors,)
+
+        # Replace the original Tensor arguments with the processed ones
+        arg_list = list(args)
+        for idx, val in zip(tensors_idx, new_tensors):
+            arg_list[idx] = val
+
+        return arg_list[0] if len(arg_list) == 1 else tuple(arg_list)
 
     def infer_shape(self, *inputs_shape):
         if len(inputs_shape) == 1:
@@ -1772,7 +1799,8 @@ class KMeansCentroids(PrimitiveWithInfer):
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor
         >>> from mindspore.ops import operations as P
-        >>> ms.set_context(mode=ms.GRAPH_MODE, device_target="Ascend")
+        >>> ms.set_context(mode=ms.GRAPH_MODE)
+        >>> ms.set_device(device_target="Ascend")
 
         >>> class Net(nn.Cell):
         >>>    def __init__(self):
@@ -2039,6 +2067,8 @@ class CheckBprop(PrimitiveWithInfer):
                              f"which is:{len(yshapes)} but got {len(xshapes)}.")
 
         def shape_equal(shape1, shape2):
+            if -2 in shape1 or -2 in shape2:
+                return True
             if len(shape1) != len(shape2):
                 return False
             for shape_axis1, shape_axis2 in zip(shape1, shape2):