mindstudio-probe 1.0.1__py3-none-any.whl

msprobe/test/mindspore_ut/test_overflow_check_tool_factory.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# 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 unittest import TestCase
+
+from msprobe.core.common_config import CommonConfig, BaseConfig
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.mindspore.overflow_check.overflow_check_tool_factory import OverflowCheckToolFactory
+
+
+class TestOverflowCheckToolFactory(TestCase):
+
+    def test_create(self):
+        json_config = {
+            "task": "overflow_check",
+            "dump_path": "/absolute_path",
+            "rank": [],
+            "step": [],
+            "level": "L2"
+        }
+
+        common_config = CommonConfig(json_config)
+        task_config = BaseConfig(json_config)
+        config = DebuggerConfig(common_config, task_config)
+
+        config.level = "module"
+        with self.assertRaises(Exception) as context:
+            OverflowCheckToolFactory.create(config)
+        self.assertEqual(str(context.exception), "valid level is needed.")
+
+        config.level = "cell"
+        with self.assertRaises(Exception) as context:
+            OverflowCheckToolFactory.create(config)
+        self.assertEqual(str(context.exception), "Overflow check in not supported in this mode.")
+
+        config.level = "kernel"
+        dumper = OverflowCheckToolFactory.create(config)
+        self.assertEqual(dumper.dump_json["common_dump_settings"]["file_format"], "npy")

msprobe/test/mindspore_ut/test_precision_debugger.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# 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 unittest import TestCase
+from unittest.mock import patch
+
+from msprobe.core.common_config import CommonConfig, BaseConfig
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.mindspore.debugger.precision_debugger import PrecisionDebugger
+
+
+class TestPrecisionDebugger(TestCase):
+    def test_start(self):
+        class Handler:
+            called = False
+
+            def handle(self):
+                Handler.called = True
+
+        json_config = {
+            "task": "statistics",
+            "dump_path": "/absolute_path",
+            "rank": [],
+            "step": [],
+            "level": "L1"
+        }
+
+        common_config = CommonConfig(json_config)
+        task_config = BaseConfig(json_config)
+        handler = Handler()
+
+        with patch("msprobe.mindspore.debugger.precision_debugger.parse_json_config",
+                   return_value=[common_config, task_config]), \
+             patch("msprobe.mindspore.debugger.precision_debugger.TaskHandlerFactory.create", return_value=handler):
+            debugger = PrecisionDebugger()
+            debugger.start()
+        self.assertTrue(isinstance(debugger.config, DebuggerConfig))
+        self.assertTrue(Handler.called)
+
+        PrecisionDebugger._instance = None
+        with self.assertRaises(Exception) as context:
+            debugger.start()
+        self.assertEqual(str(context.exception), "No instance of PrecisionDebugger found.")

msprobe/test/mindspore_ut/test_task_handler_factory.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# 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 unittest import TestCase
+from unittest.mock import patch
+
+from msprobe.core.common_config import CommonConfig, BaseConfig
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.mindspore.dump.kernel_graph_dump import KernelGraphDump
+from msprobe.mindspore.task_handler_factory import TaskHandlerFactory
+
+
+class TestTaskHandlerFactory(TestCase):
+
+    def test_create(self):
+        class HandlerFactory:
+            def create(self):
+                return None
+
+        tasks = {"statistics": HandlerFactory}
+
+        json_config = {
+            "task": "statistics",
+            "dump_path": "/absolute_path",
+            "rank": [],
+            "step": [],
+            "level": "L2"
+        }
+
+        common_config = CommonConfig(json_config)
+        task_config = BaseConfig(json_config)
+        config = DebuggerConfig(common_config, task_config)
+
+        handler = TaskHandlerFactory.create(config)
+        self.assertTrue(isinstance(handler, KernelGraphDump))
+
+        with patch("msprobe.mindspore.task_handler_factory.TaskHandlerFactory.tasks", new=tasks):
+            with self.assertRaises(Exception) as context:
+                TaskHandlerFactory.create(config)
+            self.assertEqual(str(context.exception), "Can not find task handler")
+
+        config.task = "free_benchmark"
+        with self.assertRaises(Exception) as context:
+            TaskHandlerFactory.create(config)
+        self.assertEqual(str(context.exception), "valid task is needed.")

