mindspore 2.2.14__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

mindspore/nn/layer/embedding.py

@@ -16,13 +16,14 @@
 from __future__ import absolute_import
 
 import mindspore.common.dtype as mstype
+import mindspore.ops as ops
 from mindspore import log as logger
 from mindspore.common.tensor import Tensor
 from mindspore.ops import operations as P
 from mindspore.ops import functional as F
 from mindspore.common.parameter import Parameter
 from mindspore.common.parameter import _get_unique_parameter_key
-from mindspore.common.initializer import initializer
+from mindspore.common.initializer import initializer, Normal
 from mindspore.communication.management import get_group_size, get_rank
 from mindspore.context import ParallelMode
 from mindspore.parallel._utils import _get_parallel_mode, _get_full_batch
@@ -34,13 +35,14 @@ from mindspore.ops.primitive import constexpr, _primexpr
 from mindspore.nn.layer.basic import ClipByNorm
 from mindspore.nn.cell import Cell
 
-__all__ = ['Embedding', 'EmbeddingLookup', 'MultiFieldEmbeddingLookup']
+__all__ = ['Embedding', 'EmbeddingExt', 'EmbeddingLookup', 'MultiFieldEmbeddingLookup']
 
 
 @_primexpr
 def _check_input_2d(input_shape, param_name, func_name):
     if len(input_shape) != 2:
-        raise ValueError(f"For '{func_name}', the dimension of '{param_name}' must be 2d, but got {len(input_shape)}")
+        raise ValueError(
+            f"For '{func_name}', the dimension of '{param_name}' must be 2d, but got {len(input_shape)}")
 
 
 @constexpr
@@ -65,7 +67,7 @@ class Embedding(Cell):
         use_one_hot (bool): Specifies whether to apply one_hot encoding form. Default: ``False`` .
         embedding_table (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the embedding_table.
             Refer to class `mindspore.common.initializer
-            <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.common.initializer.html>`_
+            <https://www.mindspore.cn/docs/en/master/api_python/mindspore.common.initializer.html>`_
             for the values of string when a string is specified. Default: ``'normal'`` .
         dtype (:class:`mindspore.dtype`): Data type of `x`. Default: ``mstype.float32`` .
         padding_idx (int, None): When the padding_idx encounters index, the output embedding vector of this index
@@ -104,23 +106,30 @@ class Embedding(Cell):
                  dtype=mstype.float32, padding_idx=None):
         """Initialize Embedding."""
         super(Embedding, self).__init__()
-        self.vocab_size = Validator.check_value_type('vocab_size', vocab_size, [int], self.cls_name)
-        self.embedding_size = Validator.check_value_type('embedding_size', embedding_size, [int], self.cls_name)
-        Validator.check_value_type('use_one_hot', use_one_hot, [bool], self.cls_name)
-        Validator.check_subclass("dtype", dtype, mstype.number_type, self.cls_name)
+        self.vocab_size = Validator.check_value_type(
+            'vocab_size', vocab_size, [int], self.cls_name)
+        self.embedding_size = Validator.check_value_type(
+            'embedding_size', embedding_size, [int], self.cls_name)
+        Validator.check_value_type(
+            'use_one_hot', use_one_hot, [bool], self.cls_name)
+        Validator.check_subclass(
+            "dtype", dtype, mstype.number_type, self.cls_name)
         self.use_one_hot = use_one_hot
         self.dtype = dtype
-        self.init_tensor = initializer(embedding_table, [vocab_size, embedding_size])
+        self.init_tensor = initializer(
+            embedding_table, [vocab_size, embedding_size])
         self.padding_idx = padding_idx
         if padding_idx is not None:
             self.padding_idx = Validator.check_int_range(padding_idx, 0, vocab_size, Validator.INC_LEFT,
                                                          "padding_idx", self.cls_name)
             if isinstance(self.init_tensor, Tensor) and self.init_tensor.init is not None:
                 self.init_tensor = self.init_tensor.init_data()
+            init_tensor_type = self.init_tensor.dtype
             self.init_tensor = self.init_tensor.asnumpy()
             self.init_tensor[self.padding_idx] = 0
