mindstudio-probe 1.0.4__py3-none-any.whl → 1.1.1__py3-none-any.whl

msprobe/core/compare/npy_compare.py

@@ -1,16 +1,45 @@
+# 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 abc
+
 import numpy as np
 from msprobe.core.common.utils import format_value
 from msprobe.core.common.const import Const, CompareConst
 from msprobe.core.common.log import logger
 
+from msprobe.core.common.utils import CompareException
+
 
 def handle_inf_nan(n_value, b_value):
+    def convert_to_float(value):
+        try:
+            if isinstance(value, np.ndarray):
+                return value.astype(float)
+            else:
+                return float(value)
+        except ValueError as e:
+            logger.error('\n'.join(e.args))
+            raise CompareException(CompareException.INVALID_DATA_ERROR) from e
+
+    n_value_convert, b_value_convert = convert_to_float(n_value), convert_to_float(b_value)
     """处理inf和nan的数据"""
-    n_inf = np.isinf(n_value)
-    b_inf = np.isinf(b_value)
-    n_nan = np.isnan(n_value)
-    b_nan = np.isnan(b_value)
+    n_inf = np.isinf(n_value_convert)
+    b_inf = np.isinf(b_value_convert)
+    n_nan = np.isnan(n_value_convert)
+    b_nan = np.isnan(b_value_convert)
     n_invalid = np.any(n_inf) or np.any(n_nan)
     b_invalid = np.any(b_inf) or np.any(b_nan)
     if n_invalid or b_invalid:
@@ -35,7 +64,11 @@ def get_error_type(n_value, b_value, error_flag):
     if not n_value.shape:  # 判断数据是否为标量
         return n_value, b_value, False
 
-    n_value, b_value = handle_inf_nan(n_value, b_value)  # 判断是否有nan/inf数据
+    try:
+        n_value, b_value = handle_inf_nan(n_value, b_value)  # 判断是否有nan/inf数据
+    except CompareException:
+        logger.error('Numpy data is unreadable, please check!')
+        return CompareConst.UNREADABLE, CompareConst.UNREADABLE, True
     if n_value is CompareConst.NAN or b_value is CompareConst.NAN:
         return CompareConst.NAN, CompareConst.NAN, True
     return n_value, b_value, False