msprobe/test/pytorch_ut/advisor/test_advisor.py

@@ -0,0 +1,83 @@
+import difflib
+import os
+import shutil
+import unittest
+import logging
+from unittest.mock import patch
+
+import pandas
+
+from msprobe.pytorch.advisor.advisor import Advisor
+from msprobe.pytorch.advisor.advisor_const import AdvisorConst
+
+
+class TestAdvisor(unittest.TestCase):
+
+    def setUp(self):
+        self.base_test_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
+        self.input_dir = os.path.join(self.base_test_dir, 'resources')
+        self.output_path = os.path.abspath(os.path.join(self.base_test_dir, 'test_output'))
+
+        os.makedirs(self.output_path, mode=0o700, exist_ok=True)
+        self.has_error = False
+
+        self.input_data = pandas.read_csv(os.path.join(self.input_dir, 'compare_result_20230703104808.csv'))
+        self.advisor = Advisor(self.input_data, self.output_path)
+
+    def tearDown(self) -> None:
+        shutil.rmtree(self.output_path, ignore_errors=True)
+
+    @patch("os.path.realpath")
+    def test_init(self, mock_realpath):
+        mock_realpath.return_value = 'real_output_path'
+        adv = Advisor(self.input_data, self.output_path)
+        self.assertEqual(adv.out_path, 'real_output_path')
+
+    def test_deterministic_advisor_when_api_in_need_determ_api(self):
+        msg = self.advisor.deterministic_advisor('', 'Functional.layer_norm.0.forward_input.0')
+        self.assertEqual(msg, AdvisorConst.DETERMINISTIC_SUGGEST)
+
+    def test_deterministic_advisor_when_api_not_in_need_determ_api(self):
+        mock_message = 'mock message'
+        msg = self.advisor.deterministic_advisor(mock_message, 'Functional.linear.0.forward_input.0')
+        self.assertEqual(msg, mock_message)
+
+    def test_batch_norm_advisor(self):
+        mock_message = 'mocked batch norm advisor message'
+        msg1 = self.advisor.batch_norm_advisor(mock_message, AdvisorConst.FUNC_BATCH_NORM + '' +
+                                               AdvisorConst.FORWARD_INPUT_1)
+        msg2 = self.advisor.batch_norm_advisor(mock_message, 'Functional.linear.0.forward_output.1')
+        self.assertEqual(msg1, AdvisorConst.BATCH_NORM_SUGGEST)
+        self.assertEqual(msg2, mock_message)
+
+    def test_gen_advisor_message(self):
+        self.assertIn(AdvisorConst.FORWARD_OUTPUT_SUGGEST, self.advisor.gen_advisor_message(
+            'Functional.linear.0.forward_output.1'))
+        self.assertIn(AdvisorConst.BACKWARD_INPUT_SUGGEST, self.advisor.gen_advisor_message(
+            'Functional.linear.0.backward_input.1'))
+
+    def test_advisor_summary_file(self):
+        self.advisor.analysis()
+        filenames = os.listdir(self.output_path)
+        for filename in filenames:
+            filename = os.path.join(self.output_path, filename)
+            self.result_check(os.path.join(self.input_dir, 'advisor.txt'), filename)
+        self.assertFalse(self.has_error)
+
+    def result_check(self, standard_file, output_file):
+        with open(standard_file, 'r', encoding='utf-8') as st_file:
+            standard_content = st_file.read().splitlines()
+        with open(output_file, 'r', encoding='utf-8') as out_file:
+            output_content = out_file.read().splitlines()
+        result = list(difflib.unified_diff(standard_content, output_content, n=0))
+        if result:
+            logging.basicConfig(level=logging.INFO)
+            logging.info('\n\n-------------------------------------------------------------------------')
+            logging.error(f'[ERROR] {output_file.replace(self.output_path, "")} advisor summary are inconsistent.')
+            logging.error('\n'.join(result))
+            logging.info('\n\n-------------------------------------------------------------------------')
+            self.has_error = True
+
+
+if __name__ == '__main__':
+    unittest.main()

