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

mindspore/dataset/vision/utils.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2022 Huawei Technologies Co., Ltd
+# Copyright 2019-2024 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,6 +15,7 @@
 Interpolation Mode, Resampling Filters
 """
 from enum import Enum, IntEnum
+from fractions import Fraction
 import numbers
 
 import numpy as np
@@ -127,7 +128,10 @@ class AutoAugmentPolicy(str, Enum):
                     AutoAugmentPolicy.CIFAR10: cde.AutoAugmentPolicy.DE_AUTO_AUGMENT_POLICY_CIFAR10,
                     AutoAugmentPolicy.SVHN: cde.AutoAugmentPolicy.DE_AUTO_AUGMENT_POLICY_SVHN}
 
-        return c_values.get(policy)
+        value = c_values.get(policy)
+        if value is None:
+            raise RuntimeError("Unsupported AutoAugmentPolicy, only support IMAGENET, CIFAR10, and SVHN.")
+        return value
 
 
 class Border(str, Enum):
@@ -160,7 +164,11 @@ class Border(str, Enum):
                          Border.EDGE: 'edge',
                          Border.REFLECT: 'reflect',
                          Border.SYMMETRIC: 'symmetric'}
-        return python_values.get(border_type)
+
+        value = python_values.get(border_type)
+        if value is None:
+            raise RuntimeError("Unsupported Border type, only support CONSTANT, EDGE, REFLECT and SYMMETRIC.")
+        return value
 
     @staticmethod
     def to_c_type(border_type):
@@ -172,7 +180,10 @@ class Border(str, Enum):
                     Border.REFLECT: cde.BorderType.DE_BORDER_REFLECT,
                     Border.SYMMETRIC: cde.BorderType.DE_BORDER_SYMMETRIC}
 
-        return c_values.get(border_type)
+        value = c_values.get(border_type)
+        if value is None:
+            raise RuntimeError("Unsupported Border type, only support CONSTANT, EDGE, REFLECT and SYMMETRIC.")
+        return value
 
 
 class ConvertMode(IntEnum):
@@ -250,7 +261,11 @@ class ConvertMode(IntEnum):
                     ConvertMode.COLOR_RGBA2GRAY: cde.ConvertMode.DE_COLOR_RGBA2GRAY,
                     }
 
-        return c_values.get(mode)
+        mode = c_values.get(mode)
+        if mode is None:
+            raise RuntimeError("Unsupported ConvertMode, see https://www.mindspore.cn/docs/en/master/api_python/"
+                               "dataset_vision/mindspore.dataset.vision.ConvertColor.html for more details.")
+        return mode
 
 
 class ImageBatchFormat(IntEnum):
@@ -273,7 +288,10 @@ class ImageBatchFormat(IntEnum):
         c_values = {ImageBatchFormat.NHWC: cde.ImageBatchFormat.DE_IMAGE_BATCH_FORMAT_NHWC,
                     ImageBatchFormat.NCHW: cde.ImageBatchFormat.DE_IMAGE_BATCH_FORMAT_NCHW}
 
-        return c_values.get(image_batch_format)
+        value = c_values.get(image_batch_format)
+        if value is None:
+            raise RuntimeError("Unsupported ImageBatchFormat, only support NHWC and NCHW.")
+        return value
 
 
 class ImageReadMode(IntEnum):
@@ -298,7 +316,11 @@ class ImageReadMode(IntEnum):
         c_values = {ImageReadMode.UNCHANGED: cde.ImageReadMode.DE_IMAGE_READ_MODE_UNCHANGED,
                     ImageReadMode.GRAYSCALE: cde.ImageReadMode.DE_IMAGE_READ_MODE_GRAYSCALE,
                     ImageReadMode.COLOR: cde.ImageReadMode.DE_IMAGE_READ_MODE_COLOR}
-        return c_values.get(image_read_mode)
+
+        value = c_values.get(image_read_mode)
+        if value is None:
+            raise RuntimeError("Unsupported ImageReadMode, only support UNCHANGED, GRAYSCALE and COLOR.")
+        return value
 
 
 class Inter(IntEnum):
@@ -334,7 +356,10 @@ class Inter(IntEnum):
                          Inter.LINEAR: LINEAR,
                          Inter.CUBIC: CUBIC}
 
-        return python_values.get(inter_type)
+        value = python_values.get(inter_type)
+        if value is None:
+            raise RuntimeError("Unsupported interpolation, only support NEAREST, ANTIALIAS, LINEAR and CUBIC.")
+        return value
 
     @staticmethod
     def to_c_type(inter_type):
@@ -347,7 +372,11 @@ class Inter(IntEnum):
                     Inter.AREA: cde.InterpolationMode.DE_INTER_AREA,
                     Inter.PILCUBIC: cde.InterpolationMode.DE_INTER_PILCUBIC}
 
-        return c_values.get(inter_type)
+        value = c_values.get(inter_type)
+        if value is None:
+            raise RuntimeError("Unsupported interpolation, only support NEAREST, LINEAR, CUBIC, AREA and PILCUBIC.")
+
+        return value
 
 
 class SliceMode(IntEnum):
@@ -370,7 +399,10 @@ class SliceMode(IntEnum):
         c_values = {SliceMode.PAD: cde.SliceMode.DE_SLICE_PAD,
                     SliceMode.DROP: cde.SliceMode.DE_SLICE_DROP}
 
-        return c_values.get(mode)
+        value = c_values.get(mode)
+        if value is None:
+            raise RuntimeError("Unsupported SliceMode, only support PAD and DROP.")
+        return value
 
 
 def encode_jpeg(image, quality=75):
@@ -595,6 +627,125 @@ def read_image(filename, mode=ImageReadMode.UNCHANGED):
     return cde.read_image(filename, ImageReadMode.to_c_type(mode)).as_array()
 
 
+def read_video(filename, start_pts=0, end_pts=None, pts_unit="pts"):
+    """
+    Read the video, audio, metadata from a video file.
+
+    It supports AVI, H264, H265, MOV, MP4, WMV file formats.
+
+    Args:
+        filename(str): The path to the video file to be read.
+        start_pts(Union[float, Fraction, int], optional): The start presentation timestamp of the video. Default: 0.
+        end_pts(Union[float, Fraction, int], optional): The end presentation timestamp of the video. Default: None.
+            The None is represented by 2147483647.
+        pts_unit(str, optional): The unit of the timestamps. It can be any of ["pts", "sec"]. Default: "pts".
+
+    Returns:
+        - numpy.ndarray, four dimensions uint8 data for video. The format is [T, H, W, C]. `T` is the number of frames,
+          `H` is the height, `W` is the width, `C` is the channel for RGB.
+        - numpy.ndarray, two dimensions float for audio. The format is [C, L]. `C` is the number of channels.
+          `L` is the length of the points in one channel.
+        - dict, metadata for the video and audio.
+          It contains video_fps data of type float and audio_fps data of type int.
+
+    Raises:
+        TypeError: If `filename` is not of type str.
+        TypeError: If `start_pts` is not of type [float, Fraction, int].
+        TypeError: If `end_pts` is not of type [float, Fraction, int].
+        TypeError: If `pts_unit` is not of type str.
+        RuntimeError: If `filename` does not exist, or not a regular file, or not a supported video file.
+        ValueError: If `start_pts` is less than 0.
+        ValueError: If `end_pts` is less than `start_pts`.
+        ValueError: If `pts_unit` is not in ["pts", "sec"].
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> import mindspore.dataset.vision as vision
+        >>> video_output, audio_output, metadata_output = vision.read_video("/path/to/file")
+    """
+    if not isinstance(filename, str):
+        raise TypeError("Input filename is not of type {0}, but got: {1}.".format(str, type(filename)))
+    if not isinstance(start_pts, (float, Fraction, int)):
+        raise TypeError("Input start_pts is not of type [{0}, {1}, {2}], but got: {3}".format(float, Fraction, int,
+                                                                                              type(start_pts)))
+    if start_pts < 0.0:
+        err_msg = "Not supported start_pts for " + str(start_pts) + ". The start_pts should be >= 0."
+        raise ValueError(err_msg)
+    if end_pts is None:
+        end_pts = 2147483647.0
+    if not isinstance(end_pts, (float, Fraction, int)):
+        raise TypeError("Input end_pts is not of type [{0}, {1}, {2}], but got: {3}".format(float, Fraction, int,
+                                                                                            type(end_pts)))
+    if end_pts < start_pts:
+        err_msg = "Not supported end_pts for " + str(end_pts) + ". start_pts = " + str(start_pts) + "."
+        err_msg += " The end_pts should be >= start_pts."
+        raise ValueError(err_msg)
+    if not isinstance(pts_unit, str):
+        raise TypeError("Input pts_unit is not of type {0}, but got: {1}.".format(str, type(pts_unit)))
+    if pts_unit not in ["pts", "sec"]:
+        raise ValueError("Not supported pts_unit for " + pts_unit)
+
+    video_output, audio_output, raw_metadata = cde.read_video(filename, float(start_pts), float(end_pts), pts_unit)
+
+    if video_output is not None:
+        video_output = video_output.as_array()
+    if audio_output is not None:
+        audio_output = audio_output.as_array()
+    metadata_output = {}
+    for key in raw_metadata:
+        if key == "video_fps":
+            metadata_output[key] = float(raw_metadata[key])
+            continue
+        if key == "audio_fps":
+            metadata_output[key] = int(raw_metadata[key])
+            continue
+        metadata_output[key] = raw_metadata[key]
+    return video_output, audio_output, metadata_output
+
+
+def read_video_timestamps(filename, pts_unit="pts"):
+    """
+    Read the timestamps and frames per second of a video file.
+    It supports AVI, H264, H265, MOV, MP4, WMV files.
+
+    Args:
+        filename(str): The path to the video file to be read.
+        pts_unit(str, optional): The unit of the timestamps. It can be any of ["pts", "sec"]. Default: "pts".
+
+    Returns:
+        - list, when `pts_unit` is set to "pts", list[int] is returned, when `pts_unit` is set to "sec",
+          list[float] is returned.
+        - float, the frames per second of the video file.
+
+    Raises:
+        TypeError: If `filename` is not of type str.
+        TypeError: If `pts_unit` is not of type str.
+        RuntimeError: If `filename` does not exist, or not a regular file, or not a supported video file.
+        RuntimeError: If `pts_unit` is not in ["pts", "sec"].
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> import mindspore.dataset.vision as vision
+        >>> video_timestamps, video_fps = vision.read_video_timestamps("/path/to/file")
+    """
+    if not isinstance(filename, str):
+        raise TypeError("Input filename is not of type {0}, but got: {1}.".format(str, type(filename)))
+    if not isinstance(pts_unit, str):
+        raise TypeError("Input pts_unit is not of type {0}, but got: {1}.".format(str, type(pts_unit)))
+
+    video_pts, video_fps, time_base = cde.read_video_timestamps(filename, pts_unit)
+
+    if video_pts == []:
+        return video_pts, None
+    if pts_unit == "pts":
+        return video_pts, video_fps
+    return [x * time_base for x in video_pts], video_fps
+
+
 def write_file(filename, data):
     """
     Write the one dimension uint8 data into a file using binary mode.

mindspore/dataset/vision/validators.py

@@ -24,7 +24,7 @@ from mindspore.dataset.core.validator_helpers import check_value, check_uint8, F
     check_pos_float32, check_float32, check_2tuple, check_range, check_positive, INT32_MAX, INT32_MIN, \
     parse_user_args, type_check, type_check_list, check_c_tensor_op, UINT8_MAX, UINT8_MIN, check_value_normalize_std, \
     check_value_cutoff, check_value_ratio, check_odd, check_non_negative_float32, check_non_negative_int32, \
-    check_pos_int32, check_int32, check_tensor_op, deprecator_factory, check_valid_str
+    check_pos_int32, check_int32, check_tensor_op, deprecator_factory, check_valid_str, check_independent_mode
 from mindspore.dataset.transforms.validators import check_transform_op_type
 from .utils import Inter, Border, ImageBatchFormat, ConvertMode, SliceMode, AutoAugmentPolicy
 
@@ -36,7 +36,7 @@ def check_affine(method):
         [degrees, translate, scale, shear, resample, fill_value], _ = parse_user_args(method, *args, **kwargs)
 
         type_check(degrees, (int, float), "degrees")
-        check_degrees(degrees)
+        check_value(degrees, [-180, 180], "degrees")
 
         type_check(translate, (list, tuple), "translate")
         if len(translate) != 2:
@@ -54,6 +54,9 @@ def check_affine(method):
                 raise TypeError("The length of shear should be 2.")
             for i, _ in enumerate(shear):
                 type_check(shear[i], (int, float), "shear[{}]".format(i))
+                check_value(shear[i], [-180, 180], "shear[{}]".format(i))
+        else:
+            check_value(shear, [-180, 180], "shear")
 
         type_check(resample, (Inter,), "resample")
 
@@ -182,6 +185,7 @@ def check_padding(padding):
     """Parsing the padding arguments and check if it is legal."""
     type_check(padding, (tuple, list, numbers.Number), "padding")
     if isinstance(padding, numbers.Number):
+        type_check(padding, (int,), "padding")
         check_value(padding, (0, INT32_MAX), "padding")
     if isinstance(padding, (tuple, list)):
         if len(padding) not in (2, 4):
@@ -282,7 +286,15 @@ def check_erase(method):
         check_pos_int32(height, "height")
         check_pos_int32(width, "width")
         type_check(inplace, (bool,), "inplace")
-        check_fill_value(value)
+        type_check(value, (float, int, tuple), "value")
+        if isinstance(value, (float, int)):
+            value = tuple([value] * 3)
+        type_check_list(value, (float, int), "value")
+        if isinstance(value, tuple) and len(value) == 3:
+            for i, val in enumerate(value):
+                check_value(val, (UINT8_MIN, UINT8_MAX), "value[{}]".format(i))
+        else:
+            raise TypeError("value should be a single integer/float or a 3-tuple.")
 
         return method(self, *args, **kwargs)
 