-            self.init_tensor = Tensor(self.init_tensor)
-        self.embedding_table = Parameter(self.init_tensor, name='embedding_table')
+            self.init_tensor = Tensor(self.init_tensor, init_tensor_type)
+        self.embedding_table = Parameter(
+            self.init_tensor, name='embedding_table')
         self.expand = P.ExpandDims()
         self.reshape_flat = P.Reshape()
         self.shp_flat = (-1,)
@@ -138,8 +147,10 @@ class Embedding(Cell):
         flat_ids = self.reshape_flat(ids, self.shp_flat)
 
         if self.use_one_hot:
-            one_hot_ids = self.one_hot(flat_ids, self.vocab_size, self.on_value, self.off_value)
-            output_for_reshape = self.array_mul(one_hot_ids, self.embedding_table)
+            one_hot_ids = self.one_hot(
+                flat_ids, self.vocab_size, self.on_value, self.off_value)
+            output_for_reshape = self.array_mul(
+                one_hot_ids, self.embedding_table)
         else:
             output_for_reshape = self.gather(self.embedding_table, flat_ids, 0)
 
@@ -151,6 +162,123 @@ class Embedding(Cell):
             f'embedding_table={self.embedding_table}, dtype={self.dtype}, padding_idx={self.padding_idx}'
 
 
+class EmbeddingExt(Cell):
+    r"""
+    Embedding layer.
+    Retrieve the word embeddings in weight stored in the layer using indices specified in `input`.
+
+    .. warning::
+        On Ascend, the behavior is unpredictable when the value of `input` is invalid.
+
+    Args:
+        num_embeddings (int): Size of the dictionary of embeddings.
+        embedding_dim (int): The size of each embedding vector.
+        padding_idx (int, optional): If the value is not None, the corresponding row of embedding vector
+            will not be updated in training. The value of embedding vector at `padding_idx` will default
+            to zeros when the Embedding layer is newly constructed. The value should be in range
+            `[-num_embeddings, num_embeddings)` if it's not ``None``. Default ``None``.
+        max_norm (float, optional): If the value is not None, firstly get the p-norm result of the embedding
+            vector specified by `input` where p is specified by `norm_type`; if the result is larger then `max_norm`,
+            update the embedding vector` with :math:`\frac{max\_norm}{result+1e^{-7}}`. Default ``None``.
+        norm_type (float, optional): Indicated the value of p in p-norm. Default ``2.0``.
+        scale_grad_by_freq (bool, optional): If ``True`` the gradients will be scaled by the inverse of frequency
+            of the index in `input`. Default ``False``.
+        _weight (Tensor, optional): Used to initialize the weight of Embedding. If ``None``, the weight will be
+            initialized from normal distribution :math:`{N}(\text{sigma=1.0}, \text{mean=0.0})`. Default ``None``.
+        dtype (mindspore.dtype, optional) : Dtype of Parameters. It is meaningless when `_weight` is not None.
+            Default: ``mindspore.float32``.
+
+    Inputs:
+        - **input** (Tensor) - The indices used to lookup in the embedding vector. The data type must be
+          mindspore.int32 or mindspore.int64, and the value should be in range `[0, num_embeddings)`.
+
+    Outputs:
+        Tensor, has the same data type as weight, the shape is :math:`(*input.shape, embedding\_dim)`.
+
+    Raises:
+        TypeError: If `num_embeddings` is not an int.
+        TypeError: If `embedding_dim` is not an int.
+        ValueError: If `padding_idx` is out of valid range.
+        TypeError: If `max_norm` is not a float.
+        TypeError: If `norm_type` is not a float.
+        TypeError: If `scale_grad_by_freq` is not a bool.
+        TypeError: If `dtype` is not one of mindspore.dtype.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, nn
+        >>> input = Tensor([[1, 0, 1, 1], [0, 0, 1, 0]])
+        >>> embedding = nn.mint.nn.Embedding(num_embeddings=10, embedding_dim=3)
+        >>> output = embedding(input)
+        >>> print(output)
+        [[[-0.0024154  -0.01203444  0.00811537]
+          [ 0.00233847 -0.00596091  0.00536799]
+          [-0.0024154  -0.01203444  0.00811537]
+          [-0.0024154  -0.01203444  0.00811537]]
+         [[ 0.00233847 -0.00596091  0.00536799]
+          [ 0.00233847 -0.00596091  0.00536799]
+          [-0.0024154  -0.01203444  0.00811537]
+          [ 0.00233847 -0.00596091  0.00536799]]]
+    """
+
+    def __init__(self, num_embeddings, embedding_dim, padding_idx=None, max_norm=None, norm_type=2.0,
+                 scale_grad_by_freq=False, _weight=None, dtype=mstype.float32):
+        """Initialize Embedding."""
+        super().__init__()
+        self.num_embeddings = Validator.check_value_type(
+            'num_embeddings', num_embeddings, [int], self.cls_name)
+        self.embedding_dim = Validator.check_value_type(
+            'embedding_dim', embedding_dim, [int], self.cls_name)
+        Validator.check_subclass(
+            "dtype", dtype, mstype.number_type, self.cls_name)
+        self.dtype = dtype
+        self.padding_idx = padding_idx
+        if _weight is None:
+            init_tensor = Tensor(shape=[num_embeddings, embedding_dim], dtype=dtype, init=Normal(1, 0))
+            init_tensor = self._zero_weight_by_index(init_tensor)
+            self.weight = Parameter(init_tensor, name='weight')
+        else:
+            self.weight = Parameter(_weight)
+
+        self.max_norm = max_norm
+        if max_norm is not None:
+            self.max_norm = Validator.check_value_type('max_norm', max_norm, [float], self.cls_name)
+
+        self.norm_type = norm_type
+        if norm_type is not None:
+            self.norm_type = Validator.check_value_type('norm_type', norm_type,
+                                                        [float], self.cls_name)
+
+        self.scale_grad_by_freq = scale_grad_by_freq
+        if scale_grad_by_freq is not None:
+            self.scale_grad_by_freq = Validator.check_value_type('scale_grad_by_freq',
+                                                                 scale_grad_by_freq,
+                                                                 [bool], self.cls_name)
+
+    def _zero_weight_by_index(self, init_tensor):
+        if self.padding_idx is not None:
+            self.padding_idx = Validator.check_int_range(self.padding_idx, -self.num_embeddings, self.num_embeddings,
+                                                         Validator.INC_LEFT, "padding_idx", self.cls_name)
+            if isinstance(init_tensor, Tensor) and init_tensor.init is not None:
+                init_tensor = init_tensor.init_data()
+            init_tensor[self.padding_idx] = 0
+
+        return init_tensor
+
+    def construct(self, input):
+        return ops.embedding(input, self.weight, self.padding_idx, self.max_norm,
+                             self.norm_type, self.scale_grad_by_freq)
+
+    def extend_repr(self):
+        return f'num_embeddings={self.num_embeddings}, embedding_dim={self.embedding_dim}, ' \
+               f'padding_idx={self.padding_idx}, max_norm={self.max_norm}, norm_type={self.norm_type}, ' \
+               f'scale_grad_by_freq={self.scale_grad_by_freq}, dtype={self.dtype}'
+
+
 @_primexpr
 def _make_axis_range(start, end):
     axis = tuple(range(start, end))