msprobe/test/pytorch_ut/api_accuracy_checker/common/test_common_utils.py

@@ -0,0 +1,108 @@
+import unittest
+from unittest.mock import patch
+
+from msprobe.pytorch.api_accuracy_checker.common.utils import *
+
+
+class TestUtils(unittest.TestCase):
+
+    @patch('msprobe.pytorch.api_accuracy_checker.common.utils.get_file_content_bytes')
+    def test_get_json_contents_should_raise_exception(self, mock_get_file_content_bytes):
+        mock_get_file_content_bytes.return_value = 'not a dict'
+        with self.assertRaises(CompareException) as ce:
+            get_json_contents('')
+        self.assertEqual(ce.exception.code, CompareException.INVALID_FILE_ERROR)
+
+    def test_get_json_contents_should_return_json_obj(self):
+        test_dict = {"key": "value"}
+        file_name = 'test.json'
+
+        fd = os.open(file_name, os.O_CREAT | os.O_WRONLY | os.O_TRUNC, 0o644)
+        with os.fdopen(fd, 'w') as f:
+            json.dump(test_dict, f)
+        self.assertEqual(get_json_contents(file_name), test_dict)
+        os.remove(file_name)
+
+    def test_write_csv(self):
+        test_file_name = 'test.csv'
+        test_data = [["name", "age"], ["Alice", "20"], ["Bob", "30"]]
+        write_csv(test_data, 'test.csv')
+        with open(test_file_name, 'r', encoding='utf-8-sig') as f:
+            reader = csv.reader(f)
+            for i, row in enumerate(reader):
+                self.assertEqual(row, test_data[i])
+        os.remove(test_file_name)
+
+    def test_check_need_convert(self):
+        self.assertEqual(check_need_convert('cross_entropy'), 'int32_to_int64')
+        self.assertIsNone(check_need_convert('linear'))
+
+    def test_check_object_type(self):
+        try:
+            check_object_type(123, int)
+        except Exception as e:
+            self.fail(f"check_object_type raised exception {e}")
+
+    def test_check_file_or_directory_path(self):
+        try:
+            check_file_or_directory_path(__file__)
+        except Exception as e:
+            self.fail(f"check_file_or_directory_path raised exception {e}")
+
+    def test_create_directory(self):
+        test_dir_name = 'test_dir'
+        create_directory(test_dir_name)
+        self.assertTrue(os.path.exists(test_dir_name))
+        os.rmdir(test_dir_name)
+
+    def test_get_file_content_bytes(self):
+        fd = os.open('test.txt', os.O_CREAT | os.O_WRONLY | os.O_TRUNC, 0o644)
+        with os.fdopen(fd, 'w') as f:
+            f.write("Hello, World!")
+        self.assertEqual(get_file_content_bytes('test.txt'), b"Hello, World!")
+        os.remove('test.txt')
+
+    @patch('os.path.exists')
+    def test_check_file_or_dir_path_should_raise_exe_when_dir_path_not_existed(self, mock_path_exists):
+        mock_path_exists.return_value = False
+        with self.assertRaises(CompareException) as ce:
+            check_file_or_directory_path('', isdir=True)
+        self.assertEqual(ce.exception.code, CompareException.INVALID_PATH_ERROR)
+
+    @patch('os.path.exists')
+    @patch('os.path.isdir')
+    @patch('os.access')
+    def test_check_file_or_dir_path_should_pass_when_path_is_dir(self, mock_os_access, mock_path_is_dir,
+                                                                 mock_path_exists):
+        mock_os_access.return_value = True
+        mock_path_is_dir.return_value = True
+        mock_path_exists.return_value = True
+        check_file_or_directory_path('', isdir=True)
+
+    @patch('os.path.isfile')
+    @patch('os.access')
+    def test_check_file_or_dir_path_should_raise_exe_when_file_not_access(self, mock_os_access, mock_path_is_file):
+        mock_os_access.return_value = False
+        mock_path_is_file.return_value = True
+        with self.assertRaises(CompareException) as ce:
+            check_file_or_directory_path('', isdir=False)
+        self.assertEqual(ce.exception.code, CompareException.INVALID_PATH_ERROR)
+
+    def test_check_file_or_dir_path_should_pass_when_path_is_file(self):
+        with unittest.mock.patch('os.path.isfile', return_value=True), \
+                unittest.mock.patch('os.access', return_value=True):
+            check_file_or_directory_path('', isdir=False)
+
+    def test_api_info_preprocess_no_conversion_needed(self):
+        api_name = 'linear'
+        original_api_info = {'key': 'value'}
+        convert_type, processed_api_info = api_info_preprocess(api_name, original_api_info.copy())
+        self.assertIsNone(convert_type)
+        self.assertEqual(original_api_info, processed_api_info)
+
+    def test_api_info_preprocess_cross_entropy_positive(self):
+        api_name = 'cross_entropy'
+        api_info = {'args': [{'Name': 'logit'}, {'Name': 'labels', 'Min': 1}]}
+        convert_type, processed_api_info = api_info_preprocess(api_name, api_info.copy())
+        self.assertEqual(convert_type, 'int32_to_int64')
+        self.assertEqual(processed_api_info, api_info)