@@ -58,7 +91,9 @@ def get_error_message(n_value, b_value, npu_op_name, error_flag, error_file=None
     """获取异常情况的错误信息"""
     if error_flag:
         if n_value == CompareConst.READ_NONE:
-            if error_file:
+            if error_file == 'no_bench_data':
+                return 'Bench does not have data file.'
+            elif error_file is not None:
                 return "Dump file: {} not found.".format(error_file)
             return CompareConst.NO_BENCH
         if n_value == CompareConst.NONE:
@@ -67,6 +102,8 @@ def get_error_message(n_value, b_value, npu_op_name, error_flag, error_file=None
             return "Shape of NPU and bench Tensor do not match. Skipped."
         if n_value == CompareConst.NAN:
             return "The position of inf or nan in NPU and bench Tensor do not match."
+        if n_value == CompareConst.UNREADABLE:
+            return "The npy data is unable to be read or compared, please check dump data files."
     else:
         if not n_value.shape:
             return "This is type of scalar data, can not compare."
@@ -78,10 +115,8 @@ def get_error_message(n_value, b_value, npu_op_name, error_flag, error_file=None
 
 def npy_data_check(n_value, b_value):
     error_message = ""
-    if n_value is None or b_value is None:
-        error_message += "Dump file not found.\n"
-    if n_value == "" or b_value == "":
-        error_message += "Dump file not found.\n"
+    if not isinstance(n_value, np.ndarray) or not isinstance(b_value, np.ndarray):
+        error_message += "Dump file is not ndarray.\n"
 
     # 检查 n_value 和 b_value 是否为空
     if not error_message and (n_value.size == 0 or b_value.size == 0):
@@ -96,8 +131,13 @@ def npy_data_check(n_value, b_value):
             error_message += "Dtype of NPU and bench Tensor do not match. Skipped.\n"
 
     if not error_message:
-        n_value, b_value = handle_inf_nan(n_value, b_value)  # 判断是否有 nan/inf 数据
-        if CompareConst.NAN in (n_value, b_value):
+        try:
+            n_value, b_value = handle_inf_nan(n_value, b_value)  # 判断是否有nan/inf数据
+        except CompareException:
+            logger.error('Numpy data is unreadable, please check!')
+            return True, 'Numpy data is unreadable, please check!'
+        # handle_inf_nan 会返回'Nan'或ndarray类型，使用类型判断是否存在无法处理的nan/inf数据
+        if not isinstance(n_value, np.ndarray) or not isinstance(b_value, np.ndarray):
             error_message += "The position of inf or nan in NPU and bench Tensor do not match.\n"
     if error_message == "":
         error_flag = False
@@ -146,14 +186,14 @@ class GetCosineSimilarity(TensorComparisonBasic):
 
     def apply(self, n_value, b_value, error_flag, relative_err=None):
         if error_flag:
-            if n_value == CompareConst.READ_NONE:
-                return CompareConst.NONE, ''
+            if n_value == CompareConst.READ_NONE or n_value == CompareConst.UNREADABLE:
+                return CompareConst.UNSUPPORTED, ''
             if n_value == CompareConst.NONE:
                 return CompareConst.UNSUPPORTED, ''
             if n_value == CompareConst.SHAPE_UNMATCH:
                 return CompareConst.SHAPE_UNMATCH, ''
             if n_value == CompareConst.NAN:
-                return "N/A", ''
+                return CompareConst.N_A, ''
 
         if not n_value.shape:
             return CompareConst.UNSUPPORTED, ''
@@ -184,17 +224,20 @@ class GetMaxAbsErr(TensorComparisonBasic):
     """计算最大绝对误差"""
     def apply(self, n_value, b_value, error_flag, relative_err=None):
         if error_flag:
-            if n_value == CompareConst.READ_NONE:
-                return CompareConst.NONE, ""
+            if n_value == CompareConst.READ_NONE or n_value == CompareConst.UNREADABLE:
+                return CompareConst.UNSUPPORTED, ""
             if n_value == CompareConst.NONE:
                 return 0, ""
             if n_value == CompareConst.SHAPE_UNMATCH:
                 return CompareConst.SHAPE_UNMATCH, ""
             if n_value == CompareConst.NAN:
-                return "N/A", ""
+                return CompareConst.N_A, ""
 
         temp_res = n_value - b_value
         max_value = np.max(np.abs(temp_res))
+        if np.isnan(max_value):
+            message = 'Cannot compare by MaxRelativeError, the data contains nan/inf/-inf in dump data.'
+            return CompareConst.NAN, message
         return format_value(max_value), ""
 
 
@@ -214,20 +257,20 @@ class GetMaxRelativeErr(TensorComparisonBasic):
     """计算最大相对误差"""
     def apply(self, n_value, b_value, error_flag, relative_err=None):
         if error_flag:
-            if n_value == CompareConst.READ_NONE:
-                return CompareConst.NONE, ''
+            if n_value == CompareConst.READ_NONE or n_value == CompareConst.UNREADABLE:
+                return CompareConst.UNSUPPORTED, ''
             if n_value == CompareConst.NONE:
                 return 0, ''
             if n_value == CompareConst.SHAPE_UNMATCH:
                 return CompareConst.SHAPE_UNMATCH, ''
             if n_value == CompareConst.NAN:
-                return "N/A", ''
+                return CompareConst.N_A, ''
 
         if relative_err is None:
             relative_err = get_relative_err(n_value, b_value)
         max_relative_err = np.max(np.abs(relative_err))
         if np.isnan(max_relative_err):
-            message = 'Cannot compare by MaxRelativeError, the data contains nan in dump data.'
+            message = 'Cannot compare by MaxRelativeError, the data contains nan/inf/-inf in dump data.'
             return CompareConst.NAN, message
         return format_value(max_relative_err), ''
 
@@ -236,14 +279,14 @@ class GetThousandErrRatio(TensorComparisonBasic):
     """计算相对误差小于千分之一的比例"""
     def apply(self, n_value, b_value, error_flag, relative_err=None):
         if error_flag:
-            if n_value == CompareConst.READ_NONE:
-                return CompareConst.NONE, ""
+            if n_value == CompareConst.READ_NONE or n_value == CompareConst.UNREADABLE:
+                return CompareConst.UNSUPPORTED, ""
             if n_value == CompareConst.NONE:
                 return 0, ""
             if n_value == CompareConst.SHAPE_UNMATCH:
                 return CompareConst.SHAPE_UNMATCH, ""
             if n_value == CompareConst.NAN:
-                return "N/A", ""
+                return CompareConst.N_A, ""
 
         if not n_value.shape:
             return CompareConst.NAN, ""
@@ -258,14 +301,14 @@ class GetFiveThousandErrRatio(TensorComparisonBasic):
     """计算相对误差小于千分之五的比例"""
     def apply(self, n_value, b_value, error_flag, relative_err=None):
         if error_flag:
-            if n_value == CompareConst.READ_NONE:
-                return CompareConst.NONE, ""
+            if n_value == CompareConst.READ_NONE or n_value == CompareConst.UNREADABLE:
+                return CompareConst.UNSUPPORTED, ""
             if n_value == CompareConst.NONE:
                 return 0, ""
             if n_value == CompareConst.SHAPE_UNMATCH:
                 return CompareConst.SHAPE_UNMATCH, ""
             if n_value == CompareConst.NAN:
-                return "N/A", ""
+                return CompareConst.N_A, ""
 
         if not n_value.shape:
             return CompareConst.NAN, ""
@@ -273,7 +316,8 @@ class GetFiveThousandErrRatio(TensorComparisonBasic):
             relative_err = get_relative_err(n_value, b_value)
         if not np.size(relative_err):
             return CompareConst.NAN, ""
-        return format_value(np.sum(relative_err < CompareConst.FIVE_THOUSAND_RATIO_THRESHOLD) / np.size(relative_err)), ""
+        return format_value(
+            np.sum(relative_err < CompareConst.FIVE_THOUSAND_RATIO_THRESHOLD) / np.size(relative_err)), ""
 
 
 class CompareOps: