Repository: furiosa-ai/furiosa-sdk (language: python)

Issue:
Bump up the dependency for release 0.2.x



Discussion / hints:

Fix patch:
diff --git a/python/furiosa-sdk-cli/setup.py b/python/furiosa-sdk-cli/setup.py
index 5af2c450..834e853c 100755
--- a/python/furiosa-sdk-cli/setup.py
+++ b/python/furiosa-sdk-cli/setup.py
@@ -8,7 +8,7 @@
 
 logger = logging.getLogger(__name__)
 
-version = '0.2.0.dev0'
+version = '0.2.0'
 
 my_dir = dirname(__file__)
 
diff --git a/python/furiosa-sdk-model-validator/setup.cfg b/python/furiosa-sdk-model-validator/setup.cfg
index f1bc5232..f4187ad9 100644
--- a/python/furiosa-sdk-model-validator/setup.cfg
+++ b/python/furiosa-sdk-model-validator/setup.cfg
@@ -38,8 +38,8 @@ setup_requires =
     wheel
 
 install_requires =
-    furiosa-sdk-runtime>=0.1.0
-    furiosa-sdk-quantizer>=0.1.0
+    furiosa-sdk-runtime>=0.2.0
+    furiosa-sdk-quantizer>=0.2.0
 
 [options.package_data]
 furiosa_sdk_model_validator=
diff --git a/python/furiosa-sdk-model-validator/setup.py b/python/furiosa-sdk-model-validator/setup.py
index da9dd724..2b401375 100755
--- a/python/furiosa-sdk-model-validator/setup.py
+++ b/python/furiosa-sdk-model-validator/setup.py
@@ -8,7 +8,7 @@
 
 logger = logging.getLogger(__name__)
 
-version = '0.2.0.dev0'
+version = '0.2.0'
 
 my_dir = dirname(__file__)
 
diff --git a/python/furiosa-sdk-quantizer/bin/quantize_model_with_random_input_activation b/python/furiosa-sdk-quantizer/bin/quantize_model_with_random_input_activation
deleted file mode 100755
index 8cfab69d..00000000
--- a/python/furiosa-sdk-quantizer/bin/quantize_model_with_random_input_activation
+++ /dev/null
@@ -1,29 +0,0 @@
-#!/usr/bin/env python
-import argparse
-import onnx
-
-from pathlib import Path
-from quantizer.frontend.onnx import post_training_quantization_with_random_calibration
-from quantizer.frontend.onnx.quantizer.utils import QuantizationMode
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description='Get input and output directories.')
-    parser.add_argument("-i", required=True, dest='input', type=str, help='input model file')
-    parser.add_argument("-o", required=False, dest='output', type=str, default='quantized_model.onnx',
-                        help='output file name (default: quantized_model.onnx)')
-    args = parser.parse_args()
-
-    input_file = Path(args.input)
-    output_file = args.output
-
-    if not input_file.exists():
-        print(f'input file {input_file} does not exist')
-
-    # Try quantization on input models
-    print(f'quantizing model {input_file.name}')
-    quantized_model = post_training_quantization_with_random_calibration(model=onnx.load_model(input_file),
-                                                                         per_channel=True,
-                                                                         static=True,
-                                                                         mode=QuantizationMode.dfg,
-                                                                         num_data=10)
-    onnx.save_model(quantized_model, output_file)
diff --git a/python/furiosa-sdk-quantizer/bin/quantizer b/python/furiosa-sdk-quantizer/bin/quantizer
deleted file mode 100755
index 288dc0b5..00000000
--- a/python/furiosa-sdk-quantizer/bin/quantizer
+++ /dev/null
@@ -1,19 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-import os
-
-if os.environ.get('LC_CTYPE', '') == 'UTF-8':
-    os.environ['LC_CTYPE'] = 'en_US.UTF-8'
-
-import quantizer.scripts
-
-if __name__ == '__main__':
-    try:
-        quantizer.scripts.main()
-    except Exception as e:
-        if os.environ.get('QUANTIZER_DEBUG', None) is not None:
-            raise e
-        else:
-            print(e, file=sys.stderr)
-            sys.exit(-1)
diff --git a/python/furiosa-sdk-quantizer/examples/simple_model.onnx b/python/furiosa-sdk-quantizer/examples/simple_model.onnx
deleted file mode 100644
index 5b206b8b..00000000
Binary files a/python/furiosa-sdk-quantizer/examples/simple_model.onnx and /dev/null differ
diff --git a/python/furiosa-sdk-quantizer/examples/simple_model.py b/python/furiosa-sdk-quantizer/examples/simple_model.py
deleted file mode 100644
index 4297448b..00000000
--- a/python/furiosa-sdk-quantizer/examples/simple_model.py
+++ /dev/null
@@ -1,33 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-
-class Net(nn.Module):
-
-    def __init__(self):
-        super(Net, self).__init__()
-        # 1 input image channel, 6 output channels, 3x3 square convolution
-        # kernel
-        self.conv1 = nn.Conv2d(3, 6, 3)
-        self.conv2 = nn.Conv2d(6, 12, 3)
-        self.conv3 = nn.Conv2d(12, 3, 3)
-
-    def forward(self, x):
-        # Max pooling over a (2, 2) window
-        x = self.conv1(x)
-        # If the size is a square you can only specify a single number
-        x = F.max_pool2d(self.conv2(x), 2)
-        x = self.conv3(x)
-        return x
-
-
-dummy_input = torch.randn(1, 3, 224, 224)
-input_names = ["input"]
-output_names = ["output"]
-torch.onnx.export(Net(),
-                  (dummy_input,),
-                  "simple_model.onnx",
-                  verbose=False,
-                  input_names=input_names,
-                  output_names=output_names)
diff --git a/python/furiosa-sdk-quantizer/setup.py b/python/furiosa-sdk-quantizer/setup.py
index 22c9afa0..0692dfe4 100755
--- a/python/furiosa-sdk-quantizer/setup.py
+++ b/python/furiosa-sdk-quantizer/setup.py
@@ -8,7 +8,7 @@
 
 logger = logging.getLogger(__name__)
 
-version = '0.2.0.dev0'
+version = '0.2.0'
 
 my_dir = dirname(__file__)
 