msprobe/test/pytorch_ut/api_accuracy_checker/common/test_config.py

@@ -0,0 +1,39 @@
+import unittest
+import os
+from unittest.mock import patch
+
+from msprobe.pytorch.api_accuracy_checker.common.config import Config
+
+
+class TestConfig(unittest.TestCase):
+    def setUp(self):
+        self.base_test_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))))
+        self.input_dir = os.path.join(self.base_test_dir, 'resources')
+        self.yaml_file = os.path.join(self.input_dir, "config.yaml")
+        self.cfg = Config(self.yaml_file)
+
+    def test_validate_valid_data(self):
+        for key, val in self.cfg.config.items():
+            validated_type = self.cfg.validate(key, val)
+            self.assertEqual(validated_type, val)
+
+    def test_validate_should_raise_when_invalid_type(self):
+        with self.assertRaises(ValueError):
+            self.cfg.validate('error_data_path', True)
+
+    def test_validate_should_raise_when_invalid_key(self):
+        with self.assertRaises(ValueError):
+            self.cfg.validate('invalid_key', 'mock_value')
+
+    def test_validate_precision(self):
+        self.assertEqual(self.cfg.validate('precision', 1), 1)
+
+        with self.assertRaises(ValueError):
+            self.cfg.validate('precision', -1)
+
+    def test_validate_white_list(self):
+        validate_white_list = ['conv1d', 'max_pool1d', 'dropout', '__add__']
+        self.assertEqual(self.cfg.validate('white_list', validate_white_list), validate_white_list)
+
+        with self.assertRaises(ValueError):
+            self.cfg.validate('white_list', ['invalid_api1', 'invalid_api2'])

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