@@ -181,8 +309,18 @@ class EmbeddingLookup(Cell):
             is specified. Default: ``'normal'`` .
         target (str): Specifies the target where the op is executed. The value must in
             [ ``'DEVICE'`` , ``'CPU'`` ]. Default: ``'CPU'`` .
-        slice_mode (str): The slicing way in semi_auto_parallel/auto_parallel. The value must get through
-            :class:`mindspore.nn.EmbeddingLookup`. Default: ``'batch_slice'`` .
+        slice_mode (str): The slicing way in semi_auto_parallel/auto_parallel. Default: ``'batch_slice'`` .
+
+          - batch_slice (str): Divides the input index tensor into batches and retrieves
+            the corresponding embedding vectors. This is applicable when each sample has the same number of indices.
+          - field_slice (str): Divides the input index tensor into fields and retrieves the corresponding embedding
+            vectors. This is applicable when each sample may have a different number of indices, but have the same
+            feature dimensions.
+          - table_row_slice (str): Treats the input index tensor as a 2D table, divides it by rows, and retrieves
+            the corresponding embedding vectors.
+          - table_column_slice (str): Treats the input index tensor as a 2D table, divides it by columns, and retrieves
+            the corresponding embedding vectors.
+
         manual_shapes (tuple): The accompaniment array in field slice mode. Default: ``None`` .
         max_norm (Union[float, None]): A maximum clipping value. The data type must be float16, float32
                                        or None. Default: ``None`` .
@@ -237,13 +375,16 @@ class EmbeddingLookup(Cell):
         """Initialize EmbeddingLookup."""
         super(EmbeddingLookup, self).__init__()
         Validator.check_value_type('sparse', sparse, [bool], self.cls_name)
-        self.vocab_size = Validator.check_positive_int(vocab_size, 'vocab_size')
-        self.vocab_cache_size = Validator.check_non_negative_int(vocab_cache_size, 'vocab_cache_size')
+        self.vocab_size = Validator.check_positive_int(
+            vocab_size, 'vocab_size')
+        self.vocab_cache_size = Validator.check_non_negative_int(
+            vocab_cache_size, 'vocab_cache_size')
         self.target = target
         self.sparse = sparse
         self.cache_enable = self.vocab_cache_size > 0
         self.forward_unique = False
-        Validator.check_string(target, ['CPU', 'DEVICE'], 'target', self.cls_name)
+        Validator.check_string(
+            target, ['CPU', 'DEVICE'], 'target', self.cls_name)
         if not sparse and target == 'CPU':
             raise ValueError(f"For '{self.cls_name}', 'sparse' must be True when 'target' is \"CPU\", "
                              f"but got 'sparse': {sparse} and 'target': {target}")
@@ -256,11 +397,13 @@ class EmbeddingLookup(Cell):
         enable_ps = _get_ps_context("enable_ps")
         if enable_ps:
             self._process_vocab_cache(slice_mode)
-        self.embedding_size = Validator.check_positive_int(embedding_size, 'embedding_size', self.cls_name)
+        self.embedding_size = Validator.check_positive_int(
+            embedding_size, 'embedding_size', self.cls_name)
         self.embedding_table = Parameter(initializer(param_init, [self.vocab_size, self.embedding_size],
                                                      dtype=dtype), name='embedding_table')
         parallel_mode = _get_parallel_mode()
-        is_auto_parallel = parallel_mode in (ParallelMode.SEMI_AUTO_PARALLEL, ParallelMode.AUTO_PARALLEL)
+        is_auto_parallel = parallel_mode in (
+            ParallelMode.SEMI_AUTO_PARALLEL, ParallelMode.AUTO_PARALLEL)
         self.gather_revert = P.Gather()
         self.reshape_first = P.Reshape()
         self.reshape = P.Reshape()
@@ -269,7 +412,8 @@ class EmbeddingLookup(Cell):
         if is_auto_parallel:
             self.unique = P.Unique().shard(((1,),))
         if self.cache_enable and enable_ps:
-            self._set_voacb_cache_enable_for_ps(vocab_cache_size, embedding_size, vocab_size, param_init, dtype=dtype)
+            self._set_voacb_cache_enable_for_ps(
+                vocab_cache_size, embedding_size, vocab_size, param_init, dtype=dtype)
             if is_auto_parallel:
                 self.unique.add_prim_attr('cache_enable', True)
         indices_shape_size = 2
@@ -281,11 +425,13 @@ class EmbeddingLookup(Cell):
                 raise TypeError(f"For '{self.cls_name}', the type of 'manual_shapes' must be tuple(int), "
                                 f"but got {type(manual_shapes).__name__}!")
             for dim in manual_shapes:
-                Validator.check_positive_int(dim, 'manual shape dim', self.cls_name)
+                Validator.check_positive_int(
+                    dim, 'manual shape dim', self.cls_name)
             self.gatherv2.add_prim_attr("manual_split", manual_shapes)
             self.embeddinglookup.add_prim_attr("manual_split", manual_shapes)
             self.gatherv2.shard(((get_group_size(), 1), (1, get_group_size())))
-            self.embeddinglookup.shard(((get_group_size(), 1), (1, get_group_size())))
+            self.embeddinglookup.shard(
+                ((get_group_size(), 1), (1, get_group_size())))
         elif slice_mode == "table_row_slice" and is_auto_parallel:
             full_batch = _get_full_batch()
             if (target == 'DEVICE' and not full_batch) or (self.cache_enable and enable_ps and sparse):
@@ -294,7 +440,8 @@ class EmbeddingLookup(Cell):
                 self.forward_unique = True
             indices_strategy = (1,)*indices_shape_size
             self.gatherv2.shard(((get_group_size(), 1), indices_strategy))
-            self.embeddinglookup.shard(((get_group_size(), 1), indices_strategy))
+            self.embeddinglookup.shard(
+                ((get_group_size(), 1), indices_strategy))
         elif slice_mode == "table_column_slice" and is_auto_parallel:
             if target == 'DEVICE':
                 indices_shape_size = 1
@@ -302,7 +449,8 @@ class EmbeddingLookup(Cell):
                 self.forward_unique = True
             indices_strategy = (1,)*indices_shape_size
             self.gatherv2.shard(((1, get_group_size()), indices_strategy))
-            self.embeddinglookup.shard(((1, get_group_size()), indices_strategy))
+            self.embeddinglookup.shard(
+                ((1, get_group_size()), indices_strategy))
         elif slice_mode == "batch_slice" and is_auto_parallel:
             indices_strategy = [get_group_size()]
             indices_strategy.extend([1] * (indices_shape_size - 1))
@@ -311,15 +459,18 @@ class EmbeddingLookup(Cell):
             self.embeddinglookup.shard(((1, 1), indices_strategy))
         else:
             if is_auto_parallel:
-                support_mode = ["field_slice", "table_row_slice", "table_column_slice", "batch_slice"]
+                support_mode = ["field_slice", "table_row_slice",
+                                "table_column_slice", "batch_slice"]
                 raise ValueError(f"For '{self.cls_name}', the 'slice_mode' must be in {support_mode}, "
                                  f"but got \"{slice_mode}\".")
         if self.cache_enable and not enable_ps:
-            raise ValueError(f"For '{self.cls_name}', haven't supported cache enable for not ps mode.")
+            raise ValueError(
+                f"For '{self.cls_name}', haven't supported cache enable for not ps mode.")
         self.embedding_table.unique = self.forward_unique
         self.max_norm = max_norm
         if self.max_norm is not None:
-            self.max_norm = Validator.check_positive_float(self.max_norm, 'max_norm', self.cls_name)
+            self.max_norm = Validator.check_positive_float(
+                self.max_norm, 'max_norm', self.cls_name)
             self.max_norm = Tensor(self.max_norm, dtype=mstype.float32)
 
     def _process_vocab_cache(self, slice_mode):
@@ -337,7 +488,8 @@ class EmbeddingLookup(Cell):
                 return
             self.is_ps_server = _is_role_pserver() and _enable_distributed_mindrt()
             parallel_mode = _get_parallel_mode()
-            is_auto_parallel = parallel_mode in (ParallelMode.SEMI_AUTO_PARALLEL, ParallelMode.AUTO_PARALLEL)
+            is_auto_parallel = parallel_mode in (
+                ParallelMode.SEMI_AUTO_PARALLEL, ParallelMode.AUTO_PARALLEL)
             if is_auto_parallel:
                 rank_size = get_group_size()
                 rank_id = get_rank()
@@ -366,7 +518,8 @@ class EmbeddingLookup(Cell):
             self.embedding_table.is_param_ps = True
             self.embedding_table.cache_enable = True
             self.embedding_table.key = param_key
-            _insert_hash_table_size(self.embedding_table.name, vocab_cache_size, embedding_size, vocab_size, param_key)
+            _insert_hash_table_size(
+                self.embedding_table.name, vocab_cache_size, embedding_size, vocab_size, param_key)
 
         if _enable_distributed_mindrt():
             self.rank_id = get_rank()
@@ -392,7 +545,8 @@ class EmbeddingLookup(Cell):
             raise ValueError("The Parameter Server number is zero.")
         # Assign the embedding table dimensions.
         for _ in range(server_num):
-            self.embedding_table_vocab_dim_list.append(self.vocab_size // server_num)
+            self.embedding_table_vocab_dim_list.append(
+                self.vocab_size // server_num)
         rest_vocab_size = self.vocab_size % server_num
         if rest_vocab_size != 0:
             for i in range(rest_vocab_size):
@@ -416,7 +570,8 @@ class EmbeddingLookup(Cell):
                     embedding_lookup = P.SparseGatherV2()
                 else:
                     embedding_lookup = P.Gather()
-                embedding_lookup.add_prim_attr('offset', self.embedding_offset[i])
+                embedding_lookup.add_prim_attr(
+                    'offset', self.embedding_offset[i])
             embedding_lookup.add_prim_attr('rank_id', i)
             embedding_lookup.add_prim_attr('ms_role', 'MS_PSERVER')
             self.embedding_lookup_list.append(embedding_lookup)
@@ -466,8 +621,10 @@ class EmbeddingLookup(Cell):
                 shp = self.shape(indices) + (self.embedding_size,)
                 indices_flatten = self.reshape_first(indices, (-1,))
                 unique_id, unique_idx = self.unique(indices_flatten)
-                weight_unique = self.gatherv2(self.embedding_table, unique_id, 0)
-                weight_flatten = self.gather_revert(weight_unique, unique_idx, 0)
+                weight_unique = self.gatherv2(
+                    self.embedding_table, unique_id, 0)
+                weight_flatten = self.gather_revert(
+                    weight_unique, unique_idx, 0)
                 out = self.reshape(weight_flatten, shp)
             else:
                 out = self.gatherv2(self.embedding_table, indices, 0)
@@ -504,8 +661,18 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
             is specified. Default: ``'normal'`` .
         target (str): Specifies the target where the op is executed. The value must in
             [ ``'DEVICE'`` , ``'CPU'`` ]. Default: ``'CPU'`` .
-        slice_mode (str): The slicing way in semi_auto_parallel/auto_parallel. The value must get through
-            :class:`mindspore.nn.EmbeddingLookup`. Default: ``'batch_slice'``.
+        slice_mode (str): The slicing way in semi_auto_parallel/auto_parallel. Default: ``'batch_slice'``.
+
+          - batch_slice (str): Divides the input index tensor into batches and retrieves
+            the corresponding embedding vectors. This is applicable when each sample has the same number of indices.
+          - field_slice (str): Divides the input index tensor into fields and retrieves the corresponding embedding
+            vectors. This is applicable when each sample may have a different number of indices, but have the same
+            feature dimensions.
+          - table_row_slice (str): Treats the input index tensor as a 2D table, divides it by rows, and retrieves
+            the corresponding embedding vectors.
+          - table_column_slice (str): Treats the input index tensor as a 2D table, divides it by columns, and retrieves
+            the corresponding embedding vectors.
+
         feature_num_list (tuple): The accompaniment array in field slice mode. This is unused currently.
             Default:  ``None`` .
         max_norm (Union[float, None]): A maximum clipping value. The data type must be float16, float32.
@@ -564,7 +731,8 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
         """Initialize MultiFieldEmbeddingLookup."""
         super(MultiFieldEmbeddingLookup, self).__init__(vocab_size, embedding_size, param_init, target,
                                                         slice_mode, feature_num_list, max_norm, sparse, dtype=dtype)
-        self.field_size = Validator.check_positive_int(field_size, 'field_size', self.cls_name)
+        self.field_size = Validator.check_positive_int(
+            field_size, 'field_size', self.cls_name)
         self.operator = operator
 
         self.mul = P.Mul()
@@ -582,7 +750,8 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
         self.max_mask_mul = P.Mul()
         self.max_no_equal = P.NotEqual()
 
-        Validator.check_string(operator, ['SUM', 'MAX', 'MEAN'], 'operator', self.cls_name)
+        Validator.check_string(
+            operator, ['SUM', 'MAX', 'MEAN'], 'operator', self.cls_name)
         if operator == MultiFieldEmbeddingLookup.OPERATOR_SUM:
             self.merge_op = P.UnsortedSegmentSum()
         elif operator == MultiFieldEmbeddingLookup.OPERATOR_MAX:
@@ -665,13 +834,16 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
             clip_by_norm = ClipByNorm(axis)
             out = clip_by_norm(out, self.max_norm)
 
-        weights = self.reshape(input_values, (batch_size, self.shape(input_indices)[1], 1))
+        weights = self.reshape(
+            input_values, (batch_size, self.shape(input_indices)[1], 1))
         embedding = self.mul(weights, out)
 
         if self.operator == 'MAX':
             # Fill the padding value to -inf, so the padded value will not influence the results
-            negative_inf_mask = self.cast(self.equal(weights, 0), mstype.float32)
-            inf_mask = self.inf_mask_mul(negative_inf_mask, self.negative_inf_value)
+            negative_inf_mask = self.cast(
+                self.equal(weights, 0), mstype.float32)
+            inf_mask = self.inf_mask_mul(
+                negative_inf_mask, self.negative_inf_value)
             embedding = self.inf_add(embedding, inf_mask)
             embedding = self.reshape(embedding, (-1, self.embedding_size))
             field_ids = self.reshape(field_ids, (-1,))
@@ -679,15 +851,19 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
         merged_vectors = self.merge_op(embedding, field_ids, num_segments)
 
         if self.operator == 'MAX':
-            value_count = self.count_op(self.abs(self.reshape(input_values, (-1,))), field_ids, num_segments)
-            value_zeros = self.cast(self.max_no_equal(value_count, 0.0), mstype.float32)
+            value_count = self.count_op(self.abs(self.reshape(
+                input_values, (-1,))), field_ids, num_segments)
+            value_zeros = self.cast(self.max_no_equal(
+                value_count, 0.0), mstype.float32)
             count = self.expand(value_zeros, -1)
             merged_vectors = self.max_mask_mul(merged_vectors, count)
 
         if self.operator == 'MEAN':
-            value_count = self.count_op(self.abs(input_values), field_ids, num_segments)
+            value_count = self.count_op(
+                self.abs(input_values), field_ids, num_segments)
             value_count = self.expand(value_count, -1)
             merged_vectors = self.div_no_nan(merged_vectors, value_count)
 
-        merged_vectors = self.reshape(merged_vectors, (batch_size, self.field_size, -1))
+        merged_vectors = self.reshape(
+            merged_vectors, (batch_size, self.field_size, -1))
         return merged_vectors

mindspore/nn/layer/image.py

@@ -115,7 +115,7 @@ def _get_dtype_max(dtype):
     """get max of the dtype"""
     np_type = mstype.dtype_to_nptype(dtype)
     if issubclass(np_type, numbers.Integral):
-        dtype_max = np.float64(np.iinfo(np_type).max)
+        dtype_max = np.float64(np.iinfo(np_type).max).item()
     else:
         dtype_max = 1.0
     return dtype_max
@@ -283,8 +283,7 @@ class SSIM(Cell):
         _check_input_filter_size(F.shape(img1), "img1", self.filter_size, self.cls_name)
         inner.SameTypeShape()(img1, img2)
         dtype_max_val = _get_dtype_max(F.dtype(img1))
-        max_val = F.scalar_cast(self.max_val, F.dtype(img1))
-        max_val = _convert_img_dtype_to_float32(max_val, dtype_max_val)
+        max_val = _convert_img_dtype_to_float32(self.max_val, dtype_max_val)
         img1 = _convert_img_dtype_to_float32(img1, dtype_max_val)
         img2 = _convert_img_dtype_to_float32(img2, dtype_max_val)
 
@@ -391,8 +390,7 @@ class MSSSIM(Cell):
         _check_input_dtype(F.dtype(img1), 'img1', valid_type, self.cls_name)
         inner.SameTypeShape()(img1, img2)
         dtype_max_val = _get_dtype_max(F.dtype(img1))
-        max_val = F.scalar_cast(self.max_val, F.dtype(img1))
-        max_val = _convert_img_dtype_to_float32(max_val, dtype_max_val)
+        max_val = _convert_img_dtype_to_float32(self.max_val, dtype_max_val)
         img1 = _convert_img_dtype_to_float32(img1, dtype_max_val)
         img2 = _convert_img_dtype_to_float32(img2, dtype_max_val)
 
@@ -469,8 +467,7 @@ class PSNR(Cell):
         _check_input_4d(F.shape(img2), "img2", self.cls_name)
         inner.SameTypeShape()(img1, img2)
         dtype_max_val = _get_dtype_max(F.dtype(img1))
-        max_val = F.scalar_cast(self.max_val, F.dtype(img1))
-        max_val = _convert_img_dtype_to_float32(max_val, dtype_max_val)
+        max_val = _convert_img_dtype_to_float32(self.max_val, dtype_max_val)
         img1 = _convert_img_dtype_to_float32(img1, dtype_max_val)
         img2 = _convert_img_dtype_to_float32(img2, dtype_max_val)
 

mindspore/nn/layer/math.py

@@ -136,7 +136,7 @@ class Range(Cell):
         if delta == 0:
             raise ValueError(f"For '{self.cls_name}', the 'delta' can not be zero.")
         data = np.arange(start, limit, delta)
-        if data.dtype == np.float:
+        if data.dtype == np.float_:
             self.ms_dtype = mstype.float32
         else:
             self.ms_dtype = mstype.int32