mindspore 1.10.0__cp39-cp39-win_amd64.whl → 2.0.0rc1__cp39-cp39-win_amd64.whl

mindspore/nn/layer/embedding.py

@@ -29,26 +29,23 @@ from mindspore.parallel._utils import _get_parallel_mode, _get_full_batch
 from mindspore.parallel._ps_context import _get_ps_context, _enable_distributed_mindrt
 from mindspore.parallel._ps_context import _is_role_worker, _is_role_pserver
 from mindspore.parallel._ps_context import _insert_hash_table_size, _set_cache_enable, _set_rank_id
-from mindspore._checkparam import Rel
-from mindspore._checkparam import Validator as validator
-from mindspore.ops.primitive import constexpr
+from mindspore import _checkparam as Validator
+from mindspore.ops.primitive import constexpr, _primexpr
 from mindspore.nn.layer.basic import ClipByNorm
-from mindspore.nn.layer.math import Range
 from mindspore.nn.cell import Cell
 
 __all__ = ['Embedding', 'EmbeddingLookup', 'MultiFieldEmbeddingLookup']
 
 
-@constexpr
+@_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)}")
-    return True
 
 
 @constexpr
 def _check_input_dtype(input_dtype, param_name, allow_dtypes, cls_name):
-    validator.check_type_name(param_name, input_dtype, allow_dtypes, cls_name)
+    Validator.check_type_name(param_name, input_dtype, allow_dtypes, cls_name)
 
 
 class Embedding(Cell):
@@ -102,16 +99,16 @@ 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.padding_idx = padding_idx
         if padding_idx is not None:
-            self.padding_idx = validator.check_int_range(padding_idx, 0, vocab_size, Rel.INC_LEFT,
+            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()
@@ -129,9 +126,13 @@ class Embedding(Cell):
         self.array_mul = P.MatMul()
         self.reshape = P.Reshape()
         self.get_shp = P.Shape()
+        self.get_tensor_shp = P.TensorShape()
+        self.concat = P.Concat()
 
     def construct(self, ids):
         out_shape = self.get_shp(ids) + (self.embedding_size,)
+        if F.is_sequence_value_unknown(self.get_shp(ids)):
+            out_shape = self.concat((self.get_tensor_shp(ids), Tensor([self.embedding_size])))
         flat_ids = self.reshape_flat(ids, self.shp_flat)
 
         if self.use_one_hot:
@@ -164,7 +165,7 @@ class EmbeddingLookup(Cell):
 
     Note:
         When 'target' is set to 'CPU', this module will use
-        P.EmbeddingLookup().add_prim_attr('primitive_target', 'CPU') which
+        P.EmbeddingLookup().set_device('CPU') which
         specified 'offset = 0' to lookup table.
         When 'target' is set to 'DEVICE', this module will use P.Gather() which
         specified 'axis = 0' to lookup table.
@@ -180,7 +181,7 @@ class EmbeddingLookup(Cell):
         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: :class:`mindspore.nn.EmbeddingLookup.BATCH_SLICE`.
+            :class:`mindspore.nn.EmbeddingLookup`. Default: 'nn.EmbeddingLookup.BATCH_SLICE'.
         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
@@ -230,14 +231,14 @@ class EmbeddingLookup(Cell):
                  max_norm=None, sparse=True, vocab_cache_size=0):
         """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')
+        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.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}")
@@ -245,12 +246,12 @@ class EmbeddingLookup(Cell):
             self.gatherv2 = P.SparseGatherV2()
         else:
             self.gatherv2 = P.Gather()
-        self.embeddinglookup = P.EmbeddingLookup().add_prim_attr('primitive_target', 'CPU')
+        self.embeddinglookup = P.EmbeddingLookup().set_device('CPU')
         self.is_ps_server = False
         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]),
                                          name='embedding_table')
         parallel_mode = _get_parallel_mode()
@@ -275,7 +276,7 @@ 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())))
@@ -313,7 +314,7 @@ class EmbeddingLookup(Cell):
         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):
@@ -343,13 +344,15 @@ class EmbeddingLookup(Cell):
                                      f"But got full_batch: {full_batch} and 'slice_mode': \"{slice_mode}\".")
                 self.vocab_cache_size = self.vocab_cache_size * rank_size
                 _set_rank_id(rank_id)
+
             self.cache_enable = True
+            _set_cache_enable(True)
+
             if _is_role_worker():
                 self.vocab_size = self.vocab_cache_size
 
     def _set_voacb_cache_enable_for_ps(self, vocab_cache_size, embedding_size, vocab_size, param_init):
         """PS embeddingLookup cache enable set."""
-        _set_cache_enable(True)
         if self.sparse:
             self.forward_unique = True
         param_key = _get_unique_parameter_key()
@@ -359,10 +362,10 @@ class EmbeddingLookup(Cell):
             self.embedding_table.key = param_key
             _insert_hash_table_size(self.embedding_table.name, vocab_cache_size, embedding_size, vocab_size, param_key)
 
-        if  _enable_distributed_mindrt():
+        if _enable_distributed_mindrt():
             self.rank_id = get_rank()
             if self.is_ps_server:
-                self._slice_pserver_embeddings(param_init)
+                self._slice_pserver_embeddings("zeros")
                 self._set_cache_enable_and_key_for_pserver(param_key)
 
     def _slice_pserver_embeddings(self, param_init):
@@ -382,7 +385,7 @@ class EmbeddingLookup(Cell):
         if server_num == 0:
             raise ValueError("The Parameter Server number is zero.")
         # Assign the embedding table dimensions.
-        for i in range(server_num):
+        for _ in range(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:
@@ -401,7 +404,7 @@ class EmbeddingLookup(Cell):
 
             # Add EmbeddingLookup ops on different servers.
             if self.target == 'CPU':
-                embedding_lookup = P.EmbeddingLookup().add_prim_attr('primitive_target', 'CPU')
+                embedding_lookup = P.EmbeddingLookup().set_device('CPU')
             else:
                 if self.sparse:
                     embedding_lookup = P.SparseGatherV2()
@@ -476,7 +479,7 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
 
     Note:
         When 'target' is set to 'CPU', this module will use
-        P.EmbeddingLookup().add_prim_attr('primitive_target', 'CPU') which
+        P.EmbeddingLookup().set_device('CPU') which
         specified 'offset = 0' to lookup table.
         When 'target' is set to 'DEVICE', this module will use P.Gather() which
         specified 'axis = 0' to lookup table.
@@ -484,7 +487,7 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
         'MEAN'. Ensure the input_values of the padded id is zero, so that they can be ignored. The final
         output will be zeros if the sum of absolute weight of the field is zero. This class only
         supports ['table_row_slice', 'batch_slice' and 'table_column_slice']. For the operation 'MAX' on
-        device Ascend, there is a constraint where batch_size * (seq_length + field_size) < 3500.
+        device Ascend, there is a constraint where :math:`batch\_size * (seq\_length + field\_size) < 3500`.
 
     Args:
         vocab_size (int): The size of the dictionary of embeddings.
@@ -496,7 +499,7 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
         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: :class:`mindspore.nn.EmbeddingLookup.BATCH_SLICE`.
+            :class:`mindspore.nn.EmbeddingLookup`. Default: 'nn.EmbeddingLookup.BATCH_SLICE'.
         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
                                        or None. Default: None
@@ -549,7 +552,7 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
         """Initialize MultiFieldEmbeddingLookup."""
         super(MultiFieldEmbeddingLookup, self).__init__(vocab_size, embedding_size, param_init, target,
                                                         slice_mode, feature_num_list, max_norm, sparse)
-        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()
@@ -567,7 +570,7 @@ 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:
@@ -619,7 +622,6 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
         self.negative_inf_value = -3.402823466E+38
 
     def construct(self, input_indices, input_values, field_ids):
-
         _check_input_2d(F.shape(input_indices), "input_indices", self.cls_name)
         _check_input_2d(F.shape(input_values), "input_values", self.cls_name)
         _check_input_2d(F.shape(field_ids), "field_ids", self.cls_name)
@@ -629,7 +631,7 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
 
         batch_size = self.shape(input_indices)[0]
         num_segments = batch_size * self.field_size
-        bias = Range(0, num_segments, self.field_size)()
+        bias = F.tuple_to_array(F.make_range(0, num_segments, self.field_size))
         bias = self.reshape(bias, (batch_size, -1))
         field_ids = self.bias_add(field_ids, bias)
 

mindspore/nn/layer/image.py

@@ -20,18 +20,20 @@ import numbers
 import numpy as np
 
 import mindspore.common.dtype as mstype
+import mindspore.ops as ops
 from mindspore.common.tensor import Tensor
 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.ops.primitive import constexpr
-from mindspore._checkparam import Rel, Validator as validator
+from mindspore.ops.primitive import constexpr, _primexpr
+from mindspore import _checkparam as validator
 from mindspore.nn.layer.conv import Conv2d
 from mindspore.nn.layer.container import CellList
 from mindspore.nn.layer.pooling import AvgPool2d
 from mindspore.nn.layer.activation import ReLU
 from mindspore.nn.cell import Cell
 
-__all__ = ['ImageGradients', 'SSIM', 'MSSSIM', 'PSNR', 'CentralCrop']
+__all__ = ['ImageGradients', 'SSIM', 'MSSSIM', 'PSNR', 'CentralCrop', 'PixelShuffle', 'PixelUnshuffle']
 
 
 class ImageGradients(Cell):
@@ -76,8 +78,7 @@ class ImageGradients(Cell):
         super(ImageGradients, self).__init__()
 
     def construct(self, images):
-        check = _check_input_4d(F.shape(images), "images", self.cls_name)
-        images = F.depend(images, check)
+        _check_input_4d(F.shape(images), "images", self.cls_name)
         batch_size, depth, height, width = P.Shape()(images)
         if height == 1:
             dy = P.Fill()(P.DType()(images), (batch_size, depth, 1, width), 0)
@@ -118,19 +119,18 @@ def _get_dtype_max(dtype):
     return dtype_max
 
 
-@constexpr
+@_primexpr
 def _check_input_4d(input_shape, param_name, func_name):
     if len(input_shape) != 4:
         raise ValueError(f"For '{func_name}', the dimension of '{param_name}' must be 4d, "
                          f"but got {len(input_shape)}.")
-    return True
 
 
-@constexpr
+@_primexpr
 def _check_input_filter_size(input_shape, param_name, filter_size, func_name):
     _check_input_4d(input_shape, param_name, func_name)
-    validator.check(param_name + " shape[2]", input_shape[2], "filter_size", filter_size, Rel.GE, func_name)
-    validator.check(param_name + " shape[3]", input_shape[3], "filter_size", filter_size, Rel.GE, func_name)
+    validator.check(param_name + " shape[2]", input_shape[2], "filter_size", filter_size, validator.GE, func_name)
+    validator.check(param_name + " shape[3]", input_shape[3], "filter_size", filter_size, validator.GE, func_name)
 
 
 @constexpr
@@ -265,9 +265,9 @@ class SSIM(Cell):
     def __init__(self, max_val=1.0, filter_size=11, filter_sigma=1.5, k1=0.01, k2=0.03):
         super(SSIM, self).__init__()
         validator.check_value_type('max_val', max_val, [int, float], self.cls_name)
-        validator.check_number('max_val', max_val, 0.0, Rel.GT, self.cls_name)
+        validator.check_number('max_val', max_val, 0.0, validator.GT, self.cls_name)
         self.max_val = max_val
-        self.filter_size = validator.check_int(filter_size, 1, Rel.GE, 'filter_size', self.cls_name)
+        self.filter_size = validator.check_int(filter_size, 1, validator.GE, 'filter_size', self.cls_name)
         self.filter_sigma = validator.check_positive_float(filter_sigma, 'filter_sigma', self.cls_name)
         self.k1 = validator.check_value_type('k1', k1, [float], self.cls_name)
         self.k2 = validator.check_value_type('k2', k2, [float], self.cls_name)
@@ -280,7 +280,7 @@ class SSIM(Cell):
     def construct(self, img1, img2):
         _check_input_dtype(F.dtype(img1), "img1", [mstype.float32, mstype.float16], self.cls_name)
         _check_input_filter_size(F.shape(img1), "img1", self.filter_size, self.cls_name)
-        P.SameTypeShape()(img1, img2)
+        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)
@@ -361,10 +361,10 @@ class MSSSIM(Cell):
                  filter_sigma=1.5, k1=0.01, k2=0.03):
         super(MSSSIM, self).__init__()
         validator.check_value_type('max_val', max_val, [int, float], self.cls_name)
-        validator.check_number('max_val', max_val, 0.0, Rel.GT, self.cls_name)
+        validator.check_number('max_val', max_val, 0.0, validator.GT, self.cls_name)
         self.max_val = max_val
         validator.check_value_type('power_factors', power_factors, [tuple, list], self.cls_name)
-        self.filter_size = validator.check_int(filter_size, 1, Rel.GE, 'filter_size', self.cls_name)
+        self.filter_size = validator.check_int(filter_size, 1, validator.GE, 'filter_size', self.cls_name)
         self.filter_sigma = validator.check_positive_float(filter_sigma, 'filter_sigma', self.cls_name)
         self.k1 = validator.check_value_type('k1', k1, [float], self.cls_name)
         self.k2 = validator.check_value_type('k2', k2, [float], self.cls_name)
@@ -389,7 +389,7 @@ class MSSSIM(Cell):
         _check_input_4d(F.shape(img2), "img2", self.cls_name)
         valid_type = [mstype.float64, mstype.float32, mstype.float16, mstype.uint8]
         _check_input_dtype(F.dtype(img1), 'img1', valid_type, self.cls_name)
-        P.SameTypeShape()(img1, img2)
+        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)
@@ -460,13 +460,13 @@ class PSNR(Cell):
     def __init__(self, max_val=1.0):
         super(PSNR, self).__init__()
         validator.check_value_type('max_val', max_val, [int, float], self.cls_name)
-        validator.check_number('max_val', max_val, 0.0, Rel.GT, self.cls_name)
+        validator.check_number('max_val', max_val, 0.0, validator.GT, self.cls_name)
         self.max_val = max_val
 
     def construct(self, img1, img2):
         _check_input_4d(F.shape(img1), "img1", self.cls_name)
         _check_input_4d(F.shape(img2), "img2", self.cls_name)
-        P.SameTypeShape()(img1, img2)
+        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)
@@ -479,22 +479,26 @@ class PSNR(Cell):
         return psnr
 
 
-@constexpr
-def _raise_dims_rank_error(input_shape, param_name, func_name):
+@_primexpr
+def _check_rank(rank, input_shape, param_name, func_name):
     """raise error if input is not 3d or 4d"""
-    raise ValueError(f"{func_name} {param_name} must be 3d or 4d, but got shape {input_shape}")
+    def _check():
+        if rank not in (3, 4):
+            raise ValueError(f"{func_name} {param_name} must be 3d or 4d, but got shape {input_shape}")
+    _check()
 
 
-@constexpr
+@_primexpr
 def _get_bbox(rank, shape, central_fraction):
     """get bbox start and size for slice"""
+    n, c, h, w = -1, -1, -1, -1
     if rank == 3:
         c, h, w = shape
     else:
         n, c, h, w = shape
 
-    bbox_h_start = int((float(h) - np.float32(h * central_fraction)) / 2)
-    bbox_w_start = int((float(w) - np.float32(w * central_fraction)) / 2)
+    bbox_h_start = int((float(h) - float(h * central_fraction)) / 2)
+    bbox_w_start = int((float(w) - float(w * central_fraction)) / 2)
     bbox_h_size = h - bbox_h_start * 2
     bbox_w_size = w - bbox_w_start * 2
 
@@ -539,15 +543,14 @@ class CentralCrop(Cell):
     def __init__(self, central_fraction):
         super(CentralCrop, self).__init__()
         validator.check_value_type("central_fraction", central_fraction, [float], self.cls_name)
-        validator.check_float_range(central_fraction, 0.0, 1.0, Rel.INC_RIGHT, 'central_fraction', self.cls_name)
+        validator.check_float_range(central_fraction, 0.0, 1.0, validator.INC_RIGHT, 'central_fraction', self.cls_name)
         self.central_fraction = central_fraction
         self.slice = P.Slice()
 
     def construct(self, image):
         image_shape = F.shape(image)
         rank = len(image_shape)
-        if rank not in (3, 4):
-            return _raise_dims_rank_error(image_shape, "image", self.cls_name)
+        _check_rank(rank, image_shape, "image", self.cls_name)
         if self.central_fraction == 1.0:
             return image
 
@@ -555,3 +558,96 @@ class CentralCrop(Cell):
         image = self.slice(image, bbox_begin, bbox_size)
 
         return image
+
+
+class PixelShuffle(Cell):
+    r"""
+    Applies the PixelShuffle operation over input which implements sub-pixel convolutions
+    with stride :math:`1/r` . For more details, refer to
+    `Real-Time Single Image and Video Super-Resolution Using an Efficient Sub-Pixel Convolutional Neural Network
+    <https://arxiv.org/abs/1609.05158>`_ .
+
+    Typically, the input is of shape :math:`(*, C \times r^2, H, W)` , and the output is of shape
+    :math:`(*, C, H \times r, W \times r)`, where r is an upscale factor and * is zero or more batch dimensions.
+
+    Note:
+        The dimension of input Tensor on Ascend should be less than 7.
+
+    Args:
+        upscale_factor (int): factor to shuffle the input, and is a positive integer.
+            `upscale_factor` is the above-mentioned :math:`r`.
+
+    Inputs:
+        - **input** (Tensor) - Tensor of shape :math:`(*, C \times r^2, H, W)` . The dimension of `x` is larger than 2,
+          and the length of third to last dimension can be divisible by `upscale_factor` squared.
+
+    Outputs:
+        - **output** (Tensor) - Tensor of shape :math:`(*, C, H \times r, W \times r)` .
+
+    Raises:
+        ValueError: If `upscale_factor` is not a positive integer.
+        ValueError: If the length of third to last dimension of `input` is not divisible by `upscale_factor` squared.
+        TypeError: If the dimension of `input` is less than 3.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> input_x = np.arange(3 * 2 * 8 * 4 * 4).reshape((3, 2, 8, 4, 4))
+        >>> input_x = mindspore.Tensor(input_x, mindspore.dtype.int32)
+        >>> pixel_shuffle = nn.PixelShuffle(2)
+        >>> output = pixel_shuffle(input_x)
+        >>> print(output.shape)
+        (3, 2, 2, 8, 8)
+    """
+    def __init__(self, upscale_factor):
+        super(PixelShuffle, self).__init__()
+        self.upscale_factor = upscale_factor
+
+    def construct(self, input):
+        return ops.pixel_shuffle(input, self.upscale_factor)
+
+
+class PixelUnshuffle(Cell):
+    r"""
+    Applies the PixelUnshuffle operation over input which is the inverse of PixelShuffle. For more details, refer
+    to `Real-Time Single Image and Video Super-Resolution Using an Efficient Sub-Pixel Convolutional Neural Network
+    <https://arxiv.org/abs/1609.05158>`_ .
+
+    Typically, the input is of shape :math:`(*, C, H \times r, W \times r)` , and the output is of shape
+    :math:`(*, C \times r^2, H, W)` , where r is a downscale factor and * is zero or more batch dimensions.
+
+    Args:
+        downscale_factor (int): factor to unshuffle the input, and is a positive integer.
+            `downscale_factor` is the above-mentioned :math:`r`.
+
+    Inputs:
+        - **input** (Tensor) - Tensor of shape :math:`(*, C, H \times r, W \times r)` . The dimension of `input` is
+          larger than 2, and the length of second to last dimension or last dimension can be divisible by
+          `downscale_factor` .
+
+    Outputs:
+        - **output** (Tensor) - Tensor of shape :math:`(*, C \times r^2, H, W)` .
+
+    Raises:
+        ValueError: If `downscale_factor` is not a positive integer.
+        ValueError: If the length of second to last dimension or last dimension is not divisible by `downscale_factor` .
+        TypeError: If the dimension of `input` is less than 3.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> pixel_unshuffle = nn.PixelUnshuffle(2)
+        >>> input_x = np.arange(8 * 8).reshape((1, 1, 8, 8))
+        >>> input_x = mindspore.Tensor(input_x, mindspore.dtype.int32)
+        >>> output = pixel_unshuffle(input_x)
+        >>> print(output.shape)
+        (1, 4, 4, 4)
+    """
+    def __init__(self, downscale_factor):
+        super(PixelUnshuffle, self).__init__()
+        self.downscale_factor = downscale_factor
+
+    def construct(self, input):
+        return ops.pixel_unshuffle(input, self.downscale_factor)