@@ -67,6 +67,5 @@ def write_version(filename: str = os.path.join(*[my_dir, "furiosa_sdk_quantizer"
 
     setup(
         version=version,
-        scripts=['bin/quantizer', 'bin/quantize_model_with_random_input_activation'],
         **setup_kwargs,
     )
diff --git a/python/furiosa-sdk-runtime/furiosa_sdk_runtime/_api/__init__.py b/python/furiosa-sdk-runtime/furiosa_sdk_runtime/_api/__init__.py
index edd298e8..913747bf 100644
--- a/python/furiosa-sdk-runtime/furiosa_sdk_runtime/_api/__init__.py
+++ b/python/furiosa-sdk-runtime/furiosa_sdk_runtime/_api/__init__.py
@@ -2,10 +2,6 @@
 
 import os
 
-log_enabled = os.getenv('FURIOSA_LOG')
-if log_enabled is not None and log_enabled == 'enable':
-    os.environ['RUST_LOG']="info"
-
 from .v1 import LIBNUX
 
 del os
diff --git a/python/furiosa-sdk-runtime/furiosa_sdk_runtime/_api/v1.py b/python/furiosa-sdk-runtime/furiosa_sdk_runtime/_api/v1.py
index 237effe2..07a9dfb9 100644
--- a/python/furiosa-sdk-runtime/furiosa_sdk_runtime/_api/v1.py
+++ b/python/furiosa-sdk-runtime/furiosa_sdk_runtime/_api/v1.py
@@ -86,8 +86,8 @@ def _find_native_libs():
 LIBNUX.build_timestamp.argtypes = []
 LIBNUX.build_timestamp.restype = c_char_p
 
-LIBNUX.enable_logging.argtypes = []
-LIBNUX.enable_logging.restype = None
+LIBNUX.enable_furiosa_logging.argtypes = []
+LIBNUX.enable_furiosa_logging.restype = None
 
 LIBNUX.nux_session_option_create.argtypes = []
 LIBNUX.nux_session_option_create.restype = c_void_p
@@ -192,5 +192,5 @@ def _find_native_libs():
 decref.argtypes = [ctypes.py_object]
 decref.restype = None
 
-# Enable Rust env logger
-LIBNUX.enable_logging()
+# Enable FUriosa logger
+LIBNUX.enable_furiosa_logging()
diff --git a/python/furiosa-sdk-runtime/setup.py b/python/furiosa-sdk-runtime/setup.py
index af10b2b8..1eb66dea 100755
--- a/python/furiosa-sdk-runtime/setup.py
+++ b/python/furiosa-sdk-runtime/setup.py
@@ -8,7 +8,7 @@
 
 logger = logging.getLogger(__name__)
 
-version = '0.2.0.dev0'
+version = '0.2.0'
 
 my_dir = dirname(__file__)
 
diff --git a/python/furiosa-sdk/setup.py b/python/furiosa-sdk/setup.py
index 9ef17ebb..9e56cb23 100755
--- a/python/furiosa-sdk/setup.py
+++ b/python/furiosa-sdk/setup.py
@@ -23,7 +23,7 @@
 
 logger = logging.getLogger(__name__)
 
-version = '0.2.0.dev0'
+version = '0.2.0'
 
 my_dir = dirname(__file__)
 
@@ -47,10 +47,10 @@
 
 
 EXTRAS_REQUIREMENTS: Dict[str, List[str]] = {
-    "cli": ["furiosa-sdk-cli>=0.1.0"],
-    "runtime": ["furiosa-sdk-runtime>=0.1.0"],
-    "quantizer": ["furiosa-sdk-quantizer>=0.1.0"],
-    "validator": ["furiosa-sdk-model-validator>=0.1.0"]
+    "cli": ["furiosa-sdk-cli>=0.2.0"],
+    "runtime": ["furiosa-sdk-runtime>=0.2.0"],
+    "quantizer": ["furiosa-sdk-quantizer>=0.2.0"],
+    "validator": ["furiosa-sdk-model-validator>=0.2.0"]
 }
 
 # Requirements for all "user" extras (no devel). They are de-duplicated. Note that we do not need


Test patch:
diff --git a/python/furiosa-sdk-quantizer/examples/test.onnx b/python/furiosa-sdk-quantizer/examples/test.onnx
deleted file mode 100644
index bef36507..00000000
Binary files a/python/furiosa-sdk-quantizer/examples/test.onnx and /dev/null differ
diff --git a/python/furiosa-sdk-quantizer/examples/test.py b/python/furiosa-sdk-quantizer/examples/test.py
deleted file mode 100644
index 6fd01d6e..00000000
--- a/python/furiosa-sdk-quantizer/examples/test.py
+++ /dev/null
@@ -1,25 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-
-class Net(nn.Module):
-
-    def __init__(self):
-        super(Net, self).__init__()
-        # 1 input image channel, 6 output channels, 3x3 square convolution
-        # kernel
-        self.conv1 = nn.Conv2d(3, 6, 3)
-        self.conv2 = nn.Conv2d(6, 12, 3)
-
-    def forward(self, x):
-        # Max pooling over a (2, 2) window
-        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
-        # If the size is a square you can only specify a single number
-        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
-        return x
-
-dummy_input = torch.randn(1, 3, 224, 224)
-input_names = [ "input" ]
-output_names = [ "output" ]
-torch.onnx.export(Net(), dummy_input, "test.onnx", verbose=False, input_names=input_names, output_names=output_names)
diff --git a/python/furiosa-sdk-quantizer/examples/test_dynamic_ranges.json b/python/furiosa-sdk-quantizer/examples/test_dynamic_ranges.json
deleted file mode 100644
index f2ea9bcb..00000000
--- a/python/furiosa-sdk-quantizer/examples/test_dynamic_ranges.json
+++ /dev/null
@@ -1,30 +0,0 @@
-{
-  "input": [
-    1.0536192576182657e-06,
-    0.9999936819076538
-  ],
-  "5": [
-    -0.8819856643676758,
-    1.0805355310440063
-  ],
-  "6": [
-    0.0,
-    1.0805355310440063
-  ],
-  "7": [
-    0.0,
-    1.0805355310440063
-  ],
-  "8": [
-    -0.5032250285148621,
-    0.4606616497039795
-  ],
-  "9": [
-    0.0,
-    0.4606616497039795
-  ],
-  "output": [
-    0.0,
-    0.4606616497039795
-  ]
-}
\ No newline at end of file
diff --git a/python/furiosa-sdk-quantizer/tests/__init__.py b/python/furiosa-sdk-quantizer/tests/__init__.py
deleted file mode 100644
index 1b68e253..00000000
--- a/python/furiosa-sdk-quantizer/tests/__init__.py
+++ /dev/null
@@ -1,163 +0,0 @@
-from typing import List, Tuple, Dict, Optional
-
-import io
-import onnx
-import torch
-
-import numpy as np
-
-from onnx import helper
-
-from furiosa_sdk_quantizer.frontend.onnx import __DOMAIN__, __OPSET_VERSION__
-
-
-def torch_to_onnx(torch_model: torch.nn.Module, input_shapes: List[Tuple[int, ...]]) -> onnx.ModelProto:
-    torch_model.eval()
-    f = io.BytesIO()
-    dummies = []
-    for shape in input_shapes:
-        dummies.append(torch.ones(shape, dtype=torch.float32))
-
-    torch.onnx.export(torch_model, *dummies, f, opset_version=__OPSET_VERSION__)
-    return onnx.load_model(io.BytesIO(f.getvalue()), helper.ModelProto)
-
-
-def make_test_model(input_shapes: List[Tuple[int, ...]],
-                    output_shapes: List[Tuple[int, ...]],
-                    attributes: Dict,
-                    init_shapes: Optional[List[Tuple[int, ...]]] = None,
-                    op_type: Optional[str] = 'TestOp',
-                    check_model: Optional[bool] = False) \
-        -> Tuple[onnx.ModelProto, onnx.NodeProto]:
-    inputs, input_names = make_test_value_info(input_shapes, name='X')
-    outputs, output_names = make_test_value_info(output_shapes, name='Y')
-
-    inits = None
-    if init_shapes:
-        inits, init_names = make_test_init(init_shapes, name='Z')
-        input_names += init_names
-
-    # Create the model (NodeProto)
-    node_def = helper.make_node(
-        op_type=op_type,
-        inputs=input_names,
-        outputs=output_names,
-        **attributes,
-        name='%s_0' % op_type
-    )
-
-    kwargs = {
-        'nodes': [node_def],
-        'name': 'test-model',
-        'inputs': inputs,
-        'outputs': outputs,
-        'initializer': inits,
-    }
-
-    # Create the graph (GraphProto)
-    graph_def = helper.make_graph(
-        **kwargs
-    )
-
-    # Create the model (ModelProto)
-    model_def = helper.make_model(graph_def, opset_imports=[helper.make_opsetid(__DOMAIN__, __OPSET_VERSION__)])
-
-    if check_model:
-        onnx.checker.check_model(model_def)
-        from onnx import shape_inference
-        model_def = shape_inference.infer_shapes(model_def)
-
-    return model_def, node_def
-
-
-def make_test_model_with_init_val(input_shapes: List[Tuple[int, ...]],
-                                  output_shapes: List[Tuple[int, ...]],
-                                  attributes: Dict,
-                                  init_values: List[np.ndarray],
-                                  op_type: Optional[str] = 'TestOp',
-                                  check_model: Optional[bool] = False) \
-        -> Tuple[onnx.ModelProto, onnx.NodeProto]:
-    inputs, input_names = make_test_value_info(input_shapes, name='X')
-    outputs, output_names = make_test_value_info(output_shapes, name='Y')
-
-    inits, init_names = make_test_init_with_val(init_values, name='Z')
-    input_names += init_names
-
-    # Create the model (NodeProto)
-    node_def = helper.make_node(
-        op_type=op_type,
-        inputs=input_names,
-        outputs=output_names,
-        **attributes,
-        name='%s_0' % op_type
-    )
-
-    kwargs = {
-        'nodes': [node_def],
-        'name': 'test-model',
-        'inputs': inputs,
-        'outputs': outputs,
-        'initializer': inits,
-    }
-
-    # Create the graph (GraphProto)
-    graph_def = helper.make_graph(
-        **kwargs
-    )
-
-    # Create the model (ModelProto)
-    model_def = helper.make_model(graph_def, opset_imports=[helper.make_opsetid(__DOMAIN__, __OPSET_VERSION__)])
-
-    if check_model:
-        onnx.checker.check_model(model_def)
-        from onnx import shape_inference
-        model_def = shape_inference.infer_shapes(model_def)
-
-    return model_def, node_def
-
-
-def make_test_value_info(shapes: List[Tuple[int, ...]], name: str) \
-        -> Tuple[List[onnx.ValueInfoProto], List[str]]:
-    vi_protos = list()
-    vi_names = list()
-    for idx, shape in enumerate(shapes):
-        vi = helper.make_tensor_value_info(name='%s_%d' % (name, idx),
-                                           elem_type=helper.TensorProto.FLOAT,
-                                           shape=shape)
-        vi_protos.append(vi)
-        vi_names.append(vi.name)
-
-    return vi_protos, vi_names
-
-
-def make_test_init(shapes: List[Tuple[int, ...]], name: str) \
-        -> Tuple[List[onnx.TensorProto], List[str]]:
-    init_protos = list()
-    init_names = list()
-
-    for idx, shape in enumerate(shapes):
-        val = np.ones(shape, dtype=np.float32)
-        init = helper.make_tensor(name='%s_%d' % (name, idx),
-                                  data_type=onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[val.dtype],
-                                  dims=val.shape,
-                                  vals=val.flatten())
-        init_protos.append(init)
-        init_names.append(init.name)
-
-    return init_protos, init_names
-
-
-def make_test_init_with_val(values: List[np.ndarray], name: str) \
-        -> Tuple[List[onnx.TensorProto], List[str]]:
-    init_protos = list()
-    init_names = list()
-
-    for idx, val in enumerate(values):
-        init = helper.make_tensor(name='%s_%d' % (name, idx),
-                                  data_type=onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[val.dtype],
-                                  dims=val.shape,
-                                  vals=val.flatten())
-        init_protos.append(init)
-        init_names.append(init.name)
-
-    return init_protos, init_names
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/__init__.py b/python/furiosa-sdk-quantizer/tests/frontend/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/onnx/__init__.py b/python/furiosa-sdk-quantizer/tests/frontend/onnx/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/onnx/spec/__init__.py b/python/furiosa-sdk-quantizer/tests/frontend/onnx/spec/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/onnx/spec/test_export_spec.py b/python/furiosa-sdk-quantizer/tests/frontend/onnx/spec/test_export_spec.py
deleted file mode 100644
index 2ca9d58b..00000000
--- a/python/furiosa-sdk-quantizer/tests/frontend/onnx/spec/test_export_spec.py
+++ /dev/null
@@ -1,1244 +0,0 @@
-from typing import Dict
-
-import unittest
-
-import torch
-
-import numpy as np
-import torch.nn as nn
-
-from tests import torch_to_onnx, make_test_model, make_test_model_with_init_val
-from furiosa_sdk_quantizer.frontend.onnx.spec.export_spec import OnnxExportSpec
-from furiosa_sdk_quantizer.ir.spec import Spec
-
-
-class Test_get_inputs_for_gen_spec(unittest.TestCase):
-    def evaluate_test(self,
-                      expected_input_shapes,
-                      expected_output_shapes,
-                      expected_attributes,
-                      expected_init_shapes=None):
-        model, node = make_test_model(expected_input_shapes,
-                                      expected_output_shapes,
-                                      expected_attributes,
-                                      expected_init_shapes)
-
-        input_shapes, output_shapes, attributes = OnnxExportSpec(model).get_inputs_for_gen_spec(node)
-
-        if expected_init_shapes:
-            expected_input_shapes += expected_init_shapes
-        self.assertEqual(expected_input_shapes, input_shapes)
-        self.assertEqual(expected_output_shapes, output_shapes)
-        self.assertEqual(expected_attributes, attributes)
-
-    def test_case_1(self):
-        input_shapes = [(8, 8)]
-        output_shapes = [(12, 12)]
-        init_shapes = [(16, 16, 16), ()]
-        attributes = dict()
-        self.evaluate_test(input_shapes, output_shapes, attributes, init_shapes)
-
-    def test_case_2(self):
-        input_shapes = [(8, 8), (10, 10, 10)]
-        output_shapes = [(12, 12), (7, 7, 7, 7), (3, 3, 3)]
-        attributes = {
-            'attr1': 1,
-            'attr2': [1, 2, 3],
-            'attr3': 1.2339999675750732,
-        }
-        self.evaluate_test(input_shapes, output_shapes, attributes)
-
-
-class Test_conv2d(unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='Conv', check_model=True)
-        assert node.op_type == 'Conv'
-
-        return model, node
-
-    def evaluate_test(self, expected: Dict, spec: Spec):
-        self.assertEqual(expected['batch'], spec.option.batch)
-        self.assertEqual(expected['input_channel'], spec.option.input_channel)
-        self.assertEqual(expected['output_channel'], spec.option.output_channel)
-        self.assertEqual((expected['height'], expected['width']), (spec.option.input.height, spec.option.input.width))
-        self.assertEqual(expected['kernel_shape'], (spec.option.kernel.height, spec.option.kernel.width))
-        self.assertEqual(expected.get('strides', (1, 1)), (spec.option.stride.height, spec.option.stride.width))
-        self.assertEqual(expected.get('dilations', (1, 1)), (spec.option.dilation.height, spec.option.dilation.width))
-        self.assertEqual(expected.get('group', 1), spec.option.groups)
-        self.assertEqual(expected.get('pads', (0, 0, 0, 0)), (spec.option.padding_spec.Custom.top,
-                                                              spec.option.padding_spec.Custom.bottom,
-                                                              spec.option.padding_spec.Custom.left,
-                                                              spec.option.padding_spec.Custom.right))
-
-    def test_case_1(self):
-        input_shapes = [(1, 3, 8, 12)]
-        output_shapes = [(1, 3, 7, 11)]
-        attributes = {'kernel_shape': (2, 2)}
-        init_shapes = [(3, 8, 2, 2)]
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes, init_shapes)
-        spec = OnnxExportSpec(model).conv2d(node)
-
-        kwargs = {
-            'batch': 1,
-            'input_channel': 3,
-            'output_channel': 3,
-            'height': 8,
-            'width': 12,
-        }
-        kwargs.update(attributes)
-
-        self.evaluate_test(kwargs, spec)
-
-    def test_case_2(self):
-        input_shapes = [(2, 32, 64, 48)]
-        output_shapes = [(2, 128, 22, 6)]
-        attributes = {
-            'kernel_shape': (2, 3),
-            'strides': (3, 8),
-            'dilations': (4, 5),
-            'group': 16,
-            'pads': (2, 4, 2, 4)
-
-        }
-        init_shapes = [(128, 32, 2, 4)]
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes, init_shapes)
-        spec = OnnxExportSpec(model).conv2d(node)
-
-        kwargs = {
-            'batch': 2,
-            'input_channel': 32,
-            'output_channel': 128,
-            'height': 64,
-            'width': 48,
-        }
-        kwargs.update(attributes)
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_convtranspose2d(Test_conv2d, unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='ConvTranspose', check_model=True)
-        assert node.op_type == 'ConvTranspose'
-
-        return model, node
-
-    def test_case_1(self):
-        input_shapes = [(1, 3, 8, 12)]
-        output_shapes = [(1, 8, 9, 13)]
-        attributes = {'kernel_shape': (2, 2)}
-        init_shapes = [(3, 8, 2, 2)]
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes, init_shapes)
-        spec = OnnxExportSpec(model).convtranspose2d(node)
-
-        kwargs = {
-            'batch': 1,
-            'input_channel': 3,
-            'output_channel': 8,
-            'height': 8,
-            'width': 12,
-        }
-        kwargs.update(attributes)
-
-        self.evaluate_test(kwargs, spec)
-
-    def test_case_2(self):
-        input_shapes = [(2, 32, 64, 48)]
-        output_shapes = [(2, 512, 190, 379)]
-        attributes = {
-            'kernel_shape': (2, 3),
-            'strides': (3, 8),
-            'dilations': (4, 5),
-            'group': 16,
-            'pads': (2, 4, 2, 4)
-
-        }
-        init_shapes = [(128, 32, 2, 4)]
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes, init_shapes)
-        spec = OnnxExportSpec(model).convtranspose2d(node)
-
-        kwargs = {
-            'batch': 2,
-            'input_channel': 32,
-            'output_channel': 512,
-            'height': 64,
-            'width': 48,
-        }
-        kwargs.update(attributes)
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_maxpool2d(unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='MaxPool', check_model=True)
-        assert node.op_type == 'MaxPool'
-
-        return model, node
-
-    def evaluate_test(self, expected: Dict, spec: Spec):
-        self.assertEqual(expected['batch'], spec.option.batch)
-        self.assertEqual((expected['height'], expected['width']), (spec.option.input.height, spec.option.input.width))
-        self.assertEqual(expected['kernel_shape'], (spec.option.kernel.height, spec.option.kernel.width))
-        self.assertEqual(expected.get('strides', (1, 1)),
-                         (spec.option.stride.height, spec.option.stride.width))
-        self.assertEqual(expected.get('dilations', (1, 1)), (spec.option.dilation.height, spec.option.dilation.width))
-        self.assertEqual(expected.get('pads', (0, 0, 0, 0)), (spec.option.padding_spec.Custom.top,
-                                                              spec.option.padding_spec.Custom.bottom,
-                                                              spec.option.padding_spec.Custom.left,
-                                                              spec.option.padding_spec.Custom.right))
-
-    def test_case_1(self):
-        input_shapes = [(1, 3, 8, 12)]
-        output_shapes = [(1, 3, 7, 10)]
-        attributes = {'kernel_shape': (2, 3)}
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).maxpool2d(node)
-
-        kwargs = {
-            'batch': 1,
-            'height': 8,
-            'width': 12,
-        }
-        kwargs.update(attributes)
-
-        self.evaluate_test(kwargs, spec)
-
-    def test_case_2(self):
-        input_shapes = [(2, 32, 64, 48)]
-        output_shapes = [(2, 32, 22, 6)]
-        attributes = {
-            'kernel_shape': (2, 3),
-            'dilations': (2, 2),
-            'strides': (3, 8),
-            'pads': (1, 2, 1, 2),
-        }
-
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).maxpool2d(node)
-        kwargs = {
-            'batch': 2,
-            'height': 64,
-            'width': 48
-        }
-        kwargs.update(attributes)
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_avgpool2d(unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='AveragePool', check_model=True)
-        assert node.op_type == 'AveragePool'
-
-        return model, node
-
-    def make_test_model_1(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='GlobalAveragePool', check_model=True)
-        assert node.op_type == 'GlobalAveragePool'
-
-        return model, node
-
-    def evaluate_test(self, expected: Dict, spec: Spec):
-        self.assertEqual(expected['batch'], spec.option.batch)
-        self.assertEqual((expected['height'], expected['width']), (spec.option.input.height, spec.option.input.width))
-        self.assertEqual(expected['kernel_shape'], (spec.option.kernel.height, spec.option.kernel.width))
-        self.assertEqual(expected.get('strides', (1, 1)),
-                         (spec.option.stride.height, spec.option.stride.width))
-        self.assertEqual(expected.get('pads', (0, 0, 0, 0)), (spec.option.padding_spec.Custom.top,
-                                                              spec.option.padding_spec.Custom.bottom,
-                                                              spec.option.padding_spec.Custom.left,
-                                                              spec.option.padding_spec.Custom.right))
-
-    def test_case_1(self):
-        input_shapes = [(1, 3, 8, 12)]
-        output_shapes = [(1, 3, 7, 10)]
-        attributes = {'kernel_shape': (2, 3)}
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).avgpool2d(node)
-
-        kwargs = {
-            'batch': 1,
-            'height': 8,
-            'width': 12,
-        }
-        kwargs.update(attributes)
-
-        self.evaluate_test(kwargs, spec)
-
-    def test_case_2(self):
-        input_shapes = [(2, 32, 64, 48)]
-        output_shapes = [(2, 32, 22, 7)]
-        attributes = {
-            'kernel_shape': (2, 3),
-            'strides': (3, 8),
-            'pads': (1, 2, 1, 2),
-        }
-
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).avgpool2d(node)
-        kwargs = {
-            'batch': 2,
-            'height': 64,
-            'width': 48
-        }
-        kwargs.update(attributes)
-
-        self.evaluate_test(kwargs, spec)
-
-    def test_case_3(self):
-        input_shapes = [(1, 3, 8, 12)]
-        output_shapes = [(1, 3, 1, 1)]
-        attributes = {}
-        model, node = self.make_test_model_1(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).avgpool2d(node)
-
-        kwargs = {
-            'kernel_shape': (8, 12),
-            'batch': 1,
-            'height': 8,
-            'width': 12,
-        }
-        kwargs.update(attributes)
-
-        self.evaluate_test(kwargs, spec)
-
-    def test_case_4(self):
-        input_shapes = [(2, 32, 64, 48)]
-        output_shapes = [(2, 32, 1, 1)]
-        attributes = {}
-
-        model, node = self.make_test_model_1(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).avgpool2d(node)
-        kwargs = {
-            'kernel_shape': (64, 48),
-            'batch': 2,
-            'height': 64,
-            'width': 48
-        }
-        kwargs.update(attributes)
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_gemm(unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='Gemm', check_model=True)
-        assert node.op_type == 'Gemm'
-
-        return model, node
-
-    def evaluate_test(self, expected: Dict, spec: Spec):
-        self.assertEqual(expected.get('alpha', 1.0), spec.option.alpha)
-        self.assertEqual(expected.get('beta', 1.0), spec.option.beta)
-        self.assertEqual(expected['m'], spec.option.m)
-        self.assertEqual(expected['k'], spec.option.k)
-        self.assertEqual(expected['n'], spec.option.n)
-
-    def test_case_1(self):
-        input_shapes = [(42, 64), (64, 32)]
-        output_shapes = [(42, 32)]
-        attributes = {'transA': 0}
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).gemm(node)
-
-        kwargs = {'m': 42, 'k': 64, 'n': 32}
-
-        self.evaluate_test(kwargs, spec)
-
-    def test_case_2(self):
-        input_shapes = [(42, 64), (32, 64)]
-        output_shapes = [(42, 32)]
-        attributes = {'transA': 0, 'transB': 1}
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).gemm(node)
-
-        kwargs = {'m': 42, 'k': 64, 'n': 32}
-
-        self.evaluate_test(kwargs, spec)
-
-    def test_case_3(self):
-        input_shapes = [(64, 42), (32, 64)]
-        output_shapes = [(42, 32)]
-        attributes = {'transA': 1, 'transB': 1}
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).gemm(node)
-
-        kwargs = {'m': 42, 'k': 64, 'n': 32}
-
-        self.evaluate_test(kwargs, spec)
-
-    def test_case_4(self):
-        input_shapes = [(64, 42)]
-        output_shapes = [(42, 32)]
-        attributes = {'transA': 1, 'transB': 1}
-        init_shapes = [(32, 64)]
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes, init_shapes)
-        spec = OnnxExportSpec(model).gemm(node)
-
-        kwargs = {'m': 42, 'k': 64, 'n': 32}
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_matmul(unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='MatMul', check_model=True)
-        assert node.op_type == 'MatMul'
-
-        return model, node
-
-    def evaluate_test(self, expected: Dict, spec: Spec):
-        self.assertEqual(expected['lhs_shape'], spec.option.lhs_shape)
-        self.assertEqual(expected['rhs_shape'], spec.option.rhs_shape)
-
-    def test_case_1(self):
-        input_shapes = [(1, 16, 128, 256), (1, 16, 256, 368)]
-        output_shapes = [(1, 16, 128, 368)]
-        attributes = {}
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).matmul(node)
-
-        kwargs = {'lhs_shape': [1, 16, 128, 256],
-                  'rhs_shape': [1, 16, 256, 368]}
-
-        self.evaluate_test(kwargs, spec)
-
-    def test_case_2(self):
-        input_shapes = [(32, 48)]
-        output_shapes = [(32, 24)]
-        init_shapes = [(48, 24)]
-        attributes = {}
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes, init_shapes)
-        spec = OnnxExportSpec(model).matmul(node)
-
-        kwargs = {'lhs_shape': [32, 48],
-                  'rhs_shape': [48, 24]}
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_depthtospace(unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='DepthToSpace', check_model=True)
-        assert node.op_type == 'DepthToSpace'
-
-        return model, node
-
-    def evaluate_test(self, expected: Dict, spec: Spec):
-        self.assertEqual(expected['batch'], spec.option.batch)
-        self.assertEqual(expected['height'], spec.option.height)
-        self.assertEqual(expected['width'], spec.option.width)
-        self.assertEqual(expected['channel'], spec.option.channel)
-        self.assertEqual(expected['blocksize'], spec.option.block_size)
-        self.assertEqual(expected['mode'], spec.option.mode)
-
-    def test_case_1(self):
-        input_shapes = [(1, 1024, 44, 88)]
-        output_shapes = [(1, 256, 88, 176)]
-        attributes = {
-            'blocksize': 2
-        }
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).depthtospace(node)
-
-        kwargs = {
-            'batch': 1,
-            'height': 44,
-            'width': 88,
-            'channel': 1024,
-            'mode': 'DepthColumnRow'
-        }
-        kwargs.update(attributes)
-
-        self.evaluate_test(kwargs, spec)
-
-    def test_case_2(self):
-        input_shapes = [(1, 1024, 44, 88)]
-        output_shapes = [(1, 256, 88, 176)]
-        attributes = {
-            'blocksize': 2,
-            'mode': 'CRD'
-        }
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).depthtospace(node)
-
-        kwargs = {
-            'batch': 1,
-            'height': 44,
-            'width': 88,
-            'channel': 1024,
-        }
-        kwargs.update(attributes)
-        kwargs['mode'] = 'ColumnRowDepth'
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_resize(unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_values):
-        model, node = make_test_model_with_init_val(input_shapes, output_shapes, attributes, init_values,
-                                                    op_type='Resize', check_model=True)
-        assert node.op_type == 'Resize'
-
-        return model, node
-
-    def evaluate_test(self, expected: Dict, spec: Spec):
-        self.assertEqual(expected['shape'], spec.option.shape)
-        self.assertEqual(expected['roi'], spec.option.roi)
-        self.assertEqual(expected['scales'], spec.option.scales)
-        self.assertEqual(expected['sizes'], spec.option.sizes)
-
-    def test_case(self):
-        input_shapes = [(1, 3, 224, 224)]
-        output_shapes = [(1, 3, 112, 112)]
-        attributes = {}
-        init_values = [np.array([]), np.array([]), np.array([1, 3, 112, 112])]
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes, init_values)
-        spec = OnnxExportSpec(model).resize(node)
-
-        kwargs = {'shape': [1, 3, 224, 224],
-                  'roi': [],
-                  'scales': [],
-                  'sizes': [1, 3, 112, 112]}
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_add(unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='Add', check_model=True)
-        assert node.op_type == 'Add'
-
-        return model, node
-
-    def evaluate_test(self, expected: Dict, spec: Spec):
-        self.assertEqual(expected['shape'], spec.option.shape)
-
-    def test_case(self):
-        input_shapes = [(16, 17, 18, 19), (16, 17, 18, 19)]
-        output_shapes = [(16, 17, 18, 19)]
-        attributes = {}
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).add(node)
-
-        kwargs = {'shape': [16, 17, 18, 19]}
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_sub(Test_add, unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='Sub', check_model=True)
-        assert node.op_type == 'Sub'
-
-        return model, node
-
-    def test_case(self):
-        input_shapes = [(16, 17, 18, 19), (16, 17, 18, 19)]
-        output_shapes = [(16, 17, 18, 19)]
-        attributes = {}
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).sub(node)
-
-        kwargs = {'shape': [16, 17, 18, 19]}
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_mul(Test_add, unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='Mul', check_model=True)
-        assert node.op_type == 'Mul'
-
-        return model, node
-
-    def test_case(self):
-        input_shapes = [(16, 17, 18, 19), (16, 17, 18, 19)]
-        output_shapes = [(16, 17, 18, 19)]
-        attributes = {}
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).mul(node)
-
-        kwargs = {'shape': [16, 17, 18, 19]}
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_div(Test_add, unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='Div', check_model=True)
-        assert node.op_type == 'Div'
-
-        return model, node
-
-    def test_case(self):
-        input_shapes = [(16, 17, 18, 19), (16, 17, 18, 19)]
-        output_shapes = [(16, 17, 18, 19)]
-        attributes = {}
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).div(node)
-
-        kwargs = {'shape': [16, 17, 18, 19]}
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_exp(Test_add, unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='Exp', check_model=True)
-        assert node.op_type == 'Exp'
-
-        return model, node
-
-    def test_case(self):
-        input_shapes = [(16, 17, 18, 19)]
-        output_shapes = [(16, 17, 18, 19)]
-        attributes = {}
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).exp(node)
-
-        kwargs = {'shape': [16, 17, 18, 19]}
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_sigmoid(Test_add, unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='Sigmoid', check_model=True)
-        assert node.op_type == 'Sigmoid'
-
-        return model, node
-
-    def test_case(self):
-        input_shapes = [(16, 17, 18, 19)]
-        output_shapes = [(16, 17, 18, 19)]
-        attributes = {}
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).sigmoid(node)
-
-        kwargs = {'shape': [16, 17, 18, 19]}
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_softplus(unittest.TestCase):
-    def evaluate_test(self, expected: Dict, spec: Spec):
-        self.assertEqual(expected['shape'], spec.option.input_shape)
-
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='Softplus', check_model=True)
-        assert node.op_type == 'Softplus'
-
-        return model, node
-
-    def test_case(self):
-        input_shapes = [(16, 17, 18, 19)]
-        output_shapes = [(16, 17, 18, 19)]
-        attributes = {}
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).softplus(node)
-
-        kwargs = {'shape': [16, 17, 18, 19]}
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_gelu(Test_add, unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='Gelu', check_model=False)
-        assert node.op_type == 'Gelu'
-
-        return model, node
-
-    def test_case(self):
-        input_shapes = [(16, 17, 18, 19)]
-        output_shapes = [(16, 17, 18, 19)]
-        attributes = {}
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).gelu(node)
-
-        kwargs = {'shape': [16, 17, 18, 19]}
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_reduce_mean(unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='ReduceMean', check_model=True)
-        assert node.op_type == 'ReduceMean'
-
-        return model, node
-
-    def evaluate_test(self, expected: Dict, spec: Spec):
-        self.assertEqual(expected['shape'], spec.option.shape)
-        self.assertEqual(expected['axes'], spec.option.axes)
-
-    def test_case(self):
-        input_shapes = [(12, 22, 32)]
-        output_shapes = [(12, 1, 1)]
-        attributes = {'axes': [-1, 1]}
-
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).reduce_mean(node)
-
-        kwargs = {'shape': [12, 22, 32],
-                  'axes': [2, 1]}
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_reduce_sum(Test_reduce_mean, unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='ReduceSum', check_model=True)
-        assert node.op_type == 'ReduceSum'
-
-        return model, node
-
-    def test_case(self):
-        input_shapes = [(12, 22, 32)]
-        output_shapes = [(12, 1, 1)]
-        attributes = {'axes': [-1, 1]}
-
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).reduce_sum(node)
-
-        kwargs = {'shape': [12, 22, 32],
-                  'axes': [2, 1]}
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_reduce_l2(Test_reduce_mean, unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='ReduceL2', check_model=True)
-        assert node.op_type == 'ReduceL2'
-
-        return model, node
-
-    def test_case(self):
-        input_shapes = [(12, 22, 32)]
-        output_shapes = [(12, 1, 1)]
-        attributes = {'axes': [-1, 1]}
-
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).reduce_l2(node)
-
-        kwargs = {'shape': [12, 22, 32],
-                  'axes': [2, 1]}
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_squeeze(Test_reduce_mean, unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='Squeeze', check_model=True)
-        assert node.op_type == 'Squeeze'
-
-        return model, node
-
-    def test_case(self):
-        input_shapes = [(12, 22, 32)]
-        output_shapes = [(12,)]
-        attributes = {'axes': [-1, 1]}
-
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).squeeze(node)
-
-        kwargs = {'shape': [12, 22, 32],
-                  'axes': [2, 1]}
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_unsqueeze(Test_reduce_mean, unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='Unsqueeze', check_model=True)
-        assert node.op_type == 'Unsqueeze'
-
-        return model, node
-
-    def test_case(self):
-        input_shapes = [(12, 22, 32)]
-        output_shapes = [(12, 1, 22, 32, 1)]
-        attributes = {'axes': [-1, 1]}
-
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).unsqueeze(node)
-
-        kwargs = {'shape': [12, 22, 32],
-                  'axes': [2, 1]}
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_reshape(unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_values):
-        model, node = make_test_model_with_init_val(input_shapes, output_shapes, attributes, init_values,
-                                                    op_type='Reshape', check_model=True)
-        assert node.op_type == 'Reshape'
-
-        return model, node
-
-    def evaluate_test(self, expected: Dict, spec: Spec):
-        self.assertEqual(expected['input_shape'], spec.option.input_shape)
-        self.assertEqual(expected['output_shape'], spec.option.output_shape)
-
-    def test_case(self):
-        input_shapes = [(32, 16, 256, 256)]
-        output_shapes = [(32, 64, 128, 128)]
-        attributes = {}
-        init_values = [np.array([32, -1, 128, 128])]
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes, init_values)
-        spec = OnnxExportSpec(model).reshape(node)
-
-        kwargs = {
-            'input_shape': [32, 16, 256, 256],
-            'output_shape': [32, 64, 128, 128]
-        }
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_expand(Test_reshape, unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_values):
-        # TODO fix Process finished with exit code 139 (interrupted by signal 11: SIGSEGV)
-        #  when check_model=True
-        model, node = make_test_model_with_init_val(input_shapes, output_shapes, attributes, init_values,
-                                                    op_type='Expand', check_model=False)
-        assert node.op_type == 'Expand'
-
-        return model, node
-
-    def test_case(self):
-        input_shapes = [(32, 1, 12, 12)]
-        output_shapes = [(32, 8, 12, 12)]
-        attributes = {}
-        init_values = [np.array([32, 8, 12, 12])]
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes, init_values)
-        spec = OnnxExportSpec(model).expand(node)
-
-        kwargs = {
-            'input_shape': [32, 1, 12, 12],
-            'output_shape': [32, 8, 12, 12]
-        }
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_concatenation(unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='Concat', check_model=True)
-        assert node.op_type == 'Concat'
-
-        return model, node
-
-    def evaluate_test(self, expected: Dict, spec: Spec):
-        self.assertEqual(expected['tensors'], spec.option.tensors)
-        self.assertEqual(expected['axis'], spec.option.axis)
-
-    def test_case_1(self):
-        input_shapes = [(1, 2, 3), (1, 2, 3), (1, 2, 3)]
-        output_shapes = [(1, 2, 9)]
-        attributes = {'axis': -1}
-
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).concatenation(node)
-
-        kwargs = {'tensors': [[1, 2, 3], [1, 2, 3], [1, 2, 3]],
-                  'axis': 2}
-
-        self.evaluate_test(kwargs, spec)
-
-    def test_case_2(self):
-        input_shapes = [(1, 2, 3), (1, 2, 3), (1, 2, 3)]
-        output_shapes = [(3, 2, 3)]
-        attributes = {'axis': 0}
-
-        model, node = make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).concatenation(node)
-        kwargs = {'tensors': [[1, 2, 3], [1, 2, 3], [1, 2, 3]]}
-        kwargs.update(attributes)
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_transpose(unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='Transpose', check_model=True)
-        assert node.op_type == 'Transpose'
-
-        return model, node
-
-    def evaluate_test(self, expected: Dict, spec: Spec):
-        self.assertEqual(expected['shape'], spec.option.shape)
-        self.assertEqual(expected['permutation'], spec.option.permutation)
-
-    def test_case(self):
-        input_shapes = [(1, 2, 3, 4)]
-        output_shapes = [(2, 1, 4, 3)]
-        attributes = {'perm': (1, 0, -1, 2)}
-
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).transpose(node)
-
-        kwargs = {'shape': [1, 2, 3, 4],
-                  'permutation': [1, 0, 3, 2]}
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_slice(unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_values):
-        model, node = make_test_model_with_init_val(input_shapes, output_shapes, attributes, init_values,
-                                                    op_type='Slice', check_model=True)
-        assert node.op_type == 'Slice'
-
-        return model, node
-
-    def evaluate_test(self, expected: Dict, spec: Spec):
-        self.assertEqual(expected['shape'], spec.option.shape)
-        self.assertEqual(expected['offset'], spec.option.offset)
-
-    def test_case(self):
-        input_shapes = [(1, 3, 224, 224)]
-        output_shapes = [(1, 2, 224, 224)]
-        attributes = {}
-        init_values = [np.array([1]), np.array([]), np.array([1])]
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes, init_values)
-        spec = OnnxExportSpec(model).slice(node)
-
-        kwargs = {
-            'shape': [1, 3, 224, 224],
-            'offset': [0, 1, 0, 0]
-        }
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_flatten(unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='Flatten', check_model=True)
-        assert node.op_type == 'Flatten'
-
-        return model, node
-
-    def evaluate_test(self, expected: Dict, spec: Spec):
-        self.assertEqual(expected['shape'], spec.option.shape)
-        self.assertEqual(expected['axis'], spec.option.axis)
-
-    def test_case_1(self):
-        input_shapes = [(16, 2, 3, 4, 5, 6, 7, 8)]
-        output_shapes = [(1, 16 * 2 * 3 * 4 * 5 * 6 * 7 * 8)]
-        attributes = {'axis': 0}
-
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).flatten(node)
-
-        kwargs = {'shape': [16, 2, 3, 4, 5, 6, 7, 8]}
-        kwargs.update(attributes)
-
-        self.evaluate_test(kwargs, spec)
-
-    def test_case_2(self):
-        input_shapes = [(8, 2, 3, 4, 5, 6, 7, 8)]
-        output_shapes = [(8 * 2 * 3, 4 * 5 * 6 * 7 * 8)]
-        attributes = {'axis': 3}
-
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).flatten(node)
-
-        kwargs = {'shape': [8, 2, 3, 4, 5, 6, 7, 8]}
-        kwargs.update(attributes)
-
-        self.evaluate_test(kwargs, spec)
-
-    def test_case_3(self):
-        input_shapes = [(1, 2, 3, 4, 5, 6, 7, 8)]
-        output_shapes = [(1 * 2 * 3 * 4 * 5 * 6 * 7, 8)]
-        attributes = {'axis': -1}
-
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).flatten(node)
-
-        kwargs = {
-            'shape': [1, 2, 3, 4, 5, 6, 7, 8],
-            'axis': 7}
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_pad(unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_values):
-        model, node = make_test_model_with_init_val(input_shapes, output_shapes, attributes, init_values,
-                                                    op_type='Pad', check_model=True)
-        assert node.op_type == 'Pad'
-
-        return model, node
-
-    def evaluate_test(self, expected: Dict, spec: Spec):
-        self.assertEqual(expected['shape'], spec.option.shape)
-        self.assertEqual(expected['pad'], [(p.first, p.second) for p in spec.option.pad])
-
-    def test_case(self):
-        input_shapes = [(1, 2, 3, 4)]
-        output_shapes = [(7, 10, 13, 16)]
-        attributes = dict()
-        init_values = [np.array([1, 2, 3, 4, 5, 6, 7, 8])]
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes, init_values)
-        spec = OnnxExportSpec(model).pad(node)
-
-        kwargs = {
-            'shape': [1, 2, 3, 4],
-            'pad': [(1, 5), (2, 6), (3, 7), (4, 8)]
-        }
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_layer_norm(unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='LayerNorm', check_model=False)
-        assert node.op_type == 'LayerNorm'
-
-        return model, node
-
-    def evaluate_test(self, expected: Dict, spec: Spec):
-        self.assertEqual(expected['input_shape'], spec.option.input_shape)
-        self.assertEqual(expected['eps'], spec.option.eps)
-
-    def test_case(self):
-        input_shapes = [(1, 32, 64, 64)]
-        output_shapes = [(1, 32, 64, 64)]
-        attributes = {'epsilon': 9.999999747378752e-05}
-
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).layer_norm(node)
-
-        kwargs = {'input_shape': [1, 32, 64, 64], 'eps': attributes['epsilon']}
-        kwargs.update(attributes)
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_split(unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='Split', check_model=False)
-        assert node.op_type == 'Split'
-
-        return model, node
-
-    def evaluate_test(self, expected: Dict, spec: Spec):
-        self.assertEqual(expected['shape'], spec.option.shape)
-        self.assertEqual(expected['split'], spec.option.split)
-        self.assertEqual(expected['axis'], spec.option.axis)
-
-    def test_case(self):
-        input_shapes = [(1, 284, 2)]
-        output_shapes = [(1, 284, 1), (1, 284, 1)]
-        attributes = {
-            'split': (1, 1),
-            'axis': -1
-        }
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).split(node)
-
-        kwargs = {
-            'shape': [1, 284, 2],
-            'split': [1, 1],
-            'axis': 2
-        }
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_softmax(unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_shapes=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_shapes,
-                                      op_type='Softmax', check_model=False)
-        assert node.op_type == 'Softmax'
-
-        return model, node
-
-    def evaluate_test(self, expected: Dict, spec: Spec):
-        self.assertEqual(expected['input_shape'], spec.option.input_shape)
-        self.assertEqual(expected.get('beta', 1.0), spec.option.beta)
-        self.assertEqual(expected['axis'], spec.option.axis)
-
-    def test_case(self):
-        input_shapes = [(1, 1001, 224)]
-        output_shapes = [(1, 1001, 224)]
-        attributes = {'axis': -1}
-
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).softmax(node)
-
-        kwargs = {
-            'input_shape': [1, 1001, 224],
-            'axis': 2
-        }
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_clip(unittest.TestCase):
-    def make_test_model(self, input_shapes, output_shapes, attributes, init_values=None):
-        model, node = make_test_model(input_shapes, output_shapes, attributes, init_values,
-                                      op_type='Clip', check_model=False)
-        assert node.op_type == 'Clip'
-
-        return model, node
-
-    def make_test_model_1(self, kwargs, input_shapes):
-        class Clip(nn.Module):
-            def __init__(self, kwargs):
-                super(Clip, self).__init__()
-                self.kwargs = kwargs
-
-            def forward(self, x):
-                return torch.clamp(x, **self.kwargs)
-
-        model = torch_to_onnx(Clip(kwargs), input_shapes)
-        node = model.graph.node[0]
-        assert node.op_type == 'Clip'
-
-        return model, node
-
-    def evaluate_test(self, expected: Dict, spec: Spec):
-        self.assertEqual(expected['input_shape'], spec.option.input_shape)
-        self.assertEqual(expected.get('min', None), spec.option.min)
-        self.assertEqual(expected.get('max', None), spec.option.max)
-
-    def test_case_1(self):
-        input_shapes = [(1, 2, 3, 4)]
-        output_shapes = [(1, 2, 3, 4)]
-        attributes = {
-            'min': 0.0,
-            'max': 6.0
-        }
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).clip(node)
-
-        kwargs = {
-            'input_shape': [1, 2, 3, 4],
-        }
-        kwargs.update(attributes)
-
-        self.evaluate_test(kwargs, spec)
-
-    def test_case_2(self):
-        input_shapes = [(1, 2, 3, 4)]
-        output_shapes = [(1, 2, 3, 4)]
-        attributes = {
-            'max': 0.0,
-        }
-        model, node = self.make_test_model(input_shapes, output_shapes, attributes)
-        spec = OnnxExportSpec(model).clip(node)
-
-        kwargs = {
-            'input_shape': [1, 2, 3, 4],
-        }
-        kwargs.update(attributes)
-
-        self.evaluate_test(kwargs, spec)
-
-    def test_case_3(self):
-        input_shapes = [(1, 2, 3, 4)]
-        kwargs = {'min': 0.0}
-        model, node = self.make_test_model_1(kwargs, input_shapes)
-        spec = OnnxExportSpec(model).clip(node)
-
-        kwargs.update({
-            'input_shape': [1, 2, 3, 4],
-        })
-
-        self.evaluate_test(kwargs, spec)
-
-    def test_case_4(self):
-        input_shapes = [(1, 2, 3, 4)]
-        kwargs = {'max': 0.0}
-        model, node = self.make_test_model_1(kwargs, input_shapes)
-        spec = OnnxExportSpec(model).clip(node)
-
-        kwargs.update({
-            'input_shape': [1, 2, 3, 4],
-        })
-
-        self.evaluate_test(kwargs, spec)
-
-    def test_case_5(self):
-        input_shapes = [(1, 2, 3, 4)]
-        kwargs = {
-            'min': 0.0,
-            'max': 6.0
-        }
-        model, node = self.make_test_model_1(kwargs, input_shapes)
-        spec = OnnxExportSpec(model).clip(node)
-
-        kwargs.update({
-            'input_shape': [1, 2, 3, 4],
-        })
-
-        self.evaluate_test(kwargs, spec)
-
-
-class Test_multi_node_lp_norm(unittest.TestCase):
-    def make_test_model(self, kwargs, input_shapes):
-        class LpNorm(nn.Module):
-            def __init__(self, kwargs):
-                super(LpNorm, self).__init__()
-                self.kwargs = kwargs
-
-            def forward(self, x):
-                return torch.nn.functional.normalize(x, **self.kwargs)
-
-        model = torch_to_onnx(LpNorm(kwargs), input_shapes)
-        node = model.graph.node[-1]
-        from furiosa_sdk_quantizer.frontend.onnx.utils.inference_shape import InferenceShape
-        model = InferenceShape(model).inference_shape()
-
-        assert node.op_type == 'Div'
-
-        return model, node
-
-    def evaluate_test(self, expected: Dict, spec: Spec):
-        self.assertEqual(expected['input_shape'], spec.option.input_shape)
-        self.assertEqual(expected['p'], spec.option.p)
-        self.assertEqual(expected['axis'], spec.option.axis)
-
-    def test_case(self):
-        input_shapes = [(1, 2, 3, 4)]
-        kwargs = {
-            'dim': 1,
-            'p': 2
-        }
-        model, node = self.make_test_model(kwargs, input_shapes)
-        spec, _ = OnnxExportSpec(model).multi_node_lp_norm(node)
-
-        kwargs.update({
-            'input_shape': [1, 2, 3, 4],
-            'axis': 1
-        })
-
-        self.evaluate_test(kwargs, spec)
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/__init__.py b/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/__init__.py
deleted file mode 100644
index 4ce37f65..00000000
--- a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/__init__.py
+++ /dev/null
@@ -1,98 +0,0 @@
-import abc
-from typing import List, Tuple, Union
-
-import onnx
-import unittest
-
-import numpy as np
-import onnxruntime as ort
-
-from onnx import numpy_helper
-
-from tests import torch_to_onnx
-from furiosa_sdk_quantizer.interfaces.transformer import Transformer
-from furiosa_sdk_quantizer.frontend.onnx.transformer.polish_model import PolishModel
-
-
-class TestTransformer(unittest.TestCase):
-    @staticmethod
-    def make_test_model(torch_model: callable, transformer: Union[Transformer, abc.ABCMeta],
-                        input_shapes: List[Tuple[int, ...]]):
-        orig_model = torch_to_onnx(torch_model, input_shapes)
-        # apply polish_model by default
-        orig_model = PolishModel().transform(orig_model)
-        copy_model = onnx.ModelProto()
-        copy_model.CopyFrom(orig_model)
-
-        if isinstance(transformer, Transformer):
-            trans_model = transformer.transform(copy_model)
-        elif isinstance(transformer, abc.ABCMeta):
-            trans_model = transformer(copy_model).transform()
-        else:
-            raise Exception()
-
-        return orig_model, trans_model
-
-    @staticmethod
-    def make_test_unit_model_from_onnx(onnx_model: onnx.ModelProto, transformer: Transformer):
-        copy_model = onnx.ModelProto()
-
-        copy_model.CopyFrom(onnx_model)
-        trans_model = transformer.transform(copy_model)
-
-        return onnx_model, trans_model
-
-    def check_graph_node(self, model, op_types: List[str]):
-        assert len(model.graph.node) == len(op_types)
-        for node, op_type in zip(model.graph.node, op_types):
-            self.assertTrue(node.op_type == op_type)
-
-    def check_output_value(self, orig_model, trans_model, input_shapes):
-        np_arrays = [np.random.randn(*shape).astype(np.float32) for shape in input_shapes]
-        actual = run_onnx_model(orig_model, np_arrays)
-        expected = run_onnx_model(trans_model, np_arrays)
-
-        for act, exp in zip(actual, expected):
-            self.assertListAlmostEqual(act, exp, 4)
-
-    def check_value_info(self, model):
-        value_info = {vi.name: vi for vi in
-                      list(model.graph.value_info) + list(model.graph.input) + list(model.graph.output)}
-
-        for node in model.graph.node:
-            for input in list(node.input) + list(node.output):
-                if not input:
-                    continue
-                self.assertTrue(input in value_info.keys())
-
-    def check_initializer(self, actual, expected):
-        self.assertListAlmostEqual(actual.flatten().tolist(), expected.flatten().tolist(), 4)
-
-    def check_attribute(self, actual, expected):
-        self.assertEqual(actual, expected)
-
-    def check_assertion(self, func, kwargs):
-        self.assertRaises(AssertionError, func, **kwargs)
-
-    def assertListAlmostEqual(self, list1, list2, tol):
-        self.assertEqual(len(list1), len(list2))
-        for a, b in zip(list1, list2):
-            self.assertAlmostEqual(a, b, tol)
-
-
-def run_onnx_model(model: onnx.ModelProto,
-                   input_arrays: List[np.array]) -> List[List[float]]:
-    sess = ort.InferenceSession(model.SerializeToString())
-    input_names = [inp.name for inp in sess.get_inputs()]
-    output_names = [out.name for out in sess.get_outputs()]
-    feed_dict = {k: v for k, v in zip(input_names, input_arrays)}
-    outputs = sess.run(output_names, input_feed=feed_dict)
-
-    flattened_outputs = [val.flatten().tolist() for val in outputs]
-
-    return flattened_outputs
-
-
-def init_to_numpy(model, init_name):
-    initializer = {init.name: init for init in model.graph.initializer}
-    return numpy_helper.to_array(initializer[init_name])
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/deprecated/__init__.py b/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/deprecated/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/deprecated/test_eliminate_detection_postprocess.py b/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/deprecated/test_eliminate_detection_postprocess.py
deleted file mode 100644
index 07e47089..00000000
--- a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/deprecated/test_eliminate_detection_postprocess.py
+++ /dev/null
@@ -1,36 +0,0 @@
-# TODO refactor test case
-# import unittest
-#
-# import torch
-# import torch.nn as nn
-#
-# from dss.frontend.onnx.utils.check_model import check_model
-# from dss.frontend.onnx.transformer.eliminate_detection_postprocess import EliminateSSDDetectionPostprocess
-# from tests import torch_to_onnx
-#
-#
-# class TestEliminateDetectionPostprocess(unittest.TestCase):
-#     def test_elimination(self):
-#         class TestModel(nn.Module):
-#             def __init__(self):
-#                 super(TestModel, self).__init__()
-#                 self.conv1 = nn.Conv2d(in_channels=3, out_channels=4, kernel_size=1)
-#                 self.conv2 = nn.Conv2d(in_channels=4, out_channels=6, kernel_size=1)
-#                 self.conv3 = nn.Conv2d(in_channels=4, out_channels=6, kernel_size=1)
-#
-#             def forward(self, x):
-#                 x = self.conv1(x)
-#                 y = self.conv2(x)
-#                 z = self.conv3(x)
-#                 y = torch.mul(y, torch.ones(12))
-#                 z = torch.add(z, torch.ones(12))
-#                 return y, z
-#
-#         model = torch_to_onnx(TestModel(), torch.randn(1, 3, 12, 12))
-#         model = EliminateSSDDetectionPostprocess(['8', '9']).transform(model)
-#         check_model(model)
-#
-#         self.assertEqual(len(model.graph.node), 3)
-#         self.assertEqual(model.graph.node[0].name, 'Conv_0')
-#         self.assertEqual(model.graph.node[1].name, 'Conv_1')
-#         self.assertEqual(model.graph.node[2].name, 'Conv_2')
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/deprecated/test_eliminate_identity.py b/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/deprecated/test_eliminate_identity.py
deleted file mode 100644
index 228d76ef..00000000
--- a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/deprecated/test_eliminate_identity.py
+++ /dev/null
@@ -1,148 +0,0 @@
-import abc
-
-import torch
-import torch.nn as nn
-from onnx import TensorProto
-from onnx.helper import make_node, make_model, make_tensor_value_info
-
-from furiosa_sdk_quantizer.frontend.onnx.transformer.deprecated.eliminate_identity import EliminateIdentity
-from furiosa_sdk_quantizer.frontend.onnx.transformer.extract_constant_to_initializer import ExtractConstantToInitializer
-from furiosa_sdk_quantizer.frontend.onnx.utils.check_model import check_model
-
-from tests import torch_to_onnx
-from tests.frontend.onnx.transformer import TestTransformer
-
-
-class TestEliminateIdentity(TestTransformer, abc.ABC):
-    def test_case1(self):
-        """
-        Test case1
-        from: input -> mul -> output
-        to: input -> mul -> indentity -> output
-        """
-
-        class TestModel(nn.Module, abc.ABC):
-            def forward(self, x):
-                x = torch.mul(x, torch.ones(4))
-                return x
-
-        model = torch_to_onnx(TestModel(), [(1, 4)])
-
-        new_nodes = []
-        for node in model.graph.node:
-            new_nodes.append(node)
-
-        new_nodes.append(
-            make_node(op_type='Identity',
-                      inputs='2',
-                      outputs='3')
-        )
-        model.graph.output.remove(model.graph.output[0])
-        model.graph.output.append(
-            make_tensor_value_info(name='3',
-                                   elem_type=TensorProto.FLOAT,
-                                   shape=(1, 4)))
-        model.graph.ClearField('node')
-        model.graph.node.extend(new_nodes)
-        model = make_model(model.graph)
-        model = ExtractConstantToInitializer().transform(model)
-        model = EliminateIdentity().transform(model)
-        check_model(model)
-
-        self.check_graph_node(model, ['Mul'])
-
-    def test_case2(self):
-        """
-            Test case2
-            from: input -> mul -> output
-            to: input -> identity -> mul -> output
-        """
-
-        class TestModel(nn.Module, abc.ABC):
-            def forward(self, x):
-                x = torch.mul(x, torch.ones(4))
-                return x
-
-        model = torch_to_onnx(TestModel(), [(1, 4)])
-
-        new_nodes = []
-        for node in model.graph.node:
-            if node.op_type != 'Mul':
-                new_nodes.append(node)
-                continue
-
-            new_nodes.append(
-                make_node(op_type='Identity',
-                          inputs='0',
-                          outputs='2')
-            )
-            new_nodes.append(node)
-            node.input[0] = '2'
-            node.output[0] = '3'
-
-        model.graph.output[0].name = '3'
-        model.graph.ClearField('node')
-        model.graph.node.extend(new_nodes)
-        model = make_model(model.graph)
-        model = ExtractConstantToInitializer().transform(model)
-        model = EliminateIdentity().transform(model)
-        check_model(model)
-
-        self.check_graph_node(model, ['Mul'])
-
-    def make_test_case3(self):
-        """
-            Test case2
-            from: input -> mul -> output
-            to: input -> mul -> identity -> output
-                             -> identity -> output
-        """
-
-        class TestModel(nn.Module, abc.ABC):
-            def forward(self, x):
-                x = torch.mul(x, torch.ones(4))
-                y = torch.add(x, torch.ones(4))
-                z = torch.sub(x, torch.ones(4))
-                return y, z
-
-        model = torch_to_onnx(TestModel(), [(1, 4)])
-
-        new_nodes = []
-        outputs_by_name = {oup.name: oup for oup in model.graph.output}
-
-        for node in model.graph.node:
-            new_nodes.append(node)
-            try:
-                model.graph.output.remove(outputs_by_name[node.output[0]])
-            except KeyError:
-                continue
-
-        new_nodes.append(
-            make_node(op_type='Identity',
-                      inputs='4',
-                      outputs='7')
-        )
-
-        new_nodes.append(
-            make_node(op_type='Identity',
-                      inputs='6',
-                      outputs='8')
-        )
-
-        model.graph.output.extend([
-            make_tensor_value_info(name='7',
-                                   elem_type=TensorProto.FLOAT,
-                                   shape=(1, 4)),
-            make_tensor_value_info(name='8',
-                                   elem_type=TensorProto.FLOAT,
-                                   shape=(1, 4))
-        ])
-
-        model.graph.ClearField('node')
-        model.graph.node.extend(new_nodes)
-        model = make_model(model.graph)
-        model = ExtractConstantToInitializer().transform(model)
-        model = EliminateIdentity().transform(model)
-        check_model(model)
-
-        self.check_graph_node(model, ['Mul', 'Add', 'Sub'])
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/deprecated/test_eliminate_softmax_output.py b/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/deprecated/test_eliminate_softmax_output.py
deleted file mode 100644
index f51dd0f3..00000000
--- a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/deprecated/test_eliminate_softmax_output.py
+++ /dev/null
@@ -1,96 +0,0 @@
-import abc
-
-import torch
-import torch.nn as nn
-
-from furiosa_sdk_quantizer.frontend.onnx.transformer.deprecated.eliminate_softmax_output import EliminateSoftmaxOutput
-from tests.frontend.onnx.transformer import TestTransformer
-
-
-class MultiTestModel(nn.Module, abc.ABC):
-    def forward(self, x):
-        x = torch.mul(x, torch.ones(x.shape))
-        x = torch.softmax(x, dim=3)
-        return x
-
-
-class MultiTestModel1(nn.Module, abc.ABC):
-    def forward(self, x):
-        x = torch.mul(x, torch.ones(x.shape))
-        x = torch.softmax(x, dim=1)
-        return x
-
-
-class MultiTestModel2(nn.Module, abc.ABC):
-    def forward(self, x):
-        x = torch.mul(x, torch.ones(x.shape))
-        x = torch.softmax(x, dim=1)
-        x = torch.sub(x, torch.ones(x.shape))
-        return x
-
-
-class MultiTestModel3(nn.Module, abc.ABC):
-    def forward(self, x):
-        x = torch.mul(x, torch.ones(x.shape))
-        y = torch.softmax(x, dim=0)
-        z = torch.softmax(x, dim=0)
-
-        return y, z
-
-
-class TestEliminateSoftmaxOutput(TestTransformer):
-    def make_multi_model(self, torch_model, input_shapes):
-        orig_model, trans_model = self.make_test_model(torch_model, EliminateSoftmaxOutput(), input_shapes)
-        return orig_model, trans_model
-
-    def test_case1(self):
-        """
-            Test whether the original model is well transformed for multi operator model,
-             which contains operators other than Softmax
-        """
-        input_shapes = [(1, 1, 4, 4)]
-        op_types = ['Mul']
-
-        orig_model, trans_model = self.make_multi_model(MultiTestModel(), input_shapes)
-        self.check_graph_node(trans_model, op_types)
-        self.check_assertion(self.check_output_value,
-                             {'orig_model': orig_model, 'trans_model': trans_model, 'input_shapes': input_shapes})
-        self.check_value_info(trans_model)
-
-    def test_case2(self):
-        """
-            Test whether the original model is well transformed for multi operator model,
-             which contains operators other than Softmax
-        """
-        input_shapes = [(2, 4, 8, 8, 16)]
-        op_types = ['Mul']
-        orig_model, trans_model = self.make_multi_model(MultiTestModel1(), input_shapes)
-        self.check_graph_node(trans_model, op_types)
-        self.check_assertion(self.check_output_value,
-                             {'orig_model': orig_model, 'trans_model': trans_model, 'input_shapes': input_shapes})
-        self.check_value_info(trans_model)
-
-    def test_case3(self):
-        """
-            Test whether the original model is well transformed for multi operator model,
-             which contains operators other than Softmax
-        """
-        input_shapes = [(8, 8, 8)]
-        op_types = ['Mul', 'Transpose', 'Softmax', 'Transpose', 'Sub']
-        orig_model, trans_model = self.make_multi_model(MultiTestModel2(), input_shapes)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case4(self):
-        """
-            Test whether the original model is well transformed for multi operator model,
-             which contains operators other than Softmax
-        """
-        input_shapes = [(8, 8, 8)]
-        op_types = ['Mul']
-        orig_model, trans_model = self.make_multi_model(MultiTestModel3(), input_shapes)
-        self.check_graph_node(trans_model, op_types)
-        self.check_assertion(self.check_output_value,
-                             {'orig_model': orig_model, 'trans_model': trans_model, 'input_shapes': input_shapes})
-        self.check_value_info(trans_model)
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/deprecated/test_fuse_scalar_mul_into_conv.py b/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/deprecated/test_fuse_scalar_mul_into_conv.py
deleted file mode 100644
index e41f8a6c..00000000
--- a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/deprecated/test_fuse_scalar_mul_into_conv.py
+++ /dev/null
@@ -1,92 +0,0 @@
-from abc import ABC
-
-import torch
-import torch.nn as nn
-
-import numpy as np
-
-from furiosa_sdk_quantizer.frontend.onnx.transformer.deprecated.fuse_scalar_mul_into_conv import FuseScalarMulIntoConv
-from tests.frontend.onnx.transformer import TestTransformer, init_to_numpy
-
-
-class UnitTestModel(nn.Module, ABC):
-    def __init__(self, in_channel, out_channel, mul):
-        super(UnitTestModel, self).__init__()
-        self.conv = nn.Conv2d(in_channels=in_channel, out_channels=out_channel, kernel_size=(2, 2))
-        self.mul = mul
-
-    def forward(self, x):
-        x = self.conv(x)
-        x = torch.mul(x, self.mul)
-        return x
-
-
-class UnitTestModel1(UnitTestModel):
-    def __init__(self, in_channel, out_channel, mul):
-        super(UnitTestModel, self).__init__()
-        self.conv = nn.Conv2d(in_channels=in_channel, out_channels=out_channel, kernel_size=(2, 2))
-        self.mul = mul
-
-    def forward(self, x):
-        x = self.conv(x)
-        x = torch.mul(x, torch.from_numpy(np.ones(x.shape).astype(np.float32) * self.mul))
-        return x
-
-
-class MultiTestModel(UnitTestModel):
-    def __init__(self, in_channel, out_channel, mul):
-        super(MultiTestModel, self).__init__(in_channel, out_channel, mul)
-
-    def forward(self, x):
-        x = torch.mul(x, torch.ones(x.shape))
-        x = self.conv(x)
-        x = torch.mul(x, self.mul)
-        x = torch.add(x, torch.ones(x.shape))
-        return x
-
-
-class TestFuseMulIntoConv(TestTransformer, ABC):
-    def _make_test_model(self, torch_model, input_shapes):
-        orig_model, trans_model = self.make_test_model(torch_model,
-                                                       FuseScalarMulIntoConv(),
-                                                       input_shapes)
-        return orig_model, trans_model
-
-    def test_case1(self):
-        input_shapes = [(1, 3, 4, 4)]
-        in_channel = 3
-        out_channel = 4
-        mul = 0.2
-
-        op_types = ['Conv']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel(in_channel, out_channel, mul), input_shapes)
-
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-        weight, bias = [init_to_numpy(orig_model, name) for name in ['conv.weight', 'conv.bias']]
-        fused_weight, fused_bias = [init_to_numpy(trans_model, name + '_scalar_mul_fused') for name in
-                                    ['conv.weight', 'conv.bias']]
-        self.check_initializer(weight, fused_weight / mul)
-        self.check_initializer(bias, fused_bias / mul)
-
-    def test_case2(self):
-        input_shapes = [(1, 3, 8, 8)]
-        in_channel = 3
-        out_channel = 4
-        mul = 0.2
-        op_types = ['Mul', 'Conv', 'Add']
-
-        orig_model, trans_model = self._make_test_model(MultiTestModel(in_channel, out_channel, mul), input_shapes)
-
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-        weight, bias = [init_to_numpy(orig_model, name) for name in ['conv.weight', 'conv.bias']]
-        fused_weight, fused_bias = [init_to_numpy(trans_model, name + '_scalar_mul_fused') for name in
-                                    ['conv.weight', 'conv.bias']]
-        self.check_initializer(weight, fused_weight / mul)
-        self.check_initializer(bias, fused_bias / mul)
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/deprecated/test_fuse_softmax.py b/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/deprecated/test_fuse_softmax.py
deleted file mode 100644
index 3e467f37..00000000
--- a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/deprecated/test_fuse_softmax.py
+++ /dev/null
@@ -1,92 +0,0 @@
-from abc import ABC
-
-import torch
-import torch.nn as nn
-
-from furiosa_sdk_quantizer.frontend.onnx.transformer.deprecated.fuse_softmax import FuseSoftmax
-
-from tests.frontend.onnx.transformer import TestTransformer
-
-
-class UnitTestModel(nn.Module, ABC):
-    def __init__(self, dim):
-        super(UnitTestModel, self).__init__()
-        self.dim = dim
-
-    def forward(self, x):
-        y = torch.exp(x)
-        x = torch.sum(y, dim=self.dim, keepdim=True)
-        x = torch.div(y, x)
-        return x
-
-
-class MultiTestModel(UnitTestModel, ABC):
-    def __init__(self, dim):
-        super(MultiTestModel, self).__init__(dim)
-
-    def forward(self, x):
-        x = torch.sub(x, torch.ones(x.shape))
-        y = torch.exp(x)
-        x = torch.sum(y, dim=self.dim, keepdim=True)
-        x = torch.div(y, x)
-        x = torch.sub(x, torch.ones(x.shape))
-        return x
-
-
-class TestFuseSoftmax(TestTransformer):
-    def make_unit_model(self, input_shapes, dim):
-        orig_model, trans_model = self.make_test_model(UnitTestModel(dim), FuseSoftmax(), input_shapes)
-        return orig_model, trans_model
-
-    def make_multi_model(self, input_shapes, dim):
-        orig_model, trans_model = self.make_test_model(MultiTestModel(dim), FuseSoftmax(), input_shapes)
-        return orig_model, trans_model
-
-    def test_case1(self):
-        """
-            Test the case where dim = 1(intermediate dim) for unit operator model
-        """
-        input_shapes = [(3, 2)]
-        dim = 0
-        op_types = ['Transpose', 'Softmax', 'Transpose']
-
-        orig_model, trans_model = self.make_unit_model(input_shapes, dim)
-        # TODO output values are not identical why?
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-        self.check_attribute([1, 0], trans_model.graph.node[0].attribute[0].ints)
-        self.check_attribute(len(input_shapes[0]) - 1, trans_model.graph.node[1].attribute[0].i)
-        self.check_attribute([1, 0], trans_model.graph.node[2].attribute[0].ints)
-
-    def test_case2(self):
-        """
-            Test the case where dim = 3(intermediate dim) for unit operator model
-        """
-        input_shapes = [(1, 2, 3, 4, 5)]
-        dim = 3
-        op_types = ['Transpose', 'Softmax', 'Transpose']
-
-        orig_model, trans_model = self.make_unit_model(input_shapes, dim)
-        self.check_graph_node(trans_model, op_types)
-        # TODO output values are not identical why?
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-        self.check_attribute([0, 1, 2, 4, 3], trans_model.graph.node[0].attribute[0].ints)
-        self.check_attribute(len(input_shapes[0]) - 1, trans_model.graph.node[1].attribute[0].i)
-        self.check_attribute([0, 1, 2, 4, 3], trans_model.graph.node[2].attribute[0].ints)
-
-    def test_case3(self):
-        """
-            Test the case where dim = 1(last dim) for unit operator model
-        """
-        input_shapes = [(12, 24, 3)]
-        dim = -1
-        op_types = ['Softmax']
-
-        orig_model, trans_model = self.make_unit_model(input_shapes, dim)
-        self.check_graph_node(trans_model, op_types)
-        # TODO output values are not identical why?
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-        self.check_attribute(len(input_shapes[0]) - 1, trans_model.graph.node[0].attribute[0].i)
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_convert_clip_attr_to_input.py b/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_convert_clip_attr_to_input.py
deleted file mode 100644
index f1e9e842..00000000
--- a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_convert_clip_attr_to_input.py
+++ /dev/null
@@ -1,103 +0,0 @@
-from abc import ABC
-
-import torch
-import torch.nn as nn
-
-from furiosa_sdk_quantizer.frontend.onnx.transformer.convert_clip_attr_to_input import ConvertClipAttrToInput
-
-from tests.frontend.onnx.transformer import TestTransformer, init_to_numpy
-from tests import make_test_model
-
-
-class UnitTestModel(nn.Module, ABC):
-    def __init__(self, min=None, max=None):
-        super(UnitTestModel, self).__init__()
-        self.min = min
-        self.max = max
-
-    def forward(self, x):
-        x = torch.clamp(x, self.min, self.max)
-        return x
-
-
-class MultiTestModel(UnitTestModel):
-    def __init__(self, min=None, max=None):
-        super(MultiTestModel, self).__init__(min, max)
-
-    def forward(self, x):
-        x = torch.mul(x, torch.ones(x.shape))
-        x = torch.clamp(x, self.min, self.max)
-        x = torch.add(x, torch.ones(x.shape))
-        return x
-
-
-class TestConvertClipAttrToInput(TestTransformer):
-    def make_unit_model(self, input_shapes, min=None, max=None):
-        orig_model, trans_model = self.make_test_model(UnitTestModel(min, max), ConvertClipAttrToInput(), input_shapes)
-        return orig_model, trans_model
-
-    def make_multi_model(self, input_shapes, min=None, max=None):
-        orig_model, trans_model = self.make_test_model(MultiTestModel(min, max), ConvertClipAttrToInput(), input_shapes)
-        return orig_model, trans_model
-
-    def test_case1(self):
-        input_shapes = [(1, 1, 4, 4)]
-        output_shapes = [(1, 1, 4, 4)]
-        min = 0.01
-        op_types = ['Clip']
-        onnx_model, _ = make_test_model(input_shapes=input_shapes, output_shapes=output_shapes,
-                                        attributes={'min': min}, op_type=op_types[0], check_model=False)
-        orig_model, trans_model = self.make_test_unit_model_from_onnx(onnx_model, ConvertClipAttrToInput())
-        import onnx
-        onnx.save_model(orig_model, 'tmp.onnx')
-        onnx.save_model(trans_model, 'tmp1.onnx')
-        self.check_graph_node(trans_model, op_types)
-        self.check_value_info(trans_model)
-        self.check_attribute(orig_model.graph.node[0].attribute[0].f, init_to_numpy(trans_model, 'X_0_clip_min'))
-
-    def test_case2(self):
-        input_shapes = [(1, 1, 4, 4)]
-        output_shapes = [(1, 1, 4, 4)]
-        max = 1.01
-        op_types = ['Clip']
-        onnx_model, _ = make_test_model(input_shapes=input_shapes, output_shapes=output_shapes,
-                                        attributes={'max': max}, op_type=op_types[0], check_model=False)
-        orig_model, trans_model = self.make_test_unit_model_from_onnx(onnx_model, ConvertClipAttrToInput())
-
-        self.check_graph_node(trans_model, op_types)
-        self.check_value_info(trans_model)
-        self.check_attribute(orig_model.graph.node[0].attribute[0].f, init_to_numpy(trans_model, 'X_0_clip_max'))
-
-    def test_case3(self):
-        input_shapes = [(1, 1, 4, 4)]
-        output_shapes = [(1, 1, 4, 4)]
-        min = 1.0099999904632568
-        max = 1.01
-        op_types = ['Clip']
-        onnx_model, _ = make_test_model(input_shapes=input_shapes, output_shapes=output_shapes,
-                                        attributes={'max': max, 'min': min}, op_type=op_types[0], check_model=False)
-        orig_model, trans_model = self.make_test_unit_model_from_onnx(onnx_model, ConvertClipAttrToInput())
-
-        self.check_graph_node(trans_model, op_types)
-        self.check_value_info(trans_model)
-        self.check_attribute(orig_model.graph.node[0].attribute[0].f, init_to_numpy(trans_model, 'X_0_clip_min'))
-        self.check_attribute(orig_model.graph.node[0].attribute[1].f, init_to_numpy(trans_model, 'X_0_clip_max'))
-
-    def test_case4(self):
-        input_shapes = [(8, 8, 8)]
-        op_types = ['Clip']
-        min = 0.01
-        max = None
-        orig_model, trans_model = self.make_unit_model(input_shapes, min, max)
-        self.check_graph_node(trans_model, op_types)
-        self.check_attribute(init_to_numpy(orig_model, '5'), init_to_numpy(trans_model, '5'))
-
-    def test_case5(self):
-        input_shapes = [(8, 8, 8)]
-        op_types = ['Mul', 'Clip', 'Add']
-        min = 0.01
-        max = 1.01
-        orig_model, trans_model = self.make_multi_model(input_shapes, min, max)
-        self.check_graph_node(trans_model, op_types)
-        self.check_attribute(init_to_numpy(orig_model, '36'), init_to_numpy(trans_model, '36'))
-        self.check_attribute(init_to_numpy(orig_model, '37'), init_to_numpy(trans_model, '37'))
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_convert_conv1d_to_conv2d.py b/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_convert_conv1d_to_conv2d.py
deleted file mode 100644
index 04218e1e..00000000
--- a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_convert_conv1d_to_conv2d.py
+++ /dev/null
@@ -1,41 +0,0 @@
-from abc import ABC
-
-import torch
-import torch.nn as nn
-
-from furiosa_sdk_quantizer.frontend.onnx.transformer.convert_conv1d_to_conv2d import ConvertConv1dToConv2d
-from tests.frontend.onnx.transformer import TestTransformer
-
-
-class UnitTestModel(nn.Module, ABC):
-    def __init__(self, in_channels, out_channels):
-        super(UnitTestModel, self).__init__()
-        self.in_ch = in_channels
-        self.out_ch = out_channels
-        self.conv = nn.Conv1d(in_channels=in_channels, out_channels=out_channels, kernel_size=3, bias=False)
-
-    def forward(self, x):
-        x = x.reshape((1, 1, -1))
-        x = self.conv(x)
-        x = x.reshape((1, -1, 1, 1))
-        return x
-
-
-class TestConvertConv1dToConv2d(TestTransformer, ABC):
-    def _make_test_model(self, torch_model, input_shapes):
-        orig_model, trans_model = self.make_test_model(torch_model,
-                                                       ConvertConv1dToConv2d(),
-                                                       input_shapes)
-        return orig_model, trans_model
-
-    def test_case1(self):
-        input_shapes = [(1, 16)]
-        in_channel = 1
-        out_channel = 1
-
-        op_types = ['Reshape', 'Conv', 'Reshape']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel(in_channel, out_channel), input_shapes)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_eliminate_argmax_output.py b/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_eliminate_argmax_output.py
deleted file mode 100644
index eac57d92..00000000
--- a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_eliminate_argmax_output.py
+++ /dev/null
@@ -1,76 +0,0 @@
-import abc
-
-import torch
-import torch.nn as nn
-
-from furiosa_sdk_quantizer.frontend.onnx.transformer.eliminate_argmax_output import EliminateArgmaxOutput
-from tests.frontend.onnx.transformer import TestTransformer
-
-
-class MultiTestModel(nn.Module, abc.ABC):
-    def forward(self, x):
-        x = torch.mul(x, torch.ones(x.shape))
-        x = torch.argmax(x, dim=2)
-        return x
-
-
-class MultiTestModel1(nn.Module, abc.ABC):
-    def forward(self, x):
-        x = torch.mul(x, torch.ones(x.shape))
-        x = torch.argmax(x, dim=1)
-        x = torch.sub(x, torch.ones(x.shape))
-        return x
-
-
-class MultiTestModel2(nn.Module, abc.ABC):
-    def forward(self, x):
-        x = torch.mul(x, torch.ones(x.shape))
-        y = torch.argmax(x, dim=0)
-        z = torch.argmax(x, dim=0)
-
-        return y, z
-
-
-class TestEliminateArgmaxOutput(TestTransformer):
-    def make_multi_model(self, torch_model, input_shapes):
-        orig_model, trans_model = self.make_test_model(torch_model, EliminateArgmaxOutput(), input_shapes)
-        return orig_model, trans_model
-
-    def test_case1(self):
-        """
-            Test whether the original model is well transformed for unit operator model,
-            which contains only Identity operator
-        """
-        input_shapes = [(1, 1, 4, 4)]
-        op_types = ['Mul']
-
-        orig_model, trans_model = self.make_multi_model(MultiTestModel(), input_shapes)
-        self.check_graph_node(trans_model, op_types)
-        self.check_assertion(self.check_output_value,
-                             {'orig_model': orig_model, 'trans_model': trans_model, 'input_shapes': input_shapes})
-        self.check_value_info(trans_model)
-
-    def test_case2(self):
-        """
-            Test whether the original model is well transformed for multi operator model,
-             which contains operators other than Identity
-        """
-        input_shapes = [(2, 4, 8, 8, 16)]
-        op_types = ['Mul', 'ArgMax', 'Cast', 'Sub']
-        orig_model, trans_model = self.make_multi_model(MultiTestModel1(), input_shapes)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case3(self):
-        """
-            Test whether the original model is well transformed for multi operator model,
-             which contains operators other than Identity
-        """
-        input_shapes = [(8, 8, 8)]
-        op_types = ['Mul']
-        orig_model, trans_model = self.make_multi_model(MultiTestModel2(), input_shapes)
-        self.check_graph_node(trans_model, op_types)
-        self.check_assertion(self.check_output_value,
-                             {'orig_model': orig_model, 'trans_model': trans_model, 'input_shapes': input_shapes})
-        self.check_value_info(trans_model)
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_eliminate_redundant_reshape_pattern.py b/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_eliminate_redundant_reshape_pattern.py
deleted file mode 100644
index 1572c558..00000000
--- a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_eliminate_redundant_reshape_pattern.py
+++ /dev/null
@@ -1,265 +0,0 @@
-from abc import ABC
-import torch
-import torch.nn as nn
-
-import numpy as np
-
-from furiosa_sdk_quantizer.frontend.onnx.transformer.eliminate_redundant_reshape_pattern import (Pattern_1, Pattern_2, Pattern_3,
-                                                                               Pattern_4, Pattern_5, Pattern_6,
-                                                                               Pattern_7,
-                                                                               EliminateRedundantReshapePattern)
-
-from tests.frontend.onnx.transformer import TestTransformer
-
-
-class UnitTestModel(nn.Module, ABC):
-    def forward(self, x):
-        x = torch.flatten(x, 1)
-        x = torch.unsqueeze(x, dim=1)
-        x = torch.add(x, torch.ones_like(x))
-        return x
-
-
-class UnitTestModel_1(nn.Module, ABC):
-    def forward(self, x):
-        x = torch.add(x, torch.ones_like(x))
-        x = torch.flatten(x, 1)
-        x = torch.unsqueeze(x, dim=1)
-        return x
-
-
-class UnitTestModel2(nn.Module, ABC):
-    def forward(self, x):
-        x = torch.add(x, torch.ones_like(x))
-        y = torch.reshape(x, x.shape)
-        y = torch.flatten(y, 1)
-        y = torch.unsqueeze(y, dim=1)
-        x = torch.reshape(x, x.shape)
-        x = torch.flatten(x, 1)
-        x = torch.unsqueeze(x, dim=1)
-        return x, y
-
-
-class UnitTestModel2_1(nn.Module, ABC):
-    def forward(self, x):
-        x = torch.div(x, torch.ones_like(x))
-        y = torch.reshape(x, x.shape)
-        y = torch.flatten(y, 1)
-        y = torch.unsqueeze(y, dim=1)
-        x = torch.reshape(x, x.shape)
-        x = torch.flatten(x, 1)
-        x = torch.unsqueeze(x, dim=1)
-        x = torch.add(x, torch.ones_like(x))
-        return x, y
-
-
-class UnitTestModel3(nn.Module, ABC):
-    def forward(self, x):
-        x = torch.reshape(x, x.shape)
-        x = torch.div(x, torch.ones_like(x))
-        y = torch.reshape(x, [*x.shape[1:], x.shape[0]])
-        return x, y
-
-
-class UnitTestModel3_1(nn.Module, ABC):
-    def forward(self, x):
-        x = torch.reshape(x, x.shape)
-        x = torch.div(x, torch.ones_like(x))
-        y = torch.reshape(x, [*x.shape[1:], x.shape[0]])
-        y = torch.reshape(y, [*x.shape[1:], x.shape[0]])
-        return x, y
-
-
-class UnitTestModel4(nn.Module, ABC):
-    def forward(self, x):
-        x_origin = x
-        new_shape = int(np.prod(x_origin.shape))
-        x = torch.reshape(x, [new_shape])
-        x = x.expand([1, new_shape])
-        x = x.expand([1, 1, new_shape])
-        x = torch.reshape(x, x_origin.shape)
-        x = torch.add(x, torch.ones_like(x))
-        return x
-
-
-class UnitTestModel5(nn.Module, ABC):
-    def forward(self, x):
-        x_origin = x
-        new_shape = int(np.prod(x_origin.shape))
-        x = torch.reshape(x, [new_shape])
-        x = x.expand([1, new_shape])
-        x = torch.reshape(x, x_origin.shape)
-        x = torch.add(x, torch.ones_like(x))
-        return x
-
-
-class UnitTestModel5_1(nn.Module, ABC):
-    def forward(self, x):
-        x_origin = x
-        new_shape = int(np.prod(x_origin.shape))
-        x = torch.reshape(x, [new_shape])
-        x = x.expand([1, new_shape])
-        x = torch.reshape(x, [x_origin.shape[-1], *x_origin.shape[:-1]])
-        return x
-
-
-class UnitTestModel6(nn.Module, ABC):
-    def forward(self, x):
-        x_origin = x
-        new_shape = int(np.prod(x_origin.shape[1:]))
-        x = torch.add(x, torch.ones_like(x))
-        x = torch.reshape(x, [x_origin.shape[0], 1, new_shape])
-        x = torch.reshape(x, x_origin.shape)
-        return x
-
-
-class UnitTestModel7(nn.Module, ABC):
-    def forward(self, x):
-        x_origin = x
-        new_shape = int(np.prod(x_origin.shape[1:]))
-        x = torch.add(x, torch.ones_like(x))
-        x = torch.reshape(x, [x_origin.shape[0], 1, new_shape])
-        x = torch.reshape(x, [x_origin.shape[0], 1, *x_origin.shape[1:]])
-        x = torch.reshape(x, x_origin.shape)
-        return x
-
-
-class CompoundTestModel8(nn.Module, ABC):
-    def forward(self, x):
-        x = UnitTestModel()(x)
-        x = UnitTestModel_1()(x)
-        x, a = UnitTestModel2()(x)
-        x, b = UnitTestModel2_1()(x)
-        x, c = UnitTestModel3()(x)
-        x = UnitTestModel4()(a)
-        a = UnitTestModel5()(x)
-        x = UnitTestModel5_1()(b)
-        b = UnitTestModel6()(x)
-        x = UnitTestModel7()(c)
-        return x, a, b, c
-
-
-class TestFuseRedundantReshapePattern(TestTransformer, ABC):
-    def _make_test_model(self, torch_model, input_shapes, transformer):
-        orig_model, trans_model = self.make_test_model(torch_model,
-                                                       transformer,
-                                                       input_shapes)
-        return orig_model, trans_model
-
-    def test_case1(self):
-        input_shapes = [(1, 1, 576)]
-
-        op_types = ['Add']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel(), input_shapes, Pattern_1)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case1_1(self):
-        input_shapes = [(1, 1, 576)]
-
-        op_types = ['Add']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel_1(), input_shapes, Pattern_1)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case2(self):
-        input_shapes = [(1, 1, 576)]
-
-        op_types = ['Add']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel2(), input_shapes, Pattern_2)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case2_1(self):
-        input_shapes = [(1, 1, 576)]
-
-        op_types = ['Div', 'Add']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel2_1(), input_shapes, Pattern_2)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case3(self):
-        input_shapes = [(3, 9, 9)]
-
-        op_types = ['Div', 'Reshape']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel3(), input_shapes, Pattern_3)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case3_1(self):
-        input_shapes = [(3, 9, 9)]
-
-        op_types = ['Div', 'Reshape']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel3_1(), input_shapes, Pattern_3)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case4(self):
-        input_shapes = [(2, 3, 3)]
-
-        op_types = ['Add']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel4(), input_shapes, Pattern_4)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case5(self):
-        input_shapes = [(2, 3, 3)]
-
-        op_types = ['Add']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel5(), input_shapes, Pattern_5)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case5_1(self):
-        input_shapes = [(2, 3, 3)]
-
-        op_types = ['Reshape', 'Expand', 'Reshape']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel5_1(), input_shapes, Pattern_5)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case6(self):
-        input_shapes = [(2, 3, 3)]
-
-        op_types = ['Add']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel6(), input_shapes, Pattern_6)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case7(self):
-        input_shapes = [(2, 3, 3)]
-
-        op_types = ['Add']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel7(), input_shapes, Pattern_7)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case8(self):
-        input_shapes = [(1, 16, 24, 8)]
-
-        orig_model, trans_model = self._make_test_model(CompoundTestModel8(), input_shapes,
-                                                        EliminateRedundantReshapePattern())
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_extract_constant_to_initializer.py b/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_extract_constant_to_initializer.py
deleted file mode 100644
index 328db217..00000000
--- a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_extract_constant_to_initializer.py
+++ /dev/null
@@ -1,27 +0,0 @@
-# TODO refactor test case
-# import unittest
-# import abc
-#
-# import torch
-# import torch.nn as nn
-#
-# from dss.frontend.onnx.utils.check_model import check_model
-# from dss.frontend.onnx.transformer.extract_constant_to_initializer import ExtractConstantToInitializer
-# from tests import torch_to_onnx
-#
-#
-# class TestExtractConstantToInitializer(unittest.TestCase):
-#     def test_case1(self):
-#         class TestModel(nn.Module, abc.ABC):
-#             def forward(self, x):
-#                 x = torch.mul(x, torch.ones(4))
-#                 x = torch.argmax(x, dim=1)
-#                 return x
-#
-#         model = torch_to_onnx(TestModel(), torch.randn(1, 4))
-#         model = ExtractConstantToInitializer().transform(model)
-#         check_model(model)
-#
-#         # Test#1 check if Constant node is gone.
-#         for node in model.graph.node:
-#             self.assertNotEqual(node.op_type, 'Constant', msg='Constant node must be removed.')
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_fuse_bn_into_conv.py b/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_fuse_bn_into_conv.py
deleted file mode 100644
index 0344f701..00000000
--- a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_fuse_bn_into_conv.py
+++ /dev/null
@@ -1,114 +0,0 @@
-from abc import ABC
-
-import torch
-import torch.nn as nn
-
-from furiosa_sdk_quantizer.frontend.onnx.transformer.fuse_bn_into_conv import FuseBnIntoConv
-from tests.frontend.onnx.transformer import TestTransformer
-
-
-class UnitTestModel(nn.Module, ABC):
-    def __init__(self, in_channel, out_channel):
-        super(UnitTestModel, self).__init__()
-        self.conv = nn.Conv2d(in_channels=in_channel, out_channels=out_channel, kernel_size=(2, 2))
-        self.bn = nn.BatchNorm2d(num_features=out_channel)
-        self.bn.weight = nn.Parameter(torch.ones(out_channel))
-        self.bn.bias = nn.Parameter(torch.ones(out_channel))
-
-    def forward(self, x):
-        x = self.conv(x)
-        x = self.bn(x)
-        return x
-
-
-class UnitTestModel1(UnitTestModel):
-    def __init__(self, in_channel, out_channel):
-        super(UnitTestModel1, self).__init__(in_channel, out_channel)
-
-    def forward(self, x):
-        x = self.conv(x)
-        x = torch.nn.functional.relu(x)
-        x = self.bn(x)
-        return x
-
-
-class MultiTestModel(UnitTestModel):
-    def __init__(self, in_channel, out_channel):
-        super(MultiTestModel, self).__init__(in_channel, out_channel)
-
-    def forward(self, x):
-        x = torch.mul(x, torch.ones(x.shape))
-        x = self.conv(x)
-        x = self.bn(x)
-        x = torch.add(x, torch.ones(x.shape))
-        return x
-
-
-class MultiTestModel1(UnitTestModel):
-    def __init__(self, in_channel, out_channel):
-        super(MultiTestModel1, self).__init__(in_channel, out_channel)
-
-    def forward(self, x):
-        x = torch.mul(x, torch.ones(x.shape))
-        x = self.conv(x)
-        x = torch.nn.functional.relu(x)
-        x = self.bn(x)
-        x = torch.add(x, torch.ones(x.shape))
-        return x
-
-
-class TestFuseBNIntoConv(TestTransformer, ABC):
-    def _make_test_model(self, torch_model, input_shapes):
-        orig_model, trans_model = self.make_test_model(torch_model,
-                                                       FuseBnIntoConv(),
-                                                       input_shapes)
-        return orig_model, trans_model
-
-    def test_case1(self):
-        input_shapes = [(1, 3, 4, 4)]
-        in_channel = 3
-        out_channel = 4
-
-        op_types = ['Conv']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel(in_channel, out_channel), input_shapes)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case2(self):
-        input_shapes = [(1, 3, 4, 4)]
-        in_channel = 3
-        out_channel = 4
-
-        op_types = ['Conv', 'Relu', 'Mul', 'Add']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel1(in_channel, out_channel), input_shapes)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case3(self):
-        input_shapes = [(1, 4, 4, 4)]
-        in_channel = 4
-        out_channel = 8
-
-        op_types = ['Mul', 'Conv', 'Add']
-
-        orig_model, trans_model = self._make_test_model(MultiTestModel(in_channel, out_channel), input_shapes)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case4(self):
-        input_shapes = [(1, 5, 4, 4)]
-        in_channel = 5
-        out_channel = 2
-
-        op_types = ['Mul', 'Conv', 'Relu', 'Mul', 'Add', 'Add']
-
-        orig_model, trans_model = self._make_test_model(MultiTestModel1(in_channel, out_channel),
-                                                        input_shapes)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_fuse_conv.py b/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_fuse_conv.py
deleted file mode 100644
index 861634a1..00000000
--- a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_fuse_conv.py
+++ /dev/null
@@ -1,124 +0,0 @@
-from abc import ABC
-
-import os
-
-# FIXME Without this environ setting, the following error occurred on Mac OS:
-# OMP: Error #15: Initializing libomp.dylib, but found libiomp5.dylib already initialized.
-# OMP: Hint This means that multiple copies of the OpenMP runtime have been linked into the program. \
-# That is dangerous, since it can degrade performance or cause incorrect results. \
-# The best thing to do is to ensure that only a single OpenMP runtime is linked into the process, \
-# e.g. by avoiding static linking of the OpenMP runtime in any library. As an unsafe, unsupported, \
-# undocumented workaround you can set the environment variable KMP_DUPLICATE_LIB_OK=TRUE \
-# to allow the program to continue to execute, but that may cause crashes or silently produce incorrect results. \
-# For more information, please see http://openmp.llvm.org/
-#
-# Process finished with exit code 134 (interrupted by signal 6: SIGABRT)
-os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
-
-import torch
-import torch.nn as nn
-
-from furiosa_sdk_quantizer.frontend.onnx.transformer.fuse_conv import FuseConv
-from tests.frontend.onnx.transformer import TestTransformer
-
-
-# TODO 1. Generate test model that does not meet conditions for conv fusion
-# TODO 2. Generate MatMul + Add test model directly by onnx
-class UnitTestModel(nn.Module, ABC):
-    def __init__(self, in_channel, out_channel):
-        super(UnitTestModel, self).__init__()
-        self.linear = nn.Linear(in_features=in_channel, out_features=out_channel, bias=False)
-
-    def forward(self, x):
-        x = self.linear(x)
-        x = torch.add(x, torch.ones(x.shape))
-        return x
-
-
-class UnitTestModel1(nn.Module, ABC):
-    def __init__(self, in_channel, out_channel):
-        super(UnitTestModel1, self).__init__()
-        self.linear = nn.Linear(in_features=in_channel, out_features=out_channel, bias=True)
-
-    def forward(self, x):
-        x = self.linear(x)
-        return x
-
-
-class MultiTestModel(UnitTestModel):
-    def __init__(self, in_channel, out_channel):
-        super(MultiTestModel, self).__init__(in_channel, out_channel)
-
-    def forward(self, x):
-        x = torch.mul(x, torch.ones(x.shape))
-        x = self.linear(x)
-        x = torch.add(x, torch.ones(x.shape))
-        x = torch.add(x, torch.ones(x.shape))
-        return x
-
-
-class MultiTestModel1(UnitTestModel1):
-    def __init__(self, in_channel, out_channel):
-        super(MultiTestModel1, self).__init__(in_channel, out_channel)
-
-    def forward(self, x):
-        x = torch.mul(x, torch.ones(x.shape))
-        x = self.linear(x)
-        x = torch.add(x, torch.ones(x.shape))
-        return x
-
-
-class TestFuseConv(TestTransformer, ABC):
-    def _make_test_model(self, torch_model, input_shapes):
-        orig_model, trans_model = self.make_test_model(torch_model,
-                                                       FuseConv(),
-                                                       input_shapes)
-        return orig_model, trans_model
-
-    def test_case1(self):
-        input_shapes = [(8, 16)]
-        in_channel = 16
-        out_channel = 4
-
-        op_types = ['Unsqueeze', 'Conv', 'Squeeze']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel(in_channel, out_channel), input_shapes)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case2(self):
-        input_shapes = [(8, 16)]
-        in_channel = 16
-        out_channel = 4
-
-        op_types = ['Unsqueeze', 'Conv', 'Squeeze']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel1(in_channel, out_channel), input_shapes)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case3(self):
-        input_shapes = [(8, 16)]
-        in_channel = 16
-        out_channel = 4
-
-        op_types = ['Mul', 'Unsqueeze', 'Conv', 'Squeeze', 'Add']
-
-        orig_model, trans_model = self._make_test_model(MultiTestModel(in_channel, out_channel), input_shapes)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case4(self):
-        input_shapes = [(8, 16)]
-        in_channel = 16
-        out_channel = 4
-
-        op_types = ['Mul', 'Unsqueeze', 'Conv', 'Squeeze', 'Add']
-
-        orig_model, trans_model = self._make_test_model(MultiTestModel1(in_channel, out_channel), input_shapes)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_fuse_depth_to_space.py b/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_fuse_depth_to_space.py
deleted file mode 100644
index 0484d61e..00000000
--- a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_fuse_depth_to_space.py
+++ /dev/null
@@ -1,124 +0,0 @@
-import unittest
-import abc
-
-import torch
-import torch.nn as nn
-import numpy as np
-
-from furiosa_sdk_quantizer.frontend.onnx.transformer.fuse_depth_to_space import FuseDepthToSpace
-
-from tests.frontend.onnx.transformer import TestTransformer
-
-
-class UnitTestModel(nn.Module, abc.ABC):
-    """
-        DepthToSpace DRC mode
-            https://github.com/onnx/onnx/blob/master/docs/Operators.md#depthtospace
-            b, c, h, w = x.shape
-            tmp = np.reshape(x, [b, blocksize, blocksize, c // (blocksize**2), h, w])
-            tmp = np.transpose(tmp, [0, 3, 4, 1, 5, 2])
-            y = np.reshape(tmp, [b, c // (blocksize**2), h * blocksize, w * blocksize]
-
-        DepthToSpace CRD mode
-            https://github.com/onnx/onnx/blob/master/docs/Operators.md#depthtospace
-            b, c, h, w = x.shape
-            tmp = np.reshape(x, [b, c // (blocksize ** 2), blocksize, blocksize, h, w])
-            tmp = np.transpose(tmp, [0, 1, 4, 2, 5, 3])
-            y = np.reshape(tmp, [b, c // (blocksize ** 2), h * blocksize, w * blocksize])
-    """
-
-    def __init__(self, input_shape, blocksize, mode):
-        super(UnitTestModel, self).__init__()
-        b, c, h, w = input_shape
-
-        channel_split = c // (blocksize ** 2)
-        assert channel_split * blocksize ** 2 == c
-
-        if mode == 'DCR':
-            self.permute = [0, 3, 4, 1, 5, 2]
-            self.shape_0 = [b, blocksize, blocksize, channel_split, h, w]
-        elif mode == 'CRD':
-            self.permute = [0, 1, 4, 2, 5, 3]
-            self.shape_0 = [b, channel_split, blocksize, blocksize, h, w]
-        else:
-            raise Exception()
-
-        self.shape_1 = [b, channel_split, h * blocksize, w * blocksize]
-
-    def forward(self, x):
-        x = torch.reshape(x, shape=self.shape_0)
-        x = x.permute(dims=self.permute)
-        x = torch.reshape(x, shape=self.shape_1)
-        return x
-
-
-class MultiTestModel(UnitTestModel, abc.ABC):
-    def __init__(self, input_shape, blocksize, mode):
-        super(MultiTestModel, self).__init__(input_shape, blocksize, mode)
-
-    def forward(self, x):
-        x = torch.add(x, x)
-        x = torch.reshape(x, shape=self.shape_0)
-        x = x.permute(dims=self.permute)
-        x = torch.reshape(x, shape=self.shape_1)
-        x = torch.mul(x, torch.ones_like(x))
-        return x
-
-
-class TestReifyDepthToSpace(TestTransformer):
-    def make_unit_model(self, input_shapes, blocksize, mode):
-        orig_model, trans_model = self.make_test_model(UnitTestModel(input_shapes[0], blocksize, mode),
-                                                       FuseDepthToSpace(), input_shapes)
-        return orig_model, trans_model
-
-    def make_multi_model(self, input_shapes, blocksize, mode):
-        orig_model, trans_model = self.make_test_model(UnitTestModel(input_shapes[0], blocksize, mode),
-                                                       FuseDepthToSpace(), input_shapes)
-        return orig_model, trans_model
-
-    def test_case1(self):
-        """
-            Test whether the original model is well transformed for unit operator model,
-            which contains only DepthToSpace operator
-        """
-        input_shapes = [(1, 4, 8, 8)]
-        blocksize = 2
-        mode = 'DCR'
-        op_types = ['DepthToSpace']
-
-        orig_model, trans_model = self.make_unit_model(input_shapes, blocksize, mode)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-        self.check_attribute(blocksize, trans_model.graph.node[0].attribute[0].i)
-        self.check_attribute(str.encode(mode), trans_model.graph.node[0].attribute[1].s)
-
-    def test_case2(self):
-        """
-            Test whether the original model is well transformed for unit operator model,
-            which contains only DepthToSpace operator
-        """
-        input_shapes = [(1, 9, 4, 4)]
-        blocksize = 3
-        mode = 'CRD'
-        op_types = ['DepthToSpace']
-
-        orig_model, trans_model = self.make_unit_model(input_shapes, blocksize, mode)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-        self.check_attribute(blocksize, trans_model.graph.node[0].attribute[0].i)
-        self.check_attribute(str.encode(mode), trans_model.graph.node[0].attribute[1].s)
-
-    def test_case3(self):
-        """
-            Test whether the original model is well transformed for multi operator model,
-             which contains operators other than DepthToSpace
-        """
-        input_shapes = [(1, 4, 8, 8)]
-        blocksize = 2
-        mode = 'CRD'
-
-        orig_model, trans_model = self.make_multi_model(input_shapes, blocksize, mode)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_fuse_gelu.py b/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_fuse_gelu.py
deleted file mode 100644
index 77209e87..00000000
--- a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_fuse_gelu.py
+++ /dev/null
@@ -1,58 +0,0 @@
-import abc
-
-import torch
-import torch.nn as nn
-
-from furiosa_sdk_quantizer.frontend.onnx.transformer.fuse_gelu import FuseGELU
-
-from tests.frontend.onnx.transformer import TestTransformer
-
-
-class UnitTestModel(nn.Module, abc.ABC):
-    def forward(self, x):
-        x = nn.functional.gelu(x)
-        return x
-
-
-class MultiTestModel(UnitTestModel, abc.ABC):
-    def forward(self, x):
-        x = torch.sub(x, torch.ones(x.shape))
-        x = nn.functional.gelu(x)
-        x = torch.sub(x, torch.ones(x.shape))
-        return x
-
-
-class TestFuseGELU(TestTransformer):
-    def make_unit_model(self, input_shapes):
-        orig_model, trans_model = self.make_test_model(UnitTestModel(), FuseGELU(), input_shapes)
-        return orig_model, trans_model
-
-    def make_multi_model(self, input_shapes):
-        orig_model, trans_model = self.make_test_model(MultiTestModel(), FuseGELU(), input_shapes)
-        return orig_model, trans_model
-
-    def test_case1(self):
-        """
-            Test whether the original model is well transformed for unit operator model,
-            which contains only GELU operator
-        """
-        input_shapes = [(1, 1, 4, 4)]
-        op_types = ['Gelu']
-
-        orig_model, trans_model = self.make_unit_model(input_shapes)
-
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case2(self):
-        """
-            Test whether the original model is well transformed for multi operator model,
-             which contains operators other than Gelu
-        """
-        input_shapes = [(2, 4, 8, 8, 16)]
-
-        orig_model, trans_model = self.make_multi_model(input_shapes)
-
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_fuse_lp_normalization.py b/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_fuse_lp_normalization.py
deleted file mode 100644
index 4d85b164..00000000
--- a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_fuse_lp_normalization.py
+++ /dev/null
@@ -1,73 +0,0 @@
-import abc
-
-import torch
-import torch.nn as nn
-
-from furiosa_sdk_quantizer.frontend.onnx.transformer.fuse_lp_normalization import FuseLpNormalization
-
-from tests.frontend.onnx.transformer import TestTransformer
-
-
-class UnitTestModel(nn.Module, abc.ABC):
-    def __init__(self, p, dim):
-        super(UnitTestModel, self).__init__()
-        self.lp_normalization = nn.functional.normalize
-        self.p = p
-        self.dim = dim
-
-    def forward(self, x):
-        x = self.lp_normalization(x, p=self.p, dim=self.dim)
-        return x
-
-
-class MultiTestModel(UnitTestModel, abc.ABC):
-    def __init__(self, p, dim):
-        super(MultiTestModel, self).__init__(p, dim)
-
-    def forward(self, x):
-        x = torch.add(x, torch.ones_like(x))
-        x = self.lp_normalization(x, p=self.p, dim=self.dim)
-        x = torch.div(x, torch.ones_like(x))
-        return x
-
-
-class TestFuseLpNormalization(TestTransformer):
-    def make_unit_model(self, input_shapes, p, dim):
-        orig_model, trans_model = self.make_test_model(UnitTestModel(p, dim), FuseLpNormalization(),
-                                                       input_shapes)
-        return orig_model, trans_model
-
-    def make_multi_model(self, input_shapes, p, dim):
-        orig_model, trans_model = self.make_test_model(MultiTestModel(p, dim), FuseLpNormalization(),
-                                                       input_shapes)
-        return orig_model, trans_model
-
-    def test_case1(self):
-        """
-            Test whether the original model is well transformed for unit operator model,
-            which contains only LpNormalization operator
-        """
-        input_shapes = [(1, 4, 8)]
-        p = 2
-        axis = 1
-        op_types = ['LpNormalization']
-
-        orig_model, trans_model = self.make_unit_model(input_shapes, p, axis)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-        self.check_attribute(axis, trans_model.graph.node[0].attribute[0].i)
-        self.check_attribute(p, trans_model.graph.node[0].attribute[1].i)
-
-    def test_case2(self):
-        """
-            Test whether the original model is well transformed for multi operator model,
-             which contains operators other than LpNormalization
-        """
-        input_shapes = [(1, 4, 8)]
-        p = 1
-        axis = 0
-
-        orig_model, trans_model = self.make_multi_model(input_shapes, p, axis)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_fuse_pad.py b/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_fuse_pad.py
deleted file mode 100644
index 67f07a13..00000000
--- a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_fuse_pad.py
+++ /dev/null
@@ -1,103 +0,0 @@
-from abc import ABC
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from furiosa_sdk_quantizer.frontend.onnx.transformer.fuse_pad import (Pattern_1, Pattern_2, FusePad)
-from tests.frontend.onnx.transformer import TestTransformer
-
-
-class UnitTestModel(nn.Module, ABC):
-    def __init__(self):
-        super(UnitTestModel, self).__init__()
-        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=0, ceil_mode=True)
-
-    def forward(self, x):
-        x = F.pad(x, [2, 1, 2, 1, 0, 0, 0, 0], value=float('-inf'))
-        x = self.maxpool(x)
-        x = F.pad(x, [1, 1, 1, 1, 0, 0, 0, 0], value=0.0)
-        x = self.maxpool(x)
-
-        return x
-
-
-class UnitTestModel_1(nn.Module, ABC):
-    def __init__(self):
-        super(UnitTestModel_1, self).__init__()
-        self.maxpool3d = nn.MaxPool3d(kernel_size=7, stride=3, padding=1, ceil_mode=False)
-
-    def forward(self, x):
-        x = torch.add(x, torch.ones_like(x))
-        x = F.pad(x, [1, 2, 3, 3, 2, 1, 0, 0, 0, 0], value=float('-inf'))
-        x = self.maxpool3d(x)
-        return x
-
-
-class UnitTestModel2(nn.Module, ABC):
-    def __init__(self):
-        super(UnitTestModel2, self).__init__()
-        self.avgpool = nn.AvgPool2d(kernel_size=3, stride=3, padding=0, ceil_mode=False, count_include_pad=False)
-        self.avgpool_1 = nn.AvgPool2d(kernel_size=4, stride=3, padding=2, ceil_mode=False, count_include_pad=True)
-        self.avgpool_2 = nn.AvgPool2d(kernel_size=5, stride=3, padding=1, ceil_mode=False, count_include_pad=False)
-
-    def forward(self, x):
-        x = F.pad(x, [1, 1, 1, 1, 0, 0, 0, 0], value=0.0)
-        x = self.avgpool(x)
-        x = self.avgpool_1(x)
-        x = F.pad(x, [2, 1, 1, 2, 0, 0, 0, 0], value=0.0)
-        x = self.avgpool_2(x)
-
-        return x
-
-
-class UnitTestModel3(nn.Module, ABC):
-    def forward(self, x):
-        x = UnitTestModel()(x)
-        x = UnitTestModel2()(x)
-
-        return x
-
-
-class TestFusePad(TestTransformer, ABC):
-    def _make_test_model(self, torch_model, input_shapes, transformer):
-        orig_model, trans_model = self.make_test_model(torch_model,
-                                                       transformer,
-                                                       input_shapes)
-        return orig_model, trans_model
-
-    def test_case1(self):
-        input_shapes = [(1, 3, 16, 19)]
-
-        op_types = ['MaxPool', 'Pad', 'MaxPool']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel(), input_shapes, Pattern_1)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case1_1(self):
-        input_shapes = [(1, 3, 14, 16, 17)]
-
-        op_types = ['Add', 'MaxPool']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel_1(), input_shapes, Pattern_1)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case2(self):
-        input_shapes = [(1, 3, 13, 11)]
-
-        op_types = ['AveragePool', 'AveragePool', 'Pad', 'AveragePool']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel2(), input_shapes, Pattern_2)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case3(self):
-        input_shapes = [(1, 3, 112, 112)]
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel3(), input_shapes, FusePad())
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
diff --git a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_fuse_redundant_reshape_pattern.py b/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_fuse_redundant_reshape_pattern.py
deleted file mode 100644
index 068f6c7a..00000000
--- a/python/furiosa-sdk-quantizer/tests/frontend/onnx/transformer/test_fuse_redundant_reshape_pattern.py
+++ /dev/null
@@ -1,87 +0,0 @@
-from abc import ABC
-
-import torch
-import torch.nn as nn
-
-from furiosa_sdk_quantizer.frontend.onnx.transformer.fuse_redundant_reshape_pattern import (Pattern_1, Pattern_2, Pattern_3,
-                                                                          FuseRedundantReshapePattern)
-from tests.frontend.onnx.transformer import TestTransformer
-
-
-class UnitTestModel(nn.Module, ABC):
-    def forward(self, x):
-        x = x.reshape(shape=(4, 4, 8))
-        x = x.reshape(shape=(8, 2, 8))
-        return x
-
-
-class UnitTestModel1(nn.Module, ABC):
-    def forward(self, x):
-        x = x.reshape(shape=(4, 4, 8))
-        x = x.reshape(shape=(8, 2, 8))
-        x = x.reshape(shape=(32, 4))
-        return x
-
-
-class UnitTestModel2(nn.Module, ABC):
-    def forward(self, x):
-        x = x.reshape(shape=(4, 4, 8))
-        x = x.reshape(shape=(8, 2, 8))
-        x = x.reshape(shape=(32, 4))
-        x = x.reshape(shape=(4, 4, 2, 4))
-        return x
-
-
-class UnitTestModel3(nn.Module, ABC):
-    def forward(self, x):
-        x = torch.squeeze(x, dim=1)
-        x = torch.unsqueeze(x, dim=0)
-        return x
-
-
-class TestFuseRedundantReshapePattern(TestTransformer, ABC):
-    def _make_test_model(self, torch_model, input_shapes, transformer):
-        orig_model, trans_model = self.make_test_model(torch_model,
-                                                       transformer,
-                                                       input_shapes)
-        return orig_model, trans_model
-
-    def test_case1(self):
-        input_shapes = [(16, 8)]
-
-        op_types = ['Reshape']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel(), input_shapes, Pattern_1)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case2(self):
-        input_shapes = [(16, 8)]
-
-        op_types = ['Reshape']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel1(), input_shapes, Pattern_2)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case3(self):
-        input_shapes = [(16, 8)]
-
-        op_types = ['Reshape']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel2(), input_shapes, FuseRedundantReshapePattern())
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
-
-    def test_case4(self):
-        input_shapes = [(16, 1, 8)]
-
-        op_types = ['Reshape']
-
-        orig_model, trans_model = self._make_test_model(UnitTestModel3(), input_shapes, Pattern_3)
-        self.check_graph_node(trans_model, op_types)
-        self.check_output_value(orig_model, trans_model, input_shapes)
-        self.check_value_info(trans_model)
diff --git a/python/furiosa-sdk-quantizer/tests/integration/__init__.py b/python/furiosa-sdk-quantizer/tests/integration/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/python/furiosa-sdk-runtime/tests/test_version.py b/python/furiosa-sdk-runtime/tests/test_version.py
index 1240c690..01a31521 100644
--- a/python/furiosa-sdk-runtime/tests/test_version.py
+++ b/python/furiosa-sdk-runtime/tests/test_version.py
@@ -5,7 +5,7 @@
 
 class TestTensor(unittest.TestCase):
     def test_version(self):
-        self.assertEqual(LIBNUX.version(), b"0.2.1")
+        self.assertEqual(LIBNUX.version(), b"0.2.2")
         self.assertTrue(len(str(LIBNUX.git_short_hash())) >= 9)
         self.assertEqual(len(str(LIBNUX.build_timestamp())), 22)