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

msprobe/pytorch/api_accuracy_checker/common/config.py

@@ -1,50 +1,53 @@
-import os
-import yaml
-from msprobe.pytorch.api_accuracy_checker.common.utils import check_file_or_directory_path
-from msprobe.pytorch.hook_module.utils import WrapFunctionalOps, WrapTensorOps, WrapTorchOps
-from msprobe.core.common.file_check import FileOpen
-
-WrapApi = set(WrapFunctionalOps) | set(WrapTensorOps) | set(WrapTorchOps)
-
-
-class Config:
-    def __init__(self, yaml_file):
-        check_file_or_directory_path(yaml_file, False)
-        with FileOpen(yaml_file, 'r') as file:
-            config = yaml.safe_load(file)
-        self.config = {key: self.validate(key, value) for key, value in config.items()}
-
-    def __getattr__(self, item):
-        return self.config[item]
-
-    def __str__(self):
-        return '\n'.join(f"{key}={value}" for key, value in self.config.items())
-
-    @staticmethod
-    def validate(key, value):
-        validators = {
-            'white_list': list,
-            'error_data_path': str,
-            'precision': int
-        }
-        if key not in validators:
-            raise ValueError(f"{key} must be one of {validators.keys()}")
-        if not isinstance(value, validators.get(key)):
-            raise ValueError(f"{key} must be {validators[key].__name__} type")
-        if key == 'precision' and value < 0:
-            raise ValueError("precision must be greater than 0")
-        if key == 'white_list':
-            if not isinstance(value, list):
-                raise ValueError("white_list must be a list type")
-            if not all(isinstance(i, str) for i in value):
-                raise ValueError("All elements in white_list must be of str type")
-            invalid_api = [i for i in value if i not in WrapApi]
-            if invalid_api:
-                raise ValueError(
-                    f"{', '.join(invalid_api)} is not in support_wrap_ops.yaml, please check the white_list")
-        return value
-
-
-cur_path = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
-yaml_path = os.path.join(cur_path, "config.yaml")
-msCheckerConfig = Config(yaml_path)
+import os
+from msprobe.core.common.file_utils import load_yaml, check_file_or_directory_path
+from msprobe.pytorch.pt_config import RunUTConfig
+
+
+class Config:
+    def __init__(self, yaml_file):
+        check_file_or_directory_path(yaml_file, False)
+        config = load_yaml(yaml_file)
+        self.config = {key: self.validate(key, value) for key, value in config.items()}
+
+    def __getattr__(self, item):
+        return self.config[item]
+
+    def __str__(self):
+        return '\n'.join(f"{key}={value}" for key, value in self.config.items())
+
+    @staticmethod
+    def validate(key, value):
+        validators = {
+            'white_list': list,
+            'black_list': list,
+            'error_data_path': str,
+            'precision': int,
+            'is_online': bool,
+            'nfs_path': str,
+            'host': str,
+            'port': int,
+            'rank_list': list,
+            'tls_path': str
+        }
+        if key not in validators:
+            raise ValueError(f"{key} must be one of {validators.keys()}")
+        if not isinstance(value, validators.get(key)):
+            raise ValueError(f"{key} must be {validators[key].__name__} type")
+        if key == 'precision' and value < 0:
+            raise ValueError("precision must be greater than 0")
+        if key == 'white_list':
+            RunUTConfig.check_filter_list_config(key, value)
+        if key == 'black_list':
+            RunUTConfig.check_filter_list_config(key, value)
+        if key == 'error_data_path':
+            RunUTConfig.check_error_data_path_config(value)
+        if key == 'nfs_path':
+            RunUTConfig.check_nfs_path_config(value)
+        if key == 'tls_path':
+            RunUTConfig.check_tls_path_config(value)
+        return value
+
+
+cur_path = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+yaml_path = os.path.join(cur_path, "config.yaml")
+msCheckerConfig = Config(yaml_path)

msprobe/pytorch/api_accuracy_checker/common/utils.py

