mindstudio-probe 1.0.1__py3-none-any.whl

msprobe/test/pytorch_ut/api_accuracy_checker/compare/test_compare.py

@@ -0,0 +1,125 @@
+import csv
+import os
+import shutil
+import time
+import unittest
+
+import numpy as np
+import torch.nn.functional
+
+from msprobe.pytorch.api_accuracy_checker.compare.compare import Comparator
+from msprobe.pytorch.api_accuracy_checker.compare.compare_column import CompareColumn
+from msprobe.pytorch.api_accuracy_checker.run_ut.run_ut import UtDataInfo
+
+current_time = time.strftime("%Y%m%d%H%M%S")
+RESULT_FILE_NAME = "accuracy_checking_result_" + current_time + ".csv"
+DETAILS_FILE_NAME = "accuracy_checking_details_" + current_time + '.csv'
+base_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+
+class TestCompare(unittest.TestCase):
+    def setUp(self):
+        self.output_path = os.path.join(base_dir, "../compare_result")
+        os.mkdir(self.output_path, mode=0o750)
+        self.result_csv_path = os.path.join(self.output_path, RESULT_FILE_NAME)
+        self.details_csv_path = os.path.join(self.output_path, DETAILS_FILE_NAME)
+        self.is_continue_run_ut = False
+        self.compare = Comparator(self.result_csv_path, self.details_csv_path, self.is_continue_run_ut)
+
+    def tearDown(self) -> None:
+        if os.path.exists(self.output_path):
+            shutil.rmtree(self.output_path)
+
+    def test_compare_dropout(self):
+        dummy_input = torch.randn(100, 100)
+        bench_out = torch.nn.functional.dropout2d(dummy_input, 0.3)
+        npu_out = torch.nn.functional.dropout2d(dummy_input, 0.3)
+        self.assertTrue(self.compare._compare_dropout(bench_out, npu_out))
+
+    def test_compare_core_wrapper(self):
+        dummy_input = torch.randn(100, 100)
+        bench_out, npu_out = dummy_input, dummy_input
+        test_final_success, detailed_result_total = self.compare._compare_core_wrapper("api", bench_out, npu_out)
+        actual_cosine_similarity = detailed_result_total[0][3]
+        # 设置一个小的公差值
+        tolerance = 1e-4
+        # 判断实际的余弦相似度值是否在预期值的公差范围内
+        self.assertTrue(np.isclose(actual_cosine_similarity, 1.0, atol=tolerance))
+        # 对其他值进行比较，确保它们符合预期
+        detailed_result_total[0][3] = 1.0
+        self.assertEqual(detailed_result_total, [['torch.float32', 'torch.float32', (100, 100), 1.0, 0.0, ' ', ' ', ' ',
+                                                ' ', 0.0, 0.0, 0, 0.0, 0.0, ' ', ' ', ' ', ' ', ' ', ' ', 'pass', 
+                                                '\nMax abs error is less than 0.001, consider as pass, skip other check and set to SPACE.\n']])
+        self.assertTrue(test_final_success)
+
+        bench_out, npu_out = [dummy_input, dummy_input], [dummy_input, dummy_input]
+        test_final_success, detailed_result_total = self.compare._compare_core_wrapper("api", bench_out, npu_out)
+        actual_cosine_similarity = detailed_result_total[0][3]
+        self.assertTrue(np.isclose(actual_cosine_similarity, 1.0, atol=tolerance))
+        actual_cosine_similarity = detailed_result_total[1][3]
+        self.assertTrue(np.isclose(actual_cosine_similarity, 1.0, atol=tolerance))
+        detailed_result_total[0][3] = 1.0
+        detailed_result_total[1][3] = 1.0
+        self.assertTrue(test_final_success)
+        self.assertEqual(detailed_result_total, [['torch.float32', 'torch.float32', (100, 100), 1.0, 0.0, ' ', ' ', ' ',
+                                                ' ', 0.0, 0.0, 0, 0.0, 0.0, ' ', ' ', ' ', ' ', ' ', ' ', 'pass', 
+                                                '\nMax abs error is less than 0.001, consider as pass, skip other check and set to SPACE.\n'], 
+                                                 ['torch.float32', 'torch.float32', (100, 100), 1.0, 0.0, ' ', ' ', ' ', 
+                                                ' ', 0.0, 0.0, 0, 0.0, 0.0, ' ', ' ', ' ', ' ', ' ', ' ', 'pass', 
+                                                '\nMax abs error is less than 0.001, consider as pass, skip other check and set to SPACE.\n']])
+
+    def test_compare_output(self):
+        bench_out, npu_out = torch.randn(100, 100), torch.randn(100, 100)
+        bench_grad, npu_grad = [torch.randn(100, 100)], [torch.randn(100, 100)]
+        api_name = 'Functional.conv2d.0'
+        data_info = UtDataInfo(bench_grad, npu_grad, bench_out, npu_out, None, None, None)
+        is_fwd_success, is_bwd_success = self.compare.compare_output(api_name, data_info)
+        self.assertFalse(is_fwd_success)
+        # is_bwd_success should be checked
+
+        dummy_input = torch.randn(100, 100)
+        bench_out, npu_out = dummy_input, dummy_input
+        data_info = UtDataInfo(None, None, bench_out, npu_out, None, None, None)
+        is_fwd_success, is_bwd_success = self.compare.compare_output(api_name, data_info)
+        self.assertTrue(is_fwd_success)
+        self.assertTrue(is_bwd_success)
+
+    def test_record_results(self):
+        args = ('Functional.conv2d.0', False, 'N/A', [['torch.float64', 'torch.float32', (32, 64, 112, 112), 1.0,
+                                                       0.012798667686, 'N/A', 0.81631212311, 0.159979121213, 'N/A',
+                                                       'error', '\n']], None, 0)
+        self.compare.record_results(args)
+        with open(self.details_csv_path, 'r') as file:
+            csv_reader = csv.reader(file)
+            next(csv_reader)
+            api_name_list = [row[0] for row in csv_reader]
+        self.assertEqual(api_name_list[0], 'Functional.conv2d.0.forward.output.0')
+
+    def test_compare_torch_tensor(self):
+        cpu_output = torch.Tensor([1.0, 2.0, 3.0])
+        npu_output = torch.Tensor([1.0, 2.0, 3.0])
+        compare_column = CompareColumn()
+        status, compare_column, message = self.compare._compare_torch_tensor("api", cpu_output, npu_output,
+                                                                             compare_column)
+        self.assertEqual(status, "pass")
+
+    def test_compare_bool_tensor(self):
+        cpu_output = np.array([True, False, True])
+        npu_output = np.array([True, False, True])
+        self.assertEqual(self.compare._compare_bool_tensor(cpu_output, npu_output), (0.0, 'pass', ''))
+
+    def test_compare_builtin_type(self):
+        compare_column = CompareColumn()
+        bench_out = 1
+        npu_out = 1
+        status, compare_result, message = self.compare._compare_builtin_type(bench_out, npu_out, compare_column)
+        self.assertEqual((status, compare_result.error_rate, message), ('pass', 0, ''))
+
+    def test_compare_float_tensor(self):
+        cpu_output = torch.Tensor([1.0, 2.0, 3.0])
+        npu_output = torch.Tensor([1.0, 2.0, 3.0])
+        compare_column = CompareColumn()
+        status, compare_column, message = self.compare._compare_float_tensor("api", cpu_output.numpy(),
+                                                                             npu_output.numpy(),
+                                                                             compare_column, npu_output.dtype)
+        self.assertEqual(status, "pass")

msprobe/test/pytorch_ut/api_accuracy_checker/compare/test_compare_column.py

@@ -0,0 +1,10 @@
+import unittest
+
+from msprobe.pytorch.api_accuracy_checker.compare.compare_column import ApiPrecisionOutputColumn
+
+
+class TestCompareColumns(unittest.TestCase):
+
+    def test_api_precision_output_column(self):
+        col = ApiPrecisionOutputColumn()
+        self.assertIsInstance(col.to_column_value(), list)

msprobe/test/pytorch_ut/api_accuracy_checker/compare/test_compare_utils.py

@@ -0,0 +1,43 @@
+import unittest
+
+import numpy as np
+
+from msprobe.pytorch.api_accuracy_checker.common.utils import CompareException
+from msprobe.pytorch.api_accuracy_checker.compare.compare_utils import check_dtype_comparable, convert_str_to_float
+
+
+class TestCompareUtils(unittest.TestCase):
+    def test_check_dtype_comparable(self):
+        x = np.array([1, 2, 3], dtype=np.int32)
+        y = np.array([4, 5, 6], dtype=np.int32)
+        self.assertTrue(check_dtype_comparable(x, y))
+
+        x = np.array([1.0, 2.0, 3.0], dtype=np.float32)
+        y = np.array([4.0, 5.0, 6.0], dtype=np.float32)
+        self.assertTrue(check_dtype_comparable(x, y))
+
+        x = np.array([True, False, True], dtype=np.bool_)
+        y = np.array([False, True, False], dtype=np.bool_)
+        self.assertTrue(check_dtype_comparable(x, y))
+
+        x = np.array([1, 2, 3], dtype=np.int32)
+        y = np.array([4.0, 5.0, 6.0], dtype=np.float32)
+        self.assertFalse(check_dtype_comparable(x, y))
+
+        x = np.array([1, 2, 3], dtype=np.int32)
+        y = np.array([True, False, True], dtype=np.bool_)
+        self.assertFalse(check_dtype_comparable(x, y))
+
+    def test_convert_str_to_float_when_valid_float(self):
+        self.assertEqual(convert_str_to_float("123.45"), 123.45)
+
+    def test_convert_str_to_float_when_valid_int(self):
+        self.assertEqual(convert_str_to_float("123.0"), 123.0)
+
+    def test_convert_str_to_float_when_valid_int_with_spaces(self):
+        self.assertEqual(convert_str_to_float("   123.0   "), 123.0)
+
+    def test_convert_str_to_float_when_empty_string(self):
+        with self.assertRaises(CompareException) as cm:
+            convert_str_to_float('')
+        self.assertEqual(cm.exception.code, CompareException.INVALID_DATA_ERROR)

msprobe/test/pytorch_ut/api_accuracy_checker/run_ut/dump.json

@@ -0,0 +1,179 @@
+{
+  "task": "statistics",
+  "level": "mix",
+  "dump_data_dir": null,
+  "data": {
+    "Tensor.__mul__.7.forward": {
+      "input_args": [
+        {
+          "type": "torch.Tensor",
+          "dtype": "torch.float16",
+          "shape": [
+            2048,
+            2,
+            1,
+            256
+          ],
+          "Max": 1.3955078125,
+          "Min": -1.443359375,
+          "Mean": -0.00013697147369384766,
+          "Norm": 318.5,
+          "requires_grad": true
+        },
+        {
+          "type": "torch.Tensor",
+          "dtype": "torch.float16",
+          "shape": [
+            2048,
+            1,
+            1,
+            256
+          ],
+          "Max": 1.0,
+          "Min": -1.0,
+          "Mean": 0.214599609375,
+          "Norm": 547.0,
+          "requires_grad": false
+        }
+      ],
+      "input_kwargs": {},
+      "output": [
+        {
+          "type": "torch.Tensor",
+          "dtype": "torch.float16",
+          "shape": [
+            2048,
+            2,
+            1,
+            256
+          ],
+          "Max": 1.3564453125,
+          "Min": -1.443359375,
+          "Mean": -0.0014209747314453125,
+          "Norm": 240.125,
+          "requires_grad": true
+        }
+      ]
+    },
+    "Torch.chunk.4.forward": {
+      "input_args": [
+        {
+          "type": "torch.Tensor",
+          "dtype": "torch.float16",
+          "shape": [
+            2048,
+            2,
+            1,
+            256
+          ],
+          "Max": 1.3955078125,
+          "Min": -1.443359375,
+          "Mean": -0.00013697147369384766,
+          "Norm": 318.5,
+          "requires_grad": true
+        },
+        {
+          "type": "int",
+          "value": 2
+        }
+      ],
+      "input_kwargs": {
+        "dim": {
+          "type": "int",
+          "value": -1
+        }
+      },
+      "output": [
+        {
+          "type": "torch.Tensor",
+          "dtype": "torch.float16",
+          "shape": [
+            2048,
+            2,
+            1,
+            128
+          ],
+          "Max": 1.3720703125,
+          "Min": -1.3759765625,
+          "Mean": 0.0015316009521484375,
+          "Norm": 226.25,
+          "requires_grad": true
+        },
+        {
+          "type": "torch.Tensor",
+          "dtype": "torch.float16",
+          "shape": [
+            2048,
+            2,
+            1,
+            128
+          ],
+          "Max": 1.3955078125,
+          "Min": -1.443359375,
+          "Mean": -0.0018053054809570312,
+          "Norm": 224.375,
+          "requires_grad": true
+        }
+      ]
+    },
+    "Torch.cat.8.forward": {
+      "input_args": [
+        [
+          {
+            "type": "torch.Tensor",
+            "dtype": "torch.float16",
+            "shape": [
+              2048,
+              2,
+              1,
+              128
+            ],
+            "Max": 1.443359375,
+            "Min": -1.3955078125,
+            "Mean": 0.0018053054809570312,
+            "Norm": 224.375,
+            "requires_grad": true
+          },
+          {
+            "type": "torch.Tensor",
+            "dtype": "torch.float16",
+            "shape": [
+              2048,
+              2,
+              1,
+              128
+            ],
+            "Max": 1.3720703125,
+            "Min": -1.3759765625,
+            "Mean": 0.0015316009521484375,
+            "Norm": 226.25,
+            "requires_grad": true
+          }
+        ]
+      ],
+      "input_kwargs": {
+        "dim": {
+          "type": "int",
+          "value": -1
+        }
+      },
+      "output": [
+        {
+          "type": "torch.Tensor",
+          "dtype": "torch.float16",
+          "shape": [
+            2048,
+            2,
+            1,
+            256
+          ],
+          "Max": 1.443359375,
+          "Min": -1.3955078125,
+          "Mean": 0.0016689300537109375,
+          "Norm": 318.5,
+          "requires_grad": true
+        }
+      ]
+    }
+  }
+}