@@ -346,6 +358,7 @@ def check_device_target(method):
     def new_method(self, *args, **kwargs):
         [device_target], _ = parse_user_args(method, *args, **kwargs)
         check_valid_str(device_target, ["CPU", "Ascend"], "device_target")
+        check_independent_mode("Transform in Ascend mode", (device_target == "Ascend"))
         return method(self, *args, **kwargs)
     return new_method
 

mindspore/{rewrite/ast_creator_register.py → experimental/es/__init__.py}

@@ -1,4 +1,4 @@
-# Copyright 2022 Huawei Technologies Co., Ltd
+# Copyright 2024 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,26 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-
-"""Registry the relation."""
-
+"""Experimental module for EmbeddingService."""
 from __future__ import absolute_import
-from collections import UserDict
-
-
-class Registry(UserDict):
-    """Registry class for registry functions for creating ast node."""
-
-    def register(self, obj_str, obj):
-        """Register object by str."""
-        if isinstance(obj_str, str):
-            self[obj_str] = obj
 
-    def get(self, obj_str):
-        """Get the value by str."""
-        if not isinstance(obj_str, str):
-            raise TypeError("key for ast creator registry must be string.")
-        return self[obj_str]
+from mindspore.experimental.es.embedding_service import EmbeddingService
+from mindspore.experimental.es.embedding_service_layer import EsEmbeddingLookup, ESEmbeddingSmallTableLookup
 
 
-ast_creator_registry = Registry()
+__all__ = ['EmbeddingService', 'EsEmbeddingLookup', 'ESEmbeddingSmallTableLookup']