mindstudio-probe 1.0.3__py3-none-any.whl → 1.1.0__py3-none-any.whl

msprobe/mindspore/free_benchmark/handler/fix_handler.py

@@ -1,36 +1,51 @@
-from typing import Any
-
-from mindspore import Tensor
-
-from msprobe.mindspore.common.log import logger
-from msprobe.mindspore.free_benchmark.common.handler_params import HandlerParams
-
-
-class FixHandler:
-
-    def __init__(self, api_name: str):
-        self.api_name = api_name
-
-    @staticmethod
-    def use_fuzzed_result(original_result, fuzzed_result):
-        if isinstance(original_result, Tensor):
-            return fuzzed_result.to(original_result.dtype)
-        if isinstance(original_result, dict):
-            dict_fixed_result = dict()
-            for k, v in original_result.items():
-                dict_fixed_result[k] = FixHandler.use_fuzzed_result(v, fuzzed_result[k])
-            return dict_fixed_result
-        if isinstance(original_result, (tuple, list)):
-            list_fixed_result = list()
-            for i, v in enumerate(original_result):
-                list_fixed_result.append(FixHandler.use_fuzzed_result(v, fuzzed_result[i]))
-            return type(original_result)(list_fixed_result)
-        return original_result
-
-    def handle(self, params: HandlerParams) -> Any:
-        try:
-            return FixHandler.use_fuzzed_result(params.original_result, params.fuzzed_result)
-        except Exception as e:
-            logger.error(f"{self.api_name} failed to fix.")
-            logger.error(str(e))
-            return params.original_result
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.
+
+from typing import Any
+
+from mindspore import Tensor
+
+from msprobe.mindspore.common.log import logger
+from msprobe.mindspore.free_benchmark.common.handler_params import HandlerParams
+
+
+class FixHandler:
+
+    def __init__(self, api_name: str):
+        self.api_name = api_name
+
+    @staticmethod
+    def use_fuzzed_result(original_result, fuzzed_result):
+        if isinstance(original_result, Tensor):
+            return fuzzed_result.to(original_result.dtype)
+        if isinstance(original_result, dict):
+            dict_fixed_result = dict()
+            for k, v in original_result.items():
+                dict_fixed_result[k] = FixHandler.use_fuzzed_result(v, fuzzed_result[k])
+            return dict_fixed_result
+        if isinstance(original_result, (tuple, list)):
+            list_fixed_result = list()
+            for i, v in enumerate(original_result):
+                list_fixed_result.append(FixHandler.use_fuzzed_result(v, fuzzed_result[i]))
+            return type(original_result)(list_fixed_result)
+        return original_result
+
+    def handle(self, params: HandlerParams) -> Any:
+        try:
+            return FixHandler.use_fuzzed_result(params.original_result, params.fuzzed_result)
+        except Exception as e:
+            logger.error(f"{self.api_name} failed to fix.")
+            logger.error(str(e))
+            return params.original_result

msprobe/mindspore/free_benchmark/handler/handler_factory.py

@@ -1,21 +1,36 @@
-from msprobe.mindspore.common.log import logger
-from msprobe.mindspore.free_benchmark.common.config import Config
-from msprobe.mindspore.common.const import FreeBenchmarkConst
-from .check_handler import CheckHandler
-from .fix_handler import FixHandler
-
-
-class HandlerFactory:
-    result_handlers = {
-        FreeBenchmarkConst.CHECK: CheckHandler,
-        FreeBenchmarkConst.FIX: FixHandler,
-    }
-
-    @staticmethod
-    def create(api_name: str):
-        handler = HandlerFactory.result_handlers.get(Config.handler_type)
-        if handler:
-            return handler(api_name)
-        else:
-            logger.error(f"{Config.handler_type} is not supported.")
-            raise Exception
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.
+
+from msprobe.mindspore.common.const import FreeBenchmarkConst
+from msprobe.mindspore.common.log import logger
+from msprobe.mindspore.free_benchmark.common.config import Config
+from msprobe.mindspore.free_benchmark.handler.check_handler import CheckHandler
+from msprobe.mindspore.free_benchmark.handler.fix_handler import FixHandler
+
+
+class HandlerFactory:
+    result_handlers = {
+        FreeBenchmarkConst.CHECK: CheckHandler,
+        FreeBenchmarkConst.FIX: FixHandler,
+    }
+
+    @staticmethod
+    def create(api_name: str):
+        handler = HandlerFactory.result_handlers.get(Config.handler_type)
+        if handler:
+            return handler(api_name)
+        else:
+            logger.error(f"{Config.handler_type} is not supported.")
+            raise Exception

msprobe/mindspore/free_benchmark/perturbation/add_noise.py

@@ -1,67 +1,82 @@
-from typing import Any
-
-from mindspore import Tensor, ops
-
-from msprobe.mindspore.common.log import logger
-from msprobe.mindspore.free_benchmark.perturbation.base_perturbation import BasePerturbation
-from msprobe.mindspore.free_benchmark.common.handler_params import HandlerParams
-from msprobe.mindspore.common.const import FreeBenchmarkConst
-
-
-class AddNoisePerturbation(BasePerturbation):
-
-    def handle(self, params: HandlerParams) -> Any:
-        """
-        返回增加扰动后的api输出
-
-        """
-        params.fuzzed_value = self.add_noise(params.args[params.index])
-        if not self.is_fuzzed:
-            logger.warning(f"{self.api_name} can not add noise.")
-            return False
-        return self.get_fuzzed_result(params)
-
-    def add_noise(self, inputs) -> Any:
-        """
-        返回增加扰动后的api输入
-
-        """
-        if isinstance(inputs, Tensor):
-            noise = self._get_noise(inputs)
-            if noise is not False:
-                result = ops.where(ops.abs(inputs) > self.perturbation_value ** 0.5,
-                                   ops.add(noise, inputs), inputs)
-                result = result.type(dtype=inputs.dtype)
-                self.is_fuzzed = True
-                return result
-
-        if isinstance(inputs, dict):
-            return {k: self.add_noise(v) for k, v in inputs.items()}
-
-        if isinstance(inputs, (list, tuple)):
-            return [self.add_noise(v) for v in inputs]
-
-        return inputs
-
-    def _get_noise(self, input):
-        """
-        得到要添加的噪声值
-
-        """
-        if self.is_fuzzed:
-            return False
-        if not ops.is_floating_point(input) or ops.numel(input) == 0:
-            return False
-
-        pert_value = FreeBenchmarkConst.PERT_VALUE_DICT.get(input.dtype)
-        if not pert_value:
-            return False
-        else:
-            self.perturbation_value = pert_value
-
-        max_val = ops.max(ops.abs(input))[0].item()
-        if max_val < pert_value:
-            return False
-
-        noise = ops.full(input.shape, self.perturbation_value, dtype=input.dtype)
-        return noise
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.
+
+from typing import Any
+
+from mindspore import Tensor, ops
+
+from msprobe.mindspore.common.const import FreeBenchmarkConst
+from msprobe.mindspore.common.log import logger
+from msprobe.mindspore.free_benchmark.common.handler_params import HandlerParams
+from msprobe.mindspore.free_benchmark.perturbation.base_perturbation import BasePerturbation
+
+
+class AddNoisePerturbation(BasePerturbation):
+
+    def handle(self, params: HandlerParams) -> Any:
+        """
+        返回增加扰动后的api输出
+
+        """
+        params.fuzzed_value = self.add_noise(params.args[params.index])
+        if not self.is_fuzzed:
+            logger.warning(f"{self.api_name} can not add noise.")
+            return False
+        return self.get_fuzzed_result(params)
+
+    def add_noise(self, inputs) -> Any:
+        """
+        返回增加扰动后的api输入
+
+        """
+        if isinstance(inputs, Tensor):
+            noise = self._get_noise(inputs)
+            if noise is not False:
+                result = ops.where(ops.abs(inputs) > self.perturbation_value ** 0.5,
+                                   ops.add(noise, inputs), inputs)
+                result = result.type(dtype=inputs.dtype)
+                self.is_fuzzed = True
+                return result
+
+        if isinstance(inputs, dict):
+            return {k: self.add_noise(v) for k, v in inputs.items()}
+
+        if isinstance(inputs, (list, tuple)):
+            return [self.add_noise(v) for v in inputs]
+
+        return inputs
+
+    def _get_noise(self, tensor):
+        """
+        得到要添加的噪声值
+
+        """
+        if self.is_fuzzed:
+            return False
+        if not ops.is_floating_point(tensor) or ops.numel(tensor) == 0:
+            return False
+
+        pert_value = FreeBenchmarkConst.PERT_VALUE_DICT.get(tensor.dtype)
+        if not pert_value:
+            return False
+        else:
+            self.perturbation_value = pert_value
+
+        max_val = ops.max(ops.abs(tensor))[0].item()
+        if max_val < pert_value:
+            return False
+
+        noise = ops.full(tensor.shape, self.perturbation_value, dtype=tensor.dtype)
+        return noise

msprobe/mindspore/free_benchmark/perturbation/base_perturbation.py

@@ -1,21 +1,36 @@
-from typing import Any
-
-from msprobe.mindspore.free_benchmark.common.handler_params import HandlerParams
-
-
-class BasePerturbation:
-
-    def __init__(self, api_name: str):
-        self.api_name = api_name
-        self.is_fuzzed = False
-        self.perturbation_value = None
-
-    @staticmethod
-    def get_fuzzed_result(params: HandlerParams):
-        args_front = params.args[:params.index]
-        args_rear = params.args[params.index + 1:]
-        fuzzed_result = params.original_func(*args_front, params.fuzzed_value, *args_rear, **params.kwargs)
-        return fuzzed_result
-
-    def handler(self, params: HandlerParams) -> Any:
-        pass
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.
+
+from typing import Any
+
+from msprobe.mindspore.free_benchmark.common.handler_params import HandlerParams
+
+
+class BasePerturbation:
+
+    def __init__(self, api_name: str):
+        self.api_name = api_name
+        self.is_fuzzed = False
+        self.perturbation_value = None
+
+    @staticmethod
+    def get_fuzzed_result(params: HandlerParams):
+        args_front = params.args[:params.index]
+        args_rear = params.args[params.index + 1:]
+        fuzzed_result = params.original_func(*args_front, params.fuzzed_value, *args_rear, **params.kwargs)
+        return fuzzed_result
+
+    def handler(self, params: HandlerParams) -> Any:
+        pass

msprobe/mindspore/free_benchmark/perturbation/bit_noise.py

@@ -1,63 +1,78 @@
-from typing import Any
-
-import numpy as np
-from mindspore import Tensor, ops
-
-from msprobe.mindspore.common.log import logger
-from msprobe.mindspore.common.const import FreeBenchmarkConst
-from msprobe.mindspore.free_benchmark.common.handler_params import HandlerParams
-from msprobe.mindspore.free_benchmark.perturbation.base_perturbation import BasePerturbation
-
-
-class BitNoisePerturbation(BasePerturbation):
-
-    def add_bit_noise(self, inputs) -> Any:
-        if isinstance(inputs, Tensor):
-            bit_len_type = self._get_bit_len_type(inputs)
-            if bit_len_type is not False:
-                sub_normal_np = np.finfo(FreeBenchmarkConst.MS_NUMPY_DTYPE_DICT.get(inputs.dtype)).smallest_normal
-                sub_normal = Tensor(sub_normal_np)
-                noise_type = list(FreeBenchmarkConst.MS_NUMPY_DTYPE_DICT.keys())[
-                             list(FreeBenchmarkConst.MS_NUMPY_DTYPE_DICT.values()).index(bit_len_type)]
-                noise = ops.full(inputs.shape, 1, dtype=noise_type)
-                input_np = inputs.asnumpy()
-                input_np_int = input_np.view(bit_len_type)
-                result = Tensor(input_np_int)
-                result = ops.where(ops.abs(inputs) > sub_normal,
-                                   ops.bitwise_xor(result, noise), result)
-                result_np = result.asnumpy()
-                result_np_float = result_np.view(FreeBenchmarkConst.MS_NUMPY_DTYPE_DICT.get(inputs.dtype))
-                self.is_fuzzed = True
-                return Tensor(result_np_float)
-
-        if isinstance(inputs, dict):
-            return {k: self.add_bit_noise(v) for k, v in inputs.items()}
-        if isinstance(inputs, (tuple, list)):
-            return type(inputs)([self.add_bit_noise(v) for v in inputs])
-        return inputs
-
-    def handle(self, params: HandlerParams) -> any:
-        args = params.args
-        params.fuzzed_value = self.add_bit_noise(params.args[params.index])
-        if not self.is_fuzzed:
-            logger.warning(f"{self.api_name} can not add bit noise.")
-            return False
-        params.args = args
-        return self.get_fuzzed_result(params)
-
-    def _get_bit_len_type(self, input):
-        if self.is_fuzzed:
-            return False
-        if not isinstance(input, Tensor) or not ops.is_floating_point(input) or \
-           input.numel() == 0:
-            return False
-        bit_len_type = FreeBenchmarkConst.PERT_BIT_DICT.get(input.dtype)
-        if not bit_len_type:
-            return False
-        pert_value = FreeBenchmarkConst.PERT_VALUE_DICT.get(input.dtype)
-        if not pert_value:
-            return False
-        max_val = ops.max(ops.abs(input))[0].item()
-        if max_val < pert_value:
-            return False
-        return bit_len_type
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.
+
+from typing import Any
+
+import numpy as np
+from mindspore import Tensor, ops
+
+from msprobe.mindspore.common.const import FreeBenchmarkConst
+from msprobe.mindspore.common.log import logger
+from msprobe.mindspore.free_benchmark.common.handler_params import HandlerParams
+from msprobe.mindspore.free_benchmark.perturbation.base_perturbation import BasePerturbation
+
+
+class BitNoisePerturbation(BasePerturbation):
+
+    def add_bit_noise(self, inputs) -> Any:
+        if isinstance(inputs, Tensor):
+            bit_len_type = self._get_bit_len_type(inputs)
+            if bit_len_type is not False:
+                sub_normal_np = np.finfo(FreeBenchmarkConst.MS_NUMPY_DTYPE_DICT.get(inputs.dtype)).smallest_normal
+                sub_normal = Tensor(sub_normal_np)
+                noise_type = list(FreeBenchmarkConst.MS_NUMPY_DTYPE_DICT.keys())[
+                             list(FreeBenchmarkConst.MS_NUMPY_DTYPE_DICT.values()).index(bit_len_type)]
+                noise = ops.full(inputs.shape, 1, dtype=noise_type)
+                input_np = inputs.asnumpy()
+                input_np_int = input_np.view(bit_len_type)
+                result = Tensor(input_np_int)
+                result = ops.where(ops.abs(inputs) > sub_normal,
+                                   ops.bitwise_xor(result, noise), result)
+                result_np = result.asnumpy()
+                result_np_float = result_np.view(FreeBenchmarkConst.MS_NUMPY_DTYPE_DICT.get(inputs.dtype))
+                self.is_fuzzed = True
+                return Tensor(result_np_float)
+
+        if isinstance(inputs, dict):
+            return {k: self.add_bit_noise(v) for k, v in inputs.items()}
+        if isinstance(inputs, (tuple, list)):
+            return type(inputs)([self.add_bit_noise(v) for v in inputs])
+        return inputs
+
+    def handle(self, params: HandlerParams) -> any:
+        args = params.args
+        params.fuzzed_value = self.add_bit_noise(params.args[params.index])
+        if not self.is_fuzzed:
+            logger.warning(f"{self.api_name} can not add bit noise.")
+            return False
+        params.args = args
+        return self.get_fuzzed_result(params)
+
+    def _get_bit_len_type(self, tensor):
+        if self.is_fuzzed:
+            return False
+        if not isinstance(tensor, Tensor) or not ops.is_floating_point(tensor) or \
+           tensor.numel() == 0:
+            return False
+        bit_len_type = FreeBenchmarkConst.PERT_BIT_DICT.get(tensor.dtype)
+        if not bit_len_type:
+            return False
+        pert_value = FreeBenchmarkConst.PERT_VALUE_DICT.get(tensor.dtype)
+        if not pert_value:
+            return False
+        max_val = ops.max(ops.abs(tensor))[0].item()
+        if max_val < pert_value:
+            return False
+        return bit_len_type

msprobe/mindspore/free_benchmark/perturbation/exchange_value.py

@@ -0,0 +1,77 @@
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.
+
+from typing import Any
+
+from mindspore import Tensor, ops
+
+from msprobe.mindspore.common.log import logger
+from msprobe.mindspore.free_benchmark.common.handler_params import HandlerParams
+from msprobe.mindspore.free_benchmark.perturbation.base_perturbation import BasePerturbation
+
+
+class ExchangeValuePerturbation(BasePerturbation):
+
+    @staticmethod
+    def _check_tensor_shape(inputs):
+        dims = len(inputs.shape)
+        if dims == 1 and inputs.shape[0] > 1:
+            return True
+        if dims > 1 and inputs.shape[1] > 0:
+            if inputs.shape[0] > 1 or inputs.shape[1] > 1:
+                return True
+        return False
+
+    def handle(self, params: HandlerParams) -> Any:
+        """
+        返回首尾交换后的api输出
+
+        """
+        params.fuzzed_value = self.exchange_value(params.args[params.index])
+        if not self.is_fuzzed:
+            logger.warning(f"{self.api_name} can not exchange value.")
+            return False
+        return self.get_fuzzed_result(params)
+
+    def exchange_value(self, inputs) -> Any:
+        """
+        返回首尾交换后的api输入
+
+        """
+        if isinstance(inputs, Tensor) and ops.is_floating_point(inputs):
+            if self.is_fuzzed or not self._check_tensor_shape(inputs):
+                return inputs
+            result = inputs.copy()
+            if len(inputs.shape) == 1:
+                first_element = inputs[0]
+                last_element = inputs[-1]
+                result[0] = last_element
+                result[-1] = first_element
+            else:
+                first_element = inputs[0][0]
+                last_element = inputs[-1][-1]
+                result[0][0] = last_element
+                result[-1][-1] = first_element
+
+            self.is_fuzzed = True
+            return result
+
+        if isinstance(inputs, dict):
+            return {k: self.exchange_value(v) for k, v in inputs.items()}
+
+        if isinstance(inputs, (list, tuple)):
+            return type(inputs)([self.exchange_value(v) for v in inputs])
+
+        return inputs