msprobe/test/pytorch_ut/api_accuracy_checker/run_ut/forward.json

@@ -0,0 +1,63 @@
+{
+  "Torch.chunk.4.forward": {
+    "input_args": [
+      {
+        "type": "torch.Tensor",
+        "dtype": "torch.float16",
+        "shape": [
+          2048,
+          2,
+          1,
+          256
+        ],
+        "Max": 1.3955078125,
+        "Min": -1.443359375,
+        "Mean": -0.00013697147369384766,
+        "Norm": 318.5,
+        "requires_grad": true
+      },
+      {
+        "type": "int",
+        "value": 2
+      }
+    ],
+    "input_kwargs": {
+      "dim": {
+        "type": "int",
+        "value": -1
+      }
+    },
+    "output": [
+      {
+        "type": "torch.Tensor",
+        "dtype": "torch.float16",
+        "shape": [
+          2048,
+          2,
+          1,
+          128
+        ],
+        "Max": 1.3720703125,
+        "Min": -1.3759765625,
+        "Mean": 0.0015316009521484375,
+        "Norm": 226.25,
+        "requires_grad": true
+      },
+      {
+        "type": "torch.Tensor",
+        "dtype": "torch.float16",
+        "shape": [
+          2048,
+          2,
+          1,
+          128
+        ],
+        "Max": 1.3955078125,
+        "Min": -1.443359375,
+        "Mean": -0.0018053054809570312,
+        "Norm": 224.375,
+        "requires_grad": true
+      }
+    ]
+  }
+}

msprobe/test/pytorch_ut/api_accuracy_checker/run_ut/test_data_generate.py