@@ -1,224 +1,214 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-# Copyright (C) 2023-2023. 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 json
-import os
-import re
-import csv
-
-import torch
-
-try:
-    import torch_npu
-except ImportError:
-    IS_GPU = True
-else:
-    IS_GPU = False
-
-from msprobe.pytorch.common.log import logger
-from msprobe.core.common.file_check import FileChecker, FileOpen, change_mode, create_directory
-from msprobe.core.common.const import Const, FileCheckConst
-from msprobe.core.common.utils import CompareException
-
-
-class DumpException(CompareException):
-    pass
-
-
-def write_csv(data, filepath):
-    with FileOpen(filepath, 'a', encoding='utf-8-sig') as f:
-        writer = csv.writer(f)
-        writer.writerows(data)
-
-
-def check_object_type(check_object, allow_type):
-    """
-    Function Description:
-        Check if the object belongs to a certain data type
-    Parameter:
-        check_object: the object to be checked
-        allow_type: legal data type
-    Exception Description:
-        when invalid data throw exception
-    """
-    if not isinstance(check_object, allow_type):
-        logger.error(f"{check_object} not of {allow_type} type")
-        raise CompareException(CompareException.INVALID_DATA_ERROR)
-
-
-def check_file_or_directory_path(path, isdir=False):
-    """
-    Function Description:
-        check whether the path is valid
-    Parameter:
-        path: the path to check
-        isdir: the path is dir or file
-    Exception Description:
-        when invalid data throw exception
-    """
-    if isdir:
-        if not os.path.exists(path):
-            logger.error('The path {} is not exist.'.format(path))
-            raise CompareException(CompareException.INVALID_PATH_ERROR)
-
-        if not os.path.isdir(path):
-            logger.error('The path {} is not a directory.'.format(path))
-            raise CompareException(CompareException.INVALID_PATH_ERROR)
-
-        if not os.access(path, os.W_OK):
-            logger.error(
-                'The path {} does not have permission to write. Please check the path permission'.format(path))
-            raise CompareException(CompareException.INVALID_PATH_ERROR)
-    else:
-        if not os.path.isfile(path):
-            logger.error('{} is an invalid file or non-exist.'.format(path))
-            raise CompareException(CompareException.INVALID_PATH_ERROR)
-
-    if not os.access(path, os.R_OK):
-        logger.error(
-            'The path {} does not have permission to read. Please check the path permission'.format(path))
-        raise CompareException(CompareException.INVALID_PATH_ERROR)
-
-
-def get_json_contents(file_path):
-    ops = get_file_content_bytes(file_path)
-    try:
-        json_obj = json.loads(ops)
-    except ValueError as error:
-        logger.error('Failed to load "%s". %s' % (file_path, str(error)))
-        raise CompareException(CompareException.INVALID_FILE_ERROR) from error
-    if not isinstance(json_obj, dict):
-        logger.error('Json file %s, content is not a dictionary!' % file_path)
-        raise CompareException(CompareException.INVALID_FILE_ERROR)
-    return json_obj
-
-
-def get_file_content_bytes(file):
-    with FileOpen(file, 'rb') as file_handle:
-        return file_handle.read()
-
-
-class SoftlinkCheckException(Exception):
-    pass
-
-
-def check_need_convert(api_name):
-    convert_type = None
-    for key, value in Const.CONVERT_API.items():
-        if api_name not in value:
-            continue
-        else:
-            convert_type = key
-    return convert_type
-
-
-def api_info_preprocess(api_name, api_info_dict):
-    """
-    Function Description:
-        Preprocesses the API information.
-    Parameter:
-        api_name: Name of the API.
-        api_info_dict: argument of the API.
-    Return api_info_dict:
-        convert_type: Type of conversion.
-        api_info_dict: Processed argument of the API.
-    """
-    convert_type = check_need_convert(api_name)
-    if api_name == 'cross_entropy':
-        api_info_dict = cross_entropy_process(api_info_dict)
-    return convert_type, api_info_dict
-
-
-def cross_entropy_process(api_info_dict):
-    """
-    Function Description:
-        Preprocesses the cross_entropy API information.
-    Parameter:
-        api_info_dict: argument of the API.
-    Return api_info_dict:
-        api_info_dict: Processed argument of the API.
-    """
-    if 'args' in api_info_dict and len(api_info_dict['args']) > 1 and 'Min' in api_info_dict['args'][1]:
-        if api_info_dict['args'][1]['Min'] <= 0:
-            # The second argument in cross_entropy should be -100 or not less than 0
-            api_info_dict['args'][1]['Min'] = 0
-    return api_info_dict
-
-
-def initialize_save_path(save_path, dir_name):
-    data_path = os.path.join(save_path, dir_name)
-    if os.path.exists(data_path):
-        logger.warning(f"{data_path} already exists, it will be overwritten")
-    else:
-        os.mkdir(data_path, mode=FileCheckConst.DATA_DIR_AUTHORITY)
-    data_path_checker = FileChecker(data_path, FileCheckConst.DIR)
-    data_path_checker.common_check()
-
-
-def write_pt(file_path, tensor):
-    if os.path.exists(file_path):
-        raise ValueError(f"File {file_path} already exists")
-    torch.save(tensor, file_path)
-    full_path = os.path.realpath(file_path)
-    change_mode(full_path, FileCheckConst.DATA_FILE_AUTHORITY)
-    return full_path
-
-
-def get_real_data_path(file_path):
-    targets = ['forward_real_data', 'backward_real_data', 'ut_error_data\d+']
-    pattern = re.compile(r'({})'.format('|'.join(targets)))
-    match = pattern.search(file_path)
-    if match:
-        target_index = match.start()
-        target_path = file_path[target_index:]
-        return target_path
-    else:
-        raise DumpException(DumpException.INVALID_PATH_ERROR)
-
-
-def get_full_data_path(data_path, real_data_path):
-    if not data_path:
-        return data_path
-    full_data_path = os.path.join(real_data_path, data_path)
-    return os.path.realpath(full_data_path)
-
-
-class UtDataProcessor:
-    def __init__(self, save_path):
-        self.save_path = save_path
-        self.index = 0
-
-    def save_tensors_in_element(self, api_name, element):
-        self.index = 0
-        self._save_recursive(api_name, element)
-
-    def _save_recursive(self, api_name, element):
-        if isinstance(element, torch.Tensor):
-            api_args = api_name + Const.SEP + str(self.index)
-            create_directory(self.save_path)
-            file_path = os.path.join(self.save_path, f'{api_args}.pt')
-            write_pt(file_path, element.contiguous().cpu().detach())
-            self.index += 1
-        elif element is None or isinstance(element, (bool, int, float, str, slice)):
-            self.index += 1
-        elif isinstance(element, (list, tuple)):
-            for item in element:
-                self._save_recursive(api_name, item)
-        elif isinstance(element, dict):
-            for value in element.values():
-                self._save_recursive(api_name, value)
-        else:
-            self.index += 1
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# Copyright (C) 2023-2023. 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 os
+import re
+from collections import namedtuple
+
+import torch
+
+try:
+    import torch_npu
+except ImportError:
+    IS_GPU = True
+else:
+    IS_GPU = False
+
+from msprobe.pytorch.common.log import logger
+from msprobe.pytorch.common.utils import save_pt
+from msprobe.core.common.file_utils import create_directory
+from msprobe.core.common.const import Const
+from msprobe.core.common.utils import CompareException
+
+ApiData = namedtuple('ApiData', ['name', 'args', 'kwargs', 'result', 'step', 'rank'],
+                     defaults=['unknown', None, None, None, 0, 0])
+
+
+class DumpException(CompareException):
+    pass
+
+
+def check_object_type(check_object, allow_type):
+    """
+    Function Description:
+        Check if the object belongs to a certain data type
+    Parameter:
+        check_object: the object to be checked
+        allow_type: legal data type
+    Exception Description:
+        when invalid data throw exception
+    """
+    if not isinstance(check_object, allow_type):
+        logger.error(f"{check_object} not of {allow_type} type")
+        raise CompareException(CompareException.INVALID_DATA_ERROR)
+
+
+class SoftlinkCheckException(Exception):
+    pass
+
+
+def check_need_convert(api_name):
+    convert_type = None
+    for key, value in Const.CONVERT_API.items():
+        if api_name not in value:
+            continue
+        else:
+            convert_type = key
+    return convert_type
+
+
+def api_info_preprocess(api_name, api_info_dict):
+    """
+    Function Description:
+        Preprocesses the API information.
+    Parameter:
+        api_name: Name of the API.
+        api_info_dict: argument of the API.
+    Return api_info_dict:
+        convert_type: Type of conversion.
+        api_info_dict: Processed argument of the API.
+    """
+    convert_type = check_need_convert(api_name)
+    if api_name == 'cross_entropy':
+        api_info_dict = cross_entropy_process(api_info_dict)
+    return convert_type, api_info_dict
+
+
+def cross_entropy_process(api_info_dict):
+    """
+    Function Description:
+        Preprocesses the cross_entropy API information.
+    Parameter:
+        api_info_dict: argument of the API.
+    Return api_info_dict:
+        api_info_dict: Processed argument of the API.
+    """
+    if 'input_args' in api_info_dict and len(api_info_dict['input_args']) > 1 and 'Min' in api_info_dict['input_args'][1]:
+        if api_info_dict['input_args'][1]['Min'] <= 0:
+            # The second argument in cross_entropy should be -100 or not less than 0
+            api_info_dict['input_args'][1]['Min'] = 0
+    return api_info_dict
+
+
+def initialize_save_path(save_path, dir_name):
+    data_path = os.path.join(save_path, dir_name)
+    create_directory(data_path)
+    return data_path
+
+
+def get_real_data_path(file_path):
+    targets = ['forward_real_data', 'backward_real_data', 'ut_error_data\d+']
+    pattern = re.compile(r'({})'.format('|'.join(targets)))
+    match = pattern.search(file_path)
+    if match:
+        target_index = match.start()
+        target_path = file_path[target_index:]
+        return target_path
+    else:
+        raise DumpException(DumpException.INVALID_PATH_ERROR)
+
+
+def get_full_data_path(data_path, real_data_path):
+    if not data_path:
+        return data_path
+    full_data_path = os.path.join(real_data_path, data_path)
+    return os.path.realpath(full_data_path)
+
+
+class UtDataProcessor:
+    def __init__(self, save_path):
+        self.save_path = save_path
+        self.index = 0
+
+    def save_tensors_in_element(self, api_name, element):
+        self.index = 0
+        self._save_recursive(api_name, element)
+
+    def _save_recursive(self, api_name, element):
+        if isinstance(element, torch.Tensor):
+            api_args = api_name + Const.SEP + str(self.index)
+            create_directory(self.save_path)
+            file_path = os.path.join(self.save_path, f'{api_args}.pt')
+            try:
+                tensor = element.contiguous().detach().cpu()
+            except Exception as err:
+                logger.error(f"Failed to transfer tensor to cpu for {api_args}")
+                raise DumpException(DumpException.INVALID_DATA_ERROR) from err
+            save_pt(tensor, file_path)
+            self.index += 1
+        elif element is None or isinstance(element, (bool, int, float, str, slice)):
+            self.index += 1
+        elif isinstance(element, (list, tuple)):
+            for item in element:
+                self._save_recursive(api_name, item)
+        elif isinstance(element, dict):
+            for value in element.values():
+                self._save_recursive(api_name, value)
+        else:
+            self.index += 1
+
+
+def extract_basic_api_segments(api_full_name):
+    """
+    Function Description:
+        Extract the name of the API.
+    Parameter:
+        api_full_name: Full name of the API. Example: torch.matmul.0, torch.linalg.inv.0
+    Return:
+        api_type: Type of api. Example: torch, tensor, etc.
+        api_name: Name of api. Example: matmul, linalg.inv, etc.
+    """
+    api_type = None
+    api_parts = api_full_name.split(Const.SEP)
+    api_parts_length = len(api_parts)
+    if api_parts_length == Const.THREE_SEGMENT:
+        api_type, api_name, _ = api_parts
+    elif api_parts_length == Const.FOUR_SEGMENT:
+        api_type, prefix, api_name, _ = api_parts
+        api_name = Const.SEP.join([prefix, api_name])
+    else:
+        api_name = None
+    return api_type, api_name
+
+
+def extract_detailed_api_segments(full_api_name_with_direction_status):
+    """
+    Function Description:
+        Extract the name of the API.
+    Parameter:
+        full_api_name_with_direction_status: Full name of the API. Example: torch.matmul.0.forward.output.0
+    Return:
+        api_name: Name of api. Example: matmul, mul, etc.
+        full_api_name: Full name of api. Example: torch.matmul.0
+        direction_status: Direction status of api. Example: forward, backward, etc.
+    """
+    api_type = None
+    prefix = None
+    api_name = None
+    direction_status = None
+    api_parts = full_api_name_with_direction_status.split(Const.SEP)
+    api_parts_length = len(api_parts)
+    if api_parts_length == Const.SIX_SEGMENT:
+        api_type, api_name, api_order, direction_status, _, _ = api_parts
+        full_api_name = Const.SEP.join([api_type, api_name, api_order])
+    elif api_parts_length == Const.SEVEN_SEGMENT:
+        api_type, prefix, api_name, api_order, direction_status, _, _ = api_parts
+        full_api_name = Const.SEP.join([api_type, prefix, api_name, api_order])
+        api_name = Const.SEP.join([prefix, api_name])
+    else:
+        full_api_name = None
+    return api_name, full_api_name, direction_status
+