mindstudio-probe 8.3.3__py3-none-any.whl → 26.0.0a1__py3-none-any.whl

msprobe/mindspore/free_benchmark/data/support_wrap_ops.yaml

@@ -1,638 +0,0 @@
-# List of apis that support self check
-  
-ops:
-  - adaptive_avg_pool1d
-  - adaptive_avg_pool2d
-  - adaptive_avg_pool3d
-  - adaptive_max_pool1d
-  - adaptive_max_pool2d
-  - avg_pool1d
-  - avg_pool2d
-  - avg_pool3d
-  - batch_norm
-  - bias_add
-  - conv1d
-  - conv2d
-  - conv3d
-  - deformable_conv2d
-  - fractional_max_pool3d
-  - lp_pool1d
-  - lp_pool2d
-  - lrn
-  - max_pool2d
-  - max_pool3d
-  - max_unpool1d
-  - max_unpool2d
-  - max_unpool3d
-  - binary_cross_entropy
-  - binary_cross_entropy_with_logits
-  - cosine_embedding_loss
-  - cross_entropy
-  - ctc_loss
-  - gaussian_nll_loss
-  - hinge_embedding_loss
-  - huber_loss
-  - kl_div
-  - l1_loss
-  - margin_ranking_loss
-  - mse_loss
-  - multi_margin_loss
-  - multilabel_margin_loss
-  - multilabel_soft_margin_loss
-  - nll_loss
-  - smooth_l1_loss
-  - triplet_margin_loss
-  - elu
-  - fast_gelu
-  - gelu
-  - glu
-  - gumbel_softmax
-  - hardshrink
-  - hardsigmoid
-  - hardswish
-  - hardtanh
-  - leaky_relu
-  - log_softmax
-  - logsigmoid
-  - mish
-  - prelu
-  - relu
-  - relu6
-  - rrelu
-  - selu
-  - sigmoid
-  - silu
-  - softmax
-  - softmin
-  - softshrink
-  - softsign
-  - tanh
-  - threshold
-  - cdist
-  - dist
-  - pdist
-  - choice_with_mask
-  - random_categorical
-  - log_uniform_candidate_sampler
-  - uniform_candidate_sampler
-  - affine_grid
-  - bounding_box_decode
-  - bounding_box_encode
-  - col2im
-  - check_valid
-  - crop_and_resize
-  - grid_sample
-  - interpolate
-  - iou
-  - pad
-  - padding
-  - pixel_shuffle
-  - pixel_unshuffle
-  - upsample
-  - accumulate_n
-  - acos
-  - arccos
-  - acosh
-  - add
-  - addcdiv
-  - addcmul
-  - addmv
-  - addn
-  - angle
-  - arccosh
-  - arcsin
-  - arcsinh
-  - arctan
-  - arctanh
-  - arctan2
-  - asin
-  - asinh
-  - atan
-  - atan2
-  - atanh
-  - atleast_1d
-  - atleast_2d
-  - atleast_3d
-  - bessel_i0
-  - bessel_i0e
-  - bessel_i1
-  - bessel_i1e
-  - bessel_j0
-  - bessel_j1
-  - bessel_k0
-  - bessel_k0e
-  - bessel_k1
-  - bessel_k1e
-  - bessel_y0
-  - bessel_y1
-  - ceil
-  - clamp
-  - clip
-  - cos
-  - cosh
-  - cosine_similarity
-  - cov
-  - diag_embed
-  - diff
-  - deg2rad
-  - digamma
-  - div
-  - divide
-  - erf
-  - erfc
-  - erfinv
-  - exp
-  - exp2
-  - expm1
-  - floor
-  - floor_div
-  - floor_mod
-  - float_power
-  - fmod
-  - frac
-  - gcd
-  - hypot
-  - igamma
-  - igammac
-  - imag
-  - i0
-  - inv
-  - invert
-  - lcm
-  - ldexp
-  - lerp
-  - log
-  - log2
-  - log10
-  - log1p
-  - logaddexp
-  - logaddexp2
-  - logical_and
-  - logical_not
-  - logical_or
-  - logical_xor
-  - logit
-  - mul
-  - multiply
-  - mvlgamma
-  - polar
-  - polygamma
-  - pow
-  - rad2deg
-  - ravel
-  - real
-  - reciprocal
-  - remainder
-  - rot90
-  - round
-  - rsqrt
-  - sgn
-  - sign
-  - signbit
-  - sin
-  - sinc
-  - sinh
-  - sqrt
-  - square
-  - sub
-  - subtract
-  - tan
-  - tanhshrink
-  - trapz
-  - tril_indices
-  - triu_indices
-  - true_divide
-  - trunc
-  - truncate_div
-  - truncate_mod
-  - xdivy
-  - xlogy
-  - zeta
-  - amax
-  - amin
-  - aminmax
-  - argmax
-  - argmin
-  - cummax
-  - cummin
-  - cumprod
-  - cumsum
-  - fmax
-  - histc
-  - logsumexp
-  - max
-  - mean
-  - median
-  - min
-  - norm
-  - prod
-  - std
-  - std_mean
-  - var
-  - var_mean
-  - argsort
-  - approximate_equal
-  - intopk
-  - maximum
-  - minimum
-  - msort
-  - searchsorted
-  - topk
-  - bmm
-  - addbmm
-  - addmm
-  - baddbmm
-  - addr
-  - adjoint
-  - cholesky
-  - cholesky_solve
-  - batch_dot
-  - dot
-  - eig
-  - inner
-  - inverse
-  - geqrf
-  - ger
-  - kron
-  - lu_solve
-  - lu_unpack
-  - matmul
-  - matrix_solve
-  - matrix_band_part
-  - matrix_diag
-  - matrix_diag_part
-  - matrix_set_diag
-  - mm
-  - mv
-  - outer
-  - orgqr
-  - ormqr
-  - pinv
-  - svd
-  - tensor_dot
-  - logdet
-  - slogdet
-  - qr
-  - trace
-  - bartlett_window
-  - blackman_window
-  - hamming_window
-  - hann_window
-  - kaiser_window
-  - heaviside
-  - bernoulli
-  - gamma
-  - laplace
-  - multinomial
-  - multinomial_with_replacement
-  - standard_laplace
-  - standard_normal
-  - uniform
-  - argwhere
-  - batch_to_space_nd
-  - bincount
-  - block_diag
-  - broadcast_to
-  - channel_shuffle
-  - column_stack
-  - conj
-  - count_nonzero
-  - diag
-  - diagflat
-  - diagonal
-  - dyn_shape
-  - dsplit
-  - dstack
-  - einsum
-  - expand
-  - expand_dims
-  - flip
-  - fliplr
-  - flipud
-  - gather_d
-  - gather_elements
-  - gather_nd
-  - hsplit
-  - hstack
-  - masked_fill
-  - masked_select
-  - meshgrid
-  - moveaxis
-  - movedim
-  - narrow
-  - nan_to_num
-  - nansum
-  - normal
-  - population_count
-  - sequence_mask
-  - space_to_batch_nd
-  - sparse_segment_mean
-  - sum
-  - swapaxes
-  - swapdims
-  - tril
-  - triu
-  - unbind
-  - unsorted_segment_max
-  - unsorted_segment_min
-  - unsorted_segment_prod
-  - unsorted_segment_sum
-  - vsplit
-  - vstack
-  - cross
-  - renorm
-  - tuple_to_array
-  - clip_by_global_norm
-  - clip_by_value
-  - derivative
-  - jet
-
-Tensor:
-  - __add__
-  - __and__
-  - __iadd__
-  - __ifloordiv__
-  - __imatmul__
-  - __imod__
-  - __imul__
-  - __isub__
-  - __matmul__
-  - __mod__
-  - __mul__
-  - __pow__
-  - __radd__
-  - __rmatmul__
-  - __rmod__
-  - __rmul__
-  - __rpow__
-  - __rsub__
-  - __sub__
-  - __truediv__
-  - __xor__
-  - acos
-  - acosh
-  - add
-  - addbmm
-  - addcdiv
-  - addcmul
-  - addmm
-  - addmv
-  - addr
-  - all
-  - amax
-  - amin
-  - any
-  - arccos
-  - arccosh
-  - argmax
-  - angle
-  - arcsin
-  - arcsinh
-  - arctan
-  - arctanh
-  - argmin
-  - argsort
-  - asin
-  - asinh
-  - atan
-  - atan2
-  - atanh
-  - baddbmm
-  - bernoulli
-  - bincount
-  - bmm
-  - broadcast_to
-  - cholesky_solve
-  - cholesky
-  - conj
-  - cos
-  - cosh
-  - cross
-  - cummax
-  - cummin
-  - cumprod
-  - cumsum
-  - deg2rad
-  - diag
-  - diagflat
-  - diff
-  - digamma
-  - div
-  - divide
-  - erf
-  - erfc
-  - erfinv
-  - exp
-  - expand_as
-  - expm1
-  - flip
-  - fliplr
-  - flipud
-  - float_power
-  - fmod
-  - frac
-  - gather_elements
-  - geqrf
-  - ger
-  - half
-  - hardshrink
-  - heaviside
-  - histc
-  - hypot
-  - i0
-  - igamma
-  - igammac
-  - imag
-  - index_add
-  - inner
-  - lcm
-  - ldexp
-  - lerp
-  - log
-  - log10
-  - log1p
-  - log2
-  - logaddexp
-  - logaddexp2
-  - logdet
-  - logical_and
-  - logical_not
-  - logical_or
-  - logical_xor
-  - logit
-  - logsumexp
-  - long
-  - masked_fill
-  - masked_scatter
-  - masked_select
-  - matmul
-  - mean
-  - median
-  - moveaxis
-  - movedim
-  - multinomial
-  - multiply
-  - mvlgamma
-  - nansum
-  - narrow
-  - nelement
-  - norm
-  - ormqr
-  - permute
-  - pow
-  - prod
-  - qr
-  - ravel
-  - real
-  - reciprocal
-  - remainder
-  - renorm
-  - rad2deg
-  - round
-  - rot90
-  - rsqrt
-  - sum_to_size
-  - scatter
-  - sgn
-  - short
-  - sigmoid
-  - sign
-  - signbit
-  - sin
-  - sinc
-  - sinh
-  - slogdet
-  - sort
-  - sqrt
-  - square
-  - std
-  - subtract
-  - subtract
-  - svd
-  - swapaxes
-  - swapdims
-  - tan
-  - tanh
-  - trace
-  - swapaxes
-  - topk
-  - tril
-  - true_divide
-  - trunc
-  - unbind
-  - unique_consecutive
-  - var
-  - xlogy
-  - from_numpy
-  - std
-  - var
-  - diagonal
-  - sum
-
-mint:
-  - add
-  - add_ex
-  - any_ex
-  - argmax
-  - avg_pool2d
-  - baddbmm
-  - baddbmm_ex
-  - batch_norm
-  - binary_cross_entropy_with_logits
-  - bmm
-  - broadcast_to
-  - conv2d
-  - conv_transpose2d
-  - cos
-  - cross
-  - cummax
-  - cummin
-  - cumsum
-  - div
-  - divide
-  - embedding
-  - erf
-  - erfinv
-  - exp
-  - gather
-  - gelu
-  - greater
-  - grid_sample
-  - group_norm
-  - index_select
-  - interpolate
-  - layer_norm
-  - leaky_relu
-  - linear
-  - linspace
-  - log
-  - logical_and
-  - logical_not
-  - logical_or
-  - masked_select
-  - matmul
-  - max_pool2d
-  - mean
-  - mean_ex
-  - mul
-  - normal
-  - permute
-  - permute_ex
-  - pow
-  - prod
-  - reciprocal
-  - relu
-  - remainder
-  - repeat_interleave
-  - rsqrt
-  - searchsorted
-  - sigmoid
-  - silu
-  - sin
-  - softmax
-  - softplus
-  - sort
-  - sqrt
-  - sqrt_ex
-  - square
-  - stack
-  - sub
-  - sub_ex
-  - sum
-  - tanh
-  - topk
-  - triu
-  - xlogy
-
-mint.nn.functional:
-  - absolute_import
-  - avg_pool2d
-  - batch_norm
-  - batch_norm_ex
-  - bce_with_logits
-  - binary_cross_entropy_with_logits
-  - conv_transpose2d
-  - dense
-  - embedding
-  - fold
-  - gelu
-  - grid_sample
-  - group_norm
-  - interpolate
-  - layer_norm
-  - leaky_relu
-  - linear
-  - max_pool2d
-  - max_pool2d_ex
-  - normal
-  - one_hot
-  - one_hot_ext
-  - pad
-  - relu
-  - sigmoid
-  - silu
-  - softmax
-  - softmax_ex
-  - softplus
-  - tanh
-  - unfold

msprobe/mindspore/free_benchmark/handler/base_handler.py

@@ -1,105 +0,0 @@
-# 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.
-
-import math
-from abc import ABC, abstractmethod
-from typing import Any, Optional, Tuple
-
-import mindspore as ms
-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.common.utils import Tools
-
-
-class BaseHandler(ABC):
-
-    def __init__(self, api_name_with_id: str):
-        self.api_name_with_id = api_name_with_id
-
-    @staticmethod
-    def pre_calculate(original_output, fuzzed_output):
-        abs_tol = FreeBenchmarkConst.PERT_VALUE_DICT.get(fuzzed_output.dtype,
-                                                         FreeBenchmarkConst.PERT_VALUE_DICT.get(ms.float32))
-
-        return original_output.to(fuzzed_output.dtype), fuzzed_output, abs_tol
-
-    @staticmethod
-    def get_threshold(dtype):
-        err = Tools.get_default_error_threshold(dtype)
-        return err
-
-    @staticmethod
-    def convert_overflow_ratio_to_consistent(ratio):
-        if math.isnan(ratio) or math.isinf(ratio):
-            return FreeBenchmarkConst.NO_CHANGE_ERROR_THRESHOLD
-        return ratio
-
-    @staticmethod
-    def get_endless_norm(first_tensor, second_tensor, abs_tol):
-        if first_tensor.dtype != ms.bfloat16 and second_tensor.dtype != ms.bfloat16:
-            ratio_tensor1 = ops.where(ops.abs(second_tensor) > abs_tol, ops.div(first_tensor, second_tensor), 1)
-            ratio_tensor2 = ops.where(ops.abs(first_tensor) > abs_tol, ops.div(second_tensor, first_tensor), 1)
-        else:
-            ratio_tensor1 = ops.where(ops.abs(second_tensor).to(ms.float32) > abs_tol,
-                                      ops.div(first_tensor.to(ms.float32), second_tensor.to(ms.float32)), 1)
-            ratio_tensor2 = ops.where(ops.abs(first_tensor).to(ms.float32) > abs_tol,
-                                      ops.div(second_tensor.to(ms.float32), first_tensor.to(ms.float32)), 1)
-        norm1 = BaseHandler.convert_overflow_ratio_to_consistent(ops.max(ratio_tensor1)[0].to(ms.float32).item())
-        norm2 = BaseHandler.convert_overflow_ratio_to_consistent(ops.max(ratio_tensor2)[0].to(ms.float32).item())
-        norm3 = BaseHandler.convert_overflow_ratio_to_consistent(ops.min(ratio_tensor1)[0].to(ms.float32).item())
-        ratio = FreeBenchmarkConst.SYMBOL_FLIPPING_RATIO if norm3 < 0 else max(norm1, norm2)
-
-        return ratio
-
-    @staticmethod
-    def ratio_calculate(original_output, fuzzed_output) -> float:
-        try:
-            original_output, fuzzed_output, abs_tol = BaseHandler.pre_calculate(original_output, fuzzed_output)
-        except Exception as e:
-            logger.error(f"When computing ratio, y1 or y2 dtype is not supported {str(e)}")
-            return FreeBenchmarkConst.NO_CHANGE_ERROR_THRESHOLD
-
-        abs_tol = abs_tol ** 0.5
-
-        return BaseHandler.get_endless_norm(original_output, fuzzed_output, abs_tol)
-
-    @staticmethod
-    def npu_compare(original_output, fuzzed_output) -> Tuple[bool, Optional[float]]:
-        if not isinstance(fuzzed_output, Tensor):
-            logger.error(f"The compare for output type `{type(fuzzed_output)}` is not supported")
-            return True, 1.0
-
-        # 范数计算等
-        err_thd = BaseHandler.get_threshold(original_output.dtype)
-        ratio = BaseHandler.ratio_calculate(original_output, fuzzed_output)
-        is_consistent = err_thd >= ratio >= 1.0 / err_thd
-        return is_consistent, ratio
-
-    @staticmethod
-    def is_float_tensor(output) -> bool:
-        if isinstance(output, Tensor) and ops.is_floating_point(output):
-            return True
-        if isinstance(output, (list, tuple)):
-            for i in output:
-                if isinstance(i, Tensor) and ops.is_floating_point(i):
-                    return True
-        return False
-
-    @abstractmethod
-    def handle(self, params: HandlerParams) -> Any:
-        pass