mindspore 2.5.0__cp310-cp310-win_amd64.whl → 2.6.0__cp310-cp310-win_amd64.whl

mindspore/dataset/vision/transforms.py

@@ -125,12 +125,12 @@ class AdjustBrightness(ImageTensorOperation, PyTensorOperation):
 
     Args:
         brightness_factor (float): How much to adjust the brightness, must be non negative.
-            ``0`` gives a black image, ``1`` gives the original image,
-            while ``2`` increases the brightness by a factor of 2.
+            ``0.0`` gives a black image, ``1.0`` gives the original image,
+            while ``2.0`` increases the brightness by a factor of 2.
 
     Raises:
         TypeError: If `brightness_factor` is not of type float.
-        ValueError: If `brightness_factor` is less than 0.
+        ValueError: If `brightness_factor` is less than ``0.0``.
         RuntimeError: If shape of the input image is not <H, W, C>.
 
     Supported Platforms:
@@ -173,15 +173,15 @@ class AdjustBrightness(ImageTensorOperation, PyTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input shape should be limited from [4, 6] to [8192, 4096].
+        When the device is Ascend, input shape should be limited from [4, 6] to [8192, 4096].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
+                ``"CPU"`` and ``"Ascend"`` . Default: ``"CPU"`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
+            ValueError: If `device_target` is not within the valid set of ["CPU", "Ascend"].
 
         Supported Platforms:
             ``CPU`` ``Ascend``
@@ -239,12 +239,12 @@ class AdjustContrast(ImageTensorOperation, PyTensorOperation):
 
     Args:
         contrast_factor (float): How much to adjust the contrast, must be non negative.
-            ``0`` gives a solid gray image, ``1`` gives the original image,
-            while ``2`` increases the contrast by a factor of 2.
+            ``0.0`` gives a solid gray image, ``1.0`` gives the original image,
+            while ``2.0`` increases the contrast by a factor of 2.
 
     Raises:
         TypeError: If `contrast_factor` is not of type float.
-        ValueError: If `contrast_factor` is less than 0.
+        ValueError: If `contrast_factor` is less than ``0.0``.
         RuntimeError: If shape of the input image is not <H, W, C>.
 
     Supported Platforms:
@@ -286,15 +286,15 @@ class AdjustContrast(ImageTensorOperation, PyTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input shape should be limited from [4, 6] to [8192, 4096].
+        When the device is Ascend, input shape should be limited from [4, 6] to [8192, 4096].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
+                ``"CPU"`` and ``"Ascend"`` . Default: ``"CPU"`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
+            ValueError: If `device_target` is not within the valid set of ["CPU", "Ascend"].
 
         Supported Platforms:
             ``CPU`` ``Ascend``
@@ -357,14 +357,14 @@ class AdjustGamma(ImageTensorOperation, PyTensorOperation):
     Args:
         gamma (float): Non negative real number.
             The output image pixel value is exponentially related to the input image pixel value.
-            gamma larger than 1 make the shadows darker,
-            while gamma smaller than 1 make dark regions lighter.
+            gamma larger than ``1.0`` make the shadows darker,
+            while gamma smaller than ``1.0`` make dark regions lighter.
         gain (float, optional): The constant multiplier. Default: ``1.0``.
 
     Raises:
         TypeError: If `gain` is not of type float.
         TypeError: If `gamma` is not of type float.
-        ValueError: If `gamma` is less than 0.
+        ValueError: If `gamma` is less than ``0.0``.
         RuntimeError: If given tensor shape is not <H, W> or <..., H, W, C>.
 
     Supported Platforms:
@@ -473,15 +473,15 @@ class AdjustHue(ImageTensorOperation, PyTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input shape should be limited from [4, 6] to [8192, 4096].
+        When the device is Ascend, input shape should be limited from [4, 6] to [8192, 4096].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
+                ``"CPU"`` and ``"Ascend"`` . Default: ``"CPU"`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
+            ValueError: If `device_target` is not within the valid set of ["CPU", "Ascend"].
 
         Supported Platforms:
             ``CPU`` ``Ascend``
@@ -538,12 +538,12 @@ class AdjustSaturation(ImageTensorOperation, PyTensorOperation):
 
     Args:
         saturation_factor (float): How much to adjust the saturation, must be non negative.
-            ``0`` gives a black image, ``1`` gives the original image
-            while ``2`` increases the saturation by a factor of 2.
+            ``0.0`` gives a black image, ``1.0`` gives the original image
+            while ``2.0`` increases the saturation by a factor of 2.
 
     Raises:
         TypeError: If `saturation_factor` is not of type float.
-        ValueError: If `saturation_factor` is less than 0.
+        ValueError: If `saturation_factor` is less than ``0.0``.
         RuntimeError: If shape of the input image is not <H, W, C>.
         RuntimeError: If channel of the input image is not 3.
 
@@ -586,15 +586,15 @@ class AdjustSaturation(ImageTensorOperation, PyTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input shape should be limited from [4, 6] to [8192, 4096].
+        When the device is Ascend, input shape should be limited from [4, 6] to [8192, 4096].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
+                ``"CPU"`` and ``"Ascend"`` . Default: ``"CPU"`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
+            ValueError: If `device_target` is not within the valid set of ["CPU", "Ascend"].
 
         Supported Platforms:
             ``CPU`` ``Ascend``
@@ -651,12 +651,12 @@ class AdjustSharpness(ImageTensorOperation):
 
     Args:
         sharpness_factor (float): How much to adjust the sharpness, must be
-            non negative. ``0`` gives a blurred image, ``1`` gives the
-            original image while ``2`` increases the sharpness by a factor of 2.
+            non negative. ``0.0`` gives a blurred image, ``1.0`` gives the
+            original image while ``2.0`` increases the sharpness by a factor of 2.
 
     Raises:
         TypeError: If `sharpness_factor` is not of type float.
-        ValueError: If `sharpness_factor` is less than 0.
+        ValueError: If `sharpness_factor` is less than ``0.0``.
         RuntimeError: If shape of the input image is not <H, W> or <H, W, C>.
 
     Supported Platforms:
@@ -700,16 +700,16 @@ class AdjustSharpness(ImageTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input type supports `uint8` or `float32` , input channel supports 1 and 3.
-          The input data has a height limit of [4, 8192] and a width limit of [6, 4096].
+        When the device is Ascend, input type supports `uint8` or `float32` , input channel supports 1 and 3.
+        The input data has a height limit of [4, 8192] and a width limit of [6, 4096].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
+                ``"CPU"`` and ``"Ascend"`` . Default: ``"CPU"`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
+            ValueError: If `device_target` is not within the valid set of ["CPU", "Ascend"].
 
         Supported Platforms:
             ``CPU`` ``Ascend``
@@ -754,13 +754,15 @@ class Affine(ImageTensorOperation):
     Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
 
     Args:
-        degrees (float): Rotation angle in degrees between -180 and 180, clockwise direction.
+        degrees (float): Rotation angle in degrees between ``-180`` and ``180``, clockwise direction.
         translate (Sequence[float, float]): The horizontal and vertical translations, must be a sequence of size 2
-            and value between -1 and 1.
+            and value between ``-1.0`` and ``1.0``.
         scale (float): Scaling factor, which must be positive.
-        shear (Union[float, Sequence[float, float]]): Shear angle value in degrees between -180 to 180.
-            If float is provided, shear along the x axis with this value, without shearing along the y axis;
-            If Sequence[float, float] is provided, shear along the x axis and y axis with these two values separately.
+        shear (Union[float, Sequence[float, float]]): Shear angle value in degrees between ``-180`` to ``180``.
+
+            - If float is provided, shear along the x axis with this value, without shearing along the y axis;
+            - If Sequence[float, float] is provided, shear along the x axis and y axis with these two values separately.
+
         resample (Inter, optional): Image interpolation method defined by :class:`~.vision.Inter` .
             Default: ``Inter.NEAREST``.
         fill_value (Union[int, tuple[int, int, int]], optional): Optional `fill_value` to fill the area
@@ -832,15 +834,15 @@ class Affine(ImageTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input shape should be limited from [4, 6] to [32768, 32768].
+        When the device is Ascend, input shape should be limited from [4, 6] to [32768, 32768].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
+                ``"CPU"`` and ``"Ascend"`` . Default: ``"CPU"`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
+            ValueError: If `device_target` is not within the valid set of ["CPU", "Ascend"].
 
         Supported Platforms:
             ``CPU`` ``Ascend``
@@ -904,9 +906,10 @@ class AutoAugment(ImageTensorOperation):
         interpolation (Inter, optional): Image interpolation method defined by :class:`~.vision.Inter` .
             Default: ``Inter.NEAREST``.
         fill_value (Union[int, tuple[int]], optional): Pixel fill value for the area outside the transformed image.
-            It can be an int or a 3-tuple. If it is a 3-tuple, it is used to fill R, G, B channels respectively.
-            If it is an integer, it is used for all RGB channels. The fill_value values must be in range [0, 255].
-            Default: ``0``.
+            It can be an int or a 3-tuple. Default: ``0``.
+            
+            - If it is a 3-tuple, it is used to fill R, G, B channels respectively.
+            - If it is an integer, it is used for all RGB channels. The fill_value values must be in range [0, 255].
 
     Raises:
         TypeError: If `policy` is not of type :class:`mindspore.dataset.vision.AutoAugmentPolicy` .
@@ -963,7 +966,8 @@ class AutoAugment(ImageTensorOperation):
 
 class AutoContrast(ImageTensorOperation, PyTensorOperation):
     """
-    Apply automatic contrast on input image. This operation calculates histogram of image, reassign cutoff percent
+    Automatically adjusts the contrast on the input image. This operation calculates histogram of image,
+    reassign cutoff percent
     of the lightest pixels from histogram to 255, and reassign cutoff percent of the darkest pixels from histogram to 0.
 
     Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
@@ -977,7 +981,7 @@ class AutoContrast(ImageTensorOperation, PyTensorOperation):
     Raises:
         TypeError: If `cutoff` is not of type float.
         TypeError: If `ignore` is not of type int or sequence.
-        ValueError: If `cutoff` is not in range [0, 50.0).
+        ValueError: If `cutoff` is not in range [0.0, 50.0).
         ValueError: If `ignore` is not in range [0, 255].
         RuntimeError: If given tensor shape is not <H, W> or <H, W, C>.
 
@@ -1026,17 +1030,17 @@ class AutoContrast(ImageTensorOperation, PyTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input type supports `uint8` or `float32` , input channel supports 1 and 3.
-          If the data type is float32, the expected input value is in the range [0, 1].
-          The input data has a height limit of [4, 8192] and a width limit of [6, 4096].
+        When the device is Ascend, input type supports `uint8` or `float32` , input channel supports 1 and 3.
+        If the data type is float32, the expected input value is in the range [0, 1].
+        The input data has a height limit of [4, 8192] and a width limit of [6, 4096].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
+                ``"CPU"`` and ``"Ascend"`` . Default: ``"CPU"`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
+            ValueError: If `device_target` is not within the valid set of ["CPU", "Ascend"].
 
         Supported Platforms:
             ``CPU`` ``Ascend``
@@ -1343,16 +1347,16 @@ class ConvertColor(ImageTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input type only supports `uint8` , input channel supports 1 and 3.
-          The input data has a height limit of [4, 8192] and a width limit of [6, 4096].
+        When the device is Ascend, input type only supports `uint8` , input channel supports 1 and 3.
+        The input data has a height limit of [4, 8192] and a width limit of [6, 4096].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
+                ``"CPU"`` and ``"Ascend"`` . Default: ``"CPU"`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
+            ValueError: If `device_target` is not within the valid set of ["CPU", "Ascend"].
 
         Supported Platforms:
             ``CPU`` ``Ascend``
@@ -1399,8 +1403,10 @@ class Crop(ImageTensorOperation):
         coordinates(sequence): Coordinates of the upper left corner of the cropping image. Must be a sequence of two
             values, in the form of (top, left).
         size (Union[int, sequence]): The output size of the cropped image.
-            If size is an integer, a square crop of size (size, size) is returned.
-            If size is a sequence of length 2, it should be (height, width).
+
+            - If size is an integer, a square crop of size (size, size) is returned.
+            - If size is a sequence of length 2, it should be (height, width).
+
             The size value(s) must be larger than 0.
 
     Raises:
@@ -1454,15 +1460,15 @@ class Crop(ImageTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input/output shape should be limited from [4, 6] to [32768, 32768].
+        When the device is Ascend, input/output shape should be limited from [4, 6] to [32768, 32768].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
+                ``"CPU"`` and ``"Ascend"`` . Default: ``"CPU"`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
+            ValueError: If `device_target` is not within the valid set of ["CPU", "Ascend"].
 
         Supported Platforms:
             ``CPU`` ``Ascend``
@@ -1735,13 +1741,15 @@ class Decode(ImageTensorOperation, PyTensorOperation):
         """
         Set the device for the current operator execution.
 
+        When the device is Ascend, input type only supports `uint8`. 
+
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
+                ``"CPU"`` and ``"Ascend"`` . Default: ``"CPU"`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
+            ValueError: If `device_target` is not within the valid set of ["CPU", "Ascend"].
 
         Supported Platforms:
             ``CPU`` ``Ascend``
@@ -1918,16 +1926,16 @@ class Equalize(ImageTensorOperation, PyTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input type only supports `uint8` , input channel supports 1 and 3.
-          The input data has a height limit of [4, 8192] and a width limit of [6, 4096].
+        When the device is Ascend, input type only supports `uint8` , input channel supports 1 and 3.
+        The input data has a height limit of [4, 8192] and a width limit of [6, 4096].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
+                ``"CPU"`` and ``"Ascend"`` . Default: ``"CPU"`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
+            ValueError: If `device_target` is not within the valid set of ["CPU", "Ascend"].
 
         Supported Platforms:
             ``CPU`` ``Ascend``
@@ -1979,7 +1987,7 @@ class Equalize(ImageTensorOperation, PyTensorOperation):
 
 class Erase(ImageTensorOperation):
     """
-    Erase the input image with given value.
+    Erase a specified area of the input image and fills it with the specified pixel value `value`.
 
     Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
 
@@ -1989,8 +1997,11 @@ class Erase(ImageTensorOperation):
         height (int): Height of erased region.
         width (int): Width of erased region.
         value (Union[float, Sequence[float, float, float]], optional): Pixel value used to pad the erased area.
-            Default: ``0``. If float is provided, it will be used for all RGB channels.
-            If Sequence[float, float, float] is provided, it will be used for R, G, B channels respectively.
+            Default: ``0.0``.
+
+            - If float is provided, it will be used for all RGB channels.
+            - If Sequence[float, float, float] is provided, it will be used for R, G, B channels respectively.
+
         inplace (bool, optional): Whether to apply erasing inplace. Default: ``False``.
 
     Raises:
@@ -2037,7 +2048,7 @@ class Erase(ImageTensorOperation):
     """
 
     @check_erase
-    def __init__(self, top, left, height, width, value=0, inplace=False):
+    def __init__(self, top, left, height, width, value=0.0, inplace=False):
         super().__init__()
         self.top = top
         self.left = left
@@ -2053,17 +2064,17 @@ class Erase(ImageTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input type supports `uint8` or `float32` , input channel supports 1 and 3.
-          The input data has a height limit of [4, 8192] and a width limit of [6, 4096].
-          The inplace parameter is not supported.
+        When the device is Ascend, input type supports `uint8` or `float32` , input channel supports 1 and 3.
+        The input data has a height limit of [4, 8192] and a width limit of [6, 4096].
+        The inplace parameter is not supported.
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
+                ``"CPU"`` and ``"Ascend"`` . Default: ``"CPU"`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
+            ValueError: If `device_target` is not within the valid set of ["CPU", "Ascend"].
 
         Supported Platforms:
             ``CPU`` ``Ascend``
@@ -2203,15 +2214,19 @@ class GaussianBlur(ImageTensorOperation):
 
     Args:
         kernel_size (Union[int, Sequence[int, int]]): The size of the Gaussian kernel. Must be positive and odd.
-            If the input type is int, the value will be used as both the width and height of the Gaussian kernel.
-            If the input type is Sequence[int, int], the two elements will be used as the width and height of the
-            Gaussian kernel respectively.
+
+            - If the input type is int, the value will be used as both the width and height of the Gaussian kernel.
+            - If the input type is Sequence[int, int], the two elements will be used as the width and height of the
+              Gaussian kernel respectively.
+
         sigma (Union[float, Sequence[float, float]], optional): The standard deviation of the Gaussian kernel.
             Must be positive.
-            If the input type is float, the value will be used as the standard deviation of both the width and
-            height of the Gaussian kernel.
-            If the input type is Sequence[float, float], the two elements will be used as the standard deviation
-            of the width and height of the Gaussian kernel respectively.
+
+            - If the input type is float, the value will be used as the standard deviation of both the width and
+              height of the Gaussian kernel.
+            - If the input type is Sequence[float, float], the two elements will be used as the standard deviation
+              of the width and height of the Gaussian kernel respectively.
+
             Default: ``None`` , the standard deviation of the Gaussian kernel will be obtained by the
             formula :math:`((kernel\_size - 1) * 0.5 - 1) * 0.3 + 0.8` .
 
@@ -2269,16 +2284,16 @@ class GaussianBlur(ImageTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, the parameter `kernel_size` only supports values 1, 3, and 5.
-          input shape should be limited from [4, 6] to [8192, 4096].
+        When the device is Ascend, the parameter `kernel_size` only supports values 1, 3, and 5.
+        input shape should be limited from [4, 6] to [8192, 4096].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
+                ``"CPU"`` and ``"Ascend"`` . Default: ``"CPU"`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
+            ValueError: If `device_target` is not within the valid set of ["CPU", "Ascend"].
 
         Supported Platforms:
             ``CPU`` ``Ascend``
@@ -2456,17 +2471,17 @@ class HorizontalFlip(ImageTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input type supports  `uint8` and `float32`,
-          input channel supports 1 and 3. The input data has a height limit of [4, 8192]
-          and a width limit of [6, 4096].
+        When the device is Ascend, input type supports  `uint8` and `float32`,
+        input channel supports 1 and 3. The input data has a height limit of [4, 8192]
+        and a width limit of [6, 4096].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
+                ``"CPU"`` and ``"Ascend"`` . Default: ``"CPU"`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
+            ValueError: If `device_target` is not within the valid set of ["CPU", "Ascend"].
 
         Supported Platforms:
             ``CPU`` ``Ascend``
@@ -2670,9 +2685,8 @@ class Invert(ImageTensorOperation, PyTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is CPU, input type only support `uint8` , input channel support 1/2/3.
-        - When the device is Ascend, input type supports  `uint8`/`float32`, input channel supports 1/3.
-          input shape should be limited from [4, 6] to [8192, 4096].
+        When the device is Ascend, input type supports  `uint8`/`float32`, input channel supports 1/3.
+        input shape should be limited from [4, 6] to [8192, 4096].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
@@ -3057,11 +3071,11 @@ class Normalize(ImageTensorOperation):
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
+                ``"CPU"`` and ``"Ascend"`` . Default: ``"CPU"`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
+            ValueError: If `device_target` is not within the valid set of ["CPU", "Ascend"].
 
         Supported Platforms:
             ``CPU`` ``Ascend``
@@ -3113,7 +3127,7 @@ class NormalizePad(ImageTensorOperation):
             The standard deviation values must be in range (0.0, 255.0].
         dtype (str, optional): Set the output data type of normalized image. Default: ``"float32"``.
         is_hwc (bool, optional): Specify the format of input image.
-            ``True`` - HW(C) format, ``False`` - CHW format. Default: ``True``.
+            ``True`` - HWC format, ``False`` - CHW format. Default: ``True``.
 
     Raises:
         TypeError: If `mean` is not of type sequence.
@@ -3175,14 +3189,20 @@ class Pad(ImageTensorOperation, PyTensorOperation):
     Args:
         padding (Union[int, Sequence[int, int], Sequence[int, int, int, int]]): The number of pixels
             to pad each border of the image.
-            If a single number is provided, it pads all borders with this value.
-            If a tuple or lists of 2 values are provided, it pads the (left and right)
-            with the first value and (top and bottom) with the second value.
-            If 4 values are provided as a list or tuple, it pads the left, top, right and bottom respectively.
+
+            - If a single number is provided, it pads all borders with this value.
+            - If a tuple or lists of 2 values are provided, it pads the (left and right)
+              with the first value and (top and bottom) with the second value.
+            - If 4 values are provided as a list or tuple, it pads the left, top, right and bottom respectively.
+
             The pad values must be non-negative.
+
         fill_value (Union[int, tuple[int]], optional): The pixel intensity of the borders, only valid for
-            `padding_mode` ``Border.CONSTANT``. If it is a 3-tuple, it is used to fill R, G, B channels respectively.
-            If it is an integer, it is used for all RGB channels.
+            `padding_mode` ``Border.CONSTANT``.
+            
+            - If it is a 3-tuple, it is used to fill R, G, B channels respectively.
+            - If it is an integer, it is used for all RGB channels.
+
             The fill_value values must be in range [0, 255]. Default: ``0``.
         padding_mode (Border, optional): The method of padding. Default: ``Border.CONSTANT``. Can be
             ``Border.CONSTANT``, ``Border.EDGE``, ``Border.REFLECT``, ``Border.SYMMETRIC``.
@@ -3250,15 +3270,15 @@ class Pad(ImageTensorOperation, PyTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input/output shape should be limited from [4, 6] to [32768, 32768].
+        When the device is Ascend, input/output shape should be limited from [4, 6] to [32768, 32768].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
+                ``"CPU"`` and ``"Ascend"`` . Default: ``"CPU"`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
+            ValueError: If `device_target` is not within the valid set of ["CPU", "Ascend"].
 
         Supported Platforms:
             ``CPU`` ``Ascend``
@@ -3403,6 +3423,9 @@ class Perspective(ImageTensorOperation, PyTensorOperation):
         interpolation (Inter, optional): Image interpolation method defined by :class:`~.vision.Inter` .
             Default: ``Inter.BILINEAR``.
 
+            - Ascend Mode: Only ``Inter.LINEAR`` and ``Inter.NEAREST`` interpolation methods are supported
+              when the device is set to Ascend by `.device("Ascend")` .
+
     Raises:
         TypeError: If `start_points` is not of type Sequence[Sequence[int, int]].
         TypeError: If `end_points` is not of type Sequence[Sequence[int, int]].
@@ -3461,17 +3484,17 @@ class Perspective(ImageTensorOperation, PyTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input type supports `uint8` and `float32`,
-          input channel supports 1 and 3. The input data has a height limit of [6, 8192]
-          and a width limit of [10, 4096].
+        When the device is Ascend, input type supports `uint8` and `float32`,
+        input channel supports 1 and 3. The input data has a height limit of [6, 8192]
+        and a width limit of [10, 4096].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
+                ``"CPU"`` and ``"Ascend"`` . Default: ``"CPU"`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
+            ValueError: If `device_target` is not within the valid set of ["CPU", "Ascend"].
 
         Supported Platforms:
             ``CPU`` ``Ascend``
@@ -3585,16 +3608,16 @@ class Posterize(ImageTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input type supports  `uint8`/`float32`, input channel supports 1 and 3.
-          The input data has a height limit of [4, 8192] and a width limit of [6, 4096].
+        When the device is Ascend, input type supports  `uint8`/`float32`, input channel supports 1 and 3.
+        The input data has a height limit of [4, 8192] and a width limit of [6, 4096].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
+                ``"CPU"`` and ``"Ascend"`` . Default: ``"CPU"`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
+            ValueError: If `device_target` is not within the valid set of ["CPU", "Ascend"].
 
         Supported Platforms:
             ``CPU`` ``Ascend``
@@ -3779,26 +3802,30 @@ class RandomAffine(ImageTensorOperation, PyTensorOperation):
             If `degrees` is a number, the range will be (-degrees, degrees).
             If `degrees` is a sequence, it should be (min, max).
         translate (sequence, optional): Sequence (tx_min, tx_max, ty_min, ty_max) of minimum/maximum translation in
-            x(horizontal) and y(vertical) directions, range [-1.0, 1.0]. Default: ``None``.
+            x(horizontal) and y(vertical) directions, range [-1.0, 1.0].
+            Default: ``None``, which means no translation is applied.
             The horizontal and vertical shift is selected randomly from the range:
             (tx_min*width, tx_max*width) and (ty_min*height, ty_max*height), respectively.
-            If a tuple or list of size 2, then a translate parallel to the X axis in the range of
-            (translate[0], translate[1]) is applied.
-            If a tuple or list of size 4, then a translate parallel to the X axis in the range of
-            (translate[0], translate[1]) and a translate parallel to the Y axis in the range of
-            (translate[2], translate[3]) are applied.
-            If ``None``, no translation is applied.
+
+            - If a tuple or list of size 2, then a translate parallel to the X axis in the range of
+              (translate[0], translate[1]) is applied.
+            - If a tuple or list of size 4, then a translate parallel to the X axis in the range of
+              (translate[0], translate[1]) and a translate parallel to the Y axis in the range of
+              (translate[2], translate[3]) are applied.
+
         scale (sequence, optional): Scaling factor interval, which must be non negative.
             Default: ``None``, original scale is used.
         shear (Union[float, Sequence[float, float], Sequence[float, float, float, float]], optional):
-            Range of shear factor to select from.
-            If float is provided, a shearing parallel to X axis with a factor selected from
-            ( `-shear` , `shear` ) will be applied.
-            If Sequence[float, float] is provided, a shearing parallel to X axis with a factor selected
-            from ( `shear` [0], `shear` [1]) will be applied.
-            If Sequence[float, float, float, float] is provided, a shearing parallel to X axis with a factor selected
-            from ( `shear` [0], `shear` [1]) and a shearing parallel to Y axis with a factor selected from
-            ( `shear` [2], `shear` [3]) will be applied. Default: ``None``, means no shearing.
+            Range of shear factor to select from. Default: ``None``, means no shearing.
+
+            - If float is provided, a shearing parallel to X axis with a factor selected from
+              ( `-shear` , `shear` ) will be applied.
+            - If Sequence[float, float] is provided, a shearing parallel to X axis with a factor selected
+              from ( `shear` [0], `shear` [1]) will be applied.
+            - If Sequence[float, float, float, float] is provided, a shearing parallel to X axis with a factor selected
+              from ( `shear` [0], `shear` [1]) and a shearing parallel to Y axis with a factor selected from
+              ( `shear` [2], `shear` [3]) will be applied.
+
         resample (Inter, optional): Image interpolation method defined by :class:`~.vision.Inter` .
             Default: ``Inter.NEAREST``.
         fill_value (Union[int, tuple[int]], optional): Optional fill_value to fill the area outside the transform
@@ -4172,22 +4199,28 @@ class RandomCrop(ImageTensorOperation, PyTensorOperation):
 
     Args:
         size (Union[int, Sequence[int]]): The output size of the cropped image. The size value(s) must be positive.
-            If size is an integer, a square crop of size (size, size) is returned.
-            If size is a sequence of length 2, an image of size (height, width) will be cropped.
+
+            - If size is an integer, a square crop of size (size, size) is returned.
+            - If size is a sequence of length 2, an image of size (height, width) will be cropped.
+
         padding (Union[int, Sequence[int]], optional): The number of pixels to pad each border of the image.
             The padding value(s) must be non-negative. Default: ``None``.
-            If `padding` is not ``None``, pad image first with padding values.
-            If a single number is provided, pad all borders with this value.
-            If a tuple or lists of 2 values are provided, pad the (left and right)
-            with the first value and (top and bottom) with the second value.
-            If 4 values are provided as a list or tuple,
-            pad the left, top, right and bottom respectively.
+
+            - If `padding` is not ``None``, pad image first with padding values.
+            - If a single number is provided, pad all borders with this value.
+            - If a tuple or lists of 2 values are provided, pad the (left and right)
+              with the first value and (top and bottom) with the second value.
+            - If 4 values are provided as a list or tuple,
+              pad the left, top, right and bottom respectively.
+
         pad_if_needed (bool, optional): Pad the image if either side is smaller than
             the given output size. Default: ``False``.
         fill_value (Union[int, tuple[int]], optional): The pixel intensity of the borders, only valid for
-            padding_mode Border.CONSTANT. If it is a 3-tuple, it is used to fill R, G, B channels respectively.
-            If it is an integer, it is used for all RGB channels.
-            The fill_value values must be in range [0, 255]. Default: ``0``.
+            padding_mode Border.CONSTANT. The fill_value values must be in range [0, 255]. Default: ``0``.
+
+            - If it is a 3-tuple, it is used to fill R, G, B channels respectively.
+            - If it is an integer, it is used for all RGB channels.
+
         padding_mode (Border, optional): The method of padding. Default: ``Border.CONSTANT``. It can be any of
             ``Border.CONSTANT``, ``Border.EDGE``, ``Border.REFLECT``, ``Border.SYMMETRIC``.
 
@@ -5352,7 +5385,7 @@ class RandomResizedCropWithBBox(ImageTensorOperation):
 
 class RandomResize(ImageTensorOperation):
     """
-    Resize the input image using :class:`~.vision.Inter` , a randomly selected interpolation mode.
+    Resize the input image using a randomly selected :class:`mindspore.dataset.vision.Inter` interpolation method.
 
     Args:
         size (Union[int, Sequence[int]]): The output size of the resized image. The size value(s) must be positive.
@@ -5996,9 +6029,18 @@ class Resize(ImageTensorOperation, PyTensorOperation):
             If size is an integer, the smaller edge of the image will be resized to this value with
             the same image aspect ratio.
             If size is a sequence of length 2, it should be (height, width).
+
+            - CPU mode: If the execution device is CPU by ``.device("CPU")`` , the range of size is [1, 16777216].
+
+            - Ascend mode: set the executing device to Ascend by ``.device("Ascend")`` , the value of size will be in
+              the range of [6, 32768].
+
         interpolation (Inter, optional): Image interpolation method defined by :class:`~.vision.Inter` .
             Default: ``Inter.LINEAR``.
 
+            - Ascend mode: ``Inter.ANTIALIAS`` , ``Inter.AREA`` , ``Inter.PILCUBIC`` interpolation methods are not
+              supported when the execution device is set to Ascend by ``.device("Ascend")`` .
+
     Raises:
         TypeError: If `size` is not of type int or Sequence[int].
         TypeError: If `interpolation` is not of type :class:`~.vision.Inter` .
@@ -6055,15 +6097,15 @@ class Resize(ImageTensorOperation, PyTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input/output shape should be limited from [4, 6] to [32768, 32768].
+        When the device is Ascend, input/output shape should be limited from [4, 6] to [32768, 32768].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
+                ``"CPU"`` and ``"Ascend"`` . Default: ``"CPU"`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
+            ValueError: If `device_target` is not within the valid set of ["CPU", "Ascend"].
 
         Supported Platforms:
             ``CPU`` ``Ascend``
@@ -6132,9 +6174,11 @@ class ResizedCrop(ImageTensorOperation):
         height (int): Height of the crop region.
         width (int): Width of the cropp region.
         size (Union[int, Sequence[int, int]]): The size of the output image.
-            If int is provided, the smaller edge of the image will be resized to this value,
-            keeping the image aspect ratio the same.
-            If Sequence[int, int] is provided, it should be (height, width).
+
+            - If int is provided, the smaller edge of the image will be resized to this value,
+              keeping the image aspect ratio the same.
+            - If Sequence[int, int] is provided, it should be (height, width).
+
         interpolation (Inter, optional): Image interpolation method defined by :class:`~.vision.Inter` .
             Default: ``Inter.BILINEAR``.
 
@@ -6201,17 +6245,17 @@ class ResizedCrop(ImageTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input type supports `uint8` and `float32`,
-          input channel supports 1 and 3. The input data has a height limit of [4, 32768]
-          and a width limit of [6, 32768].
+        When the device is Ascend, input type supports `uint8` and `float32`,
+        input channel supports 1 and 3. The input data has a height limit of [4, 32768]
+        and a width limit of [6, 32768].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
+                ``"CPU"`` and ``"Ascend"`` . Default: ``"CPU"`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
+            ValueError: If `device_target` is not within the valid set of ["CPU", "Ascend"].
 
         Supported Platforms:
             ``CPU`` ``Ascend``
@@ -6478,11 +6522,11 @@ class Rotate(ImageTensorOperation):
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
+                ``"CPU"`` and ``"Ascend"`` . Default: ``"CPU"`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
+            ValueError: If `device_target` is not within the valid set of ["CPU", "Ascend"].
 
         Supported Platforms:
             ``CPU`` ``Ascend``
@@ -6660,8 +6704,8 @@ class Solarize(ImageTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input type only supports `uint8` , input channel supports 1 and 3.
-          The input data has a height limit of [4, 8192] and a width limit of [6, 4096].
+        When the device is Ascend, input type only supports `uint8` , input channel supports 1 and 3.
+        The input data has a height limit of [4, 8192] and a width limit of [6, 4096].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
@@ -7238,9 +7282,9 @@ class VerticalFlip(ImageTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input type supports `uint8` and `float32`,
-          input channel supports 1 and 3. The input data has a height limit of [4, 8192]
-          and a width limit of [6, 4096].
+        When the device is Ascend, input type supports `uint8` and `float32`,
+        input channel supports 1 and 3. The input data has a height limit of [4, 8192]
+        and a width limit of [6, 4096].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports