mindspore 2.4.0__cp310-cp310-macosx_10_15_x86_64.whl

mindspore/dataset/transforms/py_transforms.py

@@ -0,0 +1,393 @@
+# Copyright 2019-2022 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.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""
+The module transforms.py_transform is implemented based on Python. It provides common
+operations including OneHotOp.
+"""
+import json
+import sys
+import numpy as np
+
+from .validators import check_one_hot_op, check_compose_list, check_random_apply, check_transforms_list, \
+    check_compose_call, deprecated_py_transforms
+from . import py_transforms_util as util
+from .c_transforms import TensorOperation
+
+
+def not_random(function):
+    """
+    Specify the function as "not random", i.e., it produces deterministic result.
+    A Python function can only be cached after it is specified as "not random".
+    """
+    function.random = False
+    return function
+
+
+class PyTensorOperation:
+    """
+    Base Python Tensor Operations class
+    """
+
+    @classmethod
+    def from_json(cls, json_string):
+        """
+        Base from_json for Python tensor operations class
+        """
+        json_obj = json.loads(json_string)
+        new_op = cls.__new__(cls)
+        new_op.__dict__ = json_obj
+        if "transforms" in json_obj.keys():
+            # operations which have transforms as input, need to call _from_json() for each transform to deseriallize
+            transforms = []
+            for json_op in json_obj["transforms"]:
+                transforms.append(getattr(
+                    sys.modules.get(json_op.get("python_module")),
+                    json_op.get("tensor_op_name")).from_json(json.dumps(json_op.get("tensor_op_params"))))
+            new_op.transforms = transforms
+        if "output_type" in json_obj.keys():
+            output_type = np.dtype(json_obj["output_type"])
+            new_op.output_type = output_type
+        return new_op
+
+    def to_json(self):
+        """
+        Base to_json for Python tensor operations class
+        """
+        json_obj = {}
+        json_trans = {}
+        if "transforms" in self.__dict__.keys():
+            # operations which have transforms as input, need to call _to_json() for each transform to serialize
+            json_list = []
+            for transform in self.transforms:
+                json_list.append(json.loads(transform.to_json()))
+            json_trans["transforms"] = json_list
+            self.__dict__.pop("transforms")
+        if "output_type" in self.__dict__.keys():
+            json_trans["output_type"] = np.dtype(
+                self.__dict__["output_type"]).name
+            self.__dict__.pop("output_type")
+        json_obj["tensor_op_params"] = self.__dict__
+        # append transforms to the tensor_op_params of the operation
+        json_obj.get("tensor_op_params").update(json_trans)
+        json_obj["tensor_op_name"] = self.__class__.__name__
+        json_obj["python_module"] = self.__class__.__module__
+        return json.dumps(json_obj)
+
+
+class OneHotOp(PyTensorOperation):
+    """
+    Apply one hot encoding transformation to the input label, make label be more smoothing and continuous.
+
+    Args:
+        num_classes (int): Number of classes of objects in dataset.
+            It should be larger than the largest label number in the dataset.
+        smoothing_rate (float, optional): Adjustable hyperparameter for label smoothing level.
+            Default: 0.0, means no smoothing is applied.
+
+    Raises:
+        TypeError: `num_classes` is not of type int.
+        TypeError: `smoothing_rate` is not of type float.
+        ValueError: `smoothing_rate` is not in range [0.0, 1.0].
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> # Assume that dataset has 10 classes, thus the label ranges from 0 to 9
+        >>> transforms_list = [py_transforms.OneHotOp(num_classes=10, smoothing_rate=0.1)]
+        >>> transform = py_transforms.Compose(transforms_list)
+        >>> mnist_dataset = mnist_dataset.map(input_columns=["label"], operations=transform)
+    """
+
+    @deprecated_py_transforms("OneHot")
+    @check_one_hot_op
+    def __init__(self, num_classes, smoothing_rate=0.0):
+        self.num_classes = num_classes
+        self.smoothing_rate = smoothing_rate
+        self.random = False
+
+    def __call__(self, label):
+        """
+        Call method.
+
+        Args:
+            label (numpy.ndarray): label to be applied label smoothing.
+
+        Returns:
+            label (numpy.ndarray), label after being Smoothed.
+        """
+        return util.one_hot_encoding(label, self.num_classes, self.smoothing_rate)
+
+
+class Compose(PyTensorOperation):
+    """
+    Compose a list of transforms.
+
+    .. Note::
+        Compose takes a list of transformations either provided in py_transforms or from user-defined implementation;
+        each can be an initialized transformation class or a lambda function, as long as the output from the last
+        transformation is a single tensor of type numpy.ndarray. See below for an example of how to use Compose
+        with py_transforms classes and check out FiveCrop or TenCrop for the use of them in conjunction with lambda
+        functions.
+
+    Args:
+        transforms (list): List of transformations to be applied.
+
+    Raises:
+        TypeError: If `transforms` is not of type list.
+        ValueError: If `transforms` is empty.
+        TypeError: If transformations in `transforms` are not Python callable objects.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> image_folder_dataset_dir = "/path/to/image_folder_dataset_directory"
+        >>> # create a dataset that reads all files in dataset_dir with 8 threads
+        >>> image_folder_dataset = ds.ImageFolderDataset(image_folder_dataset_dir, num_parallel_workers=8)
+        >>> # create a list of transformations to be applied to the image data
+        >>> transform = py_transforms.Compose([py_vision.Decode(),
+        ...                                    py_vision.RandomHorizontalFlip(0.5),
+        ...                                    py_vision.ToTensor(),
+        ...                                    py_vision.Normalize((0.491, 0.482, 0.447), (0.247, 0.243, 0.262)),
+        ...                                    py_vision.RandomErasing()])
+        >>> # apply the transform to the dataset through dataset.map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transform, input_columns=["image"])
+        >>>
+        >>> # Compose is also be invoked implicitly, by just passing in a list of ops
+        >>> # the above example then becomes:
+        >>> transforms_list = [py_vision.Decode(),
+        ...                    py_vision.RandomHorizontalFlip(0.5),
+        ...                    py_vision.ToTensor(),
+        ...                    py_vision.Normalize((0.491, 0.482, 0.447), (0.247, 0.243, 0.262)),
+        ...                    py_vision.RandomErasing()]
+        >>>
+        >>> # apply the transform to the dataset through dataset.map()
+        >>> image_folder_dataset_1 = image_folder_dataset_1.map(operations=transforms_list, input_columns=["image"])
+        >>>
+        >>> # Certain C++ and Python ops can be combined, but not all of them
+        >>> # An example of combined operations
+        >>> arr = [0, 1]
+        >>> dataset = ds.NumpySlicesDataset(arr, column_names=["cols"], shuffle=False)
+        >>> transformed_list = [py_transforms.OneHotOp(2), c_transforms.Mask(c_transforms.Relational.EQ, 1)]
+        >>> dataset = dataset.map(operations=transformed_list, input_columns=["cols"])
+        >>>
+        >>> # Here is an example of mixing vision ops
+        >>> import numpy as np
+        >>> op_list=[c_vision.Decode(),
+        ...          c_vision.Resize((224, 244)),
+        ...          py_vision.ToPIL(),
+        ...          np.array, # need to convert PIL image to a NumPy array to pass it to C++ operation
+        ...          c_vision.Resize((24, 24))]
+        >>> image_folder_dataset = image_folder_dataset.map(operations=op_list,  input_columns=["image"])
+    """
+
+    @deprecated_py_transforms()
+    @check_compose_list
+    def __init__(self, transforms):
+        self.transforms = transforms
+        if all(hasattr(transform, "random") and not transform.random for transform in self.transforms):
+            self.random = False
+
+    @check_compose_call
+    def __call__(self, *args):
+        """
+        Call method.
+
+        Returns:
+            lambda function, Lambda function that takes in an args to apply transformations on.
+        """
+        return util.compose(self.transforms, *args)
+
+    @staticmethod
+    def reduce(operations):
+        """
+        Wraps adjacent Python operations in a Compose to allow mixing of Python and C++ operations.
+
+        Args:
+            operations (list): list of tensor operations.
+
+        Returns:
+            list, the reduced list of operations.
+        """
+        # import nn and ops locally for type check
+        from mindspore import nn, ops
+        for item in operations:
+            if isinstance(item, (nn.Cell, ops.Primitive)):
+                raise ValueError("Input operations should not contain network computing operator like in "
+                                 "mindspore.nn or mindspore.ops, got operation:", str(item))
+        ops = []
+        for op in operations:
+            if str(op).find("c_transform") >= 0 or isinstance(op, TensorOperation):
+                ops.append(op)
+            else:
+                ops.append(util.FuncWrapper(op))
+        operations = ops
+        if len(operations) == 1:
+            return operations
+
+        new_ops, start_ind, end_ind = [], 0, 0
+        for i, op in enumerate(operations):
+            if str(op).find("c_transform") >= 0 or isinstance(op, TensorOperation):
+                # reset counts
+                if start_ind != end_ind:
+                    new_ops.append(Compose(operations[start_ind:end_ind]))
+                new_ops.append(op)
+                start_ind, end_ind = i + 1, i + 1
+            else:
+                end_ind += 1
+        # do additional check in case the last operation is a Python operation
+        if start_ind != end_ind:
+            new_ops.append(Compose(operations[start_ind:end_ind]))
+        return new_ops
+
+
+class RandomApply(PyTensorOperation):
+    """
+    Randomly perform a series of transforms with a given probability.
+
+    Args:
+        transforms (list): List of transformations to apply.
+        prob (float, optional): The probability to apply the transformation list. Default: 0.5.
+
+    Raises:
+        TypeError: If `transforms` is not of type list.
+        ValueError: If `transforms` is empty.
+        TypeError: If elements of `transforms` are neither Python callable objects nor data
+            processing operations in py_transforms.
+        TypeError: If `prob` is not of type float.
+        ValueError: If `prob` is not in range [0.0, 1.0].
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> from mindspore.dataset.transforms.py_transforms import Compose
+        >>> transforms_list = [py_vision.RandomHorizontalFlip(0.5),
+        ...                    py_vision.Normalize((0.491, 0.482, 0.447), (0.247, 0.243, 0.262)),
+        ...                    py_vision.RandomErasing()]
+        >>> transforms = Compose([py_vision.Decode(),
+        ...                       py_transforms.RandomApply(transforms_list, prob=0.6),
+        ...                       py_vision.ToTensor()])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms, input_columns=["image"])
+    """
+
+    @deprecated_py_transforms()
+    @check_random_apply
+    def __init__(self, transforms, prob=0.5):
+        self.prob = prob
+        self.transforms = transforms
+
+    def __call__(self, img):
+        """
+        Call method.
+
+        Args:
+            img (PIL image): Image to be randomly applied a list transformations.
+
+        Returns:
+            img (PIL image), Transformed image.
+        """
+        return util.random_apply(img, self.transforms, self.prob)
+
+
+class RandomChoice(PyTensorOperation):
+    """
+    Randomly select one transform from a series of transforms and applies that on the image.
+
+    Args:
+         transforms (list): List of transformations to be chosen from to apply.
+
+    Raises:
+        TypeError: If `transforms` is not of type list.
+        TypeError: If elements of `transforms` are neither Python callable objects nor data
+            processing operations in py_transforms.
+        ValueError: If `transforms` is empty.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> from mindspore.dataset.transforms.py_transforms import Compose
+        >>> transforms_list = [py_vision.RandomHorizontalFlip(0.5),
+        ...                    py_vision.Normalize((0.491, 0.482, 0.447), (0.247, 0.243, 0.262)),
+        ...                    py_vision.RandomErasing()]
+        >>> transforms = Compose([py_vision.Decode(),
+        ...                       py_transforms.RandomChoice(transforms_list),
+        ...                       py_vision.ToTensor()])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms, input_columns=["image"])
+    """
+
+    @deprecated_py_transforms()
+    @check_transforms_list
+    def __init__(self, transforms):
+        self.transforms = transforms
+
+    def __call__(self, img):
+        """
+        Call method.
+
+        Args:
+            img (PIL image): Image to be applied transformation.
+
+        Returns:
+            img (PIL image), Transformed image.
+        """
+        return util.random_choice(img, self.transforms)
+
+
+class RandomOrder(PyTensorOperation):
+    """
+    Perform a series of transforms to the input PIL image in a random order.
+
+    Args:
+        transforms (list): List of the transformations to apply.
+
+    Raises:
+        TypeError: If `transforms` is not of type list.
+        TypeError: If elements of `transforms` are neither Python callable objects nor data
+            processing operations in py_transforms.
+        ValueError: If `transforms` is empty.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> from mindspore.dataset.transforms.py_transforms import Compose
+        >>> transforms_list = [py_vision.RandomHorizontalFlip(0.5),
+        ...                    py_vision.Normalize((0.491, 0.482, 0.447), (0.247, 0.243, 0.262)),
+        ...                    py_vision.RandomErasing()]
+        >>> transforms = Compose([py_vision.Decode(),
+        ...                       py_transforms.RandomOrder(transforms_list),
+        ...                       py_vision.ToTensor()])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms, input_columns=["image"])
+    """
+
+    @deprecated_py_transforms()
+    @check_transforms_list
+    def __init__(self, transforms):
+        self.transforms = transforms
+
+    def __call__(self, img):
+        """
+        Call method.
+
+        Args:
+            img (PIL image): Image to apply transformations in a random order.
+
+        Returns:
+            img (PIL image), Transformed image.
+        """
+        return util.random_order(img, self.transforms)

mindspore/dataset/transforms/py_transforms_util.py

@@ -0,0 +1,255 @@
+# Copyright 2020-2022 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.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""
+Built-in py_transforms_utils functions.
+"""
+import json
+import random
+from enum import IntEnum
+from types import FunctionType, MethodType
+import numpy as np
+
+from mindspore import log as logger
+from ..core.py_util_helpers import is_numpy, ExceptionHandler
+from .. import transforms as t
+
+
+class Implementation(IntEnum):
+    """
+    Implementation types for operations
+
+    - Implementation.C: the operation is implemented in C++
+    - Implementation.PY: the operation is implemented in Python
+    """
+    C = 0
+    PY = 1
+
+
+def all_numpy(args):
+    """ for multi-input lambdas"""
+    if isinstance(args, tuple):
+        for value in args:
+            if not is_numpy(value):
+                return False
+        return True
+    return is_numpy(args)
+
+
+def compose(transforms, *args):
+    """
+    Compose a list of transforms and apply on the image.
+
+    Args:
+        img (numpy.ndarray): An image in NumPy ndarray.
+        transforms (list): A list of transform Class objects to be composed.
+
+    Returns:
+        img (numpy.ndarray), An augmented image in NumPy ndarray.
+    """
+    for transform in transforms:
+        try:
+            args = transform(*args)
+        except Exception:
+            result = ExceptionHandler(where="in map(or batch) worker and execute Python function")
+            result.reraise()
+        args = (args,) if not isinstance(args, tuple) else args
+
+    return args
+
+
+def one_hot_encoding(label, num_classes, epsilon):
+    """
+    Apply label smoothing transformation to the input label, and make label be more smoothing and continuous.
+
+    Args:
+        label (numpy.ndarray): label to be applied label smoothing.
+        num_classes (int): Num class of object in dataset, value should over 0.
+        epsilon (float): The adjustable Hyper parameter. Default is 0.0.
+
+    Returns:
+        img (numpy.ndarray), label after being one hot encoded and done label smoothed.
+
+    Examples:
+        >>> # assume num_classes = 5
+        >>> # 1) input np.array(3) output [0, 0, 0, 1, 0]
+        >>> # 2) input np.array([4, 2, 0]) output [[0, 0, 0, 0, 1], [0, 0, 1, 0, 0], [1, 0, 0, 0, 0]]
+        >>> # 3) input np.array([[4], [2], [0]]) output [[[0, 0, 0, 0, 1]], [[0, 0, 1, 0, 0][, [[1, 0, 0, 0, 0]]]
+    """
+    if isinstance(label, np.ndarray):  # the numpy should be () or (1, ) or shape: (n, 1)
+        if label.dtype not in [np.int8, np.int16, np.int32, np.int64,
+                               np.uint8, np.uint16, np.uint32, np.uint64]:
+            raise ValueError('the input numpy type should be int, but the input is: ' + str(label.dtype))
+
+        if label.ndim == 0:
+            if label >= num_classes:
+                raise ValueError('the num_classes is smaller than the category number.')
+
+            one_hot_label = np.zeros((num_classes), dtype=int)
+            one_hot_label[label] = 1
+        else:
+            label_flatten = label.flatten()
+            for item in label_flatten:
+                if item >= num_classes:
+                    raise ValueError('the num_classes:' + str(num_classes) +
+                                     ' is smaller than the category number:' + str(item))
+
+            num_elements = label_flatten.size
+            one_hot_label = np.zeros((num_elements, num_classes), dtype=int)
+            for index in range(num_elements):
+                one_hot_label[index][label_flatten[index]] = 1
+
+            new_shape = []
+            for dim in label.shape:
+                new_shape.append(dim)
+            new_shape.append(num_classes)
+            one_hot_label = one_hot_label.reshape(new_shape)
+    else:
+        raise ValueError('the input is invalid, it should be numpy.ndarray.')
+
+    return (1 - epsilon) * one_hot_label + epsilon / num_classes
+
+
+def random_order(img, transforms):
+    """
+    Applies a list of transforms in a random order.
+
+    Args:
+        img: Image to be applied transformations in a random order.
+        transforms (list): List of the transformations to be applied.
+
+    Returns:
+        img, Transformed image.
+    """
+    random.shuffle(transforms)
+    for transform in transforms:
+        img = transform(img)
+    return img
+
+
+def random_apply(img, transforms, prob):
+    """
+    Apply a list of transformation, randomly with a given probability.
+
+    Args:
+        img: Image to be randomly applied a list transformations.
+        transforms (list): List of transformations to be applied.
+        prob (float): The probability to apply the transformation list.
+
+    Returns:
+        img, Transformed image.
+    """
+    if prob < random.random():
+        return img
+    for transform in transforms:
+        img = transform(img)
+    return img
+
+
+def random_choice(img, transforms):
+    """
+    Random selects one transform from a list of transforms and applies that on the image.
+
+    Args:
+        img: Image to be applied transformation.
+        transforms (list): List of transformations to be chosen from to apply.
+
+    Returns:
+        img, Transformed image.
+    """
+    return random.choice(transforms)(img)
+
+
+class FuncWrapper:
+    """
+    Wrap function with try except logic, mainly for wrapping Python function.
+
+    Args:
+        transform: Callable Python function.
+
+    Returns:
+        result, data after apply transformation.
+    """
+
+    def __init__(self, transform):
+        if not callable(transform):
+            raise ValueError("Input operations should be callable Python function, but got: " + str(transform))
+        self.transform = transform
+        self.implementation = Implementation.C
+        try:
+            if hasattr(self.transform, "random") and not self.transform.random:
+                self.random = False
+        except KeyError:
+            self.random = True
+        self.logged_list_mixed_type_warning = False  # Warning for list mixed type result is not logged yet
+
+    def __call__(self, *args):
+        try:
+            result = self.transform(*args)
+        except Exception:
+            result = ExceptionHandler(where="in map(or batch) worker and execute Python function")
+            result.reraise()
+
+        # Check if result is list type, and mixed type warning for list type result has not been logged yet
+        if isinstance(result, list) and not self.logged_list_mixed_type_warning:
+            result0_type = type(result[0])
+            if not all((type(t) is result0_type) for t in result):  # pylint: disable=unidiomatic-typecheck
+                self.logged_list_mixed_type_warning = True
+                warn_msg = "All elements in returned list are not of the same type in Python function." + \
+                           " First element has type: " + str(result0_type)
+                logger.warning(warn_msg)
+        return result
+
+    def to_json(self):
+        """ Serialize to JSON format """
+        # User-defined Python functions cannot be fully nor correctly serialized.
+        # Log a warning, and produce minimal info for the Python UDF, so that serialization of the
+        # dataset pipeline can continue.
+        # Note that the serialized JSON output is not valid to be deserialized.
+        udf_python_warning = "Serialization of user-defined Python functions is not supported. " \
+                             "Any produced serialized JSON file output for this dataset pipeline is not valid " \
+                             "to be deserialized."
+        try:
+            if isinstance(self.transform, (FunctionType, MethodType)):
+                # common function type(include lambda, class method) / object method
+                logger.warning(udf_python_warning)
+                json_obj = {}
+                json_obj["tensor_op_name"] = self.transform.__name__
+                json_obj["python_module"] = self.__class__.__module__
+                return json.dumps(json_obj)
+            if callable(self.transform) and not isinstance(self.transform, (t.c_transforms.TensorOperation,
+                                                                            t.py_transforms.PyTensorOperation,
+                                                                            t.transforms.TensorOperation,
+                                                                            t.transforms.PyTensorOperation,
+                                                                            FuncWrapper)):
+                # udf callable class
+                logger.warning(udf_python_warning)
+                json_obj = {}
+                json_obj["tensor_op_name"] = type(self.transform).__name__
+                json_obj["python_module"] = self.__class__.__module__
+                return json.dumps(json_obj)
+            # dataset operations
+            return self.transform.to_json()
+        except Exception as e:
+            logger.warning("Skip user-defined Python method which cannot be serialized, reason is: " + str(e))
+            json_obj = {}
+            json_obj["tensor_op_name"] = "unknown"
+            json_obj["python_module"] = "unknown"
+            return json.dumps(json_obj)
+
+    def release_resource(self):
+        # release the executor which is used by current thread/process when
+        # use transform in eager mode in map op or batch op
+        # this will be call in MapOp::WorkerEntry and BatchOp::WorkerEntry
+        t.transforms.clean_unused_executors()