@@ -0,0 +1,99 @@
+# coding=utf-8
+import os
+import unittest
+import copy
+
+from msprobe.pytorch.api_accuracy_checker.run_ut.data_generate import *
+from msprobe.pytorch.api_accuracy_checker.common.utils import get_json_contents
+
+base_dir = os.path.dirname(os.path.realpath(__file__))
+forward_file = os.path.join(base_dir, "forward.json")
+forward_content = get_json_contents(forward_file)
+for key, value in forward_content.items():
+    api_full_name = key
+    api_info_dict = value
+
+max_value = 1.3945078125
+min_value = -1.444359375
+
+
+class TestDataGenerateMethods(unittest.TestCase):
+    def test_gen_api_params(self):
+        api_info = copy.deepcopy(api_info_dict)
+        args_params, kwargs_params = gen_api_params(api_info, True, None, None)
+        max_diff = abs(args_params[0].max() - max_value)
+        min_diff = abs(args_params[0].min() - min_value)
+        self.assertEqual(len(args_params), 2)
+        self.assertEqual(args_params[0].dtype, torch.float16)
+        self.assertEqual(args_params[1], 2)
+        self.assertLessEqual(max_diff, 0.001)
+        self.assertLessEqual(min_diff, 0.001)
+        self.assertEqual(args_params[0].shape, torch.Size([2048, 2, 1, 256]))
+        self.assertEqual(kwargs_params, {'dim': -1})
+
+    def test_gen_args(self):
+        args_result = gen_args(api_info_dict.get('input_args'), "conv2d")
+        max_diff = abs(args_result[0].max() - max_value)
+        min_diff = abs(args_result[0].min() - min_value)
+        self.assertEqual(len(args_result), 2)
+        self.assertEqual(args_result[0].dtype, torch.float16)
+        self.assertLessEqual(max_diff, 0.001)
+        self.assertLessEqual(min_diff, 0.001)
+        self.assertEqual(args_result[0].shape, torch.Size([2048, 2, 1, 256]))
+
+    def test_gen_data(self):
+        data = gen_data(api_info_dict.get('input_args')[0], "conv2d", True, None, None)
+        max_diff = abs(data.max() - max_value)
+        min_diff = abs(data.min() - min_value)
+        self.assertEqual(data.dtype, torch.float16)
+        self.assertEqual(data.requires_grad, True)
+        self.assertLessEqual(max_diff, 0.001)
+        self.assertLessEqual(min_diff, 0.001)
+        self.assertEqual(data.shape, torch.Size([2048, 2, 1, 256]))
+
+    def test_gen_kwargs(self):
+        api_info = copy.deepcopy(api_info_dict)
+        kwargs_params = gen_kwargs(api_info, None)
+        self.assertEqual(kwargs_params, {'dim': -1})
+
+    def test_gen_kwargs_2(self):
+        k_dict = {"inplace": {"type": "bool", "value": "False"}}
+        for key, value in k_dict.items():
+            gen_torch_kwargs(k_dict, key, value)
+        self.assertEqual(k_dict, {'inplace': False})
+
+    def test_gen_random_tensor(self):
+        data = gen_random_tensor(api_info_dict.get('input_args')[0], None)
+        max_diff = abs(data.max() - max_value)
+        min_diff = abs(data.min() - min_value)
+        self.assertEqual(data.dtype, torch.float16)
+        self.assertEqual(data.requires_grad, False)
+        self.assertLessEqual(max_diff, 0.001)
+        self.assertLessEqual(min_diff, 0.001)
+        self.assertEqual(data.shape, torch.Size([2048, 2, 1, 256]))
+
+    def test_gen_common_tensor(self):
+        info = api_info_dict.get('input_args')[0]
+        low, high = info.get('Min'), info.get('Max')
+        low_origin, high_origin = info.get('Min_origin'), info.get('Max_origin')
+        low_info = [low, low_origin]
+        high_info = [high, high_origin]
+        data_dtype = info.get('dtype')
+        shape = tuple(info.get('shape'))
+        data = gen_common_tensor(low_info, high_info, shape, data_dtype, None)
+        max_diff = abs(data.max() - max_value)
+        min_diff = abs(data.min() - min_value)
+        self.assertEqual(data.dtype, torch.float16)
+        self.assertEqual(data.requires_grad, False)
+        self.assertLessEqual(max_diff, 0.001)
+        self.assertLessEqual(min_diff, 0.001)
+        self.assertEqual(data.shape, torch.Size([2048, 2, 1, 256]))
+
+    def test_gen_bool_tensor(self):
+        info = {"type": "torch.Tensor", "dtype": "torch.bool", "shape": [1, 1, 160, 256], "Max": 1, "Min": 0,
+                "requires_grad": False}
+        low, high = info.get("Min"), info.get("Max")
+        shape = tuple(info.get("shape"))
+        data = gen_bool_tensor(low, high, shape)
+        self.assertEqual(data.shape, torch.Size([1, 1, 160, 256]))
+        self.assertEqual(data.dtype, torch.bool)

msprobe/test/pytorch_ut/api_accuracy_checker/run_ut/test_multi_run_ut.py