@@ -0,0 +1,112 @@
+import unittest
+
+import numpy as np
+
+from msprobe.pytorch.api_accuracy_checker.compare import algorithm as alg
+
+
+class TestAlgorithmMethods(unittest.TestCase):
+
+    def setUp(self):
+        self.bench_data = np.array([1.0, 1.0, 9.0], dtype=np.float16)
+        self.device_data = np.array([5.0, 2.0, 1.0], dtype=np.float16)
+        self.abs_err = np.abs(self.device_data - self.bench_data)
+        self.rel_err_origin = np.abs(self.abs_err / self.bench_data)
+        eps = np.finfo(self.bench_data.dtype).eps
+        self.abs_bench = np.abs(self.bench_data)
+        self.abs_bench_with_eps = self.abs_bench + eps
+        self.rel_err = self.abs_err / self.abs_bench_with_eps
+
+    def test_cosine_sim(self):
+        cpu_output = np.array([1.0, 2.0, 3.0])
+        npu_output = np.array([1.0, 2.0, 3.0])
+        self.assertEqual(alg.cosine_sim(cpu_output, npu_output), (1.0, True, ''))
+
+    def test_get_rmse(self):
+        inf_nan_mask = [False, False, False]
+        self.assertAlmostEqual(alg.get_rmse(self.abs_err, inf_nan_mask), 5.196, 3)
+
+    def test_get_error_balance(self):
+        self.assertEqual(alg.get_error_balance(self.bench_data, self.device_data), 1 / 3)
+
+    def test_get_small_value_err_ratio(self):
+        small_value_mask = [True, True, True, False, True]
+        abs_err_greater_mask = [False, True, True, True, False]
+        self.assertEqual(alg.get_small_value_err_ratio(small_value_mask, abs_err_greater_mask), 0.5)
+
+    def get_rel_err(self):
+        eps = np.finfo(self.bench_data.dtype).eps
+        abs_bench = np.abs(self.bench_data)
+        abs_bench_with_eps = abs_bench + eps
+        small_value_mask = [False, False, False]
+        inf_nan_mask = [False, False, False]
+        rel_err = self.abs_err / abs_bench_with_eps
+        self.assertListEqual(list(alg.get_rel_err(self.abs_err, abs_bench_with_eps, small_value_mask, inf_nan_mask)),
+                             list(rel_err))
+
+    def test_get_abs_err(self):
+        self.assertListEqual(list(alg.get_abs_err(self.bench_data, self.device_data)), [4.0, 1.0, 8.0])
+
+    def test_get_rel_err_origin(self):
+        self.assertListEqual(list(alg.get_rel_err_origin(self.abs_err, self.bench_data)), list(self.rel_err_origin))
+
+    def test_get_max_abs_err(self):
+        self.assertEqual(alg.get_max_abs_err(self.abs_err), (8.0, False))
+
+    def test_get_max_rel_err(self):
+        self.assertAlmostEqual(alg.get_max_rel_err(self.rel_err), 3.996, 3)
+
+    def test_get_mean_rel_err(self):
+        self.assertAlmostEqual(alg.get_mean_rel_err(self.rel_err), 1.961, 3)
+
+    def test_get_rel_err_ratio_thousandth(self):
+        b_value = np.array([1.0, 2.0, 3.0])
+        n_value = np.array([1.0, 2.0, 3.0])
+        abs_err = np.abs(b_value - n_value)
+        rel_err = alg.get_rel_err_origin(abs_err, b_value)
+        self.assertEqual(alg.get_rel_err_ratio(rel_err, 0.001), (1.0, True))
+
+    def test_get_rel_err_ratio_ten_thousandth(self):
+        b_value = np.array([1.0, 2.0, 3.0])
+        n_value = np.array([1.0, 2.0, 3.0])
+        abs_err = np.abs(b_value - n_value)
+        rel_err = alg.get_rel_err_origin(abs_err, b_value)
+        self.assertEqual(alg.get_rel_err_ratio(rel_err, 0.0001), (1.0, True))
+
+    def test_get_finite_and_infinite_mask(self):
+        both_finite_mask, inf_nan_mask = alg.get_finite_and_infinite_mask(self.bench_data, self.device_data)
+        self.assertListEqual(list(both_finite_mask), [True, True, True])
+        self.assertListEqual(list(inf_nan_mask), [False, False, False])
+
+    def test_get_small_value_mask(self):
+        b_value = np.array([1e-7, 1.0, 2e-6], dtype=np.float16)
+        abs_bench = np.abs(b_value)
+        both_finite_mask = [True, True, True]
+        small_value_mask = alg.get_small_value_mask(abs_bench, both_finite_mask, 1e-3)
+        self.assertListEqual(list(small_value_mask), [True, False, True])
+
+    def test_get_abs_bench_with_eps(self):
+        abs_bench, abs_bench_with_eps = alg.get_abs_bench_with_eps(self.bench_data, np.float16)
+        self.assertListEqual(list(abs_bench), list(self.abs_bench))
+        self.assertListEqual(list(abs_bench_with_eps), list(self.abs_bench_with_eps))
+
+    def test_check_inf_nan_value(self):
+        both_finite_mask, inf_nan_mask = alg.get_finite_and_infinite_mask(self.bench_data, self.device_data)
+        self.assertEqual(alg.check_inf_nan_value(inf_nan_mask, self.bench_data, self.device_data, np.float16, 0.001), 0)
+
+    def test_check_small_value(self):
+        a_value = np.array([1e-7, 1.0, 2e-6], dtype=np.float16)
+        b_value = np.array([1e-7, 1.0, 2e-6], dtype=np.float16)
+        abs_bench = np.abs(b_value)
+        both_finite_mask = [True, True, True]
+        abs_err = abs(a_value - b_value)
+        small_value_mask = alg.get_small_value_mask(abs_bench, both_finite_mask, 1e-3)
+        self.assertEqual(alg.check_small_value(abs_err, small_value_mask, 0.001), 0)
+
+    def test_check_norm_value(self):
+        both_finite_mask, inf_nan_mask = alg.get_finite_and_infinite_mask(self.bench_data, self.device_data)
+        small_value_mask = alg.get_small_value_mask(self.abs_bench, both_finite_mask, 1e-3)
+        normal_value_mask = np.logical_and(both_finite_mask, np.logical_not(small_value_mask))
+        print(normal_value_mask)
+        print(self.rel_err)
+        self.assertEqual(alg.check_norm_value(normal_value_mask, self.rel_err, 0.001), 1)

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

@@ -0,0 +1,77 @@
+import unittest
+
+import pandas as pd
+
+from msprobe.pytorch.api_accuracy_checker.compare.api_precision_compare import (
+    CompareConfig,
+    BenchmarkStandard,
+    check_csv_columns,
+    check_error_rate,
+    get_api_checker_result,
+)
+from msprobe.core.common.const import CompareConst
+
+
+class TestApiPrecisionCompare(unittest.TestCase):
+
+    def setUp(self):
+        # Setup paths and mock data
+        self.config = CompareConfig(
+            npu_csv_path='mock_npu.csv',
+            gpu_csv_path='mock_gpu.csv',
+            result_csv_path='result.csv',
+            details_csv_path='details.csv'
+        )
+
+        self.npu_data = pd.DataFrame({
+            'API_NAME': ['api1.forward', 'api1.backward'],
+            'DEVICE_DTYPE': ['float32', 'float32'],
+            'ERROR_RATE': ['0', '0.1'],
+            'SMALL_VALUE_ERROR_RATE': ['0.01', '0.02'],
+            'RMSE': ['0.1', '0.2'],
+            'MAX_REL_ERR': ['0.1', '0.2'],
+            'MEAN_REL_ERR': ['0.1', '0.2'],
+            'EB': ['0.1', '0.2']
+        })
+
+        self.gpu_data = pd.DataFrame({
+            'API_NAME': ['api1.forward', 'api1.backward'],
+            'DEVICE_DTYPE': ['float32', 'float32'],
+            'ERROR_RATE': ['0', '0'],
+            'SMALL_VALUE_ERROR_RATE': ['0.01', '0.01'],
+            'RMSE': ['0.1', '0.1'],
+            'MAX_REL_ERR': ['0.1', '0.1'],
+            'MEAN_REL_ERR': ['0.1', '0.1'],
+            'EB': ['0.1', '0.1']
+        })
+
+    def test_benchmark_standard_calc_ratio(self):
+        column_name = "TEST_COLUMN"
+        default_value = 0
+        result = BenchmarkStandard._calc_ratio(column_name, '2', '1', default_value)
+        self.assertEqual(result[0], 2.0)
+
+        result = BenchmarkStandard._calc_ratio(column_name, '0', '0', default_value)
+        self.assertEqual(result[0], 1.0)
+
+    def test_check_csv_columns(self):
+        with self.assertRaises(Exception):
+            check_csv_columns([], 'test_csv')
+
+    def test_check_error_rate(self):
+        result = check_error_rate('0')
+        self.assertEqual(result, CompareConst.PASS)
+
+        result = check_error_rate('0.1')
+        self.assertEqual(result, CompareConst.ERROR)
+
+    def test_get_api_checker_result(self):
+        result = get_api_checker_result([CompareConst.PASS, CompareConst.ERROR])
+        self.assertEqual(result, CompareConst.ERROR)
+
+        result = get_api_checker_result([CompareConst.PASS, CompareConst.PASS])
+        self.assertEqual(result, CompareConst.PASS)
+
+
+if __name__ == '__main__':
+    unittest.main()