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

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

@@ -1,39 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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()

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

@@ -1,125 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,179 +0,0 @@
-{
-  "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

@@ -1,63 +0,0 @@
-{
-  "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
-      }
-    ]
-  }
-}