@@ -0,0 +1,115 @@
+import os
+import glob
+import unittest
+import logging
+from unittest.mock import patch, mock_open, MagicMock
+import json
+import signal
+from msprobe.pytorch.api_accuracy_checker.run_ut.multi_run_ut import split_json_file, signal_handler, run_parallel_ut, \
+    prepare_config, main, ParallelUTConfig
+
+
+class TestMultiRunUT(unittest.TestCase):
+
+    def setUp(self):
+        self.test_json_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), "dump.json")
+        self.test_data = {'data': {'key1': 'TRUE', 'key2': 'TRUE', 'key3': 'TRUE'}}
+        self.test_json_content = json.dumps(self.test_data)
+        self.forward_split_files_content = [
+            {'key1': 'TRUE', 'key2': 'TRUE'},
+            {'key3': 'TRUE', 'key4': 'TRUE'}
+        ]
+
+    @patch('msprobe.pytorch.api_accuracy_checker.run_ut.multi_run_ut.FileOpen')
+    def test_split_json_file(self, mock_FileOpen):
+        mock_FileOpen.return_value.__enter__.return_value = mock_open(read_data=self.test_json_content).return_value
+        num_splits = 2
+        split_files, total_items = split_json_file(self.test_json_file, num_splits, False)
+        self.assertEqual(len(split_files), num_splits)
+        self.assertEqual(total_items, len(self.test_data.get('data')))
+
+
+    @patch('subprocess.Popen')
+    @patch('os.path.exists', return_value=True)
+    @patch('builtins.open', new_callable=mock_open)
+    @patch('json.load', side_effect=lambda f: {'key1': 'TRUE', 'key2': 'TRUE'})
+    def test_run_parallel_ut(self, mock_json_load, mock_file, mock_exists, mock_popen):
+        mock_process = MagicMock()
+        mock_process.poll.side_effect = [None, None, 1]
+        mock_process.stdout.readline.side_effect = ['[ERROR] Test Error Message\n', '']
+        mock_popen.return_value = mock_process
+
+        config = ParallelUTConfig(
+            api_files=['test.json'],
+            out_path='./',
+            num_splits=2,
+            save_error_data_flag=True,
+            jit_compile_flag=False,
+            device_id=[0, 1],
+            result_csv_path='result.csv',
+            total_items=2,
+            real_data_path=None
+        )
+
+        mock_file.side_effect = [
+            mock_open(read_data=json.dumps(self.forward_split_files_content[0])).return_value,
+            mock_open(read_data=json.dumps(self.forward_split_files_content[1])).return_value
+        ]
+
+        run_parallel_ut(config)
+
+        mock_popen.assert_called()
+        mock_exists.assert_called()
+
+    @patch('os.remove')
+    @patch('os.path.realpath', side_effect=lambda x: x)
+    @patch('msprobe.pytorch.api_accuracy_checker.run_ut.multi_run_ut.check_link')
+    @patch('msprobe.pytorch.api_accuracy_checker.run_ut.multi_run_ut.check_file_suffix')
+    @patch('msprobe.pytorch.api_accuracy_checker.run_ut.multi_run_ut.FileChecker')
+    @patch('msprobe.pytorch.api_accuracy_checker.run_ut.multi_run_ut.split_json_file',
+           return_value=(['forward_split1.json', 'forward_split2.json'], 2))
+    def test_prepare_config(self, mock_split_json_file, mock_FileChecker, mock_check_file_suffix, mock_check_link,
+                            mock_realpath, mock_remove):
+        mock_FileChecker_instance = MagicMock()
+        mock_FileChecker_instance.common_check.return_value = './'
+        mock_FileChecker.return_value = mock_FileChecker_instance
+        args = MagicMock()
+        args.api_info = 'forward.json'
+        args.out_path = './'
+        args.num_splits = 2
+        args.save_error_data = True
+        args.jit_compile = False
+        args.device_id = [0, 1]
+        args.result_csv_path = None
+        args.real_data_path = None
+
+        config = prepare_config(args)
+
+        self.assertEqual(config.num_splits, 2)
+        self.assertTrue(config.save_error_data_flag)
+        self.assertFalse(config.jit_compile_flag)
+        self.assertEqual(config.device_id, [0, 1])
+        self.assertEqual(config.total_items, 2)
+
+
+    @patch('argparse.ArgumentParser.parse_args')
+    @patch('msprobe.pytorch.api_accuracy_checker.run_ut.multi_run_ut.prepare_config')
+    @patch('msprobe.pytorch.api_accuracy_checker.run_ut.multi_run_ut.run_parallel_ut')
+    def test_main(self, mock_run_parallel_ut, mock_prepare_config, mock_parse_args):
+        main()
+        mock_parse_args.assert_called()
+        mock_prepare_config.assert_called()
+        mock_run_parallel_ut.assert_called()
+
+    def tearDown(self):
+        current_directory = os.getcwd()
+        pattern = os.path.join(current_directory, 'accuracy_checking_*')
+        files = glob.glob(pattern)
+
+        for file in files:
+            try:
+                os.remove(file)
+                logging.info(f"Deleted file: {file}")
+            except Exception as e:
+                logging.error(f"Failed to delete file {file}: {e}")
+