From 89a5428eeba570a1db42e86754a6efef779f5221 Mon Sep 17 00:00:00 2001
From: chensuyue <suyue.chen@intel.com>
Date: Mon, 12 Oct 2026 23:17:56 -0700
Subject: [PATCH 1/3] Remove TensorFlow support from INC

Signed-off-by: chensuyue <suyue.chen@intel.com>
---
 .azure-pipelines/scripts/fwk_version.sh       |    1 -
 .azure-pipelines/scripts/install_nc.sh        |    5 -
 .../scripts/models/collect_log_model.py       |    7 -
 .../scripts/models/generate_report.sh         |    2 +-
 .../models/run_model_trigger_common.sh        |    4 -
 .../scripts/models/update_yaml_config.py      |   10 -
 .azure-pipelines/scripts/ut/coverage.3x_tf    |   21 -
 .azure-pipelines/scripts/ut/run_3x_tf.sh      |   78 -
 .azure-pipelines/template/model-template.yml  |    2 +-
 .azure-pipelines/ut-3x-tf.yml                 |  118 -
 README.md                                     |   16 +-
 docs/source/TF_Quant.md                       |  115 -
 docs/source/TF_SQ.md                          |   45 -
 docs/source/TensorFlow.md                     |  216 --
 docs/source/api-doc/apis.rst                  |    9 -
 .../api-doc/tf_quantization_autotune.rst      |    6 -
 .../source/api-doc/tf_quantization_common.rst |    6 -
 .../source/api-doc/tf_quantization_config.rst |    6 -
 docs/source/autotune.md                       |   28 +-
 docs/source/coding_style.md                   |    8 +-
 docs/source/get_started.md                    |   14 +-
 docs/source/imgs/bf16_convert_tf.png          |  Bin 206833 -> 0 bytes
 docs/source/installation_guide.md             |   15 +-
 docs/source/quantization.md                   |    8 +-
 docs/source/smooth_quant.md                   |    1 -
 neural_compressor/common/base_config.py       |    4 +-
 neural_compressor/jax/utils/utility.py        |    2 +-
 neural_compressor/tensorflow/__init__.py      |   24 -
 .../tensorflow/algorithms/__init__.py         |   17 -
 .../algorithms/smoother/__init__.py           |   27 -
 .../algorithms/smoother/calibration.py        |  505 ----
 .../tensorflow/algorithms/smoother/core.py    |  196 --
 .../tensorflow/algorithms/smoother/scaler.py  |  268 ---
 .../algorithms/static_quant/__init__.py       |   17 -
 .../algorithms/static_quant/keras.py          |  788 -------
 .../algorithms/static_quant/keras.yaml        |  121 -
 .../algorithms/static_quant/tensorflow.py     | 1553 -------------
 .../algorithms/static_quant/tensorflow.yaml   |  244 --
 .../static_quant/tensorflow_itex.yaml         |  149 --
 .../tensorflow/keras/__init__.py              |   19 -
 .../tensorflow/keras/layers/__init__.py       |   24 -
 .../tensorflow/keras/layers/conv2d.py         |  415 ----
 .../tensorflow/keras/layers/dense.py          |  215 --
 .../keras/layers/depthwise_conv2d.py          |  432 ----
 .../keras/layers/layer_initializer.py         |   34 -
 .../tensorflow/keras/layers/pool2d.py         |  283 ---
 .../keras/layers/separable_conv2d.py          |  431 ----
 .../tensorflow/keras/quantization/__init__.py |   19 -
 .../tensorflow/keras/quantization/config.py   |  161 --
 .../tensorflow/quantization/__init__.py       |   24 -
 .../quantization/algorithm_entry.py           |   89 -
 .../tensorflow/quantization/autotune.py       |   84 -
 .../tensorflow/quantization/config.py         |  297 ---
 .../tensorflow/quantization/quantize.py       |  103 -
 .../tensorflow/quantization/utils/__init__.py |   14 -
 .../quantization/utils/graph_converter.py     | 1006 --------
 .../utils/graph_rewriter/__init__.py          |   14 -
 .../utils/graph_rewriter/bf16/__init__.py     |   17 -
 .../utils/graph_rewriter/bf16/bf16_convert.py |  290 ---
 .../bf16/dequantize_cast_optimizer.py         |   79 -
 .../utils/graph_rewriter/generic/__init__.py  |   17 -
 .../generic/convert_add_to_biasadd.py         |   76 -
 .../graph_rewriter/generic/convert_layout.py  |   85 -
 .../generic/convert_leakyrelu.py              |   78 -
 .../generic/convert_nan_to_random.py          |   52 -
 .../generic/convert_placeholder_to_const.py   |   99 -
 .../generic/dilated_contraction.py            |   89 -
 .../graph_rewriter/generic/dummy_biasadd.py   |  130 --
 .../generic/expanddims_optimizer.py           |   80 -
 .../generic/fetch_weight_from_reshape.py      |   88 -
 .../graph_rewriter/generic/fold_batch_norm.py |  271 ---
 .../graph_rewriter/generic/fold_constant.py   |  182 --
 .../generic/fuse_biasadd_add.py               |   75 -
 .../generic/fuse_column_wise_mul.py           |   86 -
 .../generic/fuse_conv_with_math.py            |  111 -
 .../generic/fuse_decomposed_bn.py             |  400 ----
 .../generic/fuse_decomposed_in.py             |  369 ---
 .../utils/graph_rewriter/generic/fuse_gelu.py |  227 --
 .../graph_rewriter/generic/fuse_layer_norm.py |  244 --
 .../generic/fuse_pad_with_conv.py             |  125 -
 .../generic/fuse_pad_with_fp32_conv.py        |  128 --
 .../generic/fuse_reshape_transpose.py         |  126 -
 .../generic/graph_cse_optimizer.py            |  145 --
 .../graph_rewriter/generic/grappler_pass.py   |   69 -
 .../generic/insert_print_node.py              |  223 --
 .../generic/move_squeeze_after_relu.py        |  123 -
 .../graph_rewriter/generic/pre_optimize.py    |  310 ---
 .../generic/remove_training_nodes.py          |   66 -
 .../generic/rename_batch_norm.py              |   60 -
 .../generic/split_shared_input.py             |   60 -
 .../generic/strip_equivalent_nodes.py         |   50 -
 .../generic/strip_unused_nodes.py             |   42 -
 .../generic/switch_optimizer.py               |   84 -
 .../utils/graph_rewriter/graph_base.py        |   40 -
 .../utils/graph_rewriter/int8/__init__.py     |   17 -
 .../graph_rewriter/int8/freeze_fake_quant.py  |  151 --
 .../utils/graph_rewriter/int8/freeze_value.py |  396 ----
 .../int8/fuse_conv_redundant_dequantize.py    |  152 --
 .../int8/fuse_conv_requantize.py              |  819 -------
 .../int8/fuse_matmul_redundant_dequantize.py  |  160 --
 .../int8/fuse_matmul_requantize.py            |  908 --------
 .../graph_rewriter/int8/meta_op_optimizer.py  |  115 -
 .../int8/post_hostconst_converter.py          |   53 -
 .../int8/post_quantized_op_cse.py             |  135 --
 .../graph_rewriter/int8/scale_propagation.py  |  118 -
 .../utils/graph_rewriter/qdq/__init__.py      |   17 -
 .../graph_rewriter/qdq/insert_qdq_pattern.py  |  750 ------
 .../qdq/merge_duplicated_qdq.py               |   94 -
 .../graph_rewriter/qdq/share_qdq_y_pattern.py |   60 -
 .../quantization/utils/graph_util.py          | 1118 ---------
 .../utils/quantize_graph/__init__.py          |   17 -
 .../utils/quantize_graph/qdq/__init__.py      |   17 -
 .../utils/quantize_graph/qdq/fuse_qdq_bn.py   |  303 ---
 .../quantize_graph/qdq/fuse_qdq_concatv2.py   |  261 ---
 .../utils/quantize_graph/qdq/fuse_qdq_conv.py | 2022 -----------------
 .../quantize_graph/qdq/fuse_qdq_deconv.py     |  541 -----
 .../utils/quantize_graph/qdq/fuse_qdq_in.py   |  183 --
 .../quantize_graph/qdq/fuse_qdq_matmul.py     | 1039 ---------
 .../quantize_graph/qdq/fuse_qdq_pooling.py    |  137 --
 .../utils/quantize_graph/qdq/optimize_qdq.py  |  158 --
 .../quantize_graph/quantize_graph_base.py     |  751 ------
 .../utils/quantize_graph/quantize_graph_bn.py |  298 ---
 .../quantize_graph/quantize_graph_concatv2.py |  106 -
 .../quantize_graph/quantize_graph_conv.py     |  378 ---
 .../quantize_graph_for_intel_cpu.py           |  130 --
 .../quantize_graph/quantize_graph_matmul.py   |  351 ---
 .../quantize_graph/quantize_graph_pooling.py  |   73 -
 .../utils/quantize_graph_common.py            |  448 ----
 .../utils/transform_graph/__init__.py         |   18 -
 .../utils/transform_graph/bias_correction.py  |  137 --
 .../transform_graph/graph_transform_base.py   |  111 -
 .../utils/transform_graph/insert_logging.py   |  199 --
 .../rerange_quantized_concat.py               |  313 ---
 .../tensorflow/quantization/utils/utility.py  |  621 -----
 .../tensorflow/utils/__init__.py              |   56 -
 .../tensorflow/utils/constants.py             |   60 -
 neural_compressor/tensorflow/utils/data.py    |  628 -----
 neural_compressor/tensorflow/utils/model.py   |  118 -
 .../tensorflow/utils/model_wrappers.py        | 1650 --------------
 neural_compressor/tensorflow/utils/utility.py |  456 ----
 .../torch/algorithms/weight_only/save_load.py |    2 +-
 .../transformers/models/modeling_auto.py      |    4 +-
 requirements_tf.txt                           |    6 -
 setup.py                                      |   23 +-
 test/common/test_common.py                    |    7 -
 test/tensorflow/keras/requirements.txt        |    1 -
 test/tensorflow/keras/test_config.py          |  341 ---
 test/tensorflow/keras/test_layers.py          |  213 --
 test/tensorflow/keras/test_model_wrappers.py  |   99 -
 .../ptq/newapi/test_bias_correction_newapi.py |  181 --
 .../ptq/newapi/test_big_saved_model.py        |  143 --
 .../newapi/test_graph_biasadd_add_fusion.py   |   91 -
 .../newapi/test_graph_conv_fusion_newapi.py   |  966 --------
 .../test_graph_conv_requantize_fusion.py      | 1147 ----------
 .../newapi/test_graph_depthwiseconv_fusion.py |  260 ---
 ..._graph_dequantize_cast_optimizer_newapi.py |   96 -
 .../ptq/newapi/test_graph_dq_cast_fusion.py   |   63 -
 .../newapi/test_graph_fuse_pad_conv_fp32.py   |  109 -
 .../ptq/newapi/test_graph_qdq_bn_fusion.py    |  461 ----
 .../newapi/test_graph_qdq_concat_fusion.py    |  226 --
 .../newapi/test_graph_qdq_conv3d_fusion.py    | 1000 --------
 .../ptq/newapi/test_graph_qdq_conv_fusion.py  | 1158 ----------
 .../test_graph_qdq_depthwiseconv_fusion.py    |  309 ---
 .../newapi/test_graph_qdq_matmul_fusion.py    | 1399 ------------
 .../newapi/test_graph_qdq_new_conv_fusion.py  |  126 -
 .../newapi/test_graph_qdq_pooling_fusion.py   |  111 -
 .../ptq/newapi/test_use_reshape_transpose.py  |  118 -
 .../ptq/test_auto_input_output.py             |   54 -
 .../quantization/ptq/test_bf16_convert.py     |  339 ---
 .../quantization/ptq/test_bias_correction.py  |   66 -
 .../quantization/ptq/test_data_pipline.py     |   63 -
 .../quantization/ptq/test_fold_batch_norm.py  |   78 -
 .../quantization/ptq/test_fold_const.py       |  193 --
 test/tensorflow/quantization/ptq/test_gpu.py  |  107 -
 .../quantization/ptq/test_graph_cac.py        |  146 --
 .../ptq/test_graph_column_wise_mul.py         |   49 -
 .../quantization/ptq/test_graph_concat.py     |  124 -
 .../ptq/test_graph_conv_add_relu_fusion.py    |   61 -
 .../ptq/test_graph_conv_as_output.py          |  196 --
 .../ptq/test_graph_conv_fusion.py             |  658 ------
 .../quantization/ptq/test_graph_conv_math.py  |   64 -
 .../ptq/test_graph_convert_layout.py          |   42 -
 .../ptq/test_graph_convert_leakyrelu.py       |  144 --
 .../ptq/test_graph_convert_nan.py             |   54 -
 .../ptq/test_graph_cse_optimization.py        |   94 -
 .../quantization/ptq/test_graph_debug_mode.py |   63 -
 .../test_graph_dequantize_cast_optimizer.py   |   99 -
 .../ptq/test_graph_expanddims_optimizer.py    |   43 -
 .../test_graph_fetch_weight_from_reshape.py   |  142 --
 .../quantization/ptq/test_graph_fold_bn.py    |  103 -
 .../ptq/test_graph_fuse_decomposed_bn.py      |  181 --
 .../quantization/ptq/test_graph_fuse_gelu.py  |  414 ----
 .../ptq/test_graph_input_output.py            |  192 --
 .../ptq/test_graph_insert_logging.py          |   88 -
 .../ptq/test_graph_library_detection.py       |   54 -
 .../ptq/test_graph_matmul_fusion.py           |  450 ----
 .../quantization/ptq/test_graph_meta_pass.py  |  207 --
 .../quantization/ptq/test_graph_pad_conv.py   |  183 --
 .../ptq/test_graph_post_cse_optimize.py       |  157 --
 .../ptq/test_graph_search_patterns.py         |  128 --
 .../ptq/test_graph_switch_optimizer.py        |  126 -
 .../quantization/ptq/test_graph_util.py       |  178 --
 .../quantization/ptq/test_grappler_pass.py    |   49 -
 .../ptq/test_move_squeeze_after_relu.py       |  141 --
 .../quantization/ptq/test_quantize_input.py   |   78 -
 .../quantization/ptq/test_query_yaml.py       |  239 --
 .../ptq/test_remove_training_nodes.py         |  146 --
 test/tensorflow/quantization/ptq/test_rnn.py  |   95 -
 .../ptq/test_share_nodes_graph.py             |   63 -
 .../ptq/test_strip_equivalent_nodes.py        |   64 -
 .../tensorflow/quantization/ptq/test_utils.py |  185 --
 .../quantization/test_smooth_quant.py         |  239 --
 test/tensorflow/requirements.txt              |    1 -
 test/tensorflow/test_autotune.py              |  194 --
 test/tensorflow/test_config.py                |  344 ---
 test/tensorflow/test_model_wrappers.py        |  365 ---
 test/tensorflow/test_quantize_model.py        |  160 --
 third-party-programs.txt                      |    9 +-
 218 files changed, 16 insertions(+), 46115 deletions(-)
 delete mode 100644 .azure-pipelines/scripts/ut/coverage.3x_tf
 delete mode 100644 .azure-pipelines/scripts/ut/run_3x_tf.sh
 delete mode 100644 .azure-pipelines/ut-3x-tf.yml
 delete mode 100644 docs/source/TF_Quant.md
 delete mode 100644 docs/source/TF_SQ.md
 delete mode 100644 docs/source/TensorFlow.md
 delete mode 100644 docs/source/api-doc/tf_quantization_autotune.rst
 delete mode 100644 docs/source/api-doc/tf_quantization_common.rst
 delete mode 100644 docs/source/api-doc/tf_quantization_config.rst
 delete mode 100644 docs/source/imgs/bf16_convert_tf.png
 delete mode 100644 neural_compressor/tensorflow/__init__.py
 delete mode 100644 neural_compressor/tensorflow/algorithms/__init__.py
 delete mode 100644 neural_compressor/tensorflow/algorithms/smoother/__init__.py
 delete mode 100644 neural_compressor/tensorflow/algorithms/smoother/calibration.py
 delete mode 100644 neural_compressor/tensorflow/algorithms/smoother/core.py
 delete mode 100644 neural_compressor/tensorflow/algorithms/smoother/scaler.py
 delete mode 100644 neural_compressor/tensorflow/algorithms/static_quant/__init__.py
 delete mode 100644 neural_compressor/tensorflow/algorithms/static_quant/keras.py
 delete mode 100644 neural_compressor/tensorflow/algorithms/static_quant/keras.yaml
 delete mode 100644 neural_compressor/tensorflow/algorithms/static_quant/tensorflow.py
 delete mode 100644 neural_compressor/tensorflow/algorithms/static_quant/tensorflow.yaml
 delete mode 100644 neural_compressor/tensorflow/algorithms/static_quant/tensorflow_itex.yaml
 delete mode 100644 neural_compressor/tensorflow/keras/__init__.py
 delete mode 100644 neural_compressor/tensorflow/keras/layers/__init__.py
 delete mode 100644 neural_compressor/tensorflow/keras/layers/conv2d.py
 delete mode 100644 neural_compressor/tensorflow/keras/layers/dense.py
 delete mode 100644 neural_compressor/tensorflow/keras/layers/depthwise_conv2d.py
 delete mode 100644 neural_compressor/tensorflow/keras/layers/layer_initializer.py
 delete mode 100644 neural_compressor/tensorflow/keras/layers/pool2d.py
 delete mode 100644 neural_compressor/tensorflow/keras/layers/separable_conv2d.py
 delete mode 100644 neural_compressor/tensorflow/keras/quantization/__init__.py
 delete mode 100644 neural_compressor/tensorflow/keras/quantization/config.py
 delete mode 100644 neural_compressor/tensorflow/quantization/__init__.py
 delete mode 100644 neural_compressor/tensorflow/quantization/algorithm_entry.py
 delete mode 100644 neural_compressor/tensorflow/quantization/autotune.py
 delete mode 100644 neural_compressor/tensorflow/quantization/config.py
 delete mode 100644 neural_compressor/tensorflow/quantization/quantize.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/__init__.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_converter.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/__init__.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/bf16/__init__.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/bf16/bf16_convert.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/bf16/dequantize_cast_optimizer.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/__init__.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/convert_add_to_biasadd.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/convert_layout.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/convert_leakyrelu.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/convert_nan_to_random.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/convert_placeholder_to_const.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/dilated_contraction.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/dummy_biasadd.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/expanddims_optimizer.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fetch_weight_from_reshape.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fold_batch_norm.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fold_constant.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_biasadd_add.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_column_wise_mul.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_conv_with_math.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_decomposed_bn.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_decomposed_in.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_gelu.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_layer_norm.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_pad_with_conv.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_pad_with_fp32_conv.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_reshape_transpose.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/graph_cse_optimizer.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/grappler_pass.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/insert_print_node.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/move_squeeze_after_relu.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/pre_optimize.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/remove_training_nodes.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/rename_batch_norm.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/split_shared_input.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/strip_equivalent_nodes.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/strip_unused_nodes.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/switch_optimizer.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/graph_base.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/__init__.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/freeze_fake_quant.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/freeze_value.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/fuse_conv_redundant_dequantize.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/fuse_conv_requantize.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/fuse_matmul_redundant_dequantize.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/fuse_matmul_requantize.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/meta_op_optimizer.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/post_hostconst_converter.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/post_quantized_op_cse.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/scale_propagation.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/qdq/__init__.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/qdq/insert_qdq_pattern.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/qdq/merge_duplicated_qdq.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_rewriter/qdq/share_qdq_y_pattern.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/graph_util.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/quantize_graph/__init__.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/__init__.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_bn.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_concatv2.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_conv.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_deconv.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_in.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_matmul.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_pooling.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/optimize_qdq.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_base.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_bn.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_concatv2.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_conv.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_for_intel_cpu.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_matmul.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_pooling.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/quantize_graph_common.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/transform_graph/__init__.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/transform_graph/bias_correction.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/transform_graph/graph_transform_base.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/transform_graph/insert_logging.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/transform_graph/rerange_quantized_concat.py
 delete mode 100644 neural_compressor/tensorflow/quantization/utils/utility.py
 delete mode 100644 neural_compressor/tensorflow/utils/__init__.py
 delete mode 100644 neural_compressor/tensorflow/utils/constants.py
 delete mode 100644 neural_compressor/tensorflow/utils/data.py
 delete mode 100644 neural_compressor/tensorflow/utils/model.py
 delete mode 100644 neural_compressor/tensorflow/utils/model_wrappers.py
 delete mode 100644 neural_compressor/tensorflow/utils/utility.py
 delete mode 100644 requirements_tf.txt
 delete mode 100644 test/tensorflow/keras/requirements.txt
 delete mode 100644 test/tensorflow/keras/test_config.py
 delete mode 100644 test/tensorflow/keras/test_layers.py
 delete mode 100644 test/tensorflow/keras/test_model_wrappers.py
 delete mode 100644 test/tensorflow/quantization/ptq/newapi/test_bias_correction_newapi.py
 delete mode 100644 test/tensorflow/quantization/ptq/newapi/test_big_saved_model.py
 delete mode 100644 test/tensorflow/quantization/ptq/newapi/test_graph_biasadd_add_fusion.py
 delete mode 100644 test/tensorflow/quantization/ptq/newapi/test_graph_conv_fusion_newapi.py
 delete mode 100644 test/tensorflow/quantization/ptq/newapi/test_graph_conv_requantize_fusion.py
 delete mode 100644 test/tensorflow/quantization/ptq/newapi/test_graph_depthwiseconv_fusion.py
 delete mode 100644 test/tensorflow/quantization/ptq/newapi/test_graph_dequantize_cast_optimizer_newapi.py
 delete mode 100644 test/tensorflow/quantization/ptq/newapi/test_graph_dq_cast_fusion.py
 delete mode 100644 test/tensorflow/quantization/ptq/newapi/test_graph_fuse_pad_conv_fp32.py
 delete mode 100644 test/tensorflow/quantization/ptq/newapi/test_graph_qdq_bn_fusion.py
 delete mode 100644 test/tensorflow/quantization/ptq/newapi/test_graph_qdq_concat_fusion.py
 delete mode 100644 test/tensorflow/quantization/ptq/newapi/test_graph_qdq_conv3d_fusion.py
 delete mode 100644 test/tensorflow/quantization/ptq/newapi/test_graph_qdq_conv_fusion.py
 delete mode 100644 test/tensorflow/quantization/ptq/newapi/test_graph_qdq_depthwiseconv_fusion.py
 delete mode 100644 test/tensorflow/quantization/ptq/newapi/test_graph_qdq_matmul_fusion.py
 delete mode 100644 test/tensorflow/quantization/ptq/newapi/test_graph_qdq_new_conv_fusion.py
 delete mode 100644 test/tensorflow/quantization/ptq/newapi/test_graph_qdq_pooling_fusion.py
 delete mode 100644 test/tensorflow/quantization/ptq/newapi/test_use_reshape_transpose.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_auto_input_output.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_bf16_convert.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_bias_correction.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_data_pipline.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_fold_batch_norm.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_fold_const.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_gpu.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_cac.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_column_wise_mul.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_concat.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_conv_add_relu_fusion.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_conv_as_output.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_conv_fusion.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_conv_math.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_convert_layout.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_convert_leakyrelu.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_convert_nan.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_cse_optimization.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_debug_mode.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_dequantize_cast_optimizer.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_expanddims_optimizer.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_fetch_weight_from_reshape.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_fold_bn.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_fuse_decomposed_bn.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_fuse_gelu.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_input_output.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_insert_logging.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_library_detection.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_matmul_fusion.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_meta_pass.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_pad_conv.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_post_cse_optimize.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_search_patterns.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_switch_optimizer.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_graph_util.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_grappler_pass.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_move_squeeze_after_relu.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_quantize_input.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_query_yaml.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_remove_training_nodes.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_rnn.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_share_nodes_graph.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_strip_equivalent_nodes.py
 delete mode 100644 test/tensorflow/quantization/ptq/test_utils.py
 delete mode 100644 test/tensorflow/quantization/test_smooth_quant.py
 delete mode 100644 test/tensorflow/requirements.txt
 delete mode 100644 test/tensorflow/test_autotune.py
 delete mode 100644 test/tensorflow/test_config.py
 delete mode 100644 test/tensorflow/test_model_wrappers.py
 delete mode 100644 test/tensorflow/test_quantize_model.py

diff --git a/.azure-pipelines/scripts/fwk_version.sh b/.azure-pipelines/scripts/fwk_version.sh
index f6af43af431..279139d9ac9 100644
--- a/.azure-pipelines/scripts/fwk_version.sh
+++ b/.azure-pipelines/scripts/fwk_version.sh
@@ -1,7 +1,6 @@
 #!/bin/bash
 
 echo "export FWs version..."
-export tensorflow_version='2.15.0-official'
 export pytorch_version='2.5.1'
 export torchvision_version='0.20.1'
 export ipex_version='2.5.0+cpu'
diff --git a/.azure-pipelines/scripts/install_nc.sh b/.azure-pipelines/scripts/install_nc.sh
index 869169e6864..0d73d915adb 100644
--- a/.azure-pipelines/scripts/install_nc.sh
+++ b/.azure-pipelines/scripts/install_nc.sh
@@ -23,11 +23,6 @@ if [[ $1 = *"3x_pt"* ]]; then
     fi
     python setup.py pt bdist_wheel
     uv pip install --no-deps dist/neural_compressor*.whl --force-reinstall
-elif [[ $1 = *"3x_tf"* ]]; then
-	uv pip install tensorflow==2.19.0
-    uv pip install --no-cache-dir -r requirements_tf.txt
-    python setup.py tf bdist_wheel
-    uv pip install dist/neural_compressor*.whl --force-reinstall
 elif [[ $1 = *"3x_jax"* ]]; then
     uv pip install --no-cache-dir -r requirements_jax.txt
     python setup.py jax bdist_wheel
diff --git a/.azure-pipelines/scripts/models/collect_log_model.py b/.azure-pipelines/scripts/models/collect_log_model.py
index 9abbf22996e..63c59f27bf3 100644
--- a/.azure-pipelines/scripts/models/collect_log_model.py
+++ b/.azure-pipelines/scripts/models/collect_log_model.py
@@ -21,9 +21,6 @@
     + args.build_id
     + "&view=artifacts&pathAsName=false&type=publishedArtifacts"
 )
-OOB_MODEL_LIST = ["darknet19", "densenet-121", "resnet-101"]
-
-
 def get_model_tuning_dict_results():
     tuning_result_dict = {}
 
@@ -141,10 +138,6 @@ def collect_log():
                 parse_tuning_line(line, tmp)
         print(tmp)
 
-        # oob_model no need acc
-        if (args.model in OOB_MODEL_LIST) and args.framework == "tensorflow":
-            tmp["fp32_acc"], tmp["int8_acc"] = "unknown", "unknown"
-
         # set for 3x woq models
         if args.inc_new_api.split("_")[0] == "3x":
             tmp["fp32_acc"], tmp["tuning_trials"], tmp["strategy"] = "unknown", "", ""
diff --git a/.azure-pipelines/scripts/models/generate_report.sh b/.azure-pipelines/scripts/models/generate_report.sh
index e13118fcffe..1f512c1e3d7 100644
--- a/.azure-pipelines/scripts/models/generate_report.sh
+++ b/.azure-pipelines/scripts/models/generate_report.sh
@@ -530,7 +530,7 @@ cat > ${output_dir}/report.html << eof
 <html lang="en">
 <head>
     <meta http-equiv="content-type" content="text/html; charset=ISO-8859-1">
-    <title>Daily Tests - TensorFlow - Jenkins</title>
+    <title>Daily Tests - Neural Compressor - Jenkins</title>
     <style type="text/css">
         body
         {
diff --git a/.azure-pipelines/scripts/models/run_model_trigger_common.sh b/.azure-pipelines/scripts/models/run_model_trigger_common.sh
index bdaeb613c1d..fbb791adcf9 100644
--- a/.azure-pipelines/scripts/models/run_model_trigger_common.sh
+++ b/.azure-pipelines/scripts/models/run_model_trigger_common.sh
@@ -80,8 +80,6 @@ if [ "${mode}" == "env_setup" ]; then
 elif [ "${mode}" == "tuning" ]; then
     if [ "${framework}" == "onnxrt" ]; then
         output_model=${log_dir}/${model}/${framework}-${model}-tune.onnx
-    elif [ "${framework}" == "tensorflow" ]; then
-        output_model=${log_dir}/${model}/${framework}-${model}-tune.pb
     fi
     [[ ${output_model} ]] && tuning_cmd="${tuning_cmd} --output_model=${output_model}"
 
@@ -138,8 +136,6 @@ elif [ "${mode}" == "int8_benchmark" ]; then
     $BOLD_YELLOW && echo "====== run benchmark int8 =======" && $RESET
     if [[ "${framework}" == "onnxrt" ]]; then
         model_name="${log_dir}/${model}/${framework}-${model}-tune.onnx"
-    elif [[ "${framework}" == "tensorflow" ]]; then
-        model_name="${log_dir}/${model}/${framework}-${model}-tune.pb"
     elif [[ "${framework}" == "pytorch" ]]; then
         model_name=${input_model}
         benchmark_cmd="${benchmark_cmd} --int8=true"
diff --git a/.azure-pipelines/scripts/models/update_yaml_config.py b/.azure-pipelines/scripts/models/update_yaml_config.py
index a96f262449d..70a871ddd36 100644
--- a/.azure-pipelines/scripts/models/update_yaml_config.py
+++ b/.azure-pipelines/scripts/models/update_yaml_config.py
@@ -100,7 +100,6 @@ def update_yaml_config_tuning(
     strategy_token=None,
     sampling_size=None,
     dtype=None,
-    tf_new_api=None,
 ):
     with open(yaml_file) as f:
         yaml_config = yaml.round_trip_load(f, preserve_quotes=True)
@@ -216,15 +215,6 @@ def update_yaml_config_tuning(
         except Exception as e:
             print(f"[ WARNING ] {e}")
 
-    if tf_new_api == "true":
-        try:
-            model = yaml_config.get("model", {})
-            prev_framework = model.get("framework", None)
-            model.update({"framework": "inteltensorflow"})
-            print(f"Changed framework from {prev_framework} to inteltensorflow")
-        except Exception as e:
-            print(f"[ WARNING ] {e}")
-
     print("====== update_yaml_config_tuning ========")
 
     yaml_content = yaml.round_trip_dump(yaml_config)
diff --git a/.azure-pipelines/scripts/ut/coverage.3x_tf b/.azure-pipelines/scripts/ut/coverage.3x_tf
deleted file mode 100644
index ce3946f6e92..00000000000
--- a/.azure-pipelines/scripts/ut/coverage.3x_tf
+++ /dev/null
@@ -1,21 +0,0 @@
-[run]
-branch = True
-
-[paths]
-source =
-    neural_compressor/
-    */site-packages/neural_compressor/
-    */dist-packages/neural_compressor/
-
-[report]
-include =
- */neural_compressor/common/*
- */neural_compressor/tensorflow/*
-exclude_lines =
- pragma: no cover
- raise NotImplementedError
- raise TypeError
- if self.device == "gpu":
- if device == "gpu":
- except ImportError:
- except Exception as e:
\ No newline at end of file
diff --git a/.azure-pipelines/scripts/ut/run_3x_tf.sh b/.azure-pipelines/scripts/ut/run_3x_tf.sh
deleted file mode 100644
index c2eb07dd724..00000000000
--- a/.azure-pipelines/scripts/ut/run_3x_tf.sh
+++ /dev/null
@@ -1,78 +0,0 @@
-#!/bin/bash
-python -c "import neural_compressor as nc"
-test_case="run 3x TensorFlow"
-echo "${test_case}"
-
-echo "##[section]Run import check"
-set -e
-python -c "import neural_compressor.tensorflow"
-python -c "import neural_compressor.common"
-echo "##[section]import check pass"
-
-# install requirements
-echo "##[group]set up UT env..."
-pip install -r /neural-compressor/test/tensorflow/requirements.txt
-pip install pytest-cov
-pip install pytest-html
-pip install pytest-html-merger
-pip install beautifulsoup4==4.13.5
-echo "##[endgroup]"
-pip list
-
-export COVERAGE_RCFILE=/neural-compressor/.azure-pipelines/scripts/ut/coverage.3x_tf
-inc_path=$(python -c 'import neural_compressor; print(neural_compressor.__path__[0])')
-cd /neural-compressor/test || exit 1
-rm -rf torch
-rm -rf onnxrt
-mv tensorflow/keras ../3x_keras
-mv tensorflow/quantization/ptq/newapi ../3x_newapi
-
-LOG_DIR=/neural-compressor/log_dir
-mkdir -p ${LOG_DIR}
-ut_log_name=${LOG_DIR}/ut_3x_tf.log
-
-# test for tensorflow ut
-pytest --cov="${inc_path}" -vs --disable-warnings --html=report_tf_quant.html --self-contained-html ./tensorflow/quantization 2>&1 | tee -a ${ut_log_name}
-rm -rf tensorflow/quantization
-pytest --cov="${inc_path}" --cov-append -vs --disable-warnings --html=report_tf_test_quantize_model.html --self-contained-html ./tensorflow/test_quantize_model.py 2>&1 | tee -a ${ut_log_name}
-rm -rf tensorflow/test_quantize_model.py
-pytest --cov="${inc_path}" --cov-append -vs --disable-warnings --html=report_tf.html --self-contained-html . 2>&1 | tee -a ${ut_log_name}
-
-# test for tensorflow new api ut
-pip uninstall tensorflow -y
-pip install /tf_dataset/tf_binary/230928/tensorflow*.whl
-pip install protobuf==3.20.3
-pip install horovod==0.27.0
-pip list
-rm -rf tensorflow/*
-mkdir -p tensorflow/quantization/ptq
-mv ../3x_newapi tensorflow/quantization/ptq/newapi
-find . -name "test*.py" | sed "s,\.\/,python -m pytest --cov=${inc_path} --cov-append -vs --disable-warnings ,g" > run.sh
-cat run.sh
-numactl --physcpubind="${NUMA_CPUSET:-0-15}" --membind="${NUMA_NODE:-0}" bash run.sh 2>&1 | tee -a ${ut_log_name}
-
-# test for itex ut
-rm -rf tensorflow/*
-mv ../3x_keras tensorflow/keras
-pip uninstall tensorflow -y
-pip install intel-extension-for-tensorflow[cpu]
-pytest --cov="${inc_path}" --cov-append -vs --disable-warnings --html=report_keras.html --self-contained-html ./tensorflow 2>&1 | tee -a ${ut_log_name}
-
-mkdir -p report
-mv *.html report
-pytest_html_merger -i ./report -o ./report.html
-
-cp report.html ${LOG_DIR}/
-
-set -x
-if [ $(grep -c '== FAILURES ==' ${ut_log_name}) != 0 ] || [ $(grep -c '== ERRORS ==' ${ut_log_name}) != 0 ] || \
-[ $(grep -c 'Killed' ${ut_log_name}) != 0 ] || [ $(grep -c 'core dumped' ${ut_log_name}) != 0 ] || [ $(grep -c ' passed' ${ut_log_name}) == 0 ]; then
-    echo "Find errors in pytest case, please check the output..."
-    echo "Please search for '== FAILURES ==' or '== ERRORS =='"
-    exit 1
-fi
-
-# if ut pass, collect the coverage file into artifacts
-cp .coverage ${LOG_DIR}/.coverage
-
-echo "UT finished successfully! "
\ No newline at end of file
diff --git a/.azure-pipelines/template/model-template.yml b/.azure-pipelines/template/model-template.yml
index bf7f842fc5b..49148183494 100644
--- a/.azure-pipelines/template/model-template.yml
+++ b/.azure-pipelines/template/model-template.yml
@@ -4,7 +4,7 @@ parameters:
     default: "resnet50v1.5"
   - name: framework
     type: string
-    default: "tensorflow"
+    default: "pytorch"
   - name: APIVersion
     type: string
     default: ""
diff --git a/.azure-pipelines/ut-3x-tf.yml b/.azure-pipelines/ut-3x-tf.yml
deleted file mode 100644
index ece3cfc3757..00000000000
--- a/.azure-pipelines/ut-3x-tf.yml
+++ /dev/null
@@ -1,118 +0,0 @@
-trigger: none
-
-pr:
-  autoCancel: true
-  drafts: false
-  branches:
-    include:
-      - main
-  paths:
-    include:
-      - neural_compressor/common
-      - neural_compressor/tensorflow
-      - test/tensorflow
-      - test/common
-      - setup.py
-      - requirements_tf.txt
-      - .azure-pipelines/scripts/ut/run_3x_tf.sh
-      - .azure-pipelines/template/docker-template.yml
-      - .azure-pipelines/scripts/ut/coverage.3x_tf
-
-pool: INTEL-CPU
-
-variables:
-  IMAGE_NAME: "neural-compressor"
-  IMAGE_TAG: "py310"
-  UPLOAD_PATH: $(Build.SourcesDirectory)/log_dir
-  DOWNLOAD_PATH: $(Build.SourcesDirectory)/log_dir
-  ARTIFACT_NAME: "UT_coverage_report_3x_tf"
-  REPO: $(Build.Repository.Uri)
-
-stages:
-  - stage: TensorFlow
-    displayName: Unit Test 3x TensorFlow
-    dependsOn: []
-    jobs:
-      - job:
-        displayName: Unit Test 3x TensorFlow
-        steps:
-          - template: template/ut-template.yml
-            parameters:
-              dockerConfigName: "commonDockerConfig"
-              utScriptFileName: "run_3x_tf"
-              uploadPath: $(UPLOAD_PATH)
-              utArtifact: "ut_3x"
-              utContainerName: "INCUnitTest$(NODE_LABEL)"
-
-  - stage: TensorFlow_baseline
-    displayName: Unit Test 3x TensorFlow baseline
-    dependsOn: []
-    jobs:
-      - job:
-        displayName: Unit Test 3x TensorFlow baseline
-        continueOnError: true
-        steps:
-          - template: template/ut-template.yml
-            parameters:
-              dockerConfigName: "gitCloneDockerConfig"
-              utScriptFileName: "run_3x_tf"
-              uploadPath: $(UPLOAD_PATH)
-              utArtifact: "ut_3x_baseline"
-              repo: $(REPO)
-              utContainerName: "INCUnitTest$(NODE_LABEL)"
-
-  - stage: Coverage
-    displayName: "Coverage Compare"
-    pool:
-      vmImage: "ubuntu-latest"
-    dependsOn: [TensorFlow, TensorFlow_baseline]
-    jobs:
-      - job: CollectDatafiles
-        steps:
-          - script: |
-              if [[ ! $(docker images | grep -i ${IMAGE_NAME}:${IMAGE_TAG}) ]]; then
-                docker build --build-arg USER_ID=$(id -u) --build-arg GROUP_ID=$(id -g) \
-                  -f ${BUILD_SOURCESDIRECTORY}/.azure-pipelines/docker/Dockerfile.devel -t ${IMAGE_NAME}:${IMAGE_TAG} .
-              fi
-              docker images | grep -i ${IMAGE_NAME}
-              if [[ $? -ne 0 ]]; then
-                echo "NO Such Repo"
-                exit 1
-              fi
-            displayName: "Build develop docker image"
-
-          - task: DownloadPipelineArtifact@2
-            inputs:
-              artifact:
-              patterns: '*_coverage/.coverage'
-              path: $(DOWNLOAD_PATH)
-
-          - script: |
-              echo "--- create container ---"
-              docker run -d -it --name="collectLogs" -v ${BUILD_SOURCESDIRECTORY}:/neural-compressor  ${IMAGE_NAME}:${IMAGE_TAG} /bin/bash
-              echo "--- docker ps ---"
-              docker ps
-              echo "--- collect logs ---"
-              docker exec collectLogs /bin/bash  +x -c "cd /neural-compressor/.azure-pipelines/scripts \
-              && bash install_nc.sh 3x_tf \
-              && bash ut/collect_log_3x.sh 3x_tf"
-            displayName: "Collect UT Coverage"
-
-          - task: PublishCodeCoverageResults@2
-            inputs:
-              summaryFileLocation: $(Build.SourcesDirectory)/log_dir/coverage_PR/coverage.xml
-
-          - task: PublishPipelineArtifact@1
-            condition: succeededOrFailed()
-            inputs:
-              targetPath: $(UPLOAD_PATH)
-              artifact: $(ARTIFACT_NAME)
-              publishLocation: "pipeline"
-
-          - task: Bash@3
-            condition: always()
-            inputs:
-              targetType: "inline"
-              script: |
-                docker exec collectLogs bash -c "rm -fr /neural-compressor/* && rm -fr /neural-compressor/.* || true"
-            displayName: "Docker clean up"
diff --git a/README.md b/README.md
index 419b108819c..e3cbe46ded4 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 Intel® Neural Compressor
 ===========================
-<h3> An open-source Python library supporting popular model compression techniques on mainstream deep learning frameworks (PyTorch, TensorFlow, and JAX)</h3>
+<h3> An open-source Python library supporting popular model compression techniques on mainstream deep learning frameworks (PyTorch and JAX)</h3>
 
 [![python](https://img.shields.io/badge/python-3.11%2B-blue)](https://github.com/intel/neural-compressor)
 [![version](https://img.shields.io/badge/release-3.10-green)](https://github.com/intel/neural-compressor/releases)
@@ -47,8 +47,6 @@ Intel Neural Compressor supports PyTorch with CPU, GPU and HPU. Please install t
 ```
 # Framework extension API + PyTorch dependency
 pip install neural-compressor-pt
-# Framework extension API + TensorFlow dependency
-pip install neural-compressor-tf
 # Framework extension API + JAX dependency
 pip install neural-compressor-jax
 ```    
@@ -144,18 +142,6 @@ model = load(
         <td colspan="4" align="center"><a href="./docs/source/PT_NVFP4Quant.md">NVFP4 Quantization</a></td>
     </tr>
   </tbody>
-  <thead>
-      <tr>
-        <th colspan="8">Tensorflow Extension APIs</th>
-      </tr>
-  </thead>
-  <tbody>
-      <tr>
-          <td colspan="3" align="center"><a href="./docs/source/TensorFlow.md">Overview</a></td>
-          <td colspan="3" align="center"><a href="./docs/source/TF_Quant.md">Static Quantization</a></td>
-          <td colspan="2" align="center"><a href="./docs/source/TF_SQ.md">Smooth Quantization</a></td>
-      </tr>
-  </tbody>
   <thead>
       <tr>
         <th colspan="8">Transformers-like APIs</th>
diff --git a/docs/source/TF_Quant.md b/docs/source/TF_Quant.md
deleted file mode 100644
index e79abd31e91..00000000000
--- a/docs/source/TF_Quant.md
+++ /dev/null
@@ -1,115 +0,0 @@
-
-TensorFlow Quantization
-===============
-
-1. [Introduction](#introduction)
-2. [Get Started](#get-started)  
-   2.1 [Without Accuracy Aware Tuning](#without-accuracy-aware-tuning)   
-   2.2 [With Accuracy Aware Tuning](#with-accuracy-aware-tuning)   
-   2.3 [Specify Quantization Rules](#specify-quantization-rules) 
-
-## Introduction
-
-`neural_compressor.tensorflow` supports quantizing both TensorFlow and Keras model with or without accuracy aware tuning.
-
-For the detailed quantization fundamentals, please refer to the document for [Quantization](quantization.md).
-
-## Get Started
-
-### Without Accuracy Aware Tuning
-
-This means user could leverage Intel(R) Neural Compressor to directly generate a fully quantized model without accuracy aware tuning. It's user responsibility to ensure the accuracy of the quantized model meets expectation.
-
-``` python
-# main.py
-
-# Original code
-model = tf.keras.applications.resnet50.ResNet50(weights="imagenet")
-val_dataset = ...
-val_dataloader = MyDataloader(dataset=val_dataset)
-
-# Quantization code
-from neural_compressor.tensorflow import quantize_model, StaticQuantConfig
-
-quant_config = StaticQuantConfig()
-qmodel = quantize_model(
-    model=model,
-    quant_config=quant_config,
-    calib_dataloader=val_dataloader,
-)
-qmodel.save("./output")
-```
-
-### With Accuracy Aware Tuning
-
-This means user could leverage the advance feature of Intel(R) Neural Compressor to tune out a best quantized model which has best accuracy and good performance. User should provide `eval_fn` and `eval_args`.
-
-``` python
-# main.py
-
-# Original code
-model = tf.keras.applications.resnet50.ResNet50(weights="imagenet")
-val_dataset = ...
-val_dataloader = MyDataloader(dataset=val_dataset)
-
-
-def eval_acc_fn(model) -> float:
-    ...
-    return acc
-
-
-# Quantization code
-from neural_compressor.common.base_tuning import TuningConfig
-from neural_compressor.tensorflow import autotune
-
-# it's also supported to define custom_tune_config as:
-# TuningConfig(StaticQuantConfig(weight_sym=[True, False], act_sym=[True, False]))
-custom_tune_config = TuningConfig(
-    config_set=[
-        StaticQuantConfig(weight_sym=True, act_sym=True),
-        StaticQuantConfig(weight_sym=False, act_sym=False),
-    ]
-)
-best_model = autotune(
-    model=model,
-    tune_config=custom_tune_config,
-    eval_fn=eval_acc_fn,
-    calib_dataloader=val_dataloader,
-)
-best_model.save("./output")
-```
-
-### Specify Quantization Rules
-Intel(R) Neural Compressor support specify quantization rules by operator name or operator type. Users can set `local` in dict or use `set_local` method of config class to achieve the above purpose.
-
-1. Example of setting `local` from a dict
-```python
-quant_config = {
-    "static_quant": {
-        "global": {
-            "weight_dtype": "int8",
-            "weight_sym": True,
-            "weight_granularity": "per_tensor",
-            "act_dtype": "int8",
-            "act_sym": True,
-            "act_granularity": "per_tensor",
-        },
-        "local": {
-            "conv1": {
-                "weight_dtype": "fp32",
-                "act_dtype": "fp32",
-            }
-        },
-    }
-}
-config = StaticQuantConfig.from_dict(quant_config)
-```
-2. Example of using `set_local`
-```python
-quant_config = StaticQuantConfig()
-conv2d_config = StaticQuantConfig(
-    weight_dtype="fp32",
-    act_dtype="fp32",
-)
-quant_config.set_local("conv1", conv2d_config)
-```
diff --git a/docs/source/TF_SQ.md b/docs/source/TF_SQ.md
deleted file mode 100644
index 7bbd14853ea..00000000000
--- a/docs/source/TF_SQ.md
+++ /dev/null
@@ -1,45 +0,0 @@
-# Smooth Quant
-
-- [Introduction](#introduction)
-- [Usage](#usage)
-  - [Using a Fixed `alpha`](#using-a-fixed-alpha)
-  - [Determining the `alpha` through auto-tuning](#determining-the-alpha-through-auto-tuning)
-
-## Introduction
-
-Quantization is a common compression operation to reduce memory and accelerate inference by converting the floating point matrix to an integer matrix. For large language models (LLMs) with gigantic parameters, the systematic outliers make quantification of activations difficult.  [SmoothQuant](https://arxiv.org/abs/2211.10438), a training free post-training quantization (PTQ) solution, offline migrates this difficulty from activations to weights with a mathematically equivalent transformation.
-
-Please refer to the document of [Smooth Quant](smooth_quant.md) for detailed fundamental knowledge.
-
-## Usage
-There are two ways to apply smooth quantization: 1) using a fixed `alpha` for the entire model or 2) determining the `alpha` through auto-tuning.
-
-### Using a Fixed `alpha`
-To set a fixed alpha for the entire model, users can follow this example:
-
-```python
-from neural_compressor.tensorflow import SmoothQuantConfig, StaticQuantConfig
-
-quant_config = [SmoothQuantConfig(alpha=0.5), StaticQuantConfig()]
-q_model = quantize_model(output_graph_def, [sq_config, static_config], calib_dataloader)
-```
-The `SmoothQuantConfig` should be combined with `StaticQuantConfig` in a list because we still need to insert QDQ and apply pattern fusion after the smoothing process.
-
-
-### Determining the `alpha` through auto-tuning
-Users can search for the best `alpha`  for the entire model.The tuning process looks for the optimal `alpha` value from a list of `alpha` values provided by the user.
-
-Here is an example:
-
-```python
-from neural_compressor.tensorflow import StaticQuantConfig, SmoothQuantConfig
-
-custom_tune_config = TuningConfig(config_set=[SmoothQuantConfig(alpha=[0.5, 0.6, 0.7]), StaticQuantConfig()])
-best_model = autotune(
-    model="fp32_model",
-    tune_config=custom_tune_config,
-    eval_fn=eval_fn_wrapper,
-    calib_dataloader=calib_dataloader,
-)
-```
-> Please note that, it may a considerable amount of time as the tuning process applies each `alpha` to the entire model and uses the evaluation result on the entire dataset as the metric to determine the best `alpha`.
diff --git a/docs/source/TensorFlow.md b/docs/source/TensorFlow.md
deleted file mode 100644
index 01c8ce8c0b6..00000000000
--- a/docs/source/TensorFlow.md
+++ /dev/null
@@ -1,216 +0,0 @@
-TensorFlow
-===============
-
-- [Introduction](#introduction)
-- [API for TensorFlow](#api-for-tensorflow)
-  - [Support Matrix](#support-matrix)
-    - [Quantization Scheme](#quantization-scheme)
-    - [Quantization Approaches](#quantization-approaches)
-      - [Post Training Static Quantization](#post-training-static-quantization)
-      - [Smooth Quantization](#smooth-quantization)
-      - [Mixed Precision](#mixed-precison)
-    - [Backend and Device](#backend-and-device)
-
-## Introduction
-
-`neural_compressor.tensorflow` provides a integrated API for applying quantization on various TensorFlow model format, such as `pb`, `saved_model` and `keras`. The comprehensive range of supported models includes but not limited to CV models, NLP models, and large language models. 
-
-In terms of ease of use, neural compressor is committed to providing flexible and scalable user interfaces. While `quantize_model` is designed to provide a fast and straightforward quantization experience, the `autotune` offers an advanced option of reducing accuracy loss during quantization.
-
-
-## API for TensorFlow
-
-Intel(R) Neural Compressor provides `quantize_model` and `autotune` as main interfaces for supported algorithms on TensorFlow framework.
-
-**quantize_model**
-
-The design philosophy of the `quantize_model` interface is easy-of-use. With minimal parameters requirement, including `model`, `quant_config`, `calib_dataloader`, `calib_iteration`, it offers a straightforward choice of quantizing TF model in one-shot.
-
-```python
-def quantize_model(
-    model: Union[str, tf.keras.Model, BaseModel],
-    quant_config: Union[BaseConfig, list],
-    calib_dataloader: Callable = None,
-    calib_iteration: int = 100,
-    calib_func: Callable = None,
-):
-```
-`model` should be a string of the model's location, the object of Keras model or INC TF model wrapper class.
-
-`quant_config` is either the `StaticQuantConfig` object or a list contains `SmoothQuantConfig` and `StaticQuantConfig` to indicate what algorithm should be used and what specific quantization rules should be applied.
-
-`calib_dataloader` is used to load the data samples for calibration phase. In most cases, it could be the partial samples of the evaluation dataset.
-
-`calib_iteration` is used to decide how many iterations the calibration process will be run.
-
-`calib_func` is a substitution for `calib_dataloader` when the built-in calibration function of INC does not work for model inference.
-
-
-Here is a simple example of using `quantize_model` interface with a dummy calibration dataloader and the default `StaticQuantConfig`:
-```python
-from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-from neural_compressor.tensorflow.utils import DummyDataset
-
-dataset = DummyDataset(shape=(100, 32, 32, 3), label=True)
-calib_dataloader = MyDataLoader(dataset=dataset)
-quant_config = StaticQuantConfig()
-
-qmodel = quantize_model("fp32_model.pb", quant_config, calib_dataloader)
-```
-**autotune**
-
-The `autotune` interface, on the other hand, provides greater flexibility and power. It's particularly useful when accuracy is a critical factor. If the initial quantization doesn't meet the tolerance of accuracy loss, `autotune` will iteratively try quantization rules according to the `tune_config`. 
-
-Just like `quantize_model`, `autotune` requires `model`, `calib_dataloader` and `calib_iteration`. And the `eval_fn`, `eval_args` are used to build evaluation process.
-
-
-
-```python
-def autotune(
-    model: Union[str, tf.keras.Model, BaseModel],
-    tune_config: TuningConfig,
-    eval_fn: Callable,
-    eval_args: Optional[Tuple[Any]] = None,
-    calib_dataloader: Callable = None,
-    calib_iteration: int = 100,
-    calib_func: Callable = None,
-) -> Optional[BaseModel]:
-```
-`model` should be a string of the model's location, the object of Keras model or INC TF model wrapper class.
-
-`tune_config` is the `TuningConfig` object which contains multiple quantization rules.
-
-`eval_fn` is the evaluation function that measures the accuracy of a model.
-
-`eval_args` is the supplemental arguments required by the defined evaluation function.
-
-`calib_dataloader` is used to load the data samples for calibration phase. In most cases, it could be the partial samples of the evaluation dataset.
-
-`calib_iteration` is used to decide how many iterations the calibration process will be run.
-
-`calib_func` is a substitution for `calib_dataloader` when the built-in calibration function of INC does not work for model inference.
-
-Here is a simple example of using `autotune` interface with different quantization rules defined by a list of  `StaticQuantConfig`:
-```python
-from neural_compressor.common.base_tuning import TuningConfig
-from neural_compressor.tensorflow import StaticQuantConfig, autotune
-
-calib_dataloader = MyDataloader(dataset=Dataset())
-custom_tune_config = TuningConfig(
-    config_set=[
-        StaticQuantConfig(weight_sym=True, act_sym=True),
-        StaticQuantConfig(weight_sym=False, act_sym=False),
-    ]
-)
-best_model = autotune(
-    model="baseline_model",
-    tune_config=custom_tune_config,
-    eval_fn=eval_acc_fn,
-    calib_dataloader=calib_dataloader,
-)
-```
-
-### Support Matrix
-
-#### Quantization Scheme
-
-| Framework  |                         Backend Library                         |         Symmetric Quantization          |  Asymmetric Quantization |
-|:-----------|:---------------------------------------------------------------:|:---------------------------------------:|-------------------------:|
-| TensorFlow |         [oneDNN](https://github.com/oneapi-src/oneDNN)          | Activation (int8/uint8), Weight (int8)  |                        - |
-| Keras      | [ITEX](https://github.com/intel/intel-extension-for-tensorflow) | Activation (int8/uint8), Weight (int8)  |                        - |
-
-
-+ Symmetric Quantization
-    + int8: scale = 2 * max(abs(rmin), abs(rmax)) / (max(int8) - min(int8) - 1)
-    + uint8: scale = max(rmin, rmax) / (max(uint8) - min(uint8))
-
-#### Quantization Approaches
-
-The supported Quantization methods for TensorFlow and Keras are listed below:
-<table class="center">
-    <thead>
-        <tr>
-            <th>Types</th>
-            <th>Quantization</th>
-            <th>Dataset Requirements</th>
-            <th>Framework</th>
-            <th>Backend</th>
-        </tr>
-    </thead>
-    <tbody>
-        <tr>
-            <td rowspan="2" align="center">Post-Training Static Quantization (PTQ)</td>
-            <td rowspan="2" align="center">weights and activations</td>
-            <td rowspan="2" align="center">calibration</td>
-            <td align="center">Keras</td>
-            <td align="center"><a href="https://github.com/intel/intel-extension-for-tensorflow">ITEX</a></td>
-        </tr>
-        <tr>
-            <td align="center">TensorFlow</td>
-            <td align="center"><a href="https://github.com/tensorflow/tensorflow">TensorFlow</a>/<a href="https://github.com/Intel-tensorflow/tensorflow">Intel TensorFlow</a></td>
-        </tr>
-        <tr>
-            <td rowspan="1" align="center">Smooth Quantization(SQ)</td>
-            <td rowspan="1" align="center">weights</td>
-            <td rowspan="1" align="center">calibration</td>
-            <td align="center">Tensorflow</td>
-            <td align="center"><a href="https://github.com/tensorflow/tensorflow">TensorFlow</a>/<a href="https://github.com/Intel-tensorflow/tensorflow">Intel TensorFlow</a></td>
-        </tr>
-        <tr>
-            <td rowspan="1" align="center">Mixed Precision(MP)</td>
-            <td rowspan="1" align="center">weights and activations</td>
-            <td rowspan="1" align="center">NA</td>
-            <td align="center">Tensorflow</td>
-            <td align="center"><a href="https://github.com/tensorflow/tensorflow">TensorFlow</a>/<a href="https://github.com/Intel-tensorflow/tensorflow">Intel TensorFlow</a></td>
-        </tr>
-    </tbody>
-</table>
-<br>
-<br>
-
-##### Post Training Static Quantization
-
-The min/max range in weights and activations are collected offline on a so-called `calibration` dataset. This dataset should be able to represent the data distribution of those unseen inference dataset. The `calibration` process runs on the original fp32 model and dumps out all the tensor distributions for `Scale` and `ZeroPoint` calculations. Usually preparing 100 samples are enough for calibration.
-
-Refer to the [PTQ Guide](./TF_Quant.md) for detailed information.
-
-##### Smooth Quantization
-
-Smooth Quantization (SQ) is an advanced quantization technique designed to optimize model performance while maintaining high accuracy. Unlike traditional quantization methods that can lead to significant accuracy loss, SQ focuses on a more refined approach by taking a balance between the scale of activations and weights. 
-
-Refer to the [SQ Guide](./TF_SQ.md) for detailed information.
-
-##### Mixed Precision
-The Mixed Precision (MP) is enabled with Post Training Static Quantization. Once `BF16` is supported on machine, the matched operators will be automatically converted.
-
-#### Backend and Device
-Intel(R) Neural Compressor supports TF GPU with [ITEX-XPU](https://github.com/intel/intel-extension-for-tensorflow). We will automatically run model on GPU by checking if it has been installed.
-
-<table class="center">
-    <thead>
-        <tr>
-            <th>Framework</th>
-            <th>Backend</th>
-            <th>Backend Library</th>
-            <th>Backend Value</th>
-            <th>Support Device(cpu as default)</th> 
-        </tr>
-    </thead>
-    <tbody>
-        <tr>
-            <td rowspan="2" align="left">TensorFlow</td>
-            <td align="left">TensorFlow</td>
-            <td align="left">OneDNN</td>
-            <td align="left">"default"</td>
-            <td align="left">cpu</td>
-        </tr>
-        <tr>
-            <td align="left">ITEX</td>
-            <td align="left">OneDNN</td>
-            <td align="left">"itex"</td>
-            <td align="left">cpu | gpu</td>
-        </tr>  
-    </tbody>
-</table>
-<br>
-<br>
diff --git a/docs/source/api-doc/apis.rst b/docs/source/api-doc/apis.rst
index 98e89b31cc8..0e0aa184744 100644
--- a/docs/source/api-doc/apis.rst
+++ b/docs/source/api-doc/apis.rst
@@ -10,15 +10,6 @@ API
    torch_quantization_config.rst
    torch_quantization_autotune.rst
 
-**Tensorflow Extension API:**
-
-.. toctree::
-   :maxdepth: 1
-
-   tf_quantization_common.rst
-   tf_quantization_config.rst
-   tf_quantization_autotune.rst
-
 ** JAX Extension API:**
 
 .. toctree::
diff --git a/docs/source/api-doc/tf_quantization_autotune.rst b/docs/source/api-doc/tf_quantization_autotune.rst
deleted file mode 100644
index 241b7e42c77..00000000000
--- a/docs/source/api-doc/tf_quantization_autotune.rst
+++ /dev/null
@@ -1,6 +0,0 @@
-Tensorflow Quantization AutoTune
-============
-
-.. autoapisummary::
-
-   neural_compressor.tensorflow.quantization.autotune
diff --git a/docs/source/api-doc/tf_quantization_common.rst b/docs/source/api-doc/tf_quantization_common.rst
deleted file mode 100644
index 3b39d2c79cb..00000000000
--- a/docs/source/api-doc/tf_quantization_common.rst
+++ /dev/null
@@ -1,6 +0,0 @@
-Tensorflow Quantization Base API
-#################################
-
-.. autoapisummary::
-
-   neural_compressor.tensorflow.quantization.quantize
diff --git a/docs/source/api-doc/tf_quantization_config.rst b/docs/source/api-doc/tf_quantization_config.rst
deleted file mode 100644
index 4f5c757c31c..00000000000
--- a/docs/source/api-doc/tf_quantization_config.rst
+++ /dev/null
@@ -1,6 +0,0 @@
-Tensorflow Quantization Config
-============
-
-.. autoapisummary::
-
-   neural_compressor.tensorflow.quantization.config
diff --git a/docs/source/autotune.md b/docs/source/autotune.md
index 9a8884e0b74..4c7ed71dae1 100644
--- a/docs/source/autotune.md
+++ b/docs/source/autotune.md
@@ -4,8 +4,7 @@ AutoTune
 1. [Overview](#overview)
 2. [How it Works](#how-it-works)
 3. [Working with Autotune](#working-with-autotune) \
-    3.1 [Working with PyTorch Model](#working-with-pytorch-model) \
-    3.1 [Working with Tensorflow Model](#working-with-tensorflow-model)
+    3.1 [Working with PyTorch Model](#working-with-pytorch-model)
 
 
 ## Overview
@@ -63,28 +62,3 @@ tune_config = TuningConfig(
 )
 q_model = autotune(model, tune_config=tune_config, eval_fn=eval_fn)
 ```
-
-### Working with Tensorflow Model
-
-The example below demonstrates how to autotune a TensorFlow model on two `StaticQuantConfig` configurations.
-
-```python
-from neural_compressor.tensorflow.quantization import StaticQuantConfig, autotune
-
-calib_dataloader = MyDataloader(...)
-custom_tune_config = TuningConfig(
-    config_set=[
-        StaticQuantConfig(weight_sym=True, act_sym=True),
-        StaticQuantConfig(weight_sym=False, act_sym=False),
-    ]
-)
-
-
-def eval_fn(model) -> float:
-    return ...
-
-
-best_model = autotune(
-    model="baseline_model", tune_config=custom_tune_config, eval_fn=eval_fn, calib_dataloader=calib_dataloader
-)
-```
diff --git a/docs/source/coding_style.md b/docs/source/coding_style.md
index 18467b7936e..635e8fa3b86 100644
--- a/docs/source/coding_style.md
+++ b/docs/source/coding_style.md
@@ -64,8 +64,6 @@ logger.info("extraneous leading spaces.")
 ```python
 from neural_compressor.common import logger
 
-logger.info("Current TensorFlow Version is: %s", tf.__version__)  # Use a pattern-string (with %-placeholders)
-
 logger.info("Current $PAGER is: %s", os.getenv("PAGER", default=""))  # Better readability
 
 # Handle long string
@@ -84,8 +82,6 @@ logger.warning(
 - Not recommend
 
 ```python
-logger.info(f"Current TensorFlow Version is: {tf.__version__}")  # Use f-string
-
 logger.info("Current $PAGER is:")  # One sentence in two lines
 logger.info(os.getenv("PAGER", default=""))
 ```
@@ -104,8 +100,8 @@ eval_result: float = evaluator.eval(model)
 # Declare aliases of complex types
 from typing import TypeAlias
 
-_LossAndGradient: TypeAlias = tuple[tf.Tensor, tf.Tensor]
-ComplexTFMap: TypeAlias = Mapping[str, _LossAndGradient]
+_LossAndGradient: TypeAlias = tuple[float, float]
+LossAndGradientMap: TypeAlias = Mapping[str, _LossAndGradient]
 ```
 
 - Not recommend
diff --git a/docs/source/get_started.md b/docs/source/get_started.md
index 7e6943dbacf..e02fd066567 100644
--- a/docs/source/get_started.md
+++ b/docs/source/get_started.md
@@ -21,7 +21,7 @@ quantized_model = convert(model=prepared_model)
 ```
 
 ## Feature Matrix
-Intel Neural Compressor extends PyTorch, TensorFlow and JAX's APIs to support compression techniques.
+Intel Neural Compressor extends PyTorch and JAX's APIs to support compression techniques.
 The below table provides a quick overview of the APIs available in Intel Neural Compressor 3.X.
 The project mainly focuses on quantization-related features, especially for algorithms that benefit LLM accuracy and inference.
 It also provides some common modules across different frameworks. For example, Auto-tune support accuracy driven quantization and mixed precision, benchmark aimed to measure the multiple instances performance of the quantized model.
@@ -58,18 +58,6 @@ It also provides some common modules across different frameworks. For example, A
         <td colspan="2" align="center"><a href="PT_MixedPrecision.md">Mixed Precision</a></td>
     </tr>
   </tbody>
-  <thead>
-      <tr>
-        <th colspan="8">Tensorflow Extension APIs</th>
-      </tr>
-  </thead>
-  <tbody>
-      <tr>
-          <td colspan="3" align="center"><a href="TensorFlow.md">Overview</a></td>
-          <td colspan="3" align="center"><a href="TF_Quant.md">Static Quantization</a></td>
-          <td colspan="2" align="center"><a href="TF_SQ.md">Smooth Quantization</a></td>
-      </tr>
-  </tbody>
   <thead>
       <tr>
         <th colspan="8">Transformers-like APIs</th>
diff --git a/docs/source/imgs/bf16_convert_tf.png b/docs/source/imgs/bf16_convert_tf.png
deleted file mode 100644
index e876d414448d0ecadd61b8f48d8ded3e2148dcd1..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 206833
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
TPPgNsu8j=MPZgYW{Ox}LrOrzq

diff --git a/docs/source/installation_guide.md b/docs/source/installation_guide.md
index 78a6ba0904d..94a1ea04883 100644
--- a/docs/source/installation_guide.md
+++ b/docs/source/installation_guide.md
@@ -42,11 +42,10 @@ https://pytorch.org/get-started/locally
 ### Install from Binary
 - Install from Pypi
 ```Shell
-# Framework extension API for PyTorch/Tensorflow/JAX
+# Framework extension API for PyTorch/JAX
 pip install neural-compressor
 # Framework extension API + corresponding framework dependency
 pip install neural-compressor[pt]
-pip install neural-compressor[tf]
 pip install neural-compressor[jax]
 ```
 ```Shell
@@ -54,10 +53,6 @@ pip install neural-compressor[jax]
 pip install neural-compressor-pt
 ```
 ```Shell
-# Framework extension API + TensorFlow dependency
-pip install neural-compressor-tf
-```
-```Shell
 # Framework extension API + JAX dependency, available since v3.9
 pip install neural-compressor-jax
 ```
@@ -75,11 +70,6 @@ git fetch --tags && git checkout "$(git tag -l 'v*' --sort=-v:refname | head -n
 INC_PT_ONLY=1 pip install .
 ```
 
-```Shell
-# TensorFlow framework extension API + TensorFlow dependency
-INC_TF_ONLY=1 pip install .
-```
-
 ```Shell
 # JAX framework extension API + JAX dependency, available since v3.8
 INC_JAX_ONLY=1 pip install .
@@ -110,7 +100,6 @@ INC_JAX_ONLY=1 pip install .
 <thead>
   <tr style="vertical-align: middle; text-align: center;">
     <th>Framework</th>
-    <th>TensorFlow</th>
     <th>PyTorch</th>
     <th>JAX</th>
   </tr>
@@ -119,8 +108,6 @@ INC_JAX_ONLY=1 pip install .
   <tr align="center">
     <th>Version</th>
     <td class="tg-7zrl">
-    <a href=https://github.com/tensorflow/tensorflow/releases/tag/v2.19.0>2.19</a><br></td>
-    <td class="tg-7zrl">
     <a href=https://github.com/pytorch/pytorch/releases/tag/v2.12.0>2.12</a><br>
     <a href=https://github.com/pytorch/pytorch/releases/tag/v2.11.0>2.11</a><br>
     <a href=https://github.com/pytorch/pytorch/releases/tag/v2.10.0>2.10</a><br></td>
diff --git a/docs/source/quantization.md b/docs/source/quantization.md
index 2c8f9d1a999..4b59b7cb968 100644
--- a/docs/source/quantization.md
+++ b/docs/source/quantization.md
@@ -62,12 +62,6 @@ If UINT8 is specified, $Scale = max(abs(X_{f_{max}}), abs(X_{f_{min}})) / 255$ a
 Sometimes the reduce_range feature, that's using 7 bit width (1 sign bit + 6 data bits) to represent int8 range, may be needed on some early Xeon platforms, it's because those platforms may have overflow issues due to fp16 intermediate calculation result when executing int8 dot product operation. After AVX512_VNNI instruction is introduced, this issue gets solved by supporting fp32 intermediate data.
 
 
-#### Quantization Scheme in TensorFlow
-+ Symmetric Quantization
-    + int8: scale = 2 * max(abs(rmin), abs(rmax)) / (max(int8) - min(int8) - 1)
-    + uint8: scale = max(rmin, rmax) / (max(uint8) - min(uint8))
-
-
 #### Quantization Scheme in PyTorch
 + Symmetric Quantization
     + int8: scale = max(abs(rmin), abs(rmax)) / (float(max(int8) - min(int8)) / 2)
@@ -371,7 +365,7 @@ This tuning algorithm creates a tuning space by querying framework quantization
 
 Neural compressor also support to quantize all quantizable ops without accuracy tuning, using `quantize_model` interface to achieve that. 
 
-For supported quantization methods for `accuracy aware tuning` and the detailed API usage, please refer to the document of [PyTorch](PyTorch.md) or [TensorFlow](TensorFlow.md) respectively.
+For supported quantization methods for `accuracy aware tuning` and the detailed API usage, please refer to the documentation for [PyTorch](PyTorch.md) or [JAX](JAX.md).
 
 User could refer to below chart to understand the whole tuning flow.
 
diff --git a/docs/source/smooth_quant.md b/docs/source/smooth_quant.md
index 0bd837df464..e4cbaa9970b 100644
--- a/docs/source/smooth_quant.md
+++ b/docs/source/smooth_quant.md
@@ -300,7 +300,6 @@ In our experiments, an $\alpha$ range of [0.0, 1.0] with a step_size of 0.1 is f
 |:---------:|----------------|---------------------------|
 | PyTorch   | [0-1] / 'auto' | False                     |
 | IPEX      | [0-1] / 'auto' | True / False(Version>2.1) |
-| Tensorflow| [0-1]          | False                     |
 
 ## Reference
 
diff --git a/neural_compressor/common/base_config.py b/neural_compressor/common/base_config.py
index 0f8aee804a4..3d45170e596 100644
--- a/neural_compressor/common/base_config.py
+++ b/neural_compressor/common/base_config.py
@@ -626,7 +626,7 @@ def _op_type_to_str(op_type: Callable) -> str:
         Returns:
             str: String identifier for the operator type.
         """
-        # * Ort and TF may override this method.
+        # * Backend-specific subclasses may override this method.
         op_type_name = getattr(op_type, "__name__", "")
         if op_type_name == "":
             logger.warning("The op_type %s has no attribute __name__.", op_type)
@@ -642,7 +642,7 @@ def _is_op_type(name: str) -> bool:
         Returns:
             bool: True if the identifier is an operator type, otherwise False.
         """
-        # * Ort and TF may override this method.
+        # * Backend-specific subclasses may override this method.
         return not isinstance(name, str)
 
     @classmethod
diff --git a/neural_compressor/jax/utils/utility.py b/neural_compressor/jax/utils/utility.py
index f27c2db9678..b7fa9bccf57 100644
--- a/neural_compressor/jax/utils/utility.py
+++ b/neural_compressor/jax/utils/utility.py
@@ -85,7 +85,7 @@ def register_algo(name):
 
     Usage example:
         @register_algo(name=example_algo)
-        def example_algo(model: tf.keras.Model, quant_config: StaticQuantConfig) -> tf.keras.Model:
+        def example_algo(model: keras.Model, quant_config: StaticQuantConfig) -> keras.Model:
             ...
     Args:
         name (str): The name under which the algorithm function will be registered.
diff --git a/neural_compressor/tensorflow/__init__.py b/neural_compressor/tensorflow/__init__.py
deleted file mode 100644
index c40489b0bb0..00000000000
--- a/neural_compressor/tensorflow/__init__.py
+++ /dev/null
@@ -1,24 +0,0 @@
-# Copyright (c) 2023 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Intel Neural Compressor Tensorflow API."""
-
-from neural_compressor.tensorflow.utils import register_algo, Model
-from neural_compressor.tensorflow.quantization import (
-    autotune,
-    quantize_model,
-    StaticQuantConfig,
-    SmoothQuantConfig,
-    get_default_sq_config,
-    get_default_static_quant_config,
-)
diff --git a/neural_compressor/tensorflow/algorithms/__init__.py b/neural_compressor/tensorflow/algorithms/__init__.py
deleted file mode 100644
index 3373ec76ae7..00000000000
--- a/neural_compressor/tensorflow/algorithms/__init__.py
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright (c) 2023 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Initialize all algorithms."""
-
-from neural_compressor.tensorflow.algorithms.smoother import SmoothQuant
-from neural_compressor.tensorflow.algorithms.static_quant import KerasAdaptor, TensorFlowAdaptor, Tensorflow_ITEXAdaptor
diff --git a/neural_compressor/tensorflow/algorithms/smoother/__init__.py b/neural_compressor/tensorflow/algorithms/smoother/__init__.py
deleted file mode 100644
index 60f38f4cbdc..00000000000
--- a/neural_compressor/tensorflow/algorithms/smoother/__init__.py
+++ /dev/null
@@ -1,27 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Initialize classes of smooth quant algorithm."""
-
-from neural_compressor.tensorflow.algorithms.smoother.core import SmoothQuant
-from neural_compressor.tensorflow.algorithms.smoother.scaler import (
-    SmoothQuantScaler,
-    SmoothQuantScalerLLM,
-)
-from neural_compressor.tensorflow.algorithms.smoother.calibration import (
-    SmoothQuantCalibration,
-    SmoothQuantCalibrationLLM,
-)
diff --git a/neural_compressor/tensorflow/algorithms/smoother/calibration.py b/neural_compressor/tensorflow/algorithms/smoother/calibration.py
deleted file mode 100644
index 004bcdb27c0..00000000000
--- a/neural_compressor/tensorflow/algorithms/smoother/calibration.py
+++ /dev/null
@@ -1,505 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Tensorflow model calibration process for Smooth Quantization."""
-
-import copy
-import logging
-import os
-import tempfile
-import time
-from collections import OrderedDict, UserDict
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.core.framework import attr_value_pb2, graph_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-from tensorflow.python.saved_model import load, tag_constants
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper
-from neural_compressor.tensorflow.quantization.utils.utility import (
-    iterator_sess_run,
-    parse_saved_model,
-    reconstruct_saved_model,
-)
-from neural_compressor.tensorflow.utils import CaptureOutputToFile, TensorflowLLMModel
-
-logger = logging.getLogger("neural_compressor")
-debug = bool(logger.level == logging.DEBUG)
-
-
-class SmoothQuantCalibration:
-    """A class for performing smooth quantization calibration on a Tensorflow model.
-
-    Args:
-        model (Model): The Tensorflow wrapper model to be calibrated.
-        dataloader (DataLoader): The data loader for the calibration dataset.
-        iterations (int): The number of iterations to run the calibration process.
-        op_types (List[str]): The types of operations to be quantized.
-        percentile (float): The percentile of calibration to remove outliers.
-    """
-
-    def __init__(self, model, dataloader, iterations, op_types, percentile):
-        """Initializes a SmoothQuantCalibration object."""
-        self.model = model
-        self.dataloader = dataloader
-        self.iterations = iterations
-        # self.iterations = 3
-        self.op_types = op_types
-        self.percentile = percentile
-        self._sq_input_node_names = []
-        self._sq_output_tensor_dict = {}
-        self._sq_weight_node_names = {}  # mapping from its weight node name to the concrete output node name
-
-    def _inference_for_calibration(self, model):
-        """Run the calibration on the input graph.
-
-        Args:
-            model(TensorflowBaseModel): input TensorflowBaseModel
-        """
-        # ITEX optimization has broken INC calibration process.
-        # INC needs turn off ITEX optimization pass in calibration stage.
-        # TODO ITEX will provide API to replace setting environment variable.
-        os.environ["ITEX_REMAPPER"] = "0"
-        sess = model.sess
-        iter_op = model.iter_op
-        input_tensor = model.input_tensor
-        output_tensor = [item + ":0" for item in self._sq_input_node_names]
-        # TF table initialization: https://github.com/tensorflow/tensorflow/issues/8665
-        node_names = [node.name for node in sess.graph.as_graph_def().node]
-        if "init_all_tables" in node_names:  # pragma: no cover
-            init_table_op = sess.graph.get_operation_by_name("init_all_tables")
-            sess.run(init_table_op)
-
-        logger.info("Start sampling on calibration dataset for Smooth Quantization.")
-        if hasattr(self.dataloader, "__len__") and len(self.dataloader) == 0:  # pragma: no cover
-            feed_dict = {}
-            for output_idx, output in enumerate(
-                sess.run(output_tensor, feed_dict)
-                if iter_op == []
-                else iterator_sess_run(sess, iter_op, feed_dict, output_tensor, self.iterations)
-            ):
-                self._sq_output_tensor_dict.setdefault(self._sq_input_node_names[output_idx], []).append(output)
-        for idx, (inputs, labels) in enumerate(self.dataloader):
-            if len(input_tensor) == 1:
-                feed_dict = {}
-                if (
-                    isinstance(inputs, dict) or isinstance(inputs, OrderedDict) or isinstance(inputs, UserDict)
-                ):  # pragma: no cover
-                    for name in inputs:
-                        for tensor in input_tensor:
-                            pos = tensor.name.rfind(":")
-                            t_name = tensor.name if pos < 0 else tensor.name[:pos]
-                            if name == t_name:
-                                feed_dict[tensor] = inputs[name]
-                                break
-                else:
-                    feed_dict = {input_tensor[0]: inputs}  # get raw tensor using index [0]
-            else:  # pragma: no cover
-                assert len(input_tensor) == len(inputs), "inputs len must equal with input_tensor"
-                feed_dict = {}
-                if isinstance(inputs, dict) or isinstance(inputs, OrderedDict) or isinstance(inputs, UserDict):
-                    for name in inputs:
-                        for tensor in input_tensor:
-                            pos = tensor.name.rfind(":")
-                            t_name = tensor.name if pos < 0 else tensor.name[:pos]
-                            if name in [tensor.name, t_name]:
-                                feed_dict[tensor] = inputs[name]
-                                break
-                else:
-                    # sometimes the input_tensor is not the same order with inputs
-                    # we should check and pair them
-                    def check_shape(tensor, data):
-                        """Validate that a tensor shape matches the sample data."""
-                        # scalar or 1 dim default True
-                        if (
-                            tensor.shape is None
-                            or tensor.shape.dims is None
-                            or len(tensor.shape.dims) == 1
-                            or not hasattr(data, "shape")
-                        ):
-                            return True
-                        tensor_shape = tuple(tensor.shape)
-                        data_shape = tuple(data.shape)
-                        for tensor_dim, data_dim in zip(tensor_shape, data_shape):
-                            if tensor_dim is not None and tensor_dim != data_dim:
-                                return False
-                        return True
-
-                    disorder_tensors = []
-                    disorder_inputs = []
-                    for idx, sort_tensor in enumerate(input_tensor):
-                        sort_input = inputs[idx]
-                        if check_shape(sort_tensor, sort_input):
-                            feed_dict.update({sort_tensor: sort_input})
-                        else:
-                            disorder_tensors.append(sort_tensor)
-                            disorder_inputs.append(sort_input)
-                    for i, dis_tensor in enumerate(disorder_tensors):
-                        for j, dis_input in enumerate(disorder_inputs):
-                            if check_shape(dis_tensor, dis_input):
-                                feed_dict.update({dis_tensor: dis_input})
-                                break
-            for output_idx, output in enumerate(
-                sess.run(output_tensor, feed_dict)
-                if iter_op == []
-                else iterator_sess_run(sess, iter_op, feed_dict, output_tensor, self.iterations)
-            ):
-                self._sq_output_tensor_dict.setdefault(self._sq_input_node_names[output_idx], []).append(output)
-            if idx + 1 == self.iterations:
-                break
-        os.environ["ITEX_REMAPPER"] = "1"
-
-    def _generate_calibration_data(self):
-        """Generate the calibration data."""
-        sorted_graph = QuantizeGraphHelper().get_sorted_graph(
-            self.model.graph_def, self.model.input_node_names, self.model.output_node_names
-        )
-
-        for node in sorted_graph.node:
-            if node.op not in self.op_types:
-                continue
-            # Fix retval already been set issue
-            if "while" in node.input[0]:  # pragma: no cover
-                continue
-            self._sq_input_node_names.append(node.input[0])
-            self._sq_weight_node_names[node.input[1]] = node.name
-
-        self._inference_for_calibration(self.model)
-
-    def _get_maxval_per_channel(self, tensor_data, percentile):
-        """Get the max values per input channel.
-
-        Args:
-            tensor_data: The input tensors
-            percentile: The percentile of calibration to remove outliers
-
-        Returns:
-            The max values per input channel
-        """
-        permute_datas = []
-        for data in tensor_data:  # iteration_num * (N, H, W, C)
-            if len(data.shape) == 3:  # pragma: no cover
-                # TODO  matmul batchsize*seq*inchannel
-                tensor = np.abs(np.reshape(data, (-1, data.shape[-1])))
-                permute_datas.append(tensor)
-            elif len(data.shape) == 4:  # already NHWC
-                # tensor = np.transpose(data, [0, 3, 1, 2])
-                tensor = data
-                tensor = np.abs(np.reshape(tensor, (-1, tensor.shape[-1])))
-                permute_datas.append(tensor)
-            elif len(data.shape) == 2:  # (?, ic)
-                permute_datas.append(np.abs(data))
-            else:  # pragma: no cover
-                assert False, "not supported"
-        permute_datas = np.concatenate(permute_datas, axis=0)
-        permute_datas = permute_datas.reshape(-1, permute_datas.shape[-1])
-        # try:
-        #     np.percentile(permute_datas, percentile, axis=0)
-        # except FloatingPointError:
-        #     indexes = [i for i,e in enumerate(np.percentile(permute_datas, percentile, axis=0)) if np.isnan(e)][0]
-        #     np.seterr(all='warning')
-        max_per_channels = np.percentile(permute_datas, percentile, axis=0)
-        # max_per_channels = np.max(permute_datas, axis=0)
-        max_per_channels = max_per_channels.astype(np.single)
-        return max_per_channels
-
-    def __call__(self):
-        """Generates calibration data and calculate the maximum values per channel.
-
-        Returns:
-            max_vals_per_channel (dict): A dictionary containing the maximum values per channel.
-            sq_weight_node_names (dict): A dictionary mapping from weight names to target node names.
-        """
-        self._generate_calibration_data()
-        max_vals_per_channel = {}
-        for key in self._sq_output_tensor_dict.keys():
-            max_val_per_channel = self._get_maxval_per_channel(
-                self._sq_output_tensor_dict[key], percentile=self.percentile
-            )
-            max_vals_per_channel[key] = max_val_per_channel
-        return max_vals_per_channel, self._sq_weight_node_names
-
-
-class SmoothQuantCalibrationLLM(SmoothQuantCalibration):
-    """A class for performing smooth quantization calibration on a Tensorflow LLM model.
-
-    Args:
-        model (str): A path to the original Tensorflow model.
-        iterations (int): The number of iterations to run the calibration process.
-        op_types (List[str]): The types of operations to be quantized.
-        percentile (float): The percentile of calibration to remove outliers.
-        eval_func (function):  The function to inference the model.
-        temp_path (str): The temporary path to store median model.
-        weight_name_mapping (): A function that convert weight tensor name in autotrackable to node name in graph_def
-    """
-
-    def __init__(self, model_path, dataloader, iterations, op_types, percentile, temp_path, weight_name_mapping):
-        """Initializes a SmoothQuantCalibrationLLM object."""
-        self.func = None
-        self.graph_def = None
-        self.frozen_func = None
-        self._saved_model = None
-        self.model = model_path
-        self.dataloader = dataloader
-        self.iterations = iterations
-        self.op_types = op_types
-        self.percentile = percentile
-        self.temp_path = temp_path
-        self.weight_name_mapping = weight_name_mapping
-        self.print_node_list = []
-        self._sq_input_node_names = []
-        self._sq_target_node_names = {}
-        self._sq_output_tensor_dict = {}
-        self._sq_weight_tensor_dict = {}
-
-    def _parse_calibration_logs(self, tmp_dump_file):
-        """Parse calibration logs for llm saved_model."""
-        valid_data = []
-        with open(tmp_dump_file) as file:
-            for i in file.readlines():
-                if i.startswith(";"):
-                    valid_data.append(i.strip())
-
-        for activation in valid_data:
-            [key, value] = activation.rsplit(":")
-            activation_name = key[1:-9]
-            import json
-
-            value = value.replace(" ", ",")
-            value = value.replace("][", "],[")
-            data = json.loads(value)
-            if activation_name not in self._sq_output_tensor_dict:
-                self._sq_output_tensor_dict[activation_name] = [np.array(data)]
-            else:
-                self._sq_output_tensor_dict[activation_name].append(np.array(data))
-
-    def _insert_print_for_activation(self, graph_def):
-        """Insert print node in the graph to do the calibration for llm saved_model."""
-        cur_graph = GraphAnalyzer()
-        cur_graph.graph = graph_def
-
-        graph_info = cur_graph.parse_graph()
-        for cur_list in self.print_node_list:
-            pre_node_name = cur_list[0]
-            post_node_name = cur_list[-1]
-            insert_node_pairs = []
-            top_node = graph_info[pre_node_name].node
-            if top_node.op == "ConcatV2":
-                for i in range(top_node.attr["N"].i):
-                    insert_node_pairs.append([top_node.input[i], post_node_name])
-            elif top_node.op in ("BatchMatMul", "BatchMatMulV2"):
-                insert_node_pairs.append([top_node.input[0], post_node_name])
-                if graph_info[top_node.input[1]].node.op != "Const":
-                    insert_node_pairs.append([top_node.input[1], post_node_name])
-            elif top_node.op in ("Conv2DBackpropInput", "Conv3DBackpropInputV2"):
-                insert_node_pairs.append([top_node.input[2], post_node_name])
-            else:
-                refresh_pre_node_name = graph_info[pre_node_name].node.input[0]
-                # Check the Conv2D could be fused with previous Pad or not.
-                # If so, we need to update the pre-node name correspondingly.
-                refresh_pre_node = graph_info[Helper.node_name_from_input(refresh_pre_node_name)].node
-                if refresh_pre_node.op == "Pad" and top_node.op in ("Conv2D", "Conv3D"):
-                    insert_node_pairs.append([refresh_pre_node_name, post_node_name])
-                    refresh_pre_node_name = refresh_pre_node.input[0]
-
-                insert_node_pairs.append([refresh_pre_node_name, post_node_name])
-
-            output_names = []
-            for node_pair_names in insert_node_pairs:
-                for index, each_node_name in enumerate(node_pair_names):
-                    name_with_sig = each_node_name
-                    node_name_prefix = name_with_sig.replace(":", "__port__").replace("^", "__hat__")
-                    print_node = Helper.create_node(
-                        "Print",
-                        node_name_prefix + "_print__{}".format(index),
-                        [each_node_name + ":0", each_node_name + ":0"],
-                    )
-
-                    if index == 0:
-                        msg = ";{}__print__:".format(each_node_name)
-                        # workaround for swish_f32, attribute T is not in the op definition
-                        if "swish_f32" in graph_info[pre_node_name].node.name:
-                            src_dt = attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum)
-                        else:
-                            src_dt = graph_info[pre_node_name].node.attr["T"]
-                    else:
-                        break
-
-                    print_node.attr["T"].CopyFrom(src_dt)
-
-                    print_node.attr["message"].s = msg.encode()
-                    print_node.attr["first_n"].i = -1
-                    print_node.attr["summarize"].i = 102400000
-
-                    attr_u = [dtypes.as_dtype(src_dt.type).as_datatype_enum]
-                    print_node.attr["U"].list.CopyFrom(attr_value_pb2.AttrValue.ListValue(type=attr_u))
-                    post_node_names = graph_info[Helper.node_name_from_input(each_node_name)].outputs
-                    if post_node_names:
-                        for post_node_name in post_node_names:
-                            post_node = graph_info[post_node_name].node
-                            if each_node_name not in post_node.input:
-                                continue
-                            if (
-                                post_node.op == "FusedBatchNormV3"
-                                and "_print_identity"
-                                not in graph_info[Helper.node_name_from_input(post_node.name)].node.input[0]
-                            ):
-                                identity_node = Helper.create_node(
-                                    "Identity",
-                                    post_node.name + "_print_identity",
-                                    [graph_info[Helper.node_name_from_input(post_node.name)].node.input[0]],
-                                )
-                                identity_node.attr["T"].CopyFrom(src_dt)
-                                cur_graph.add_node(
-                                    identity_node,
-                                    graph_info[Helper.node_name_from_input(post_node.name)].node.input[0],
-                                    [post_node.name],
-                                )
-                                identity_node.input.append("^" + print_node.name)
-                            else:
-                                post_node.input.append("^" + print_node.name)
-
-                        cur_graph.add_node(print_node, each_node_name, [])
-                    else:
-                        identity_node1 = Helper.create_node(
-                            "Identity", print_node.name + "_identity", [print_node.name]
-                        )
-                        identity_node1.attr["T"].CopyFrom(src_dt)
-                        cur_graph.add_node(print_node, each_node_name, [identity_node1.name])
-                        cur_graph.add_node(identity_node1, print_node.name, [])
-                        output_names.append(identity_node1.name)
-
-        return cur_graph.dump_graph()
-
-    def evaluate(self, model):
-        """Evaluate function that inference the model to apply calibration.
-
-        Args:
-            model (tf.python.trackable.autotrackable): The model to be evaluated.
-            The object is usually gotten by using tf.saved_model.load(model_dir) API.
-
-        Returns:
-            accuracy (float): The accuracy result.
-        """
-        input_tensor_names = model.input_tensor_names
-        auto_trackable = model.model
-        infer = auto_trackable.signatures["serving_default"]
-        for idx, (inputs, _) in enumerate(self.dataloader):
-            feed_dict = {}
-            if len(input_tensor_names) == 1:
-                feed_dict[input_tensor_names[0]] = inputs
-            else:
-                assert len(input_tensor_names) == len(inputs), "inputs len must equal with input_tensor"
-                for i, input_tensor_name in enumerate(input_tensor_names):
-                    feed_dict[input_tensor_name] = inputs[i]
-
-            _ = infer(**feed_dict)
-
-            if idx >= self.iterations:
-                break
-
-    def _inference(self, sampling_graph_def):
-        """Inference the model to apply calibration.
-
-        Args:
-            sampling_graph_def: The temporary graph_def for inference.
-        """
-        logger.info("Start sampling on calibration dataset for Smooth Quantization.")
-        # reconstruct graph_def that inserted print node to saved_model
-        reconstruct_saved_model(sampling_graph_def, self.func, self.frozen_func, self._saved_model, self.temp_path)
-        model = TensorflowLLMModel(self.temp_path)
-
-        input_tensor_names = model.input_tensor_names
-        auto_trackable = model.model
-        infer = auto_trackable.signatures["serving_default"]
-        for idx, (inputs, _) in enumerate(self.dataloader):
-            feed_dict = {}
-            if len(input_tensor_names) == 1:
-                feed_dict[input_tensor_names[0]] = inputs
-            else:
-                assert len(input_tensor_names) == len(inputs), "inputs len must equal with input_tensor"
-                for i, input_tensor_name in enumerate(input_tensor_names):
-                    feed_dict[input_tensor_name] = inputs[i]
-
-            _ = infer(**feed_dict)
-
-            if idx >= self.iterations:
-                break
-
-    def _inference_for_calibration(self, model):
-        """Run the calibration on the input graph."""
-        sampling_graph_def = self._insert_print_for_activation(model)
-        tmp_dump_file = tempfile.mkstemp(suffix=".log")[1]
-        with CaptureOutputToFile(tmp_dump_file):
-            self._inference(sampling_graph_def)
-        self._parse_calibration_logs(tmp_dump_file)
-        del sampling_graph_def
-
-    def _get_weight_tensors(self):
-        """Load and cache weight tensors needed for smooth quantization."""
-        model = load.load(self.model, [tag_constants.SERVING])
-        for weight_tensor in model.variables:
-            parsed_name = self.weight_name_mapping(weight_tensor.name)
-            if parsed_name in self._sq_target_node_names:
-                self._sq_weight_tensor_dict[parsed_name] = weight_tensor.numpy()
-
-        assert len(self._sq_weight_tensor_dict) == len(
-            self._sq_target_node_names
-        ), "Failed to get weights for some nodes, please check variables"
-
-    def _generate_calibration_data(self, input_node_names, output_node_names):
-        """Generate the calibration data."""
-        sorted_graph = QuantizeGraphHelper().get_sorted_graph(
-            self.graph_def,
-            input_node_names,
-            output_node_names,
-        )
-
-        for node in sorted_graph.node:
-            if node.op not in self.op_types:
-                continue
-            # Fix retval already been set issue
-            if "while" in node.input[0]:  # pragma: no cover
-                continue
-            self._sq_input_node_names.append(node.input[0])
-            self.print_node_list.append([node.name])
-            self._sq_target_node_names[node.input[1]] = node.name
-        self._get_weight_tensors()
-        sampling_graph_def = copy.deepcopy(self.graph_def)
-        self._inference_for_calibration(sampling_graph_def)
-
-    def __call__(self, input_node_names, output_node_names):
-        """Generates calibration data and calculate the maximum values per channel.
-
-        Args:
-            input_node_names: (list): A list of names for input nodes.
-            output_node_names: (list): A list of names for output nodes.
-
-        Returns:
-            max_vals_per_channel (dict): A dictionary containing the maximum values per channel.
-            sq_target_node_names (dict): A dictionary mapping from weight names to target node names.
-            sq_weight_tensor_dict (dict): A dictionary containing tensor of weights.
-        """
-        self.graph_def, self._saved_model, self.func, self.frozen_func, _, _ = parse_saved_model(self.model)
-        self._generate_calibration_data(input_node_names, output_node_names)
-        max_vals_per_channel = {}
-        for activation_name, output_tensor in self._sq_output_tensor_dict.items():
-            max_val_per_channel = self._get_maxval_per_channel(output_tensor, percentile=self.percentile)
-            max_vals_per_channel[activation_name] = max_val_per_channel
-        return max_vals_per_channel, self._sq_target_node_names, self._sq_weight_tensor_dict, self.graph_def
diff --git a/neural_compressor/tensorflow/algorithms/smoother/core.py b/neural_compressor/tensorflow/algorithms/smoother/core.py
deleted file mode 100644
index 64efd596c04..00000000000
--- a/neural_compressor/tensorflow/algorithms/smoother/core.py
+++ /dev/null
@@ -1,196 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""The core components of sq."""
-
-from typing import Callable, Dict
-
-import tensorflow as tf
-
-from neural_compressor.common import logger
-from neural_compressor.common.utils import DEFAULT_WORKSPACE
-from neural_compressor.tensorflow.algorithms.smoother.calibration import (
-    SmoothQuantCalibration,
-    SmoothQuantCalibrationLLM,
-)
-from neural_compressor.tensorflow.algorithms.smoother.scaler import SmoothQuantScaler, SmoothQuantScalerLLM
-from neural_compressor.tensorflow.quantization.config import SmoothQuantConfig
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.utils import SPR_BASE_VERSIONS, BaseModel, TensorflowLLMModel, TFConfig
-
-
-class SmoothQuant:
-    """The class that performs smooth quantization."""
-
-    def __init__(
-        self,
-        config: SmoothQuantConfig,
-        calib_dataloader: Callable = None,
-        calib_iteration: int = 1,
-        calib_func: Callable = None,
-    ):
-        """Convert the model by smooth quant.
-
-        Args:
-            config: the SmoothQuantConfig class used to set this class.
-            calibdataloader: the calibration dataloader.
-            calib_iteration: how many steps of iterations on the dataloader to move forward.
-            calib_func: the function used for calibration, should be a substitution for calib_dataloader
-            when the built-in calibration function of INC does not work for model inference.
-
-        Returns:
-            model: A smoothed Tensorflow model
-        """
-        assert calib_func is None, "calibration function is not supported for smooth quant."
-        self.config = config
-        self.calib_dataloader = calib_dataloader
-        self.calib_iteration = calib_iteration
-
-        self.new_api = tf.version.VERSION in SPR_BASE_VERSIONS
-        self.device = TFConfig.global_config["device"]
-        self.itex_mode = TFConfig.global_config["backend"] == "itex"
-
-        for _, value in self.config.items():
-            single_config = value
-            break
-
-        self.alpha = single_config.alpha
-        self.folding = single_config.folding
-        self.percentile = single_config.percentile
-        self.op_types = single_config.op_types
-        self.scales_per_op = single_config.scales_per_op
-        self.record_max_info = single_config.record_max_info
-        self.weight_clip = single_config.weight_clip
-        self.auto_alpha_args = single_config.auto_alpha_args
-
-    def get_weight_from_input_tensor(self, model, input_tensor_names):
-        """Extracts weight tensors and their associated nodes from a smooth quant node's input tensor.
-
-        Args:
-            model: A TensorFlow model containing a `graph_def` attribute.
-            input_tensor_names: A list of input tensor names to search for weight tensors.
-
-        Returns:
-            A tuple of two dictionaries:
-            - sq_weight_tensors: A dictionary mapping each input tensor name
-                to a dict of its associated weight tensors with weight name.
-            - sq_weights_nodes: A dictionary mapping each input tensor name
-                to a dict of its associated weight nodes with weight name.
-        """
-        g_analyzer = GraphAnalyzer()
-        g_analyzer.graph = model.graph_def
-        graph_info = g_analyzer.parse_graph()
-
-        sq_weight_tensors = {}
-        sq_weights_nodes = {}
-
-        from tensorflow.python.framework import tensor_util
-
-        for name in input_tensor_names:
-            # Use dict rather than list to fix the QKV/VQK misorder issue
-            curr_weight_tensors = {}
-            curr_weights_nodes = {}
-            next_node_names = graph_info[name].outputs
-            for node_name in next_node_names:
-                curr_node = graph_info[node_name].node
-                if curr_node.op not in self.op_types:
-                    continue
-                if len(curr_node.input) >= 2:
-                    weight_name = curr_node.input[1]
-                    weight_node = graph_info[weight_name].node
-                    weight_tensor = tensor_util.MakeNdarray(weight_node.attr["value"].tensor)
-                    curr_weight_tensors[weight_name] = weight_tensor
-                    curr_weights_nodes[weight_name] = weight_node
-            # {input node -> {xxx_q_proj_matmul: value1, xxx_v_proj_matmul: value2, ...}, ...}
-            sq_weight_tensors[name] = curr_weight_tensors
-            sq_weights_nodes[name] = curr_weights_nodes
-        return sq_weight_tensors, sq_weights_nodes
-
-    def apply_smooth_quant(self, model: BaseModel):
-        """Apply smooth quant to the model."""
-        logger.info("Start Smoothing process for Smooth Quantization.")
-
-        # Do a pre-optimization before smooth quant
-        from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.pre_optimize import PreOptimization
-
-        pre_optimizer_handle = PreOptimization(model, self.new_api, self.device)
-        pre_optimized_model = pre_optimizer_handle.get_optimized_model(self.itex_mode)
-        model.graph_def = pre_optimized_model.graph_def
-
-        # Run calibration to get max values per channel
-
-        calibration = SmoothQuantCalibration(
-            model, self.calib_dataloader, self.calib_iteration, self.op_types, self.percentile
-        )
-        max_vals_per_channel, sq_weight_node_names = calibration()
-
-        # Get weight tensors and weight nodes based on the input tensor
-        sq_weight_tensors, sq_weights_nodes = self.get_weight_from_input_tensor(model, max_vals_per_channel.keys())
-
-        # Calculate the smooth quant scaler and insert Mul op into the graph
-        scaler = SmoothQuantScaler(model, self.calib_dataloader, self.alpha, self.scales_per_op)
-        model, mul_list = scaler.transform(
-            max_vals_per_channel, sq_weight_tensors, sq_weights_nodes, sq_weight_node_names
-        )
-
-        return model
-
-    def apply_smooth_quant_LLM(self, model: BaseModel):
-        """Apply smooth quant to the LLM model."""
-        # Do a pre-optimization before smooth quant
-        from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.pre_optimize import PreOptimization
-
-        pre_optimizer_handle = PreOptimization(model, self.new_api, self.device)
-        pre_optimized_model = pre_optimizer_handle.get_optimized_model(self.itex_mode)
-        model.graph_def = pre_optimized_model.graph_def
-
-        llm_temp_dir = DEFAULT_WORKSPACE + "/temp_saved_model"
-        # Run calibration to get max values per channel
-        calibration = SmoothQuantCalibrationLLM(
-            model._model,
-            self.calib_dataloader,
-            self.calib_iteration,
-            self.op_types,
-            self.percentile,
-            llm_temp_dir,
-            model.weight_name_mapping,
-        )
-        max_vals_per_channel, sq_target_node_names, sq_weight_tensor_dict, sq_graph_def = calibration(
-            model.input_node_names, model.output_node_names
-        )
-
-        # Calculate the smooth quant scaler and insert Mul op into the graph
-        scaler = SmoothQuantScalerLLM(sq_graph_def, self.alpha, self.scales_per_op, self.op_types)
-        sq_graph_def, sq_weight_scale_dict, mul_list = scaler.transform(
-            max_vals_per_channel, sq_weight_tensor_dict, sq_target_node_names
-        )
-        model.graph_def = sq_graph_def
-        model.model_path = llm_temp_dir
-        model.sq_weight_scale_dict = sq_weight_scale_dict
-        return model
-
-    def __call__(self, model: BaseModel):
-        """Convert the model by smooth quant.
-
-        Args:
-            model: original model
-
-        Returns:
-            model: A smoothed Tensorflow model
-        """
-        apply_func = self.apply_smooth_quant_LLM if isinstance(model, TensorflowLLMModel) else self.apply_smooth_quant
-
-        return apply_func(model)
diff --git a/neural_compressor/tensorflow/algorithms/smoother/scaler.py b/neural_compressor/tensorflow/algorithms/smoother/scaler.py
deleted file mode 100644
index 839c5e2332a..00000000000
--- a/neural_compressor/tensorflow/algorithms/smoother/scaler.py
+++ /dev/null
@@ -1,268 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Tensorflow scaling model weights and activations for Smooth Quantization."""
-
-import logging
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-
-logger = logging.getLogger("neural_compressor")
-
-
-class SmoothQuantScaler:
-    """A class for scaling model weights using Smooth Quantization method.
-
-    Args:
-        model: Tensorflow model to be scaled
-        dataloader: Tensorflow dataloader for the dataset
-        alpha: float, the scaling factor
-        scales_per_op: bool, each op will have an individual scale or
-                       ops with the same input will share a scale
-    """
-
-    def __init__(self, model, dataloader, alpha, scales_per_op):
-        """Initialization."""
-        self.model = model
-        self.dataloader = dataloader
-        self.alpha = alpha
-        self.scales_per_op = scales_per_op
-        self.mul_list = []
-        self.g_analyzer = GraphAnalyzer()
-        self.g_analyzer.graph = self.model
-
-    def _adjust_activation(self, scale, input_node_name, output_node_name, w_i):
-        """Insert the Mul node after the activation before the weight node.
-
-        Args:
-            scale: smooth scale with the shape (ic,)
-            input_node_name: the parent input node
-            output_node_name: the concrete output weight node name
-            w_i: distinguish between different output weight nodes on different branches when naming
-        """
-        from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-
-        node_suffix = str(w_i)
-        mul_const_node = Helper.create_constant_node(input_node_name + "/scale_mul" + node_suffix, scale, tf.float32)
-        mul_node = Helper.create_node(
-            "Mul",
-            input_node_name + "_mul" + node_suffix,
-            [input_node_name + "/scale_mul" + node_suffix, input_node_name],
-        )
-        Helper.set_attr_dtype(mul_node, "T", dtypes.float32)
-        self.mul_list.append(mul_node.name)
-        self.g_analyzer.add_node(mul_node, input_node_name, [output_node_name])
-        self.g_analyzer.add_node(mul_const_node, None, [input_node_name + "_mul" + node_suffix])
-
-    def _adjust_weight(self, scale, weight_node, original_weight):
-        """In-place adjust weight by scale.
-
-        Args:
-            scale: smooth scale with the shape (ic,)
-            weight_node: reference to the original const weight node
-            original_weight: numpy value of the original const weight node
-        """
-        # scale: (ic,)
-        original_shape = original_weight.shape
-        if len(original_shape) == 4:  # (fh, hw, ic, oc)
-            W = np.transpose(original_weight, [0, 1, 3, 2])  # move input channel to last dimension
-            W *= scale
-            W = np.transpose(W, [0, 1, 3, 2])  # move input channel back
-            weight_node.attr["value"].tensor.CopyFrom(tensor_util.make_tensor_proto(W))
-        elif len(original_shape) == 2:  # (ic, oc) if transpose_a == transpose_b == false
-            W = np.transpose(original_weight, [1, 0])
-            W *= scale
-            W = np.transpose(W, [1, 0])
-            weight_node.attr["value"].tensor.CopyFrom(tensor_util.make_tensor_proto(W))
-
-    def transform(self, max_vals_per_channel, sq_weight_tensors, sq_weights_nodes, sq_weight_node_names):
-        """Apply scaling to weights and activations based on the maximum values per channel.
-
-        Args:
-            max_vals_per_channel (dict): A dictionary containing the maximum values per channel for each input node.
-            sq_weight_tensors (dict): A dictionary containing the name -> weight tensors mapping for each input node.
-            sq_weights_nodes (dict): A dictionary containing the name -> constant nodes mapping for each input node.
-            sq_weight_node_names (dict): A dictionary from weight node name to the its concrete output node name.
-
-        Returns:
-            tuple: A tuple containing the modified model and a list of the inserted multiplication nodes.
-        """
-        logger.info("Start scaling on model graph for Smooth Quantization.")
-        if self.scales_per_op:
-            # 1. obtain the smooth scale per op
-            # 2. adjust weight
-            # 3. adjust activation
-            for idx, input_node_name in enumerate(max_vals_per_channel):
-                A_max_per_in_channel = max_vals_per_channel[input_node_name]
-                W_dict = sq_weight_tensors[input_node_name]
-                # Use the const nodes before to get weight values
-                W_const_node_dict = sq_weights_nodes[input_node_name]
-                # Get the concrete weight node as the output of Mul insertion
-                for w_i, W_name in enumerate(W_dict):
-                    W = W_dict[W_name]
-                    if len(W.shape) == 4:
-                        # https://www.tensorflow.org/api_docs/python/tf/nn/conv2d
-                        # weight: [filter_height, filter_width, in_channels, out_channels]
-                        # activation: NHWC, also batch_shape + [in_height, in_width, in_channels]
-                        tensor = np.abs(np.transpose(W, [0, 1, 3, 2]))
-                        # reduce weight max to (in_channel, ), aligned with activation max
-                        W_max_per_in_channel = np.max(np.reshape(tensor, (-1, tensor.shape[-1])), axis=0)
-                    elif len(W.shape) == 2:  # matmul
-                        # reduce weight max to (in_channel, ), aligned with activation max
-                        tensor = np.abs(W)
-                        W_max_per_in_channel = np.max(tensor, axis=1)
-                    else:  # pragma: no cover
-                        assert False, "not supported"
-                    cur_const_node = W_const_node_dict[W_name]
-                    try:
-                        scale = np.power(A_max_per_in_channel, self.alpha) / np.power(
-                            W_max_per_in_channel, (1 - self.alpha)
-                        )
-                    except ValueError as e:  # pragma: no cover
-                        logger.info(e)
-                        logger.info("Skip smoothing the node: {}".format(cur_const_node.name))
-                        continue
-                    # clip the scales that are too small
-                    scale = np.clip(scale, a_min=1e-5, a_max=1e8)
-                    # skip smoothing the op where scale has elements that less than 1
-                    # if np.any(scale < 1):
-                    #     logger.info("skip smooth quant: {}".format(input_node_name))
-                    #     continue
-                    self._adjust_weight(scale, cur_const_node, W)
-                    self._adjust_activation(1 / scale, input_node_name, sq_weight_node_names[cur_const_node.name], w_i)
-        else:
-            pass
-        sq_graph_def = self.g_analyzer.dump_graph()
-        sq_graph_def.library.CopyFrom(self.model.graph_def.library)
-        self.model.graph_def = sq_graph_def
-        return self.model, self.mul_list
-
-
-class SmoothQuantScalerLLM(SmoothQuantScaler):
-    """A class for scaling model weights for TF LLM models using Smooth Quantization method.
-
-    Args:
-        graph_def: graph_def of the model to be scaled
-        alpha: float, the scaling factor
-        scales_per_op: bool, each op will have an individual scale or
-                       ops with the same input will share a scale
-        op_types:
-    """
-
-    def __init__(self, graph_def, alpha, scales_per_op, op_types):
-        """Initialization."""
-        self.graph_def = graph_def
-        self.alpha = alpha
-        self.scales_per_op = scales_per_op
-        self.op_types = op_types
-
-        self.graph_info = None
-        self.mul_list = []
-        self.sq_weight_scale_dict = {}
-
-    def _parse_weight_dict(self, max_vals_per_channel, sq_weight_tensor_dict):
-        """Parse weight related dictionaries to two required dictionaries.
-
-        Args:
-            max_vals_per_channel (dict): A dictionary containing the maximum values per channel.
-            sq_weight_tensor_dict (dict): A dictionary containing tensor of weights.
-
-        Returns:
-            sq_weight_tensors: A dictionary whose structure is like {input_node_name: weight_tensor}}.
-            sq_weights_node_names: A dictionary whose structure is like {input_node_name: weight_node_name}}.
-        """
-        sq_weight_tensors = {}
-        sq_weight_node_names = {}
-        for input_node_name in max_vals_per_channel:
-            curr_weight_tensors = []
-            curr_weights_node_names = []
-            next_node_names = self.graph_info[input_node_name].outputs
-            for node_name in next_node_names:
-                curr_node = self.graph_info[node_name].node
-                if curr_node.op not in self.op_types:
-                    continue
-                if len(curr_node.input) >= 2:
-                    weight_name = curr_node.input[1]
-                    weight_tensor = sq_weight_tensor_dict[weight_name]
-                    curr_weight_tensors.append(weight_tensor)
-                    curr_weights_node_names.append(weight_name)
-            sq_weight_tensors[input_node_name] = curr_weight_tensors
-            sq_weight_node_names[input_node_name] = curr_weights_node_names
-        return sq_weight_tensors, sq_weight_node_names
-
-    def transform(self, max_vals_per_channel, sq_weight_tensor_dict, sq_target_node_names):
-        """Apply scaling to weights and activations based on the maximum values per channel.
-
-        Args:
-            max_vals_per_channel (dict): A dictionary containing the maximum values per channel for each input node.
-            sq_weight_tensor_dict (dict): A dictionary whose structure is like {input_node_name: weight_tensor}.
-            sq_target_node_names (dict): A dictionary whose structure is like {weight_node_name: target_node_name}.
-        """
-        self.g_analyzer = GraphAnalyzer()
-        self.g_analyzer.graph = self.graph_def
-        self.graph_info = self.g_analyzer.parse_graph()
-        sq_weight_tensors, sq_weight_node_names = self._parse_weight_dict(max_vals_per_channel, sq_weight_tensor_dict)
-        logger.info("Start scaling on model graph for Smooth Quantization.")
-        if self.scales_per_op:
-            # 1. obtain the smooth scale per op
-            # 2. adjust weight
-            # 3. adjust activation
-            for _, input_node_name in enumerate(max_vals_per_channel):
-                activation_max_per_in_channel = max_vals_per_channel[input_node_name]
-                W_lst = sq_weight_tensors[input_node_name]  # VQK weight value
-                # Use the const nodes before to get weight values, VQK ReadVariable
-                W_node_name_lst = sq_weight_node_names[input_node_name]
-                # Get the concrete weight node as the output of Mul insertion, QKV ReadVariable
-                for w_i, W in enumerate(W_lst):
-                    if len(W.shape) == 4:
-                        # https://www.tensorflow.org/api_docs/python/tf/nn/conv2d
-                        # weight: [filter_height, filter_width, in_channels, out_channels]
-                        # activation: NHWC, also batch_shape + [in_height, in_width, in_channels]
-                        tensor = np.abs(np.transpose(W, [0, 1, 3, 2]))
-                        # reduce weight max to (in_channel, ), aligned with activation max
-                        W_max_per_in_channel = np.max(np.reshape(tensor, (-1, tensor.shape[-1])), axis=0)
-                    elif len(W.shape) == 2:  # matmul
-                        # reduce weight max to (in_channel, ), aligned with activation max
-                        tensor = np.abs(W)
-                        W_max_per_in_channel = np.max(tensor, axis=1)
-                    else:  # pragma: no cover
-                        assert False, "not supported"
-                    cur_weight_node_name = W_node_name_lst[w_i]
-                    try:
-                        scale = np.power(activation_max_per_in_channel, self.alpha) / np.power(
-                            W_max_per_in_channel, (1 - self.alpha)
-                        )
-                    except ValueError as e:  # pragma: no cover
-                        logger.info(e)
-                        logger.info("Skip smoothing the node: {}".format(cur_weight_node_name))
-                        continue
-                    # clip the scales that are too small
-                    scale = np.clip(scale, a_min=1e-5, a_max=1e8)
-                    # skip smoothing the op where scale has elements that less than 1
-                    # if np.any(scale < 1):
-                    #     logger.info("skip smooth quant: {}".format(input_node_name))
-                    #     continue
-                    self.sq_weight_scale_dict[cur_weight_node_name] = scale
-                    self._adjust_activation(1 / scale, input_node_name, sq_target_node_names[cur_weight_node_name], w_i)
-        else:
-            pass
-        sq_graph_def = self.g_analyzer.dump_graph()
-        sq_graph_def.library.CopyFrom(self.graph_def.library)
-        return sq_graph_def, self.sq_weight_scale_dict, self.mul_list
diff --git a/neural_compressor/tensorflow/algorithms/static_quant/__init__.py b/neural_compressor/tensorflow/algorithms/static_quant/__init__.py
deleted file mode 100644
index 50d953411fb..00000000000
--- a/neural_compressor/tensorflow/algorithms/static_quant/__init__.py
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright (c) 2023 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Initialize classes of static quant algorithm."""
-
-from neural_compressor.tensorflow.algorithms.static_quant.keras import KerasAdaptor
-from neural_compressor.tensorflow.algorithms.static_quant.tensorflow import TensorFlowAdaptor, Tensorflow_ITEXAdaptor
diff --git a/neural_compressor/tensorflow/algorithms/static_quant/keras.py b/neural_compressor/tensorflow/algorithms/static_quant/keras.py
deleted file mode 100644
index f844ca038e4..00000000000
--- a/neural_compressor/tensorflow/algorithms/static_quant/keras.py
+++ /dev/null
@@ -1,788 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""The quantization classes for Keras."""
-
-import copy
-import json
-import os
-from collections import OrderedDict, UserDict
-from typing import Callable, Dict
-
-import numpy as np
-import tensorflow as tf
-import yaml
-
-from neural_compressor.common import logger
-from neural_compressor.common.utils import DEFAULT_WORKSPACE
-from neural_compressor.tensorflow.keras.layers import (
-    QAvgPool2D,
-    QConv2D,
-    QDense,
-    QDepthwiseConv2D,
-    QMaxPool2D,
-    QSeparableConv2D,
-)
-from neural_compressor.tensorflow.quantization.config import StaticQuantConfig
-from neural_compressor.tensorflow.utils import deep_get, dump_elapsed_time, version1_gte_version2
-
-
-class KerasAdaptor:
-    """The keras class of framework adaptor layer."""
-
-    supported_op = [
-        "Conv2D",
-        "Dense",
-        "SeparableConv2D",
-        "DepthwiseConv2D",
-        "AveragePooling2D",
-        "MaxPooling2D",
-        "AvgPool2D",
-        "MaxPool2D",
-    ]
-
-    custom_layers = {
-        "QConv2D": QConv2D,
-        "QDepthwiseConv2D": QDepthwiseConv2D,
-        "QSeparableConv2D": QSeparableConv2D,
-        "QDense": QDense,
-        "QMaxPool2D": QMaxPool2D,
-        "QAvgPool2D": QAvgPool2D,
-        "QMaxPooling2D": QMaxPool2D,
-        "QAveragePooling2D": QAvgPool2D,
-    }
-
-    def __init__(self, framework_specific_info):
-        """Initialize the KerasAdaptor class with framework specific information."""
-        self.framework_specific_info = framework_specific_info
-        self.approach = deep_get(self.framework_specific_info, "approach", False)
-        self.quantize_config = {"op_wise_config": {}}
-        self.device = self.framework_specific_info["device"]
-        self.backend = self.framework_specific_info["backend"]
-        self.recipes = deep_get(self.framework_specific_info, "recipes", {})
-
-        self.pre_optimized_model = None
-        self.pre_optimizer_handle = None
-        self.bf16_ops = []
-        self.fp32_ops = []
-        self.query_handler = KerasQuery(local_config_file=os.path.join(os.path.dirname(__file__), "keras.yaml"))
-
-        self.fp32_results = []
-        self.fp32_preds_as_label = False
-        self.callbacks = []
-
-        self.conv_format = {}
-        self.fold_conv = []
-        self.keras3 = True if version1_gte_version2(tf.__version__, "2.16.1") else False
-        if not os.path.exists(DEFAULT_WORKSPACE):
-            os.makedirs(DEFAULT_WORKSPACE)
-        self.tmp_dir = (DEFAULT_WORKSPACE + "tmp_model.keras") if self.keras3 else (DEFAULT_WORKSPACE + "tmp_model")
-
-    def _set_weights(self, qmodel, layer_weights):
-        """Set fp32 weights to qmodel."""
-        for qlayer in qmodel.layers:
-            if qlayer.get_weights():
-                if qlayer.name in layer_weights:
-                    qlayer.set_weights(layer_weights[qlayer.name])
-                else:  # pragma: no cover
-                    hit_layer = False
-                    for sub_layer in qlayer.submodules:
-                        if sub_layer.name in layer_weights:
-                            qlayer.set_weights(layer_weights[sub_layer.name])
-                            hit_layer = True
-                            break
-                    if not hit_layer:
-                        raise ValueError("Can not match the module weights....")
-        return qmodel
-
-    def _check_quantize_format(self, model):
-        """The function that checks format for conv ops."""
-        input_layer_dict = {}
-        layer_name_mapping = {}
-
-        for layer in model.layers:
-            layer_name_mapping[layer.name] = layer
-            for node in layer._outbound_nodes:
-                layer_name = node.operation.name if self.keras3 else node.outbound_layer.name
-                if layer_name not in input_layer_dict:
-                    input_layer_dict[layer_name] = [layer.name]
-                else:
-                    input_layer_dict[layer_name].append(layer.name)
-
-        for layer in model.layers:
-            if layer.__class__.__name__ in self.supported_op:
-                self.conv_format[layer.name] = "s8"
-                input_layer_names = input_layer_dict[layer.name]
-                for input_layer_name in input_layer_names:
-                    check_layer = layer_name_mapping[input_layer_name]
-                    if check_layer.__class__.__name__ == "Activation" and check_layer.activation.__name__ in ["relu"]:
-                        self.conv_format[layer.name] = "u8"
-                        break
-
-    def _fuse_bn_keras3(self, fuse_conv_bn, fp32_layers):  # pragma: no cover
-        """Fuse batch normalization into convolution layers for Keras 3 graphs."""
-        fuse_layers = []
-        fused_bn_name = ""
-        for idx, layer in enumerate(fp32_layers):
-            if hasattr(layer, "_outbound_nodes"):
-                if layer.name == fused_bn_name:
-                    continue
-
-                if layer.name in self.conv_weights.keys():
-                    new_outbound_nodes = []
-                    conv_weight = self.conv_weights[layer.name]
-                    for outbound_node in layer._outbound_nodes:
-                        outbound_layer = outbound_node.operation
-                        if outbound_layer.__class__.__name__ in ("BatchNormalization"):
-                            fused_bn_name = outbound_layer.name
-                            bn_weight = self.bn_weights[fused_bn_name]
-                            self.layer_weights[layer.name] = fuse_conv_bn(
-                                conv_weight, bn_weight, layer.__class__.__name__, outbound_layer.epsilon
-                            )
-                            self.fold_conv.append(layer.name)
-                            for node in outbound_layer._outbound_nodes:
-                                new_outbound_nodes.append(node)
-                        else:
-                            new_outbound_nodes.append(outbound_node)
-                    layer._outbound_nodes.clear()
-                    for node in new_outbound_nodes:
-                        layer._outbound_nodes.append(node)
-
-                fuse_layers.append(layer)
-            else:
-                if (
-                    idx > 0
-                    and layer.__class__.__name__ == "BatchNormalization"
-                    and fp32_layers[idx - 1].__class__.__name__ == "Conv2D"
-                ):
-                    conv_name = fp32_layers[idx - 1].name
-                    conv_weight = self.conv_weights[conv_name]
-                    bn_weight = self.bn_weights[layer.name]
-                    conv_type = fp32_layers[idx - 1].__class__.__name__
-
-                    self.layer_weights[conv_name] = fuse_conv_bn(conv_weight, bn_weight, conv_type, layer.epsilon)
-                    self.fold_conv.append(conv_name)
-                else:
-                    fuse_layers.append(layer)
-
-        return fuse_layers
-
-    def _fuse_bn_keras2(self, fuse_conv_bn, fp32_layers):  # pragma: no cover
-        """Fuse batch normalization into convolution layers for Keras 2 graphs."""
-        fuse_layers = []
-        for idx, layer in enumerate(fp32_layers):
-            if hasattr(layer, "_inbound_nodes"):
-                if layer.__class__.__name__ in ("BatchNormalization"):
-                    for bn_inbound_node in layer._inbound_nodes:
-                        inbound_layer = bn_inbound_node.inbound_layers
-                        if inbound_layer.name in self.conv_weights.keys():
-                            conv_layer = inbound_layer
-                            conv_weight = self.conv_weights[conv_layer.name]
-                            bn_weight = self.bn_weights[layer.name]
-
-                            self.layer_weights[conv_layer.name] = fuse_conv_bn(
-                                conv_weight, bn_weight, conv_layer.__class__.__name__, layer.epsilon
-                            )
-                            self.fold_conv.append(conv_layer.name)
-                        else:
-                            fuse_layers.append(layer)
-                elif len(layer._inbound_nodes):
-                    new_bound_nodes = []
-                    # OpLambda node will have different bound node
-                    if layer.__class__.__name__ in ("TFOpLambda", "SlicingOpLambda"):
-                        fuse_layers.append(layer)
-                    else:
-                        for bound_node in layer._inbound_nodes:
-                            inbound_layers = bound_node.inbound_layers
-                            if not isinstance(inbound_layers, list):
-                                inbound_layers = [inbound_layers]
-                            for inbound_layer in inbound_layers:
-                                if inbound_layer in self.bn_weights.keys():
-                                    for bn_inbound_node in inbound_layer._inbound_nodes:
-                                        bn_inbound_layer = bn_inbound_node.inbound_layers
-                                        if bn_inbound_layer.name in self.conv_weights.keys():
-                                            new_bound_nodes.append(bn_inbound_node)
-                                        else:
-                                            if bound_node not in new_bound_nodes:
-                                                new_bound_nodes.append(bound_node)
-                                else:
-                                    new_bound_nodes.append(bound_node)
-
-                        layer._inbound_nodes.clear()
-                        for bound_node in new_bound_nodes:
-                            layer._inbound_nodes.append(bound_node)
-                        fuse_layers.append(layer)
-                else:
-                    fuse_layers.append(layer)
-            else:
-                if (
-                    idx > 0
-                    and layer.__class__.__name__ == "BatchNormalization"
-                    and fp32_layers[idx - 1].__class__.__name__ == "Conv2D"
-                ):
-                    conv_name = fp32_layers[idx - 1].name
-                    conv_weight = self.conv_weights[conv_name]
-                    bn_weight = self.bn_weights[layer.name]
-                    conv_type = fp32_layers[idx - 1].__class__.__name__
-
-                    self.layer_weights[conv_name] = fuse_conv_bn(conv_weight, bn_weight, conv_type, layer.epsilon)
-                    self.fold_conv.append(conv_name)
-                else:
-                    fuse_layers.append(layer)
-
-        return fuse_layers
-
-    def _fuse_bn(self, model):  # pragma: no cover
-        """Fusing Batch Normalization."""
-        model.save(self.tmp_dir)
-        fuse_bn_model = tf.keras.models.load_model(self.tmp_dir)
-        fp32_layers = fuse_bn_model.layers
-
-        def fuse_conv_bn(conv_weight, bn_weight, conv_type="Conv2D", eps=1.0e-5):
-            """Fuse convolution weights with batch normalization parameters.
-
-            Args:
-                conv_weight (list[np.ndarray]): Convolution weights and optional bias.
-                bn_weight (list[np.ndarray]): BatchNorm parameters.
-                conv_type (str): Convolution layer type.
-                eps (float): Epsilon used in BatchNorm.
-
-            Returns:
-                list[np.ndarray]: Fused convolution weights (and bias).
-            """
-            assert conv_type in [
-                "Conv2D",
-                "DepthwiseConv2D",
-                "SeparableConv2D",
-            ], "only support Conv2D, DepthwiseConv2D, SeparableConv2D..."
-            if len(bn_weight) > 3:
-                if conv_type == "DepthwiseConv2D":
-                    gamma = bn_weight[0].reshape(1, 1, bn_weight[0].shape[0], 1)
-                    var = bn_weight[3].reshape(1, 1, bn_weight[3].shape[0], 1)
-                else:
-                    gamma = bn_weight[0].reshape(1, 1, 1, bn_weight[0].shape[0])
-                    var = bn_weight[3].reshape(1, 1, 1, bn_weight[3].shape[0])
-                beta = bn_weight[1]
-                mean = bn_weight[2]
-            else:
-                gamma = 1.0
-                beta = bn_weight[0]
-                mean = bn_weight[1]
-                if conv_type == "DepthwiseConv2D":
-                    var = bn_weight[2].reshape(1, 1, bn_weight[2].shape[0], 1)
-                else:
-                    var = bn_weight[2].reshape(1, 1, 1, bn_weight[2].shape[0])
-
-            if len(conv_weight) == 1:
-                weight = conv_weight[0]
-                bias = np.zeros_like(beta)
-            elif len(conv_weight) == 2 and conv_type == "SeparableConv2D":
-                depth_weight = conv_weight[0]
-                weight = conv_weight[1]
-                bias = np.zeros_like(beta)
-            elif len(conv_weight) == 2 and conv_type != "SeparableConv2D":
-                weight = conv_weight[0]
-                bias = conv_weight[1]
-            elif len(conv_weight) == 3:
-                depth_weight = conv_weight[0]
-                weight = conv_weight[1]
-                bias = conv_weight[2]
-            scale_value = gamma / np.sqrt(var + eps)
-            weight = weight * scale_value
-            bias = beta + (bias - mean) * scale_value.reshape(-1)
-            bias = bias.reshape(-1)
-            return [depth_weight, weight, bias] if conv_type == "SeparableConv2D" else [weight, bias]
-
-        fuse_bn_function = self._fuse_bn_keras3 if self.keras3 else self._fuse_bn_keras2
-        fused_layers = fuse_bn_function(fuse_conv_bn, fp32_layers)
-
-        for idx, layer in enumerate(fused_layers):
-            if (
-                layer.__class__.__name__ in ("Conv2D", "DepthwiseConv2D", "SeparableConv2D")
-                and layer.name in self.fold_conv
-            ):
-                conv_config = layer.get_config()
-                conv_config["use_bias"] = True
-                conv_layer = type(layer).from_config(conv_config)
-                for node in layer._outbound_nodes:
-                    conv_layer._outbound_nodes.append(node)
-                fused_layers[idx] = conv_layer
-
-        bn_surgery = KerasSurgery(model)
-        bn_fused_model = bn_surgery.convert(fused_layers, self.conv_weights.keys())
-        bn_fused_model = self._set_weights(bn_fused_model, self.layer_weights)
-
-        bn_fused_model.save(self.tmp_dir)
-        bn_fused_model = tf.keras.models.load_model(self.tmp_dir)
-
-        return bn_fused_model
-
-    @dump_elapsed_time("Pass quantize model")
-    def quantize(self, quant_config, model, dataloader, iteration, calib_func=None):
-        """Execute the quantize process on the specified model.
-
-        Args:
-            quant_config(dict): The user defined 'StaticQuantConfig' class.
-            model (object): The model to do quantization.
-            dataloader(object): The calibration dataloader used to load quantization dataset.
-            iteration(int): The iteration of calibration.
-            calib_func (optional): the function used for calibration, should be a substitution for calibration
-            dataloader when the built-in calibration function of INC does not work for model inference.
-        """
-        assert calib_func is None, "The calibration function is not supported on Keras backend yet"
-        self.query_fw_capability(model)
-        converter = KerasConfigConverter(quant_config, iteration)
-        tune_cfg = converter.parse_to_tune_cfg()
-        self.tuning_cfg_to_fw(tune_cfg)
-
-        logger.debug("Dump quantization configurations:")
-        logger.debug(self.quantize_config)
-        calib_sampling_size = tune_cfg.get("calib_sampling_size", 1)
-
-        if hasattr(dataloader, "batch_size") and calib_sampling_size % dataloader.batch_size != 0:
-            iter = self.quantize_config["calib_iteration"]
-            logger.warning(
-                "Please note that calibration sampling size {} "
-                "isn't divisible exactly by batch size {}. "
-                "So the real sampling size is {}.".format(
-                    calib_sampling_size, dataloader.batch_size, dataloader.batch_size * iter
-                )
-            )
-
-        from neural_compressor.tensorflow.keras.layers import layer_initializer_dict
-
-        q_layer_dict = {}
-        for layer in self.pre_optimized_model.layers:
-            if layer.__class__.__name__ in self.supported_op and layer.name in self.quantize_config["op_wise_config"]:
-                op_config = self.quantize_config["op_wise_config"][layer.name]
-                granularity = "per_channel" if op_config[0] else "per_tensor"
-                q_layer_class = "Q" + layer.__class__.__name__
-                q_config = {"T": self.conv_format[layer.name], "granularity": granularity}
-                q_layer = layer_initializer_dict[q_layer_class](layer, q_config)
-                q_layer_dict[layer.name] = q_layer
-
-        calib_surgery = KerasSurgery(self.pre_optimized_model)
-        calibration_model = calib_surgery.convert(q_layer_dict=q_layer_dict)
-        calibration_model = self._set_weights(calibration_model, self.layer_weights)
-
-        quantized_model = self._calibrate(
-            calibration_model,
-            dataloader,
-            self.quantize_config["calib_iteration"],
-        )
-
-        return quantized_model
-
-    def _calibrate(self, model, dataloader=None, calib_interation=None):
-        """Apply calibration.
-
-        Args:
-            model(tf.keras.Model): The model inserted with FakeQuant layers for calibration.
-            dataloader(object): The calibration dataloader used to load quantization dataset.
-            calib_interation(int): The iteration of calibration.
-        """
-        # run eagerly to fetch the numpy min/max
-        results = {}
-        model.compile(run_eagerly=True)
-        for idx, (inputs, _) in enumerate(dataloader):
-            _ = model.predict_on_batch(inputs)
-            for layer in model.layers:
-                if (
-                    layer.__class__.__name__[1:] in self.supported_op
-                    and layer.name in self.quantize_config["op_wise_config"]
-                ):
-                    min_value = layer.act_min_value.numpy()
-                    max_value = layer.act_max_value.numpy()
-
-                    if layer.name not in results:
-                        results[layer.name] = {"min": [min_value], "max": [max_value]}
-                    else:
-                        results[layer.name]["min"].append(min_value)
-                        results[layer.name]["max"].append(max_value)
-            if idx + 1 == calib_interation:
-                break
-
-        for idx, layer in enumerate(model.layers):
-            if (
-                layer.__class__.__name__[1:] in self.supported_op
-                and layer.name in self.quantize_config["op_wise_config"]
-            ):
-                layer.act_min_value = np.min(results[layer.name]["min"])
-                layer.act_max_value = np.max(results[layer.name]["max"])
-                layer.quant_status = "quantize"
-                # for layers that have weights
-                if layer.name in self.layer_weights:
-                    kernel = self.layer_weights[layer.name][0]
-                    dim = list(range(0, kernel.ndim))
-                    t_dim = [dim.pop(-1)]
-                    t_dim.extend(dim)
-                    channel_size = kernel.shape[-1]
-                    kernel_channel = kernel.transpose(t_dim).reshape(channel_size, -1)
-
-                    layer.weight_min_value = np.min(kernel_channel, axis=1).tolist()
-                    layer.weight_max_value = np.max(kernel_channel, axis=1).tolist()
-                else:
-                    # default value, but never expected to be used
-                    # cause no kernel weights for this layer
-                    layer.weight_min_value = [-10000]
-                    layer.weight_max_value = [10000]
-
-        model.save(self.tmp_dir)
-        quantized_model = tf.keras.models.load_model(self.tmp_dir)
-
-        return quantized_model
-
-    def query_fw_capability(self, model):
-        """The function is used to return framework tuning capability.
-
-        Args:
-            model (object): The model to query quantization tuning capability.
-        """
-        if not isinstance(model, tf.keras.Model):
-            model = model.model
-        fp32_config = {"weight": {"dtype": "fp32"}, "activation": {"dtype": "fp32"}}
-        bf16_config = {"weight": {"dtype": "bf16"}, "activation": {"dtype": "bf16"}}
-        int8_type = self.query_handler.get_op_types_by_precision(precision="int8")
-        op_capability = self.query_handler.get_quantization_capability()
-        conv_config = copy.deepcopy(op_capability["int8"]["Conv2D"])
-        conv_config = copy.deepcopy(op_capability["int8"]["SeparableConv2D"])
-        conv_config = copy.deepcopy(op_capability["int8"]["DepthwiseConv2D"])
-        dense_config = copy.deepcopy(op_capability["int8"]["Dense"])
-        maxpool_config = copy.deepcopy(op_capability["int8"]["MaxPooling2D"])
-        avgpool_config = copy.deepcopy(op_capability["int8"]["AveragePooling2D"])
-        other_config = copy.deepcopy(op_capability["int8"]["default"])
-
-        # # get fp32 layer weights
-        self.fp32_model = model
-        self.conv_weights = {}
-        self.bn_weights = {}
-        self.layer_weights = {}
-        for layer in self.fp32_model.layers:
-            if layer.get_weights():
-                if (
-                    isinstance(layer, tf.keras.layers.Conv2D)
-                    or isinstance(layer, tf.keras.layers.DepthwiseConv2D)
-                    or isinstance(layer, tf.keras.layers.SeparableConv2D)
-                ):
-                    self.conv_weights[layer.name] = copy.deepcopy(layer.get_weights())
-                elif isinstance(layer, tf.keras.layers.BatchNormalization):
-                    self.bn_weights[layer.name] = copy.deepcopy(layer.get_weights())
-                self.layer_weights[layer.name] = copy.deepcopy(layer.get_weights())
-
-        self._check_quantize_format(self.fp32_model)
-        self.pre_optimized_model = self._fuse_bn(self.fp32_model)
-
-        quantizable_layer_details = OrderedDict()
-        for layer in self.fp32_model.layers:
-            layer_class = layer.__class__.__name__
-            if layer_class == "Conv2D":
-                quantizable_layer_details[(layer.name, layer_class)] = [conv_config, bf16_config, fp32_config]
-            elif layer_class == "Dense":
-                quantizable_layer_details[(layer.name, layer_class)] = [dense_config, bf16_config, fp32_config]
-            elif layer_class in {"AveragePooling2D", "AvgPool2D"}:
-                quantizable_layer_details[(layer.name, layer_class)] = [avgpool_config, bf16_config, fp32_config]
-            elif layer_class in {"MaxPooling2D", "MaxPool2D"}:
-                quantizable_layer_details[(layer.name, layer_class)] = [maxpool_config, bf16_config, fp32_config]
-            else:
-                quantizable_layer_details[(layer.name, layer_class)] = [bf16_config, fp32_config]
-
-        capability = {
-            "opwise": copy.deepcopy(quantizable_layer_details),
-            "optypewise": self.get_optype_wise_ability(quantizable_layer_details),
-        }
-        logger.debug("Dump framework quantization capability:")
-        logger.debug(capability)
-
-        return capability
-
-    def get_optype_wise_ability(self, quantizable_op_details):
-        """Get the op type wise capability by generating the union value of each op type.
-
-        Returns:
-            [string dict]: the key is op type while the value is the
-                           detail configurations of activation and weight for this op type.
-        """
-        res = OrderedDict()
-        for op in quantizable_op_details:
-            if op[1] not in res:
-                res[op[1]] = {"activation": quantizable_op_details[op][0]["activation"]}
-                if "weight" in quantizable_op_details[op][0]:
-                    res[op[1]]["weight"] = quantizable_op_details[op][0]["weight"]
-        return res
-
-    def tuning_cfg_to_fw(self, tuning_cfg):
-        """Parse tune_config and set framework variables.
-
-        Args:
-            tuning_cfg (dict): The dict of tuning config.
-        """
-        self.quantize_config["calib_iteration"] = tuning_cfg["calib_iteration"]
-        self.quantize_config["device"] = self.device
-        self.quantize_config["advance"] = deep_get(tuning_cfg, "advance")
-        fp32_ops = []
-        bf16_ops = []
-        bf16_type = set(self.query_handler.get_op_types_by_precision(precision="bf16"))
-        dispatched_op_names = [j[0] for j in tuning_cfg["op"]]
-        invalid_op_names = [i for i in self.quantize_config["op_wise_config"] if i not in dispatched_op_names]
-
-        for op_name in invalid_op_names:
-            self.quantize_config["op_wise_config"].pop(op_name)
-
-        for each_op_info in tuning_cfg["op"]:
-            op_name = each_op_info[0]
-
-            if tuning_cfg["op"][each_op_info]["activation"]["dtype"] == "bf16":  # pragma: no cover
-                if each_op_info[1] in bf16_type:
-                    bf16_ops.append(op_name)
-                continue
-
-            if tuning_cfg["op"][each_op_info]["activation"]["dtype"] == "fp32":
-                if op_name in self.quantize_config["op_wise_config"]:
-                    self.quantize_config["op_wise_config"].pop(op_name)
-                    fp32_ops.append(op_name)
-                continue
-
-            is_perchannel = False
-            bit = None
-            if "weight" in tuning_cfg["op"][each_op_info]:
-                is_perchannel = tuning_cfg["op"][each_op_info]["weight"]["granularity"] == "per_channel"
-                # bit = tuning_cfg['op'][each_op_info]['weight']['bit']
-            weight_bit = bit if bit else 7.0
-            algorithm = tuning_cfg["op"][each_op_info]["activation"]["algorithm"]
-            is_asymmetric = False
-            if "activation" in tuning_cfg["op"][each_op_info]:
-                is_asymmetric = tuning_cfg["op"][each_op_info]["activation"]["scheme"] == "asym"
-            self.quantize_config["op_wise_config"][op_name] = (is_perchannel, algorithm, is_asymmetric, weight_bit)
-        self.bf16_ops = bf16_ops
-        if self.bf16_ops:
-            self.bf16_ops.pop(-1)
-        self.fp32_ops = fp32_ops
-
-
-class KerasQuery:
-    """Class that queries configs from yaml settings."""
-
-    def __init__(self, local_config_file=None):
-        """Initialize KerasQuery."""
-        self.version = tf.version.VERSION
-        self.cfg = local_config_file
-        self.cur_config = None
-        self._one_shot_query()
-
-    def _one_shot_query(self):
-        """Query cur configs in one shot."""
-        with open(self.cfg) as f:
-            content = yaml.safe_load(f)
-            try:
-                self.cur_config = self._get_specified_version_cfg(content)
-            except Exception as e:
-                logger.info("Fail to parse {} due to {}.".format(self.cfg, str(e)))
-                self.cur_config = None
-                raise ValueError(
-                    "Please check if the format of {} follows Neural Compressor yaml schema.".format(self.cfg)
-                )
-
-    def _get_specified_version_cfg(self, data):
-        """Get the configuration for the current runtime.
-
-        If there's no matched configuration in the input yaml, we'll
-        use the `default` field of yaml.
-        Args:
-            data (Yaml content): input yaml file.
-
-        Returns:
-            [dictionary]: the content for specific version.
-        """
-        default_config = None
-        for sub_data in data:
-            if sub_data["version"]["name"] == self.version:
-                return sub_data
-
-            if sub_data["version"]["name"] == "default":
-                default_config = sub_data
-
-        return default_config
-
-    def get_quantization_capability(self):
-        """Get the supported op types' quantization capability.
-
-        Returns:
-            [dictionary list]: A list composed of dictionary which key is precision
-            and value is a dict that describes all op types' quantization capability.
-        """
-        return self.cur_config["capabilities"]
-
-    def get_op_types_by_precision(self, precision):
-        """Get op types per precision.
-
-        Args:
-            precision (string): precision name
-
-        Returns:
-            [string list]: A list composed of op type.
-        """
-        assert precision in list(self.cur_config["ops"].keys())
-        return self.cur_config["ops"][precision]
-
-
-class KerasConfigConverter:
-    """Convert `StaticQuantConfig` to the format used by static quant algo."""
-
-    support_int8_weight = {"Dense", "Conv2D", "DepthwiseConv2D", "SeparableConv2D"}
-
-    def __init__(self, quant_config: StaticQuantConfig, calib_iteration: int):
-        """Init parser for keras static quant config.
-
-        Args:
-            quant_config: the keras static quant config.
-            calib_iteration: the iteration of calibration.
-        """
-        self.quant_config = quant_config
-        self.calib_iteration = calib_iteration
-
-    def update_config(self, quant_config, op_key):
-        """Update op-wise config.
-
-        Args:
-            quant_config: the keras static quant config.
-            op_key: a tuple such as (layer type, layer name).
-        """
-        op_value = {"activation": {}}
-        op_value["activation"].update(
-            {
-                "dtype": quant_config.act_dtype,
-                "quant_mode": "static",
-                "scheme": ("sym" if quant_config.act_sym else "asym"),
-                "granularity": quant_config.act_granularity,
-                "algorithm": "minmax",
-            }
-        )
-        if op_key[1] not in self.support_int8_weight:
-            return op_value
-
-        op_value["weight"] = {
-            "dtype": quant_config.weight_dtype,
-            "scheme": "sym" if quant_config.weight_sym else "asym",
-            "granularity": quant_config.weight_granularity,
-            "algorithm": "minmax",
-        }
-        return op_value
-
-    def parse_to_tune_cfg(self) -> Dict:
-        """The function that parses StaticQuantConfig to keras tuning config."""
-        tune_cfg = {"op": OrderedDict()}
-        for op_key, config in self.quant_config.items():
-            op_value = self.update_config(config, op_key)
-            tune_cfg["op"].update({op_key: op_value})
-            tune_cfg["calib_iteration"] = self.calib_iteration
-
-        return tune_cfg
-
-
-class KerasSurgery:
-    """The class that inserts FakeQuant or QDQ layers before the target layers."""
-
-    def __init__(self, model):
-        """Init the KerasSurgery class.
-
-        Args:
-            model: the model to be modified.
-        """
-        import shutil
-
-        self.model_outputs = []
-        self.keras3 = True if version1_gte_version2(tf.__version__, "2.16.1") else False
-        self.tmp_dir = (DEFAULT_WORKSPACE + "tmp_model.keras") if self.keras3 else (DEFAULT_WORKSPACE + "tmp_model")
-        model.save(self.tmp_dir)
-        self.model = tf.keras.models.load_model(self.tmp_dir)
-        shutil.rmtree(self.tmp_dir, ignore_errors=True)
-
-    def _parse_inputs(self, BN_fused_layers=None, conv_names=None):
-        """Create a input_layer_dict from model.
-
-        Args:
-            BN_fused_layers: The layers in which BN layers have been fused.
-            conv_names: The name list of conv layers where BNs are fused.
-
-        Returns:
-            input_layer_dict: The dict that mapping for layer names to their input layer names.
-        """
-        input_layer_dict = {}
-        layers = BN_fused_layers if BN_fused_layers else self.model.layers
-        for layer in layers:
-            for node in layer._outbound_nodes:
-                out_layer = node.operation if self.keras3 else node.outbound_layer
-                out_layer_names = [out_layer.name]
-                if conv_names and out_layer.__class__.__name__ in ("BatchNormalization") and layer.name in conv_names:
-                    out_layer_names = (
-                        [node.operation.name for node in out_layer._outbound_nodes]
-                        if self.keras3
-                        else [node.outbound_layer.name for node in out_layer._outbound_nodes]
-                    )
-
-                for out_layer_name in out_layer_names:
-                    if out_layer_name not in input_layer_dict:
-                        input_layer_dict[out_layer_name] = [layer.name]
-                    else:
-                        input_layer_dict[out_layer_name].append(layer.name)
-
-        try:
-            model_input = self.model.input
-        except ValueError:  # pragma: no cover
-            model_input = self.model.inputs[0]
-
-        return input_layer_dict, model_input
-
-    def convert(self, BN_fused_layers=None, conv_names=None, q_layer_dict=None):
-        """Generate optimized model by fusing BN layers or replacing Keras layers to custom quantized layers.
-
-        Args:
-            BN_fused_layers: The layers in which BN layers have been fused.
-            conv_names: The name list of conv layers where BNs are fused.
-            q_layer_dict: The dict mapping from keras layers to custom quantized layers.
-        """
-        input_layer_dict, model_input = self._parse_inputs(BN_fused_layers, conv_names)
-        output_tensor_dict = {"keras.Input": model_input}
-        layers = BN_fused_layers if BN_fused_layers else self.model.layers
-
-        for idx, layer in enumerate(layers):
-            if layer.__class__.__name__ == "InputLayer":
-                output_tensor_dict[layer.name] = output_tensor_dict["keras.Input"]
-                continue
-
-            input_tensors = (
-                output_tensor_dict["keras.Input"]
-                if idx == 0
-                else [output_tensor_dict[input_layer] for input_layer in input_layer_dict[layer.name]]
-            )
-
-            while isinstance(input_tensors, list) and len(input_tensors) == 1:
-                input_tensors = input_tensors[0]
-
-            if self.keras3:
-                layer._inbound_nodes.clear()
-
-            cur_layer = q_layer_dict[layer.name] if q_layer_dict and layer.name in q_layer_dict else layer
-            x = cur_layer(input_tensors)
-            output_tensor_dict[layer.name] = x
-
-            if not isinstance(self.model, tf.keras.models.Sequential) and layer.name in self.model.output_names:
-                self.model_outputs.append(x)
-
-        if not self.model_outputs:
-            self.model_outputs.append(x)
-
-        return tf.keras.models.Model(inputs=self.model.inputs, outputs=self.model_outputs)
diff --git a/neural_compressor/tensorflow/algorithms/static_quant/keras.yaml b/neural_compressor/tensorflow/algorithms/static_quant/keras.yaml
deleted file mode 100644
index 055d3a28530..00000000000
--- a/neural_compressor/tensorflow/algorithms/static_quant/keras.yaml
+++ /dev/null
@@ -1,121 +0,0 @@
-## Copyright (c) 2021 Intel Corporation
-##
-## Licensed under the Apache License, Version 2.0 (the "License");
-## you may not use this file except in compliance with the License.
-## You may obtain a copy of the License at
-##
-##    http://www.apache.org/licenses/LICENSE-2.0
-##
-## Unless required by applicable law or agreed to in writing, software
-## distributed under the License is distributed on an "AS IS" BASIS,
-## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-## See the License for the specific language governing permissions and
-## limitations under the License.
-##
-#
--
-  version:
-    name: 'default'
-
-  precisions: &common_precisions
-    names: int8, fp32
-    valid_mixed_precisions: []
-
-  ops: &common_ops
-    int8: ['Conv2D', 'SeparableConv2D', 'DepthwiseConv2D', 'Dense', 'AveragePooling2D', 'MaxPooling2D',
-           'AvgPool2D', 'MaxPool2D']
-    bf16: ['Dense', 'Conv1D', 'Conv2D', 'Conv3D', 'SeparableConv1D', 'SeparableConv2D', 'Conv1DTranspose',
-           'Conv2DTranspose', 'Conv3DTranspose', 'DepthwiseConv2D', 'AveragePooling2D', 'MaxPooling2D',
-           'AvgPool2D', 'MaxPool2D', 'MaxPooling1D', 'MaxPooling3D', 'AveragePooling1D', 'AveragePooling3D',
-           'GlobalMaxPooling1D', 'GlobalMaxPooling2D', 'GlobalMaxPooling3D', 'GlobalAveragePooling1D',
-           'GlobalAveragePooling2D', 'GlobalAveragePooling3D','SimpleRNN', 'TimeDistributed', 'ConvLSTM1D',
-           'ConvLSTM2D', 'ConvLSTM3D', 'TextVectorization', 'Discretization', 'CategoryEncoding', 'Hashing',
-           'StringLookup', 'IntegerLookup', 'Resizing', 'Rescaling', 'CenterCrop', 'RandomCrop', 'RandomFlip',
-           'RandomTranslation', 'Activation', 'RandomRotation', 'RandomZoom', 'RandomHeight', 'RandomWidth',
-           'RandomContrast', 'RandomBrightness', 'Normalization', 'BatchNormalization', 'LayerNormalization',
-           'UnitNormalization', 'GroupNormalization', 'Dropout', 'SpatialDropout1D', 'SpatialDropout2D',
-           'SpatialDropout3D', 'GaussianDropout', 'GaussianNoise', 'ActivityRegularization', 'AlphaDropout',
-           'MultiHeadAttention', 'Attention', 'AdditiveAttention', 'Reshape', 'Flatten', 'RepeatVector',
-           'Permute', 'Cropping1D', 'Cropping2D', 'Cropping3D', 'UpSampling1D', 'UpSampling2D', 'UpSampling3D',
-           'ZeroPadding1D', 'ZeroPadding2D', 'ZeroPadding3D', 'Concatenate', 'Average', 'Maximum', 'Minimum',
-           'Add', 'Subtract', 'Multiply', 'Dot', 'LocallyConnected1D', 'LocallyConnected2D', 'Embedding',
-           'Masking', 'Lambda', 'ReLU', 'Softmax', 'LeakyReLU', 'PReLU', 'ELU', 'ThresholdedReLU'
-          ]
-    fp32: ['*'] # '*' means all op types
-
-  capabilities: &common_capabilities
-    int8: {
-          'Conv2D':  {
-            'weight':   {
-                        'dtype': ['int8'],
-                        'scheme': ['sym'],
-                        'granularity': ['per_tensor'],
-                        'algorithm': ['minmax']
-                        },
-            'activation': {
-                        'dtype': ['int8'],
-                        'quant_mode': 'static',
-                        'scheme': ['sym'],
-                        'granularity': ['per_tensor'],
-                        'algorithm': ['minmax']
-                        }
-                    },
-          'DepthwiseConv2D':  {
-            'weight':   {
-                        'dtype': ['int8'],
-                        'scheme': ['sym'],
-                        'granularity': ['per_tensor'],
-                        'algorithm': ['minmax']
-                        },
-            'activation': {
-                        'dtype': ['int8'],
-                        'quant_mode': 'static',
-                        'scheme': ['sym'],
-                        'granularity': ['per_tensor'],
-                        'algorithm': ['minmax']
-                        }
-                    },
-          'SeparableConv2D':  {
-            'weight':   {
-                        'dtype': ['int8'],
-                        'scheme': ['sym'],
-                        'granularity': ['per_tensor'],
-                        'algorithm': ['minmax']
-                        },
-            'activation': {
-                        'dtype': ['int8'],
-                        'quant_mode': 'static',
-                        'scheme': ['sym'],
-                        'granularity': ['per_tensor'],
-                        'algorithm': ['minmax']
-                        }
-                    },
-          'Dense': {
-            'weight':   {
-                        'dtype': ['int8'],
-                        'scheme': ['sym'],
-                        'algorithm': ['minmax'],
-                        'granularity': ['per_tensor'],
-                        },
-            'activation': {
-                        'dtype': ['int8'],
-                        'quant_mode': 'static',
-                        'scheme': ['sym'],
-                        'algorithm': ['minmax'],
-                        'granularity': ['per_tensor'],
-                        }
-                    },
-         'default': &ref_default_static {
-             'activation': {
-                        'dtype': ['int8'],
-                        'quant_mode': 'static',
-                        'scheme': ['sym'],
-                        'algorithm': ['minmax'],
-                        'granularity': ['per_tensor']
-                        }
-                    },
-          'AveragePooling2D': *ref_default_static,
-          'AvgPool2D': *ref_default_static,
-          'MaxPooling2D': *ref_default_static,
-          'MaxPool2D': *ref_default_static,
-          }
diff --git a/neural_compressor/tensorflow/algorithms/static_quant/tensorflow.py b/neural_compressor/tensorflow/algorithms/static_quant/tensorflow.py
deleted file mode 100644
index 1fb6b05fcc5..00000000000
--- a/neural_compressor/tensorflow/algorithms/static_quant/tensorflow.py
+++ /dev/null
@@ -1,1553 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Tensorflow Adaptor Classes."""
-
-import copy
-import math
-import os
-import re
-from collections import OrderedDict, UserDict
-from copy import deepcopy
-from typing import Callable, Dict
-
-import numpy as np
-import tensorflow as tf
-import yaml
-from pkg_resources import parse_version
-
-from neural_compressor.common import logger
-from neural_compressor.tensorflow.quantization.config import StaticQuantConfig
-from neural_compressor.tensorflow.utils import (
-    SPR_BASE_VERSIONS,
-    UNIFY_OP_TYPE_MAPPING,
-    BaseDataLoader,
-    BaseModel,
-    CpuInfo,
-    Statistics,
-    deep_get,
-    dump_elapsed_time,
-    singleton,
-    version1_eq_version2,
-    version1_gte_version2,
-    version1_lt_version2,
-)
-
-spr_base_verions = SPR_BASE_VERSIONS
-
-
-class TensorFlowAdaptor:
-    """Adaptor Layer for stock tensorflow and spr-base."""
-
-    unify_op_type_mapping = UNIFY_OP_TYPE_MAPPING
-
-    def __init__(self, framework_specific_info):
-        """Initialization.
-
-        Args:
-            framework_specific_info: framework specific info passed from strategy.
-        """
-        os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
-        os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
-        self.quantize_config = {"op_wise_config": {}}
-        self.framework_specific_info = framework_specific_info
-        self.approach = deep_get(self.framework_specific_info, "approach", False)
-        self.device = self.framework_specific_info["device"]
-        self.work_dir = os.path.abspath(self.framework_specific_info["workspace_path"])
-        self.recipes = deep_get(self.framework_specific_info, "recipes", {})
-        self.performance_only = deep_get(self.framework_specific_info, "performance_only", False)
-        self.use_bf16 = deep_get(self.framework_specific_info, "use_bf16", False)
-        self.backend = self.framework_specific_info["backend"]
-        self.format = self.framework_specific_info["format"]
-        os.makedirs(self.work_dir, exist_ok=True)
-
-        self.model = None
-        self.pre_optimized_model = None
-        self.pre_optimizer_handle = None
-
-        self.bf16_ops = []
-        self.fp32_ops = []
-        self.smooth_quant_mul_ops = []
-        self.dump_times = 0  # for tensorboard
-
-        cfg_yaml_name = "{}.yaml".format(self.__class__.__name__[: -len("Adaptor")].lower())
-        self.itex_mode = self.backend == "itex" or cfg_yaml_name == "tensorflow_itex.yaml"
-
-        if self.itex_mode:  # pragma: no cover
-            self._check_itex()
-
-        self.query_handler = TensorflowQuery(
-            local_config_file=os.path.join(os.path.dirname(__file__), cfg_yaml_name),
-            performance_only=self.performance_only,
-            itex_mode=self.itex_mode,
-        )
-
-        self.new_api = tf.version.VERSION in spr_base_verions
-        self.qdq_enabled = self.itex_mode or self.format == "QDQ" or self.new_api
-        self.op_wise_sequences = self.query_handler.get_eightbit_patterns(self.qdq_enabled)
-
-        self.fp32_results = []
-        self.fp32_preds_as_label = False
-        # self.benchmark = GLOBAL_STATE.STATE == MODE.BENCHMARK
-        self.benchmark = False
-        self.callbacks = []
-
-        self.optype_statistics = None
-
-        self._last_dequantize_ops = None
-
-    def _check_itex(self):  # pragma: no cover
-        """Verify that Intel Extension for TensorFlow is installed."""
-        try:
-            import intel_extension_for_tensorflow
-        except:
-            raise ImportError(
-                "The Intel® Extension for TensorFlow is not installed. "
-                "Please install it to run models on ITEX backend"
-            )
-
-    def _tuning_cfg_to_fw(self, tuning_cfg):
-        """Parse the neural_compressor wrapped configuration to Tensorflow.
-
-        Args:
-            tuning_cfg (dict): configuration for quantization.
-        """
-        self.quantize_config["calib_iteration"] = tuning_cfg["calib_iteration"]
-        self.quantize_config["device"] = self.device
-        self.quantize_config["advance"] = deep_get(tuning_cfg, "advance")
-        fp32_ops = []
-        bf16_ops = []
-        dispatched_op_names = [j[0] for j in tuning_cfg["op"]]
-
-        invalid_op_names = [i for i in self.quantize_config["op_wise_config"] if i not in dispatched_op_names]
-
-        for op_name in invalid_op_names:  # pragma: no cover
-            self.quantize_config["op_wise_config"].pop(op_name)
-
-        for each_op_info in tuning_cfg["op"]:
-            op_name = each_op_info[0]
-
-            if tuning_cfg["op"][each_op_info]["activation"]["dtype"] in ["fp32", "bf16"]:
-                if op_name in self.quantize_config["op_wise_config"]:
-                    self.quantize_config["op_wise_config"].pop(op_name)
-                if tuning_cfg["op"][each_op_info]["activation"]["dtype"] == "fp32":
-                    fp32_ops.append(op_name)
-                if tuning_cfg["op"][each_op_info]["activation"]["dtype"] == "bf16":  # pragma: no cover
-                    bf16_ops.append(op_name)
-                continue
-
-            is_perchannel = False
-            bit = None
-            if "weight" in tuning_cfg["op"][each_op_info]:
-                is_perchannel = tuning_cfg["op"][each_op_info]["weight"]["granularity"] == "per_channel"
-                # bit = tuning_cfg['op'][each_op_info]['weight']['bit']
-            weight_bit = bit if bit else 7.0
-
-            algorithm = tuning_cfg["op"][each_op_info]["activation"]["algorithm"]
-
-            is_asymmetric = False
-            if "activation" in tuning_cfg["op"][each_op_info]:
-                is_asymmetric = tuning_cfg["op"][each_op_info]["activation"]["scheme"] == "asym"
-            self.quantize_config["op_wise_config"][op_name] = (is_perchannel, algorithm, is_asymmetric, weight_bit)
-
-        self.fp32_ops = fp32_ops
-        self.bf16_ops = bf16_ops
-
-    @dump_elapsed_time("Pass quantize model")
-    def quantize(
-        self,
-        quant_config: StaticQuantConfig,
-        model: BaseModel,
-        calib_dataloader: Callable = None,
-        calib_iteration: int = 100,
-        calib_func: Callable = None,
-    ):
-        """Execute the quantize process on the specified model.
-
-        Args:
-            quant_config: a quantization configuration.
-            model: the fp32 model to be quantized.
-            calib_dataloader: a data loader for calibration.
-            calib_iteration: the iteration of calibration.
-            calib_func: the function used for calibration, should be a substitution for calib_dataloader
-            when the built-in calibration function of INC does not work for model inference.
-
-        Returns:
-            converted_model: the quantized INC model wrapper.
-        """
-        assert (
-            self.approach != "post_training_dynamic_quant"
-        ), "Dynamic Quantization is not supported on TensorFlow framework now!"
-
-        assert (
-            self.approach != "quant_aware_training"
-        ), "Quantize Aware Training is not supported on TensorFlow framework now!"
-
-        self.calib_sampling_size = calib_dataloader.batch_size * calib_iteration if calib_dataloader else 100
-        tune_cfg = self.parse_quant_config(quant_config, model, calib_iteration)
-        self._tuning_cfg_to_fw(tune_cfg)
-        self.bf16_ops.extend(self.smooth_quant_mul_ops)
-        logger.debug("Dump quantization configurations:")
-        logger.debug(self.quantize_config)
-        from neural_compressor.tensorflow.quantization.utils.graph_converter import GraphConverter
-
-        calib_sampling_size = tune_cfg.get("calib_sampling_size", 1)
-        if isinstance(calib_dataloader, BaseDataLoader):
-            batch_size = calib_dataloader.batch_size
-            try:
-                for i in range(batch_size):
-                    if calib_sampling_size % (batch_size - i) == 0:
-                        calib_batch_size = batch_size - i
-                        if i != 0:  # pragma: no cover
-                            logger.warning(
-                                "Reset `calibration.dataloader.batch_size` field "
-                                "to {}".format(calib_batch_size) + " to make sure the sampling_size is "
-                                "divisible exactly by batch size"
-                            )
-                        break
-                tmp_iterations = int(math.ceil(calib_sampling_size / calib_batch_size))
-                calib_dataloader.batch(calib_batch_size)
-                self.quantize_config["calib_iteration"] = tmp_iterations
-                converted_model = GraphConverter(
-                    model,
-                    qt_config=self.quantize_config,
-                    recipes=self.recipes,
-                    int8_sequences=self.op_wise_sequences,
-                    fp32_ops=self.fp32_ops,
-                    bf16_ops=self.bf16_ops,
-                    data_loader=calib_dataloader,
-                    calib_func=calib_func,
-                    qdq_enabled=self.qdq_enabled,
-                    new_api=self.new_api,
-                    performance_only=self.performance_only,
-                    use_bf16=self.use_bf16,
-                ).convert()
-            except Exception:  # pragma: no cover
-                from neural_compressor.tensorflow.quantization.utils.utility import get_model_input_shape
-
-                batch_size = get_model_input_shape(model)
-                logger.warning(
-                    "Fail to forward with batch size={}, set to {} now.".format(calib_dataloader.batch_size, batch_size)
-                )
-                calib_dataloader.batch(batch_size)
-                self.quantize_config["calib_iteration"] = calib_sampling_size
-                converted_model = GraphConverter(
-                    model,
-                    qt_config=self.quantize_config,
-                    recipes=self.recipes,
-                    int8_sequences=self.op_wise_sequences,
-                    fp32_ops=self.fp32_ops,
-                    bf16_ops=self.bf16_ops,
-                    data_loader=calib_dataloader,
-                    calib_func=calib_func,
-                    qdq_enabled=self.qdq_enabled,
-                    new_api=self.new_api,
-                    performance_only=self.performance_only,
-                    use_bf16=self.use_bf16,
-                ).convert()
-        else:  # pragma: no cover
-            if hasattr(calib_dataloader, "batch_size") and calib_sampling_size % calib_dataloader.batch_size != 0:
-                iter = self.quantize_config["calib_iteration"]
-                logger.warning(
-                    "Please note that calibration sampling size {} "
-                    "isn't divisible exactly by batch size {}. "
-                    "So the real sampling size is {}.".format(
-                        calib_sampling_size, calib_dataloader.batch_size, calib_dataloader.batch_size * iter
-                    )
-                )
-            converted_model = GraphConverter(
-                model,
-                qt_config=self.quantize_config,
-                recipes=self.recipes,
-                int8_sequences=self.op_wise_sequences,
-                fp32_ops=self.fp32_ops,
-                bf16_ops=self.bf16_ops,
-                data_loader=calib_dataloader,
-                calib_func=calib_func,
-                qdq_enabled=self.qdq_enabled,
-                new_api=self.new_api,
-                performance_only=self.performance_only,
-                use_bf16=self.use_bf16,
-            ).convert()
-        # just save framework_specific_info feature for recover
-        converted_model.q_config.update({"framework_specific_info": self.framework_specific_info})
-
-        self._dump_model_op_stats(converted_model.graph_def)
-
-        return converted_model
-
-    def _dump_model_op_stats(self, model_graphdef):
-        """Dump the whole model's OPs statistics information for analysis."""
-        fp32_op_list_uint8 = copy.deepcopy(self.query_handler.get_op_types_by_precision(precision="uint8"))
-        fp32_op_list_int8 = copy.deepcopy(self.query_handler.get_op_types_by_precision(precision="int8"))
-        fp32_op_list = list(set(fp32_op_list_uint8).union(set(fp32_op_list_int8)))
-
-        int8_op_prefix_list = [
-            "QuantizedConv2D",
-            "_FusedQuantizedConv3D",
-            "QuantizedDepthwise",
-            "QuantizedMaxPool",
-            "QuantizedAvgPool",
-            "QuantizedConcatV2",
-            "QuantizedMatMul",
-            "_QuantizedFusedBatchNorm",
-            "_QuantizedMatMul",
-            "_QuantizedBatchMatMul",
-            "_QuantizedFusedInstanceNorm",
-            "_FusedQuantizedDeconv2D",
-            "_FusedQuantizedDeconv3D",
-        ]
-        from tensorflow.python.framework import dtypes
-
-        res = {}
-        for op_type in fp32_op_list:
-            res[op_type] = {"INT8": 0, "BF16": 0, "FP32": 0}
-        res["QuantizeV2"] = {"INT8": 0, "BF16": 0, "FP32": 0}
-        res["Dequantize"] = {"INT8": 0, "BF16": 0, "FP32": 0}
-        res["Cast"] = {"INT8": 0, "BF16": 0, "FP32": 0}
-        fp32_op_list.extend(["QuantizeV2", "Dequantize", "Cast"])
-        for i in model_graphdef.node:
-            if i.op == "Const":
-                continue
-            possible_int8_res = [name for name in int8_op_prefix_list if i.op.find(name) != -1]
-
-            if any(possible_int8_res):  # pragma: no cover
-                origin_op_type = possible_int8_res[0].split("Quantized")[-1]
-                if origin_op_type == "FusedBatchNorm":
-                    origin_op_type = "FusedBatchNormV3"
-                if origin_op_type == "FusedInstanceNorm":
-                    origin_op_type = "_MklFusedInstanceNorm"
-                if origin_op_type == "Depthwise":
-                    origin_op_type = "DepthwiseConv2dNative"
-                if origin_op_type == "BatchMatMul":
-                    origin_op_type = "BatchMatMulV2"
-                if origin_op_type == "FusedBatchMatMulV2":
-                    origin_op_type = "_MklFusedBatchMatMulV2"
-                if origin_op_type == "Deconv2D":
-                    origin_op_type = "Conv2DBackpropInput"
-                if origin_op_type == "Deconv3D":
-                    origin_op_type = "Conv3DBackpropInputV2"
-                res[origin_op_type]["INT8"] += 1
-
-            if i.op in fp32_op_list:
-                if "T" not in i.attr and i.op != "Cast":  # pragma: no cover
-                    continue
-                if i.op == "Cast":
-                    if i.attr["DstT"].type == dtypes.bfloat16:
-                        res[i.op]["BF16"] += 1
-                    elif i.attr["DstT"].type == dtypes.float32:
-                        res[i.op]["FP32"] += 1
-                elif i.attr["T"].type == dtypes.bfloat16:
-                    res[i.op]["BF16"] += 1
-                elif i.attr["T"].type in (dtypes.quint8, dtypes.qint8):
-                    res[i.op]["INT8"] += 1
-                else:
-                    res[i.op]["FP32"] += 1
-
-        field_names = ["Op Type", "Total", "INT8", "BF16", "FP32"]
-        output_data = [
-            [op_type, sum(res[op_type].values()), res[op_type]["INT8"], res[op_type]["BF16"], res[op_type]["FP32"]]
-            for op_type in fp32_op_list
-        ]
-
-        Statistics(output_data, header="Mixed Precision Statistics", field_names=field_names).print_stat()
-        self.optype_statistics = field_names, output_data
-
-    def _query_bf16_ops(self, matched_nodes):
-        """Collect the bf16 OPs configuration for quantization."""
-        self.bf16_op_details = OrderedDict()
-
-        valid_precision = self.query_handler.get_mixed_precision_combination()
-        if ("bf16" in valid_precision and CpuInfo().bf16) or os.getenv("FORCE_BF16") == "1":
-            for details in matched_nodes:
-                node_op = details[-1][0]
-                node_name = details[0]
-
-                self.bf16_op_details[(node_name, node_op)] = [
-                    {"weight": {"dtype": ["bf16"]}, "activation": {"dtype": ["bf16"]}},
-                    {"weight": {"dtype": "fp32"}, "activation": {"dtype": "fp32"}},
-                ]
-
-    def _query_quantizable_ops(self, matched_nodes):
-        """Collect the op-wise configuration for quantization.
-
-        Returns:
-            OrderDict: op-wise configuration.
-        """
-        bf16_common_config = {"weight": {"dtype": "bf16"}, "activation": {"dtype": "bf16"}}
-        fp32_common_config = {"weight": {"dtype": "fp32"}, "activation": {"dtype": "fp32"}}
-        uint8_type = self.query_handler.get_op_types_by_precision(precision="uint8")
-        int8_type = self.query_handler.get_op_types_by_precision(precision="int8")
-        bf16_type = self.query_handler.get_op_types_by_precision(precision="bf16")
-        tf_quantizable_op_type = list(set(uint8_type).union(set(int8_type)))
-
-        valid_precision = self.query_handler.get_mixed_precision_combination()
-        op_capability = self.query_handler.get_quantization_capability()
-        conv_config = copy.deepcopy(op_capability["Conv2D"])
-        conv3d_config = copy.deepcopy(op_capability["Conv3D"]) if "Conv3D" in op_capability else None
-        matmul_config = copy.deepcopy(op_capability["MatMul"])
-        other_config = copy.deepcopy(op_capability["default"])
-
-        self.quantizable_op_details = OrderedDict()
-        self.recipes_ops = {}
-
-        self._init_op_stat = {i: [] for i in tf_quantizable_op_type}
-
-        exclude_first_quantizable_op = (
-            True
-            if "first_conv_or_matmul_quantization" in self.recipes
-            and not self.recipes["first_conv_or_matmul_quantization"]
-            else False
-        )
-        for details in matched_nodes:
-            node_op = details[-1][0]
-            node_name = details[0]
-            patterns = details[-1]
-            pat_length = len(patterns)
-            pattern_info = {
-                "sequence": [[",".join(patterns[: pat_length - i]) for i in range(pat_length)][0]],
-                "precision": ["int8"],
-            }
-            first_conv_or_matmul_node = []
-            if (
-                node_op in tf_quantizable_op_type
-                and node_name not in self.exclude_node_names
-                and (node_name, self.unify_op_type_mapping[node_op]) not in self.quantizable_op_details
-            ):
-                if (
-                    self.unify_op_type_mapping[node_op].find("conv2d") != -1
-                    or self.unify_op_type_mapping[node_op].find("matmul") != -1
-                ) and len(first_conv_or_matmul_node) == 0:
-                    first_conv_or_matmul_node.append((node_name, self.unify_op_type_mapping[node_op]))
-                    self.recipes_ops["first_conv_or_matmul_quantization"] = first_conv_or_matmul_node
-                if exclude_first_quantizable_op and (  # pragma: no cover
-                    self.unify_op_type_mapping[node_op].find("conv2d") != -1
-                    or self.unify_op_type_mapping[node_op].find("matmul") != -1
-                ):
-                    exclude_first_quantizable_op = False
-                    self.exclude_node_names.append(node_name)
-                    continue
-                self._init_op_stat[node_op].append(node_name)
-                if self.unify_op_type_mapping[node_op].find("conv2d") != -1:
-                    conv2d_int8_config = copy.deepcopy(conv_config)
-                    conv2d_int8_config["pattern"] = pattern_info
-                    self.quantizable_op_details[(node_name, self.unify_op_type_mapping[node_op])] = [
-                        conv2d_int8_config,
-                        fp32_common_config,
-                    ]
-                elif self.unify_op_type_mapping[node_op].find("conv3d") != -1:
-                    conv3d_int8_config = copy.deepcopy(conv3d_config)
-                    conv3d_int8_config["pattern"] = pattern_info
-                    self.quantizable_op_details[(node_name, self.unify_op_type_mapping[node_op])] = [
-                        conv3d_int8_config,
-                        fp32_common_config,
-                    ]
-                elif self.unify_op_type_mapping[node_op].find("matmul") != -1:
-                    matmul_int8_config = copy.deepcopy(matmul_config)
-                    matmul_int8_config["pattern"] = pattern_info
-                    # TODO enable the sym mode once the tf fixed the mkldequantize_op.cc bug.
-                    # is_positive_input = self.pre_optimizer_handle.has_positive_input(node_name)
-                    # matmul_scheme = 'sym' if is_positive_input else 'asym'
-                    matmul_scheme = ["asym"]
-                    matmul_int8_config["activation"]["scheme"] = matmul_scheme
-                    self.quantizable_op_details[(node_name, self.unify_op_type_mapping[node_op])] = [
-                        matmul_int8_config,
-                        fp32_common_config,
-                    ]
-                else:
-                    self.quantizable_op_details[(node_name, self.unify_op_type_mapping[node_op])] = [
-                        copy.deepcopy(other_config),
-                        fp32_common_config,
-                    ]
-                if node_op in bf16_type and (
-                    ("bf16" in valid_precision and CpuInfo().bf16) or os.getenv("FORCE_BF16") == "1"
-                ):
-                    self.quantizable_op_details[(node_name, self.unify_op_type_mapping[node_op])].insert(
-                        1, bf16_common_config
-                    )
-
-                self.quantize_config["op_wise_config"][node_name] = (False, "minmax", False)
-        return self.quantizable_op_details
-
-    def _filter_unquantizable_concat(self, matched_nodes):
-        """Filter out unquantizable ConcatV2 Ops based on the positive input rule."""
-        target_concat_nodes = [i[0] for i in matched_nodes if i[-1][0] == "ConcatV2"]
-        from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper
-        from neural_compressor.tensorflow.quantization.utils.utility import GraphAnalyzer
-
-        g = GraphAnalyzer()
-        g.graph = self.pre_optimized_model.graph_def
-        graph_info = g.parse_graph()
-        concat_nodes = g.query_fusion_pattern_nodes([["ConcatV2"]])
-        for i in concat_nodes:
-            concat_node_name = i[0]
-            if concat_node_name not in target_concat_nodes:  # pragma: no cover
-                continue
-            input_positive_status = []
-            for index in range(graph_info[concat_node_name].node.attr["N"].i):
-                each_input_name = GraphRewriterHelper.node_name_from_input(
-                    graph_info[concat_node_name].node.input[index]
-                )
-                each_input_node = graph_info[each_input_name].node
-                positive_input = False
-                if each_input_node.op in ("Relu", "Relu6"):
-                    positive_input = True
-                else:
-                    positive_input = g.has_positive_input(each_input_node.name)
-                input_positive_status.append(positive_input)
-            if not any(input_positive_status):  # pragma: no cover
-                matched_nodes.remove(i)
-
-    def _filter_unquantizable_concat_performance_only(self, matched_nodes):
-        """OOB filter out unquantizable ConcatV2 OPs by checking the control flow rule."""
-        target_concat_nodes = [i[0] for i in matched_nodes if i[-1][0] == "ConcatV2"]
-        from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper
-        from neural_compressor.tensorflow.quantization.utils.utility import GraphAnalyzer
-
-        g = GraphAnalyzer()
-        g.graph = self.pre_optimized_model.graph_def
-        graph_info = g.parse_graph()
-        concat_nodes = g.query_fusion_pattern_nodes([["ConcatV2"]])
-        for i in concat_nodes:
-            concat_node_name = i[0]
-            if concat_node_name not in target_concat_nodes:  # pragma: no cover
-                continue
-            input_positive_status = []
-            control_flow = False
-            for index in range(graph_info[concat_node_name].node.attr["N"].i):
-                each_input_name = GraphRewriterHelper.node_name_from_input(
-                    graph_info[concat_node_name].node.input[index]
-                )
-                each_input_node = graph_info[each_input_name].node
-                if each_input_node.op in ("Switch"):  # pragma: no cover
-                    control_flow = True
-            if control_flow:  # pragma: no cover
-                matched_nodes.remove(i)
-
-    def parse_quant_config(self, quant_config, model, calib_iteration):
-        """Parse the quant_config to tune_cfg.
-
-        Args:
-            quant_config: a quantization configuration.
-            model: the fp32 model to be quantized.
-            calib_iteration: the number of iteration for calibration.
-
-        Returns:
-            tune_cfg: a dict composed by necessary information for quantization.
-        """
-        capability = self._query_fw_capability(model)
-        config_converter = TensorflowConfigConverter(quant_config, capability)
-        tune_cfg = config_converter.parse_to_tune_cfg()
-        tune_cfg["calib_sampling_size"] = self.calib_sampling_size
-        tune_cfg["calib_iteration"] = calib_iteration
-        tune_cfg["approach"] = "post_training_static_quant"
-        tune_cfg["recipe_cfgs"] = tune_cfg.get("recipe_cfgs", {})
-        tune_cfg["trial_number"] = 1
-
-        return tune_cfg
-
-    def _query_fw_capability(self, model):
-        """Collect the model-wise and op-wise configuration for quantization.
-
-        Args:
-            model (tf.compat.v1.GraphDef): model definition.
-
-        Returns:
-            [dict]: model-wise & op-wise configuration for quantization.
-        """
-        if self.pre_optimized_model is None:
-            from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.pre_optimize import (
-                PreOptimization,
-            )
-
-            self.pre_optimizer_handle = PreOptimization(model, self.new_api, self.device)
-            self.pre_optimized_model = self.pre_optimizer_handle.get_optimized_model(self.itex_mode)
-            model.graph_def = self.pre_optimized_model.graph_def
-
-        self.exclude_node_names = self.pre_optimizer_handle.get_excluded_node_names()
-        patterns = self.query_handler.generate_internal_patterns()
-        bf16_patterns = self.query_handler.get_bf16_patterns()
-        matched_nodes = self.pre_optimizer_handle.get_matched_nodes(patterns)
-        matched_bf16_nodes = self.pre_optimizer_handle.get_matched_nodes(bf16_patterns)
-        original_graph_node_name = [i.name for i in model.graph_def.node]
-        matched_nodes = sorted(
-            matched_nodes, reverse=True, key=lambda i: (original_graph_node_name.index(i[0]), len(i[-1]))
-        )
-
-        def check_match(patterns, input_pattern):
-            """Check whether an input pattern matches a configured pattern list."""
-            for i in patterns:
-                if input_pattern == [i for i in i.replace("+", " ").strip().split(" ") if i]:  # pragma: no cover
-                    return True
-            return False
-
-        if (self.new_api and self.performance_only) or self.itex_mode or os.getenv("TF_FORCE_CONCAT_OPTS") == "1":
-            self._filter_unquantizable_concat_performance_only(matched_nodes)
-        else:
-            self._filter_unquantizable_concat(matched_nodes)
-        copied_matched_nodes = copy.deepcopy(matched_nodes)
-        for i in copied_matched_nodes:
-            if i[-1][0] in self.query_handler.get_op_types()["int8"]:
-                continue
-
-            if not self.pre_optimizer_handle.has_positive_input(i[0]) and not check_match(
-                self.query_handler.get_fuse_patterns()["int8"], i[-1]
-            ):
-                matched_nodes.remove(i)
-
-        del copied_matched_nodes
-
-        copied_matched_nodes = copy.deepcopy(matched_bf16_nodes)
-        for i in copied_matched_nodes:
-            for j in matched_nodes:
-                if i[0] == j[0] and i in matched_bf16_nodes:
-                    matched_bf16_nodes.remove(i)
-
-        del copied_matched_nodes
-
-        self._query_quantizable_ops(matched_nodes)
-        self._query_bf16_ops(matched_bf16_nodes)
-        capability = {"optypewise": self.get_optype_wise_ability(), "recipes_ops": self.recipes_ops}
-        capability["opwise"] = copy.deepcopy(self.quantizable_op_details)
-        capability["opwise"].update(self.bf16_op_details)
-        logger.debug("Dump framework quantization capability:")
-        logger.debug(capability)
-
-        return capability
-
-    def quantize_input(self, model):
-        """Quantize the model to be able to take quantized input.
-
-        Remove graph QuantizedV2 op and move its input tensor to QuantizedConv2d
-        and calculate the min-max scale.
-
-        Args:
-            model (tf.compat.v1.GraphDef): The model to quantize input
-
-        Return:
-            model (tf.compat.v1.GraphDef): The quantized input model
-            scale (float): The scale for dataloader to generate quantized input
-        """
-        scale = None
-        # quantize input only support tensorflow version > 2.1.0
-        if version1_lt_version2(tf.version.VERSION, "2.1.0"):  # pragma: no cover
-            logger.warning("Quantize input needs tensorflow 2.1.0 and newer.")
-            return model, scale
-
-        graph_def = model.as_graph_def()
-        node_name_mapping = {}
-        quantize_nodes = []
-        for node in graph_def.node:
-            node_name_mapping[node.name] = node
-            if node.op == "QuantizeV2":
-                quantize_nodes.append(node)
-
-        target_quantize_nodes = []
-        for node in quantize_nodes:
-            # only support Quantizev2 input op Pad and Placeholder
-            if (
-                node_name_mapping[node.input[0]].op == "Pad"
-                and node_name_mapping[node_name_mapping[node.input[0]].input[0]].op == "Placeholder"
-            ) or node_name_mapping[node.input[0]].op == "Placeholder":
-                target_quantize_nodes.append(node)
-        assert len(target_quantize_nodes) == 1, "only support 1 QuantizeV2 from Placeholder"
-        quantize_node = target_quantize_nodes[0]
-
-        quantize_node_input = node_name_mapping[quantize_node.input[0]]
-        quantize_node_outputs = [node for node in graph_def.node if quantize_node.name in node.input]
-
-        from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper
-
-        if quantize_node_input.op == "Pad":
-            pad_node_input = node_name_mapping[quantize_node_input.input[0]]
-            assert pad_node_input.op == "Placeholder", "only support Pad between QuantizeV2 and Placeholder"
-            from tensorflow.python.framework import tensor_util
-
-            paddings_tensor = tensor_util.MakeNdarray(
-                node_name_mapping[quantize_node_input.input[1]].attr["value"].tensor
-            ).flatten()
-
-            quantize_node.input[0] = quantize_node_input.input[0]
-            for conv_node in quantize_node_outputs:
-                assert "Conv2D" in conv_node.op, "only support QuantizeV2 to Conv2D"
-
-                GraphRewriterHelper.set_attr_int_list(conv_node, "padding_list", paddings_tensor)
-            graph_def.node.remove(quantize_node_input)
-
-        from tensorflow.python.framework import dtypes
-
-        GraphRewriterHelper.set_attr_dtype(node_name_mapping[quantize_node.input[0]], "dtype", dtypes.qint8)
-
-        for conv_node in quantize_node_outputs:
-            for index, conv_input in enumerate(conv_node.input):
-                if conv_input == quantize_node.name:
-                    conv_node.input[index] = quantize_node.input[0]
-                elif conv_input == quantize_node.name + ":1":
-                    conv_node.input[index] = quantize_node.input[1]
-                elif conv_input == quantize_node.name + ":2":
-                    conv_node.input[index] = quantize_node.input[2]
-
-        # get the input's min-max value and calculate scale
-        max_node = node_name_mapping[quantize_node.input[2]]
-        min_node = node_name_mapping[quantize_node.input[1]]
-        max_value = max_node.attr["value"].tensor.float_val[0]
-        min_value = min_node.attr["value"].tensor.float_val[0]
-        scale = 127.0 / max(abs(max_value), abs(min_value))
-        # remove QuantizeV2 node
-        graph_def.node.remove(quantize_node)
-
-        graph = tf.Graph()
-        with graph.as_default():
-            # use name='' to avoid 'import/' to name scope
-            tf.import_graph_def(graph_def, name="")
-        return graph, scale
-
-    def get_optype_wise_ability(self):
-        """Get the op type wise capability by generating the union value of each op type.
-
-        Returns:
-            [string dict]: the key is op type while the value is the
-                           detail configurations of activation and weight for this op type.
-        """
-        res = OrderedDict()
-        for op in self.quantizable_op_details:
-            if op[1] not in res:
-                res[op[1]] = {"activation": self.quantizable_op_details[op][0]["activation"]}
-                if "weight" in self.quantizable_op_details[op][0]:
-                    res[op[1]]["weight"] = self.quantizable_op_details[op][0]["weight"]
-        for op in self.bf16_op_details:
-            if op[1] not in res:
-                res[op[1]] = {"activation": {"dtype": ["bf16"]}, "weight": {"dtype": ["bf16"]}}
-        return res
-
-
-class Tensorflow_ITEXAdaptor(TensorFlowAdaptor):  # pragma: no cover
-    """Tensorflow ITEX Adaptor Class."""
-
-    def __init__(self, framework_specific_info):
-        """Initialization.
-
-        Args:
-            framework_specific_info: framework specific information.
-        """
-        super().__init__(framework_specific_info)
-
-    @dump_elapsed_time("Pass quantize model")
-    def quantize(
-        self,
-        quant_config: StaticQuantConfig,
-        model: BaseModel,
-        calib_dataloader: Callable = None,
-        calib_iteration: int = 100,
-        calib_func: Callable = None,
-    ):
-        """Execute the quantize process on the specified model.
-
-        Args:
-            quant_config: a quantization configuration.
-            model: the fp32 model to be quantized.
-            calib_dataloader: a data loader for calibration.
-            calib_iteration: the iteration of calibration.
-            calib_func: the function used for calibration, should be a substitution for calib_dataloader
-            when the built-in calibration function of INC does not work for model inference.
-
-        Returns:
-            converted_model: the quantized INC model wrapper.
-        """
-        self.calib_sampling_size = calib_dataloader.batch_size * calib_iteration
-        tune_cfg = self.parse_quant_config(quant_config, model, calib_iteration)
-        self._tuning_cfg_to_fw(tune_cfg)
-        logger.debug("Dump quantization configurations:")
-        logger.debug(self.quantize_config)
-        from neural_compressor.tensorflow.quantization.utils.graph_converter import GraphConverter
-
-        self.calib_sampling_size = tune_cfg.get("calib_sampling_size", 1)
-        if isinstance(calib_dataloader, BaseDataLoader):
-            batch_size = calib_dataloader.batch_size
-            try:
-                for i in range(batch_size):
-                    if self.calib_sampling_size % (batch_size - i) == 0:
-                        calib_batch_size = batch_size - i
-                        if i != 0:  # pragma: no cover
-                            logger.warning(
-                                "Reset `calibration.dataloader.batch_size` field "
-                                "to {}".format(calib_batch_size) + " to make sure the sampling_size is "
-                                "divisible exactly by batch size"
-                            )
-                        break
-                tmp_iterations = int(math.ceil(self.calib_sampling_size / calib_batch_size))
-                calib_dataloader.batch(calib_batch_size)
-                self.quantize_config["calib_iteration"] = tmp_iterations
-
-                converted_model = GraphConverter(
-                    model,
-                    qt_config=self.quantize_config,
-                    recipes=self.recipes,
-                    int8_sequences=self.op_wise_sequences,
-                    fp32_ops=self.fp32_ops,
-                    bf16_ops=self.bf16_ops,
-                    data_loader=calib_dataloader,
-                    calib_func=calib_func,
-                    itex_mode=self.itex_mode,
-                    qdq_enabled=self.qdq_enabled,
-                    new_api=self.new_api,
-                    performance_only=self.performance_only,
-                    use_bf16=self.use_bf16,
-                ).convert()
-            except Exception:  # pragma: no cover
-                from neural_compressor.tensorflow.quantization.utils.utility import get_model_input_shape
-
-                batch_size = get_model_input_shape(model)
-                logger.warning(
-                    "Fail to forward with batch size={}, set to {} now.".format(calib_dataloader.batch_size, batch_size)
-                )
-                calib_dataloader.batch(batch_size)
-                self.quantize_config["calib_iteration"] = self.calib_sampling_size
-                converted_model = GraphConverter(
-                    model,
-                    qt_config=self.quantize_config,
-                    recipes=self.recipes,
-                    int8_sequences=self.op_wise_sequences,
-                    fp32_ops=self.fp32_ops,
-                    bf16_ops=self.bf16_ops,
-                    data_loader=calib_dataloader,
-                    itex_mode=self.itex_mode,
-                    qdq_enabled=self.qdq_enabled,
-                    new_api=self.new_api,
-                    performance_only=self.performance_only,
-                    use_bf16=self.use_bf16,
-                ).convert()
-        else:  # pragma: no cover
-            if hasattr(calib_dataloader, "batch_size") and self.calib_sampling_size % calib_dataloader.batch_size != 0:
-                iter = self.quantize_config["calib_iteration"]
-                logger.warning(
-                    "Please note that calibration sampling size {} "
-                    "isn't divisible exactly by batch size {}. "
-                    "So the real sampling size is {}.".format(
-                        self.calib_sampling_size, calib_dataloader.batch_size, calib_dataloader.batch_size * iter
-                    )
-                )
-            converted_model = GraphConverter(
-                model,
-                qt_config=self.quantize_config,
-                recipes=self.recipes,
-                int8_sequences=self.op_wise_sequences,
-                fp32_ops=self.fp32_ops,
-                bf16_ops=self.bf16_ops,
-                data_loader=calib_dataloader,
-                calib_func=calib_func,
-                itex_mode=self.itex_mode,
-                qdq_enabled=self.qdq_enabled,
-                new_api=self.new_api,
-                performance_only=self.performance_only,
-                use_bf16=self.use_bf16,
-            ).convert()
-
-        self._dump_model_op_stats(converted_model.graph_def)
-
-        return converted_model
-
-
-class TensorFlowConfig:
-    """Base config class for TensorFlow."""
-
-    def __init__(self, precisions=None):
-        """Init an TF object."""
-        self._precisions = precisions
-
-    @property
-    def precisions(self):
-        """Get precision."""
-        return self._precisions
-
-    @precisions.setter
-    def precisions(self, precisions):  # pragma: no cover
-        """Set precision."""
-        if not isinstance(precisions, list):
-            precisions = [precisions]
-        for pr in precisions:
-            self.check_value("precisions", pr, str, ["int8", "uint8", "fp32", "bf16", "fp16"])
-        self._precisions = precisions
-
-    @staticmethod
-    def check_value(name, src, supported_type, supported_value=[]):  # pragma: no cover
-        """Check if the given object is the given supported type and in the given supported value.
-
-        Example::
-            def datatype(self, datatype):
-                if self.check_value("datatype", datatype, list, ["fp32", "bf16", "uint8", "int8"]):
-                    self._datatype = datatype
-        """
-        if isinstance(src, list) and any([not isinstance(i, supported_type) for i in src]):
-            assert False, "Type of {} items should be {} but not {}".format(
-                name, str(supported_type), [type(i) for i in src]
-            )
-        elif not isinstance(src, list) and not isinstance(src, supported_type):
-            assert False, "Type of {} should be {} but not {}".format(name, str(supported_type), type(src))
-
-        if len(supported_value) > 0:
-            if isinstance(src, str) and src not in supported_value:
-                assert False, "{} is not in supported {}: {}. Skip setting it.".format(src, name, str(supported_value))
-            elif (
-                isinstance(src, list)
-                and all([isinstance(i, str) for i in src])
-                and any([i not in supported_value for i in src])
-            ):
-                assert False, "{} is not in supported {}: {}. Skip setting it.".format(src, name, str(supported_value))
-
-        return True
-
-
-class TensorflowQuery:
-    """Tensorflow Query Capability Class."""
-
-    def __init__(self, local_config_file=None, performance_only=False, itex_mode=False, quant_mode="static"):
-        """Initialization.
-
-        Args:
-            local_config_file: local configuration file name.
-            performance_only: oob performance only mode.
-            itex_mode: check if itex mode.
-            quant_mode: quantization mode, static or dynamic.
-        """
-        self.version = tf.version.VERSION
-        self.cfg = local_config_file
-        self.cur_config = None
-        self.performance_only = performance_only
-        self.quant_mode = quant_mode
-        self.itex_mode = itex_mode
-        self._one_shot_query()
-
-    def _get_specified_version_cfg(self, data):
-        """Get the configuration for the current runtime.
-
-        If there's no matched configuration in the input yaml, we'll
-        use the configuration of the nearest framework version field of yaml.
-
-        Args:
-            data (Yaml content): input yaml file.
-
-        Returns:
-            [dictionary]: the content for specific version.
-        """
-        from functools import cmp_to_key
-
-        config = None
-
-        def _compare(version1, version2):
-            """Compare two TensorFlow version strings for sorting."""
-            if parse_version(version1) == parse_version(version2):  # pragma: no cover
-                return 0
-            elif parse_version(version1) < parse_version(version2):
-                return -1
-            else:
-                return 1
-
-        fallback_list = []
-        for sub_data in data:
-            if "default" in sub_data["version"]["name"]:
-                assert config is None, "Only one default config " "is allowed in framework yaml file."
-                config = sub_data
-
-            if self.version in sub_data["version"]["name"]:
-                return sub_data
-            else:
-                if sub_data["version"]["name"] == [
-                    "2.11.0202242",
-                    "2.11.0202250",
-                    "2.11.0202317",
-                    "2.11.0202323",
-                    "2.14.0202335",
-                    "2.14.dev202335",
-                    "2.15.0202341",
-                ]:
-                    continue
-                sorted_list = copy.deepcopy(sub_data["version"]["name"])
-                sorted_list.remove("default") if "default" in sorted_list else None
-                if isinstance(sorted_list, list):
-                    # TensorFlow 1.15.0-up1/up2/up3 release versions are abnoraml release naming
-                    # convention. Replacing them with dot for version comparison.
-                    sorted_list = [i.replace("-up", ".") for i in sorted_list]
-                    sorted_list = sorted(sorted_list, key=cmp_to_key(_compare), reverse=True)
-                else:  # pragma: no cover
-                    assert isinstance(sorted_list, str)
-                    sorted_list = list(sorted_list.replace("-up", ".").split())
-                for i in sorted_list:
-                    if parse_version(self.version) >= parse_version(i):
-                        fallback_list.append([i, sub_data])
-                        break
-
-        assert config is not None, "The default config in framework yaml must exist."
-        nearest_version = str(0)
-        for fallback in fallback_list:
-            if parse_version(fallback[0]) > parse_version(nearest_version):
-                nearest_version = fallback[0]
-                config = fallback[1]
-
-        return config
-
-    def _one_shot_query(self):
-        """One short query for some patterns."""
-        # pylint: disable=E1136
-        with open(self.cfg) as f:
-            content = yaml.safe_load(f)
-            try:
-                self.cur_config = self._get_specified_version_cfg(content)
-                if not self.performance_only:
-                    remove_int8_ops = [
-                        "FusedBatchNorm",
-                        "FusedBatchNormV2",
-                        "FusedBatchNormV3",
-                        "_MklFusedInstanceNorm",
-                    ]
-                    for op_type in remove_int8_ops:
-                        while op_type in self.cur_config["int8"][self.quant_mode].keys():
-                            self.cur_config["int8"][self.quant_mode].pop(op_type, None)
-
-            except Exception as e:
-                logger.info("Fail to parse {} due to {}.".format(self.cfg, str(e)))
-                self.cur_config = None
-                raise ValueError(
-                    "Please check if the format of {} follows Neural Compressor yaml schema.".format(self.cfg)
-                )
-        self._update_cfg_with_usr_definition()
-
-    def _update_cfg_with_usr_definition(self):
-        """Add user defined precision configuration."""
-        tensorflow_config = TensorFlowConfig()
-        if tensorflow_config.precisions is not None:  # pragma: no cover
-            self.cur_config["precisions"]["names"] = ",".join(tensorflow_config.precisions)
-
-    def get_version(self):
-        """Get the current backend version information.
-
-        Returns:
-            [string]: version string.
-        """
-        return self.cur_config["version"]["name"]
-
-    def get_op_types(self):
-        """Get the supported op types by all precisions.
-
-        Returns:
-            [dictionary list]: A list composed of dictionary which key is precision
-            and value is the op types.
-        """
-        return {
-            "int8": self.get_op_types_by_precision("int8"),
-            "uint8": self.get_op_types_by_precision("uint8"),
-            "bf16": self.get_op_types_by_precision("bf16"),
-        }
-
-    def get_fuse_patterns(self):
-        """Get supported patterns by low precisions.
-
-        Returns:
-            [dictionary list]: A list composed of dictionary which key is precision
-            and value is the supported patterns.
-        """
-        spr_int8_pattern_list = [
-            "Conv2D + BiasAdd",
-            "Conv2D + BiasAdd + Add + Relu6 + Mul + Mul",
-            "Conv2D + Add + Relu6 + Mul + Mul",
-            "Conv2D + BiasAdd + swish_f32",
-            "Conv2D + Add + swish_f32",
-            "Conv2D + AddV2 + swish_f32",
-            "Conv2D + swish_f32",
-            "Conv2D + BiasAdd + Relu",
-            "Conv2D + Relu",
-            "Conv2D + BiasAdd + Elu",
-            "Conv2D + Elu",
-            "Conv2D + BiasAdd + Relu6",
-            "Conv2D + Relu6",
-            "Conv2D + BiasAdd + LeakyRelu",
-            "Conv2D + BiasAdd + Add + LeakyRelu",
-            "Conv2D + BiasAdd + AddV2 + LeakyRelu",
-            "Conv2D + Add + LeakyRelu",
-            "Conv2D + AddV2 + LeakyRelu",
-            "Conv2D + LeakyRelu",
-            "Conv2D + BiasAdd + Sigmoid",
-            "Conv2D + Sigmoid",
-            "Conv2D + BiasAdd + LeakyRelu + AddV2",
-            "Conv2D + BiasAdd + LeakyRelu + Add",
-            "Conv2D + LeakyRelu + AddV2",
-            "Conv2D + LeakyRelu + Add",
-            "Conv2D + BiasAdd + Relu + AddV2",
-            "Conv2D + BiasAdd + Relu + Add",
-            "Conv2D + Relu + AddV2",
-            "Conv2D + Relu + Add",
-            "Conv2D + Add",
-            "Conv2D + AddV2",
-            "Conv2D + AddV2 + Add",
-            "Conv2D + Add + Add",
-            "Conv2D + BiasAdd + Add",
-            "Conv3D + Add",
-            "Conv3D + AddV2",
-            "Conv3D + BiasAdd",
-            "Conv3D + BiasAdd + Add",
-            "Conv3D + BiasAdd + AddV2",
-            "Conv3D + AddV2 + AddV2",
-            "DepthwiseConv2dNative + BiasAdd + Add + Relu6 + Mul + Mul",
-            "DepthwiseConv2dNative + Add + Relu6 + Mul + Mul",
-            "DepthwiseConv2dNative + BiasAdd + swish_f32",
-            "DepthwiseConv2dNative + Add + swish_f32",
-            "DepthwiseConv2dNative + AddV2 + swish_f32",
-            "DepthwiseConv2dNative + swish_f32",
-            "DepthwiseConv2dNative + BiasAdd + LeakyRelu",
-            "DepthwiseConv2dNative + LeakyRelu",
-            "DepthwiseConv2dNative + BiasAdd + Relu6",
-            "DepthwiseConv2dNative + Relu6",
-            "DepthwiseConv2dNative + BiasAdd + Relu",
-            "DepthwiseConv2dNative + Relu",
-            "DepthwiseConv2dNative + Add + Relu6",
-            "DepthwiseConv2dNative + BiasAdd",
-            "FusedBatchNormV3 + Relu",
-            "FusedBatchNormV3 + LeakyRelu",
-            "_MklFusedInstanceNorm + Relu",
-            "_MklFusedInstanceNorm + LeakyRelu",
-            "Conv2DBackpropInput + BiasAdd",
-            "Conv3DBackpropInputV2 + BiasAdd",
-        ]
-
-        spr_uint8_pattern_list = [
-            "Conv2D + BiasAdd + AddN + Relu",
-            "Conv2D + AddN + Relu",
-            "Conv2D + BiasAdd + AddN + Relu6",
-            "Conv2D + AddN + Relu6",
-            "Conv2D + BiasAdd + AddV2 + Relu",
-            "Conv2D + AddV2 + Relu",
-            "Conv2D + BiasAdd + AddV2 + Relu6",
-            "Conv2D + AddV2 + Relu6",
-            "Conv2D + BiasAdd + Add + Relu",
-            "Conv2D + Add + Relu",
-            "Conv2D + BiasAdd + Add + Relu6",
-            "Conv2D + Add + Relu6",
-            "Conv2D + BiasAdd + Relu",
-            "Conv2D + BiasAdd + Relu6",
-            "Conv2D + Relu",
-            "Conv2D + Relu6",
-            "Conv2D + BiasAdd",
-            "Conv2D + Add + Add + Relu",
-            "DepthwiseConv2dNative + BiasAdd + Relu6",
-            "DepthwiseConv2dNative + Relu6",
-            "DepthwiseConv2dNative + BiasAdd + Relu",
-            "DepthwiseConv2dNative + Relu",
-            "DepthwiseConv2dNative + Add + Relu6",
-            "DepthwiseConv2dNative + BiasAdd",
-            "MatMul + BiasAdd",
-            "MatMul + BiasAdd + Add",
-            "MatMul + BiasAdd + AddV2",
-            "MatMul + BiasAdd + Relu",
-            "MatMul + BiasAdd + Relu6",
-            "MatMul + BiasAdd + LeakyRelu",
-            "MatMul + BiasAdd + Gelu",
-            "MatMul + BiasAdd + Elu",
-            "MatMul + BiasAdd + Tanh",
-            "MatMul + BiasAdd + Sigmoid",
-            "MatMul + Add",
-            "MatMul + AddV2",
-            "MatMul + Relu",
-            "MatMul + Relu6",
-            "MatMul + LeakyRelu",
-            "MatMul + Gelu",
-            "MatMul + Elu",
-            "MatMul + Tanh",
-            "MatMul + Sigmoid",
-            "BatchMatMul + Mul",
-            "BatchMatMulV2 + Mul",
-            "BatchMatMul + Add",
-            "BatchMatMulV2 + Add",
-            "BatchMatMul + AddV2",
-            "BatchMatMulV2 + AddV2",
-            "BatchMatMul + Mul + Add",
-            "BatchMatMulV2 + Mul + Add",
-            "BatchMatMul + Mul + AddV2",
-            "BatchMatMulV2 + Mul + AddV2",
-            "Conv3D + AddV2 + AddV2 + Relu",
-            "Conv3D + Add + Relu",
-            "Conv3D + AddV2 + Relu",
-            "Conv3D + Relu",
-            "Conv3D + Relu6",
-            "Conv3D + Add + Relu6",
-            "Conv3D + AddV2 + Relu6",
-            "Conv3D + Elu",
-            "Conv3D + LeakyRelu",
-            "Conv3D + BiasAdd + Relu",
-            "Conv3D + BiasAdd + Relu6",
-            "Conv3D + BiasAdd + Elu",
-            "Conv3D + BiasAdd + LeakyRelu",
-            "Conv3D + Add + Elu",
-            "Conv3D + Add + LeakyRelu",
-            "Conv2DBackpropInput + BiasAdd",
-            "Conv3DBackpropInputV2 + BiasAdd",
-        ]
-
-        tf_int8_pattern_list = ["Conv2D + BiasAdd", "Conv2D + BiasAdd + Relu", "Conv2D + BiasAdd + Relu6"]
-        tf_uint8_pattern_list = [
-            "Conv2D + BiasAdd + AddN + Relu",
-            "Conv2D + BiasAdd + AddN + Relu6",
-            "Conv2D + BiasAdd + AddV2 + Relu",
-            "Conv2D + BiasAdd + AddV2 + Relu6",
-            "Conv2D + BiasAdd + Add + Relu",
-            "Conv2D + BiasAdd + Add + Relu6",
-            "Conv2D + BiasAdd + Relu",
-            "Conv2D + BiasAdd + Relu6",
-            "Conv2D + Add + Relu",
-            "Conv2D + Add + Relu6",
-            "Conv2D + Relu",
-            "Conv2D + Relu6",
-            "Conv2D + BiasAdd",
-            "DepthwiseConv2dNative + BiasAdd + Relu6",
-            "DepthwiseConv2dNative + BiasAdd + Relu",
-            "DepthwiseConv2dNative + Add + Relu6",
-            "DepthwiseConv2dNative + BiasAdd",
-            "MatMul + BiasAdd + Relu",
-            "MatMul + BiasAdd",
-        ]
-        tf1_15_up3_int8_pattern_list = [
-            "Conv2D + BiasAdd",
-            "Conv2D + BiasAdd + Relu",
-            "Conv2D + BiasAdd + LeakyRelu",
-            "Conv2D + BiasAdd + LeakyRelu + AddV2",
-            "Conv2D + BiasAdd + Relu6",
-        ]
-        tf1_15_up3_uint8_pattern_list = [
-            "Conv2D + BiasAdd + AddN + Relu",
-            "Conv2D + BiasAdd + AddN + Relu6",
-            "Conv2D + BiasAdd + AddV2 + Relu",
-            "Conv2D + BiasAdd + AddV2 + Relu6",
-            "Conv2D + BiasAdd + Add + Relu",
-            "Conv2D + BiasAdd + Add + Relu6",
-            "Conv2D + BiasAdd + Relu",
-            "Conv2D + BiasAdd + Relu6",
-            "Conv2D + Add + Relu",
-            "Conv2D + Add + Relu6",
-            "Conv2D + Relu",
-            "Conv2D + Relu6",
-            "Conv2D + BiasAdd",
-            "DepthwiseConv2dNative + BiasAdd + Relu6",
-            "DepthwiseConv2dNative + Add + Relu6",
-            "DepthwiseConv2dNative + BiasAdd",
-            "MatMul + BiasAdd + Relu",
-            "MatMul + BiasAdd",
-        ]
-        old_tf_int8_pattern_list = ["MatMul + BiasAdd + Relu", "MatMul + BiasAdd"]
-        old_tf_uint8_pattern_list = [
-            "Conv2D + BiasAdd + AddN + Relu",
-            "Conv2D + BiasAdd + AddN + Relu6",
-            "Conv2D + BiasAdd + AddV2 + Relu",
-            "Conv2D + BiasAdd + AddV2 + Relu6",
-            "Conv2D + BiasAdd + Add + Relu",
-            "Conv2D + BiasAdd + Add + Relu6",
-            "Conv2D + BiasAdd + Relu",
-            "Conv2D + BiasAdd + Relu6",
-            "Conv2D + Add + Relu",
-            "Conv2D + Add + Relu6",
-            "Conv2D + Relu",
-            "Conv2D + Relu6",
-            "Conv2D + BiasAdd",
-            "DepthwiseConv2dNative + BiasAdd + Relu6",
-            "DepthwiseConv2dNative + Add + Relu6",
-            "DepthwiseConv2dNative + BiasAdd",
-            "MatMul + BiasAdd + Relu",
-            "MatMul + BiasAdd",
-        ]
-
-        for index, pattern in enumerate(spr_int8_pattern_list):
-            spr_int8_pattern_list[index] = "Dequantize + " + pattern + " + QuantizeV2"
-        for index, pattern in enumerate(spr_uint8_pattern_list):
-            spr_uint8_pattern_list[index] = "Dequantize + " + pattern + " + QuantizeV2"
-
-        if not self.performance_only:
-            remove_int8_ops = ["FusedBatchNorm", "FusedBatchNormV2", "FusedBatchNormV3", "_MklFusedInstanceNorm"]
-            for op_type in remove_int8_ops:
-                patterns = [
-                    f"Dequantize + {op_type} + Relu + QuantizeV2",
-                    f"Dequantize + {op_type} + LeakyRelu + QuantizeV2",
-                ]
-                for pattern in patterns:
-                    while pattern in spr_int8_pattern_list:
-                        spr_int8_pattern_list.remove(pattern)
-                    while pattern in spr_uint8_pattern_list:
-                        spr_uint8_pattern_list.remove(pattern)
-
-        patterns = {}
-        if tf.version.VERSION in spr_base_verions or self.itex_mode:
-            patterns["int8"] = spr_int8_pattern_list
-            patterns["uint8"] = spr_uint8_pattern_list
-        elif version1_gte_version2(tf.version.VERSION, "2.1.0"):
-            patterns["int8"] = tf_int8_pattern_list
-            patterns["uint8"] = tf_uint8_pattern_list
-            if self.itex_mode:  # pragma: no cover
-                patterns["int8"].append("FusedBatchNormV3 + Relu")
-                patterns["int8"].append("FusedBatchNormV3 + LeakyRelu")
-        elif version1_eq_version2(tf.version.VERSION, "1.15.0-up3"):  # pragma: no cover
-            patterns["int8"] = tf1_15_up3_int8_pattern_list
-            patterns["uint8"] = tf1_15_up3_uint8_pattern_list
-        else:  # pragma: no cover
-            patterns["int8"] = old_tf_int8_pattern_list
-            patterns["uint8"] = old_tf_uint8_pattern_list
-
-        return patterns
-
-    def get_quantization_capability(self):
-        """Get the supported op types' quantization capability.
-
-        Returns:
-            [dictionary list]: A list composed of dictionary which key is precision
-            and value is a dict that describes all op types' quantization capability.
-        """
-        for op_type, _ in self.cur_config["int8"][self.quant_mode].items():
-            self.cur_config["int8"][self.quant_mode][op_type]["activation"]["quant_mode"] = self.quant_mode
-        return self.cur_config["int8"][self.quant_mode]
-
-    def get_op_types_by_precision(self, precision):
-        """Get op types per precision.
-
-        Args:
-            precision (string): precision name
-
-        Returns:
-            [string list]: A list composed of op type.
-        """
-        assert precision in ("bf16", "uint8", "int8")
-
-        if precision == "int8":
-            if tf.version.VERSION in spr_base_verions or self.itex_mode:
-                op_type_list = [key for key in self.cur_config["int8"][self.quant_mode].keys()]
-                if not self.performance_only and not self.itex_mode:
-                    remove_int8_ops = [
-                        "FusedBatchNorm",
-                        "FusedBatchNormV2",
-                        "FusedBatchNormV3",
-                        "_MklFusedInstanceNorm",
-                    ]
-                    for op_type in remove_int8_ops:
-                        while op_type in op_type_list:
-                            op_type_list.remove(op_type)
-                return op_type_list
-            if version1_gte_version2(tf.version.VERSION, "2.1.0") or version1_eq_version2(
-                tf.version.VERSION, "1.15.0-up3"
-            ):
-                return ["Conv2D", "MatMul", "ConcatV2", "MaxPool", "AvgPool"]
-            return ["MatMul", "ConcatV2", "MaxPool", "AvgPool"]  # pragma: no cover
-        if precision == "uint8":
-            if tf.version.VERSION in spr_base_verions:
-                return [key for key in self.cur_config["int8"][self.quant_mode].keys() if "Norm" not in key]
-            if version1_gte_version2(tf.version.VERSION, "2.1.0") or version1_eq_version2(
-                tf.version.VERSION, "1.15.0-up3"
-            ):
-                return ["Conv2D", "MatMul", "ConcatV2", "MaxPool", "AvgPool", "DepthwiseConv2dNative"]
-            return ["Conv2D", "MatMul", "ConcatV2", "MaxPool", "AvgPool"]  # pragma: no cover
-        if precision == "bf16":
-            if tf.version.VERSION in spr_base_verions:
-                return self.cur_config[precision]
-            if version1_gte_version2(tf.version.VERSION, "2.1.0") or version1_eq_version2(
-                tf.version.VERSION, "1.15.0-up3"
-            ):
-                return self.cur_config[precision]
-            return []  # pragma: no cover
-
-    def get_mixed_precision_combination(self):
-        """Get the valid mixed precisions.
-
-        Returns:
-            [string list]: valid precision list.
-        """
-        if version1_gte_version2(tf.version.VERSION, "2.1.0") or version1_eq_version2(tf.version.VERSION, "1.15.0-up3"):
-            return ["int8", "uint8", "bf16", "fp32"]
-        return ["uint8", "fp32"]
-
-    def get_bf16_patterns(self):
-        """Get BF16 pattern list.
-
-        Returns:
-            [List]: bf16 pattern list.
-        """
-        bf16_op_types = [i for i in self.get_op_types_by_precision("bf16")]
-        res = []
-        for i in bf16_op_types:
-            res.append([[i]])
-
-        return res
-
-    def get_eightbit_patterns(self, qdq_enabled=False):
-        """Get eightbit op wise sequences information.
-
-        Returns:
-            [dictionary]: key is the op type while value is the list of sequences start
-                        with the op type same as key value.
-        """
-        quantizable_op_types = self.get_op_types_by_precision("int8") + self.get_op_types_by_precision("uint8")
-        int8_patterns = [
-            i.replace("+", " ").split()
-            for i in list(set(self.get_fuse_patterns()["int8"] + self.get_fuse_patterns()["uint8"]))
-        ]
-        res = {}
-        for i in quantizable_op_types:
-            if qdq_enabled:
-                res[i] = [["Dequantize", i, "QuantizeV2"]]
-            else:
-                res[i] = [[i]]
-
-        for pattern in int8_patterns:
-            if qdq_enabled:
-                op_type = pattern[1]
-            else:
-                op_type = pattern[0]
-            if op_type in res:
-                res[op_type].append(pattern)
-
-        return res
-
-    def generate_internal_patterns(self):
-        """Translate the patterns defined in the yaml to internal pattern expression."""
-
-        def _generate_pattern(data):
-            """Generate a normalized internal pattern from op sequences."""
-            length = [len(i) for i in data]
-            res = []
-            for index in range(max(length)):
-                if index <= min(length) - 1:
-                    tmp = [i[index] for i in data]
-                    if len(set(tmp)) == 1:
-                        res.append([tmp[0]])
-                    else:
-                        res.append(tuple(set(tmp)))
-                else:
-                    tmp1 = [i[index] for i in data if len(i) > index]
-                    res.append(tuple(set(tmp1)))
-
-            return res
-
-        op_level_sequences = {}
-
-        for k, op_level_all_sequences in self.get_eightbit_patterns().items():
-            op_level_sequences[k] = []
-            sorted_sequences = sorted(op_level_all_sequences)
-            last_len = 1
-            each_combination = []
-            for index, value in enumerate(sorted_sequences):
-                if len(value) >= last_len:
-                    last_len = len(value)
-                    each_combination.append(value)
-                else:
-                    op_level_sequences[k].append(copy.deepcopy(each_combination))
-                    each_combination.clear()
-                    each_combination.append(value)
-                    last_len = len(value)
-
-                if index == len(sorted_sequences) - 1:
-                    op_level_sequences[k].append(copy.deepcopy(each_combination))
-
-        final_out = []
-        for _, op_level_sequences in op_level_sequences.items():
-            for similar_sequences in op_level_sequences:
-                final_out.append(_generate_pattern(similar_sequences))
-
-        return final_out
-
-
-class TensorflowConfigConverter:
-    """Convert `StaticQuantConfig` to the format used by static quant algo."""
-
-    unify_op_type_mapping = UNIFY_OP_TYPE_MAPPING
-
-    def __init__(self, quant_config: StaticQuantConfig, capability: Dict):
-        """Init parser for TF static quant config.
-
-        Args:
-            quant_config: the keras static quant config.
-            capability: the supported config lists for each op.
-        """
-        self.quant_config = quant_config
-        self.capability = capability
-
-    def update_opwise_config(self):
-        """Update op-wise config.
-
-        Args:
-            quant_config: the Tensorflow static quant config.
-        """
-        op_wise_config = {}
-        for op_name, op_config in self.quant_config.items():
-            op_key_name = (op_name[0], self.unify_op_type_mapping[op_name[1]])
-            if op_key_name not in self.capability["opwise"]:
-                continue
-            single_op_cap = self.capability["opwise"][op_key_name][0]
-            single_op_config = {"activation": {}}
-
-            single_op_config["activation"]["dtype"] = (
-                op_config.act_dtype
-                if op_config.act_dtype in single_op_cap["activation"]["dtype"]
-                or op_config.act_dtype in ("fp32", "bf16")
-                else single_op_cap["activation"]["dtype"][0]
-            )
-
-            single_op_config["activation"]["scheme"] = "sym" if op_config.act_sym else "asym"
-            if single_op_config["activation"]["scheme"] not in single_op_cap["activation"]["scheme"]:
-                single_op_config["activation"]["scheme"] = single_op_cap["activation"]["scheme"][0]
-
-            single_op_config["activation"]["granularity"] = (
-                op_config.act_granularity
-                if op_config.act_granularity in single_op_cap["activation"]["granularity"]
-                else single_op_cap["activation"]["granularity"][0]
-            )
-
-            single_op_config["activation"]["algorithm"] = (
-                op_config.act_algorithm
-                if op_config.act_algorithm in single_op_cap["activation"]["algorithm"]
-                else single_op_cap["activation"]["algorithm"][0]
-            )
-
-            if "weight" not in single_op_cap:
-                op_wise_config.update({op_key_name: single_op_config})
-                continue
-
-            single_op_config["weight"] = {}
-            single_op_config["weight"]["dtype"] = (
-                op_config.weight_dtype
-                if op_config.weight_dtype in single_op_cap["weight"]["dtype"]
-                or op_config.weight_dtype in ("fp32", "bf16")
-                else single_op_cap["weight"]["dtype"][0]
-            )
-
-            single_op_config["weight"]["scheme"] = "sym" if op_config.weight_sym else "asym"
-            if single_op_config["weight"]["scheme"] not in single_op_cap["weight"]["scheme"]:
-                single_op_config["weight"]["scheme"] = single_op_cap["weight"]["scheme"][0]
-
-            single_op_config["weight"]["granularity"] = (
-                op_config.weight_granularity
-                if op_config.weight_granularity in single_op_cap["weight"]["granularity"]
-                else single_op_cap["weight"]["granularity"][0]
-            )
-
-            single_op_config["weight"]["algorithm"] = (
-                op_config.weight_algorithm
-                if op_config.weight_algorithm in single_op_cap["weight"]["algorithm"]
-                else single_op_cap["weight"]["algorithm"][0]
-            )
-
-            op_wise_config.update({op_key_name: single_op_config})
-
-        return op_wise_config
-
-    def parse_to_tune_cfg(self):
-        """The function that parses StaticQuantConfig to keras tuning config."""
-        op_wise_config = self.update_opwise_config()
-        tune_cfg = {"op": op_wise_config}
-
-        return tune_cfg
diff --git a/neural_compressor/tensorflow/algorithms/static_quant/tensorflow.yaml b/neural_compressor/tensorflow/algorithms/static_quant/tensorflow.yaml
deleted file mode 100644
index acd8857eda0..00000000000
--- a/neural_compressor/tensorflow/algorithms/static_quant/tensorflow.yaml
+++ /dev/null
@@ -1,244 +0,0 @@
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
----
--
-  version:
-    name: ['2.11.0202242', '2.11.0202250', '2.11.0202317', '2.11.0202323', '2.14.0202335', '2.14.dev202335', '2.15.0202341']
-
-  bf16: ["_MklLayerNorm", "Conv2D", "Conv2DBackpropFilter", "Conv2DBackpropInput", "Conv3D", "Conv3DBackpropFilterV2", "Conv3DBackpropInputV2",
-          "DepthwiseConv2dNative", "DepthwiseConv2dNativeBackpropFilter", "DepthwiseConv2dNativeBackpropInput", "GRUBlockCell",
-          "AUGRUBlockCell", "MklGRU", "MklAUGRU", "MatMul", "BatchMatMul", "BatchMatMulV2", "_MklFusedBatchMatMulV2", "Einsum", # allow_list
-          "Add", "AddN", "AddV2", "AvgPool", "AvgPool3D", "AvgPool3DGrad", "AvgPoolGrad", "BiasAdd", "BiasAddGrad", "BiasAddV1",
-          "Erf", "FusedBatchNormV2", "FusedBatchNormGradV2", "FusedBatchNormV3", "FusedBatchNormGradV3", "LeakyRelu", "LeakyReluGrad",
-          "Mean", "Mul", "Sub", "Elu", "EluGrad", "FloorDiv", "_FusedBatchNormEx", "Log", "Log1p", "LogSoftmax", "Prod", "RealDiv",
-          "Reciprocal", "Rsqrt", "Selu", "SeluGrad", "Sigmoid", "SigmoidGrad", "Softmax", "Softplus", "SoftplusGrad", "Softsign",
-          "SoftsignGrad", "Sqrt", "Square", "SquaredDifference", "Sum", "Tanh", "TanhGrad", "SparseSegmentSqrtN", # infer_list
-          "Abs", "ArgMax","ArgMin","BatchToSpace","BatchToSpaceND","BroadcastTo","Ceil","CheckNumerics","ClipByValue","Concat","ConcatV2",
-          "DepthToSpace","DynamicPartition","DynamicStitch","EnsureShape","Enter","Equal","Exit","ExpandDims","Fill","Floor","Gather",
-          "GatherNd","GatherV2","Greater","GreaterEqual","Identity","IsFinite","IsInf","IsNan","Less","LessEqual","Max","Maximum","MaxPool",
-          "MaxPool3D","MaxPool3DGrad","MaxPoolGrad","MaxPoolGradGrad","MaxPoolGradGradV2","MaxPoolGradV2","MaxPoolV2","Merge","Min","Minimum",
-          "MirrorPad","MirrorPadGrad","Neg","NextIteration","NotEqual","OnesLike","Pack","Pad","PadV2","PreventGradient","Rank","Relu","Relu6",
-          "Relu6Grad","ReluGrad","Reshape","ResizeNearestNeighbor","ResizeNearestNeighborGrad", "ResizeBilinear", "Reverse","ReverseSequence",
-          "ReverseV2","Round", "Select","SelectV2","Shape","ShapeN","Sign","Slice","Snapshot","SpaceToBatch","SpaceToBatchND","SpaceToDepth",
-          "Split","SplitV","Squeeze","StopGradient","StridedSlice","StridedSliceGrad","Switch","Tile","TopK","TopKV2","Transpose",
-          "Where","Unpack","ZerosLike" #clear list
-          ]
-  fp32: ['*'] # '*' means all op types
-  int8: {
-    'static': {
-        'Conv2D': {
-          'weight': {
-                      'dtype': ['int8'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_channel','per_tensor'],
-                      'algorithm': ['minmax']
-                      },
-          'activation': {
-                      'dtype': ['int8', 'uint8'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax', 'kl']
-                      }
-                  },
-        'FusedBatchNormV3': {
-          'activation': {
-                      'dtype': ['int8'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax', 'kl']
-                      }
-                  },
-        'Conv3D': {
-          'weight': {
-                      'dtype': ['int8'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_channel', 'per_tensor'],
-                      'algorithm': ['minmax']
-                      },
-          'activation': {
-                      'dtype': ['int8', 'uint8'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax', 'kl']
-                      }
-                  },
-        '_MklFusedInstanceNorm': {
-          'activation': {
-                      'dtype': ['int8', 'fp32'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax', 'kl']
-                      }
-                  },
-        'MatMul': {
-          'weight': {
-                      'dtype': ['int8'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor', 'per_channel'],
-                      'algorithm': ['minmax']
-                      },
-          'activation': {
-                      'dtype': ['int8', 'uint8'],
-                      'scheme': ['asym', 'sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax']
-                      }
-                  },
-        'BatchMatMul': {
-          'weight': {
-                      'dtype': ['int8', 'fp32'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax']
-                      },
-          'activation': {
-                      'dtype': ['int8', 'fp32'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax']
-                      }
-                  },
-        'BatchMatMulV2': {
-          'weight': {
-                      'dtype': ['int8'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax']
-                      },
-          'activation': {
-                      'dtype': ['int8', 'uint8'],
-                      'scheme': ['asym', 'sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax']
-                      }
-                  },
-        'DepthwiseConv2dNative': &ref_default_static {
-          'activation': {
-                      'dtype': ['uint8'],
-                      'algorithm': ['minmax'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor']
-                      }
-                  },
-        'ConcatV2': *ref_default_static,
-        'FusedBatchNorm': *ref_default_static,
-        'FusedBatchNormV2': *ref_default_static,
-        'MaxPool': *ref_default_static,
-        'MaxPool3D': *ref_default_static,
-        'AvgPool': *ref_default_static,
-        'Conv2DBackpropInput': *ref_default_static,
-        'Conv3DBackpropInputV2': *ref_default_static,
-        'default': *ref_default_static
-    },
-    'dynamic': {
-    }
-  }
-
-
--
-  version:
-    name: ['2.1.0', '2.2.0', '2.3.0', '2.4.0', '2.5.0', '2.6.0', '2.6.1', '2.6.2', '2.7.0', '2.8.0', '2.9.0', '2.9.1', '2.10.0', '2.11.0', '2.12.0', '2.13.0', '2.14.0', '2.14.1', '2.15.0', '2.15.1', '1.15.0-up1', '1.15.0-up2', '1.15.0-up3']
-
-  bf16: ['Conv2D', 'Conv3D', 'MatMul', 'BatchMatMul', 'MaxPool', 'MaxPool3D', 'AvgPool', 'AvgPool3D', 'DepthwiseConv2dNative']
-  fp32: ['*'] # '*' means all op types
-
-  int8: {
-    'static': {
-      'Conv2D': {
-        'weight': {
-                    'dtype': ['int8'],
-                    'scheme': ['sym'],
-                    'granularity': ['per_channel','per_tensor'],
-                    'algorithm': ['minmax']
-                    },
-        'activation': {
-                    'dtype': ['int8', 'uint8'],
-                    'scheme': ['sym'],
-                    'granularity': ['per_tensor'],
-                    'algorithm': ['minmax', 'kl']
-                    }
-                },
-      'MatMul': {
-        'weight': {
-                    'dtype': ['int8'],
-                    'scheme': ['sym'],
-                    'granularity': ['per_tensor'],
-                    'algorithm': ['minmax']
-                    },
-        'activation': {
-                    'dtype': ['int8', 'uint8'],
-                    'scheme': ['asym', 'sym'],
-                    'granularity': ['per_tensor'],
-                    'algorithm': ['minmax']
-                    }
-                },
-      'DepthwiseConv2dNative': *ref_default_static,
-      'ConcatV2': *ref_default_static,
-      'MaxPool': *ref_default_static,
-      'AvgPool': *ref_default_static,
-      'default': *ref_default_static
-    },
-    'dynamic': {
-    }
-  }
-
-
-
--
-  version:
-    name: ['default', '1.15.0', '1.15.2', '2.0.0', '2.0.1']
-
-  bf16: []
-  fp32: ['*'] # '*' means all op types
-  int8: {
-    'static': {
-      'Conv2D': {
-        'weight': {
-                    'dtype': ['int8'],
-                    'scheme': ['sym'],
-                    'granularity': ['per_channel','per_tensor'],
-                    'algorithm': ['minmax']
-                    },
-        'activation': {
-                    'dtype': ['uint8'],
-                    'scheme': ['sym'],
-                    'granularity': ['per_tensor'],
-                    'algorithm': ['minmax', 'kl']
-                    }
-                },
-      'MatMul': {
-        'weight': {
-                    'dtype': ['int8'],
-                    'scheme': ['sym'],
-                    'granularity': ['per_tensor'],
-                    'algorithm': ['minmax']
-                    },
-        'activation': {
-                    'dtype': ['uint8'],
-                    'scheme': ['asym', 'sym'],
-                    'granularity': ['per_tensor'],
-                    'algorithm': ['minmax']
-                    }
-                },
-      'DepthwiseConv2dNative': *ref_default_static,
-      'ConcatV2': *ref_default_static,
-      'MaxPool': *ref_default_static,
-      'AvgPool': *ref_default_static,
-      'default': *ref_default_static
-    },
-    'dynamic': {
-    }
-  }
diff --git a/neural_compressor/tensorflow/algorithms/static_quant/tensorflow_itex.yaml b/neural_compressor/tensorflow/algorithms/static_quant/tensorflow_itex.yaml
deleted file mode 100644
index 8cd3f69902e..00000000000
--- a/neural_compressor/tensorflow/algorithms/static_quant/tensorflow_itex.yaml
+++ /dev/null
@@ -1,149 +0,0 @@
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
----
--
-  version:
-    name: ['default']
-
-  bf16: ["_MklLayerNorm", "Conv2D", "Conv2DBackpropFilter", "Conv2DBackpropInput", "Conv3D", "Conv3DBackpropFilterV2", "Conv3DBackpropInputV2",
-          "DepthwiseConv2dNative", "DepthwiseConv2dNativeBackpropFilter", "DepthwiseConv2dNativeBackpropInput", "GRUBlockCell",
-          "AUGRUBlockCell", "MklGRU", "MklAUGRU", "MatMul", "BatchMatMul", "BatchMatMulV2", "_MklFusedBatchMatMulV2", "Einsum", # allow_list
-          "Add", "AddN", "AddV2", "AvgPool", "AvgPool3D", "AvgPool3DGrad", "AvgPoolGrad", "BiasAdd", "BiasAddGrad", "BiasAddV1",
-          "Erf", "FusedBatchNormV2", "FusedBatchNormGradV2", "FusedBatchNormV3", "FusedBatchNormGradV3", "LeakyRelu", "LeakyReluGrad",
-          "Mean", "Mul", "Sub", "Elu", "EluGrad", "FloorDiv", "_FusedBatchNormEx", "Log", "Log1p", "LogSoftmax", "Prod", "RealDiv",
-          "Reciprocal", "Rsqrt", "Selu", "SeluGrad", "Sigmoid", "SigmoidGrad", "Softmax", "Softplus", "SoftplusGrad", "Softsign",
-          "SoftsignGrad", "Sqrt", "Square", "SquaredDifference", "Sum", "Tanh", "TanhGrad", "SparseSegmentSqrtN", # infer_list
-          "Abs", "ArgMax","ArgMin","BatchToSpace","BatchToSpaceND","BroadcastTo","Ceil","CheckNumerics","ClipByValue","Concat","ConcatV2",
-          "DepthToSpace","DynamicPartition","DynamicStitch","EnsureShape","Enter","Equal","Exit","ExpandDims","Fill","Floor","Gather",
-          "GatherNd","GatherV2","Greater","GreaterEqual","Identity","IsFinite","IsInf","IsNan","Less","LessEqual","Max","Maximum","MaxPool",
-          "MaxPool3D","MaxPool3DGrad","MaxPoolGrad","MaxPoolGradGrad","MaxPoolGradGradV2","MaxPoolGradV2","MaxPoolV2","Merge","Min","Minimum",
-          "MirrorPad","MirrorPadGrad","Neg","NextIteration","NotEqual","OnesLike","Pack","Pad","PadV2","PreventGradient","Rank","Relu","Relu6",
-          "Relu6Grad","ReluGrad","Reshape","ResizeNearestNeighbor","ResizeNearestNeighborGrad", "ResizeBilinear", "Reverse","ReverseSequence",
-          "ReverseV2","Round", "Select","SelectV2","Shape","ShapeN","Sign","Slice","Snapshot","SpaceToBatch","SpaceToBatchND","SpaceToDepth",
-          "Split","SplitV","Squeeze","StopGradient","StridedSlice","StridedSliceGrad","Switch","Tile","TopK","TopKV2","Transpose",
-          "Where","Unpack","ZerosLike" #clear list
-  ]
-  fp32: ['*'] # '*' means all op types
-
-  int8: {
-    'static': {
-        'Conv2D': {
-          'weight': {
-                      'dtype': ['int8'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_channel','per_tensor'],
-                      'algorithm': ['minmax']
-                      },
-          'activation': {
-                      'dtype': ['int8', 'uint8'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax', 'kl']
-                      }
-                  },
-        'FusedBatchNormV3': {
-          'activation': {
-                      'dtype': ['int8'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax', 'kl']
-                      }
-                  },
-        'Conv3D': {
-          'weight': {
-                      'dtype': ['int8'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_channel', 'per_tensor'],
-                      'algorithm': ['minmax']
-                      },
-          'activation': {
-                      'dtype': ['int8', 'uint8'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax', 'kl']
-                      }
-                  },
-        '_MklFusedInstanceNorm': {
-          'activation': {
-                      'dtype': ['int8', 'fp32'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax', 'kl']
-                      }
-                  },
-        'MatMul': {
-          'weight': {
-                      'dtype': ['int8'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax']
-                      },
-          'activation': {
-                      'dtype': ['int8', 'uint8'],
-                      'scheme': ['asym', 'sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax']
-                      }
-                  },
-        'BatchMatMul': {
-          'weight': {
-                      'dtype': ['int8', 'fp32'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax']
-                      },
-          'activation': {
-                      'dtype': ['int8', 'fp32'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax']
-                      }
-                  },
-        'BatchMatMulV2': {
-          'weight': {
-                      'dtype': ['int8'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax']
-                      },
-          'activation': {
-                      'dtype': ['int8', 'uint8'],
-                      'scheme': ['asym', 'sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax']
-                      }
-                  },
-        'DepthwiseConv2dNative': &ref_default_static {
-          'activation': {
-                      'dtype': ['uint8'],
-                      'algorithm': ['minmax'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor']
-                      }
-                  },
-        'ConcatV2': *ref_default_static,
-        'FusedBatchNorm': *ref_default_static,
-        'FusedBatchNormV2': *ref_default_static,
-        'MaxPool': *ref_default_static,
-        'MaxPool3D': *ref_default_static,
-        'AvgPool': *ref_default_static,
-        'Conv2DBackpropInput': *ref_default_static,
-        'Conv3DBackpropInputV2': *ref_default_static,
-        'default': *ref_default_static
-    },
-    'dynamic': {
-    }
-  }
diff --git a/neural_compressor/tensorflow/keras/__init__.py b/neural_compressor/tensorflow/keras/__init__.py
deleted file mode 100644
index a0539eec3e9..00000000000
--- a/neural_compressor/tensorflow/keras/__init__.py
+++ /dev/null
@@ -1,19 +0,0 @@
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Initialize classes for Keras quantization."""
-
-from neural_compressor.tensorflow.keras.quantization import (
-    StaticQuantConfig,
-    get_default_static_quant_config,
-)
diff --git a/neural_compressor/tensorflow/keras/layers/__init__.py b/neural_compressor/tensorflow/keras/layers/__init__.py
deleted file mode 100644
index ee4249138b3..00000000000
--- a/neural_compressor/tensorflow/keras/layers/__init__.py
+++ /dev/null
@@ -1,24 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Initialize custom layers for Keras quantization."""
-
-from neural_compressor.tensorflow.keras.layers.conv2d import QConv2D
-from neural_compressor.tensorflow.keras.layers.dense import QDense
-from neural_compressor.tensorflow.keras.layers.depthwise_conv2d import QDepthwiseConv2D
-from neural_compressor.tensorflow.keras.layers.pool2d import QAvgPool2D, QMaxPool2D
-from neural_compressor.tensorflow.keras.layers.separable_conv2d import QSeparableConv2D
-from neural_compressor.tensorflow.keras.layers.layer_initializer import layer_initializer_dict
diff --git a/neural_compressor/tensorflow/keras/layers/conv2d.py b/neural_compressor/tensorflow/keras/layers/conv2d.py
deleted file mode 100644
index 26d6a812ece..00000000000
--- a/neural_compressor/tensorflow/keras/layers/conv2d.py
+++ /dev/null
@@ -1,415 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Initialize custom conv2d layers for Keras quantization."""
-
-import json
-
-import tensorflow as tf
-from tensorflow.keras import activations, constraints, initializers, regularizers
-
-from neural_compressor.tensorflow.utils import version1_gte_version2
-
-if version1_gte_version2(tf.__version__, "2.16.1"):
-    from keras import ops
-    from keras.src.layers.convolutional.base_conv import BaseConv  # pylint: disable=E0401
-elif version1_gte_version2(tf.__version__, "2.13.0"):
-    from keras.src.layers.convolutional.base_conv import Conv  # pylint: disable=E0401
-else:
-    from keras.layers.convolutional.base_conv import Conv  # pylint: disable=E0401
-
-if version1_gte_version2(tf.__version__, "2.16.1"):  # pragma: no cover
-
-    class QConv2D(BaseConv):
-        """The custom quantized Conv2D layer."""
-
-        def __init__(
-            self,
-            name,
-            filters,
-            kernel_size,
-            strides=(1, 1),
-            padding="valid",
-            data_format=None,
-            dilation_rate=(1, 1),
-            groups=1,
-            activation=None,
-            use_bias=True,
-            kernel_initializer="glorot_uniform",
-            bias_initializer="zeros",
-            kernel_regularizer=None,
-            bias_regularizer=None,
-            activity_regularizer=None,
-            kernel_constraint=None,
-            bias_constraint=None,
-            act_min_value=None,
-            act_max_value=None,
-            weight_min_value=None,
-            weight_max_value=None,
-            granularity="per_tensor",
-            quant_status="calib",
-            quant_mode="SCALED",
-            quant_T="s8",
-            quant_round_mode="HALF_AWAY_FROM_ZERO",
-            quant_narrow_range=False,
-            quant_axis=None,
-            **kwargs
-        ):
-            """Initialize custom quantized Conv2D layer."""
-            super(QConv2D, self).__init__(
-                name=name,
-                rank=2,
-                filters=filters,
-                kernel_size=kernel_size,
-                strides=strides,
-                padding=padding,
-                data_format=data_format,
-                dilation_rate=dilation_rate,
-                groups=groups,
-                activation=activations.get(activation),
-                use_bias=use_bias,
-                kernel_initializer=initializers.get(kernel_initializer),
-                bias_initializer=initializers.get(bias_initializer),
-                kernel_regularizer=regularizers.get(kernel_regularizer),
-                bias_regularizer=regularizers.get(bias_regularizer),
-                activity_regularizer=regularizers.get(activity_regularizer),
-                kernel_constraint=constraints.get(kernel_constraint),
-                bias_constraint=constraints.get(bias_constraint),
-                **kwargs
-            )
-            T_map = {"s8": tf.qint8, "u8": tf.quint8}
-            self.weight_min_value = weight_min_value
-            self.weight_max_value = weight_max_value
-            self.act_min_value = act_min_value
-            self.act_max_value = act_max_value
-            self.granularity = granularity
-            self.quant_status = quant_status
-            self.quant_mode = quant_mode
-            self.quant_T = T_map[quant_T]
-            self.quant_round_mode = quant_round_mode
-            self.quant_narrow_range = quant_narrow_range
-            self.quant_axis = quant_axis
-
-        def call(self, inputs):
-            """The __call__ function of custom quantized Conv2D layer."""
-            if self.quant_status == "calib" and not isinstance(inputs, tf.keras.KerasTensor):
-                if self.granularity == "per_tensor":
-                    self.act_min_value = tf.math.reduce_min(inputs)
-                    self.act_max_value = tf.math.reduce_max(inputs)
-                else:
-                    self.act_min_value = tf.math.reduce_min(inputs, axis=1)
-                    self.act_max_value = tf.math.reduce_max(inputs, axis=1)
-                kernel = self.kernel
-            elif self.quant_status == "quantize":
-                assert (
-                    self.act_min_value is not None
-                ), "Invalid activation min-max values, please check calibration process"
-                inputs, _, _ = tf.quantization.quantize(
-                    inputs,
-                    self.act_min_value,
-                    self.act_max_value,
-                    self.quant_T,
-                    mode=self.quant_mode,
-                    round_mode=self.quant_round_mode,
-                    narrow_range=self.quant_narrow_range,
-                    axis=self.quant_axis,
-                )
-                inputs = tf.quantization.dequantize(
-                    inputs,
-                    self.act_min_value,
-                    self.act_max_value,
-                    mode=self.quant_mode,
-                    narrow_range=self.quant_narrow_range,
-                    axis=self.quant_axis,
-                )
-
-                kernel_size = self.kernel.shape[-1]
-
-                if not self.weight_min_value:
-                    self.weight_min_value = [-10000] * kernel_size
-                if not self.weight_max_value:
-                    self.weight_max_value = [10000] * kernel_size
-
-                # add the Q/DQ here
-                kernel, _, _ = tf.quantization.quantize(
-                    self.kernel, self.weight_min_value, self.weight_max_value, tf.qint8, axis=3, mode="SCALED"
-                )
-                kernel = tf.quantization.dequantize(
-                    kernel,
-                    self.weight_min_value,
-                    self.weight_max_value,
-                    axis=3,
-                    mode="SCALED",
-                )
-
-            outputs = self.convolution_op(
-                inputs,
-                kernel,
-            )
-            if self.use_bias:
-                if self.data_format == "channels_last":
-                    bias_shape = (1,) * (self.rank + 1) + (self.filters,)
-                else:
-                    bias_shape = (1, self.filters) + (1,) * self.rank
-                bias = ops.reshape(self.bias, bias_shape)
-                outputs += bias
-
-            if self.activation is not None:
-                return self.activation(outputs)
-            return outputs
-
-        @classmethod
-        def from_config(cls, config):
-            """Deserialize this class from a config dict."""
-            return cls(**config)
-
-        def get_config(self):
-            """Serialize this class to a config dict."""
-            config = super(QConv2D, self).get_config()
-            config.update(
-                {
-                    "act_min_value": self.act_min_value,
-                    "act_max_value": self.act_max_value,
-                    "weight_min_value": self.weight_min_value,
-                    "weight_max_value": self.weight_max_value,
-                    "granularity": self.granularity,
-                    "quant_status": self.quant_status,
-                    "quant_mode": self.quant_mode,
-                    "quant_T": "s8" if self.quant_T == tf.qint8 else "u8",
-                    "quant_round_mode": self.quant_round_mode,
-                    "quant_narrow_range": self.quant_narrow_range,
-                    "quant_axis": self.quant_axis,
-                }
-            )
-
-            return config
-
-else:
-
-    class QConv2D(Conv):
-        """The custom quantized Conv2D layer."""
-
-        def __init__(
-            self,
-            name,
-            filters,
-            kernel_size,
-            strides=(1, 1),
-            padding="valid",
-            data_format=None,
-            dilation_rate=(1, 1),
-            groups=1,
-            activation=None,
-            use_bias=True,
-            kernel_initializer="glorot_uniform",
-            bias_initializer="zeros",
-            kernel_regularizer=None,
-            bias_regularizer=None,
-            activity_regularizer=None,
-            kernel_constraint=None,
-            bias_constraint=None,
-            act_min_value=None,
-            act_max_value=None,
-            weight_min_value=None,
-            weight_max_value=None,
-            granularity="per_tensor",
-            quant_status="calib",
-            quant_mode="SCALED",
-            quant_T="s8",
-            quant_round_mode="HALF_AWAY_FROM_ZERO",
-            quant_narrow_range=False,
-            quant_axis=None,
-            **kwargs
-        ):
-            """Initialize custom quantized Conv2D layer."""
-            super(QConv2D, self).__init__(
-                name=name,
-                rank=2,
-                filters=filters,
-                kernel_size=kernel_size,
-                strides=strides,
-                padding=padding,
-                data_format=data_format,
-                dilation_rate=dilation_rate,
-                groups=groups,
-                activation=activations.get(activation),
-                use_bias=use_bias,
-                kernel_initializer=initializers.get(kernel_initializer),
-                bias_initializer=initializers.get(bias_initializer),
-                kernel_regularizer=regularizers.get(kernel_regularizer),
-                bias_regularizer=regularizers.get(bias_regularizer),
-                activity_regularizer=regularizers.get(activity_regularizer),
-                kernel_constraint=constraints.get(kernel_constraint),
-                bias_constraint=constraints.get(bias_constraint),
-                **kwargs
-            )
-            T_map = {"s8": tf.qint8, "u8": tf.quint8}
-            self.weight_min_value = weight_min_value
-            self.weight_max_value = weight_max_value
-            self.act_min_value = act_min_value
-            self.act_max_value = act_max_value
-            self.granularity = granularity
-            self.quant_status = quant_status
-            self.quant_mode = quant_mode
-            self.quant_T = T_map[quant_T]
-            self.quant_round_mode = quant_round_mode
-            self.quant_narrow_range = quant_narrow_range
-            self.quant_axis = quant_axis
-
-        def call(self, inputs):
-            """The __call__ function of custom quantized Conv2D layer."""
-            if self.quant_status == "calib":
-                if self.granularity == "per_tensor":
-                    self.act_min_value = tf.math.reduce_min(inputs)
-                    self.act_max_value = tf.math.reduce_max(inputs)
-                else:
-                    self.act_min_value = tf.math.reduce_min(inputs, axis=1)
-                    self.act_max_value = tf.math.reduce_max(inputs, axis=1)
-                kernel = self.kernel
-            elif self.quant_status == "quantize":
-                assert (
-                    self.act_min_value is not None
-                ), "Invalid activation min-max values, please check calibration process"
-                inputs, _, _ = tf.quantization.quantize(
-                    inputs,
-                    self.act_min_value,
-                    self.act_max_value,
-                    self.quant_T,
-                    mode=self.quant_mode,
-                    round_mode=self.quant_round_mode,
-                    narrow_range=self.quant_narrow_range,
-                    axis=self.quant_axis,
-                )
-                inputs = tf.quantization.dequantize(
-                    inputs,
-                    self.act_min_value,
-                    self.act_max_value,
-                    mode=self.quant_mode,
-                    narrow_range=self.quant_narrow_range,
-                    axis=self.quant_axis,
-                )
-
-                kernel_size = self.kernel.shape[-1]
-
-                if not self.weight_min_value:
-                    self.weight_min_value = [-10000] * kernel_size
-                if not self.weight_max_value:
-                    self.weight_max_value = [10000] * kernel_size
-
-                # add the Q/DQ here
-                kernel, _, _ = tf.quantization.quantize(
-                    self.kernel, self.weight_min_value, self.weight_max_value, tf.qint8, axis=3, mode="SCALED"
-                )
-                kernel = tf.quantization.dequantize(
-                    kernel,
-                    self.weight_min_value,
-                    self.weight_max_value,
-                    axis=3,
-                    mode="SCALED",
-                )
-            outputs = tf.keras.backend.conv2d(
-                inputs,
-                kernel,
-                strides=self.strides,
-                padding=self.padding,
-                data_format=self.data_format,
-                dilation_rate=self.dilation_rate,
-            )
-
-            if self.use_bias:
-                outputs = tf.keras.backend.bias_add(outputs, self.bias, data_format=self.data_format)
-
-            if self.activation is not None:
-                return self.activation(outputs)
-
-            return outputs
-
-        @classmethod
-        def from_config(cls, config):
-            """Deserialize this class from a config dict."""
-            return cls(**config)
-
-        def get_config(self):
-            """Serialize this class to a config dict."""
-            config = super(QConv2D, self).get_config()
-            config.update(
-                {
-                    "act_min_value": self.act_min_value,
-                    "act_max_value": self.act_max_value,
-                    "weight_min_value": self.weight_min_value,
-                    "weight_max_value": self.weight_max_value,
-                    "granularity": self.granularity,
-                    "quant_status": self.quant_status,
-                    "quant_mode": self.quant_mode,
-                    "quant_T": "s8" if self.quant_T == tf.qint8 else "u8",
-                    "quant_round_mode": self.quant_round_mode,
-                    "quant_narrow_range": self.quant_narrow_range,
-                    "quant_axis": self.quant_axis,
-                }
-            )
-
-            return config
-
-
-def initialize_int8_conv2d(fp32_layer, q_config):
-    """Initialize int8 conv2d."""
-    kwargs = fp32_layer.get_config()
-
-    param_list = [
-        "name",
-        "filters",
-        "kernel_size",
-        "strides",
-        "padding",
-        "data_format",
-        "dilation_rate",
-        "groups",
-        "activation",
-        "use_bias",
-        "kernel_initializer",
-        "bias_initializer",
-        "kernel_regularizer",
-        "activity_regularizer",
-        "bias_regularizer",
-        "kernel_constraint",
-        "bias_constraint",
-    ]
-    for p in param_list:  # pragma: no cover
-        if p in kwargs:
-            del kwargs[p]
-
-    return QConv2D(
-        name=fp32_layer.name,
-        filters=fp32_layer.filters,
-        kernel_size=fp32_layer.kernel_size,
-        strides=fp32_layer.strides,
-        padding=fp32_layer.padding,
-        data_format=fp32_layer.data_format,
-        dilation_rate=fp32_layer.dilation_rate,
-        groups=fp32_layer.groups,
-        activation=fp32_layer.activation,
-        use_bias=fp32_layer.use_bias,
-        kernel_initializer=fp32_layer.kernel_initializer,
-        bias_initializer=fp32_layer.bias_initializer,
-        kernel_regularizer=fp32_layer.kernel_regularizer,
-        bias_regularizer=fp32_layer.bias_regularizer,
-        activity_regularizer=fp32_layer.activity_regularizer,
-        kernel_constraint=fp32_layer.kernel_constraint,
-        bias_constraint=fp32_layer.bias_constraint,
-        quant_T=q_config["T"],
-        granularity=q_config["granularity"],
-        **kwargs
-    )
diff --git a/neural_compressor/tensorflow/keras/layers/dense.py b/neural_compressor/tensorflow/keras/layers/dense.py
deleted file mode 100644
index 33bee5a9c78..00000000000
--- a/neural_compressor/tensorflow/keras/layers/dense.py
+++ /dev/null
@@ -1,215 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Initialize custom dense layers for Keras quantization."""
-
-import json
-
-import tensorflow as tf
-from tensorflow.keras import activations, backend, constraints, initializers, regularizers
-from tensorflow.keras.layers import Dense
-
-from neural_compressor.tensorflow.utils import version1_gte_version2
-
-
-class QDense(Dense):
-    """The custom quantized Dense layer."""
-
-    def __init__(
-        self,
-        name,
-        units,
-        activation=None,
-        use_bias=True,
-        kernel_initializer="glorot_uniform",
-        bias_initializer="zeros",
-        kernel_regularizer=None,
-        bias_regularizer=None,
-        activity_regularizer=None,
-        kernel_constraint=None,
-        bias_constraint=None,
-        act_min_value=None,
-        act_max_value=None,
-        weight_min_value=None,
-        weight_max_value=None,
-        granularity="per_tensor",
-        quant_status="calib",
-        quant_mode="SCALED",
-        quant_T="s8",
-        quant_round_mode="HALF_AWAY_FROM_ZERO",
-        quant_narrow_range=False,
-        quant_axis=None,
-        **kwargs
-    ):
-        """Initialize custom quantized Dense layer."""
-        super(QDense, self).__init__(
-            name=name,
-            units=units,
-            activation=activation,
-            use_bias=use_bias,
-            kernel_initializer=kernel_initializer,
-            bias_initializer=bias_initializer,
-            kernel_regularizer=kernel_regularizer,
-            bias_regularizer=bias_regularizer,
-            activity_regularizer=activity_regularizer,
-            kernel_constraint=kernel_constraint,
-            bias_constraint=bias_constraint,
-            **kwargs
-        )
-        T_map = {"s8": tf.qint8, "u8": tf.quint8}
-        self.weight_min_value = weight_min_value
-        self.weight_max_value = weight_max_value
-        self.act_min_value = act_min_value
-        self.act_max_value = act_max_value
-        self.granularity = granularity
-        self.quant_status = quant_status
-        self.quant_mode = quant_mode
-        self.quant_T = T_map[quant_T]
-        self.quant_round_mode = quant_round_mode
-        self.quant_narrow_range = quant_narrow_range
-        self.quant_axis = quant_axis
-
-    def call(self, inputs):
-        """The __call__ function of custom quantized Dense layer."""
-        if self.quant_status == "calib" and not (
-            version1_gte_version2(tf.__version__, "2.16.1") and isinstance(inputs, tf.keras.KerasTensor)
-        ):
-            if self.granularity == "per_tensor":
-                self.act_min_value = tf.math.reduce_min(inputs)
-                self.act_max_value = tf.math.reduce_max(inputs)
-            else:
-                self.act_min_value = tf.math.reduce_min(inputs, axis=1)
-                self.act_max_value = tf.math.reduce_max(inputs, axis=1)
-            kernel = self.kernel
-        elif self.quant_status == "quantize":
-            assert self.act_min_value is not None, "Invalid activation min-max values, please check calibration process"
-            inputs, _, _ = tf.quantization.quantize(
-                inputs,
-                self.act_min_value,
-                self.act_max_value,
-                self.quant_T,
-                mode=self.quant_mode,
-                round_mode=self.quant_round_mode,
-                narrow_range=self.quant_narrow_range,
-                axis=self.quant_axis,
-            )
-            inputs = tf.quantization.dequantize(
-                inputs,
-                self.act_min_value,
-                self.act_max_value,
-                mode=self.quant_mode,
-                narrow_range=self.quant_narrow_range,
-                axis=self.quant_axis,
-            )
-
-            kernel_size = self.kernel.shape[-1]
-
-            if not self.weight_min_value:
-                self.weight_min_value = [-10000] * kernel_size
-            if not self.weight_max_value:
-                self.weight_max_value = [10000] * kernel_size
-
-            # add the Q/DQ here
-            kernel, _, _ = tf.quantization.quantize(
-                self.kernel,
-                self.weight_min_value,
-                self.weight_max_value,
-                tf.qint8,
-                axis=1,
-                mode="SCALED",
-            )
-            kernel = tf.quantization.dequantize(
-                kernel,
-                self.weight_min_value,
-                self.weight_max_value,
-                axis=1,
-                mode="SCALED",
-            )
-
-        outputs = tf.keras.backend.dot(inputs, kernel)
-
-        if self.use_bias:
-            outputs = tf.keras.backend.bias_add(outputs, self.bias)
-        if self.activation is not None:
-            outputs = self.activation(outputs)
-        return outputs
-
-    @classmethod
-    def from_config(cls, config):
-        """Deserialize this class from a config dict."""
-        return cls(**config)
-
-    def get_config(self):
-        """Serialize this class to a config dict."""
-        config = super(QDense, self).get_config()
-        config.update(
-            {
-                "act_min_value": self.act_min_value,
-                "act_max_value": self.act_max_value,
-                "weight_min_value": self.weight_min_value,
-                "weight_max_value": self.weight_max_value,
-                "granularity": self.granularity,
-                "quant_status": self.quant_status,
-                "quant_mode": self.quant_mode,
-                "quant_T": "s8" if self.quant_T == tf.qint8 else "u8",
-                "quant_round_mode": self.quant_round_mode,
-                "quant_narrow_range": self.quant_narrow_range,
-                "quant_axis": self.quant_axis,
-            }
-        )
-
-        return config
-
-
-def initialize_int8_dense(fp32_layer, q_config):
-    """Initialize int8 dense."""
-    kwargs = fp32_layer.get_config()
-
-    param_list = [
-        "name",
-        "units",
-        "activation",
-        "use_bias",
-        "kernel_initializer",
-        "bias_initializer",
-        "kernel_regularizer",
-        "activity_regularizer",
-        "bias_regularizer",
-        "kernel_constraint",
-        "bias_constraint",
-    ]
-    for p in param_list:  # pragma: no cover
-        if p in kwargs:
-            del kwargs[p]
-
-    q_layer = QDense(
-        name=fp32_layer.name,
-        units=fp32_layer.units,
-        activation=fp32_layer.activation,
-        use_bias=fp32_layer.use_bias,
-        kernel_initializer=fp32_layer.kernel_initializer,
-        bias_initializer=fp32_layer.bias_initializer,
-        kernel_regularizer=fp32_layer.kernel_regularizer,
-        bias_regularizer=fp32_layer.bias_regularizer,
-        activity_regularizer=fp32_layer.activity_regularizer,
-        kernel_constraint=fp32_layer.kernel_constraint,
-        bias_constraint=fp32_layer.bias_constraint,
-        quant_T=q_config["T"],
-        granularity=q_config["granularity"],
-        **kwargs
-    )
-
-    return q_layer
diff --git a/neural_compressor/tensorflow/keras/layers/depthwise_conv2d.py b/neural_compressor/tensorflow/keras/layers/depthwise_conv2d.py
deleted file mode 100644
index 90b823b0fb8..00000000000
--- a/neural_compressor/tensorflow/keras/layers/depthwise_conv2d.py
+++ /dev/null
@@ -1,432 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Initialize custom depthwise conv2d layers for Keras quantization."""
-
-import json
-
-import tensorflow as tf
-from tensorflow.keras import activations, constraints, initializers, regularizers
-
-from neural_compressor.tensorflow.utils import version1_gte_version2
-
-if version1_gte_version2(tf.__version__, "2.16.1"):
-    from keras.src import ops
-    from keras.src.layers.convolutional.base_depthwise_conv import BaseDepthwiseConv  # pylint: disable=E0401
-elif version1_gte_version2(tf.__version__, "2.13.0"):
-    from keras.src.layers.convolutional.base_depthwise_conv import DepthwiseConv  # pylint: disable=E0401
-    from keras.src.utils import conv_utils, tf_utils  # pylint: disable=E0401
-else:
-    from keras.layers.convolutional.base_depthwise_conv import DepthwiseConv  # pylint: disable=E0401
-    from keras.utils import conv_utils, tf_utils  # pylint: disable=E0401
-
-if version1_gte_version2(tf.__version__, "2.16.1"):
-
-    class QDepthwiseConv2D(BaseDepthwiseConv):  # pragma: no cover
-        """The custom quantized DepthwiseConv2D layer."""
-
-        def __init__(
-            self,
-            kernel_size,
-            strides=(1, 1),
-            padding="valid",
-            depth_multiplier=1,
-            data_format=None,
-            dilation_rate=(1, 1),
-            activation=None,
-            use_bias=True,
-            depthwise_initializer="glorot_uniform",
-            bias_initializer="zeros",
-            depthwise_regularizer=None,
-            bias_regularizer=None,
-            activity_regularizer=None,
-            depthwise_constraint=None,
-            bias_constraint=None,
-            act_min_value=None,
-            act_max_value=None,
-            weight_min_value=None,
-            weight_max_value=None,
-            granularity="per_tensor",
-            quant_status="calib",
-            quant_mode="SCALED",
-            quant_T="s8",
-            quant_round_mode="HALF_AWAY_FROM_ZERO",
-            quant_narrow_range=False,
-            quant_axis=None,
-            **kwargs
-        ):
-            """Initialize custom quantized DepthwiseConv2D layer."""
-            super().__init__(
-                2,
-                kernel_size=kernel_size,
-                strides=strides,
-                padding=padding,
-                depth_multiplier=depth_multiplier,
-                data_format=data_format,
-                dilation_rate=dilation_rate,
-                activation=activation,
-                use_bias=use_bias,
-                depthwise_initializer=depthwise_initializer,
-                bias_initializer=bias_initializer,
-                depthwise_regularizer=depthwise_regularizer,
-                bias_regularizer=bias_regularizer,
-                activity_regularizer=activity_regularizer,
-                depthwise_constraint=depthwise_constraint,
-                bias_constraint=bias_constraint,
-                **kwargs
-            )
-            T_map = {"s8": tf.qint8, "u8": tf.quint8}
-            self.weight_min_value = weight_min_value
-            self.weight_max_value = weight_max_value
-            self.act_min_value = act_min_value
-            self.act_max_value = act_max_value
-            self.granularity = granularity
-            self.quant_status = quant_status
-            self.quant_mode = quant_mode
-            self.quant_T = T_map[quant_T]
-            self.quant_round_mode = quant_round_mode
-            self.quant_narrow_range = quant_narrow_range
-            self.quant_axis = quant_axis
-
-        def call(self, inputs):
-            """The __call__ function of custom quantized DepthwiseConv2D layer."""
-            if self.quant_status == "calib" and not isinstance(inputs, tf.keras.KerasTensor):
-                if self.granularity == "per_tensor":
-                    self.act_min_value = tf.math.reduce_min(inputs)
-                    self.act_max_value = tf.math.reduce_max(inputs)
-                else:
-                    self.act_min_value = tf.math.reduce_min(inputs, axis=1)
-                    self.act_max_value = tf.math.reduce_max(inputs, axis=1)
-                kernel = self.kernel
-            elif self.quant_status == "quantize":
-                assert (
-                    self.act_min_value is not None
-                ), "Invalid activation min-max values, please check calibration process"
-                inputs, _, _ = tf.quantization.quantize(
-                    inputs,
-                    self.act_min_value,
-                    self.act_max_value,
-                    self.quant_T,
-                    mode=self.quant_mode,
-                    round_mode=self.quant_round_mode,
-                    narrow_range=self.quant_narrow_range,
-                    axis=self.quant_axis,
-                )
-                inputs = tf.quantization.dequantize(
-                    inputs,
-                    self.act_min_value,
-                    self.act_max_value,
-                    mode=self.quant_mode,
-                    narrow_range=self.quant_narrow_range,
-                    axis=self.quant_axis,
-                )
-
-                # add the Q/DQ here
-                kernel, _, _ = tf.quantization.quantize(
-                    self.kernel, self.weight_min_value, self.weight_max_value, tf.qint8, axis=3, mode="SCALED"
-                )
-                kernel = tf.quantization.dequantize(
-                    kernel,
-                    self.weight_min_value,
-                    self.weight_max_value,
-                    axis=3,
-                    mode="SCALED",
-                )
-
-            input_channel = self._get_input_channel(inputs.shape)
-            outputs = ops.depthwise_conv(
-                inputs,
-                kernel,
-                strides=self.strides,
-                padding=self.padding,
-                dilation_rate=self.dilation_rate,
-                data_format=self.data_format,
-            )
-
-            if self.use_bias:
-                if self.data_format == "channels_last":
-                    bias_shape = (1,) * (self.rank + 1) + (self.depth_multiplier * input_channel,)
-                else:
-                    bias_shape = (1, self.depth_multiplier * input_channel) + (1,) * self.rank
-                bias = ops.reshape(self.bias, bias_shape)
-                outputs += bias
-
-            if self.activation is not None:
-                return self.activation(outputs)
-            return outputs
-
-        @classmethod
-        def from_config(cls, config):
-            """Deserialize this class from a config dict."""
-            return cls(**config)
-
-        def get_config(self):
-            """Serialize this class to a config dict."""
-            config = super(QDepthwiseConv2D, self).get_config()
-            config.update(
-                {
-                    "act_min_value": self.act_min_value,
-                    "act_max_value": self.act_max_value,
-                    "weight_min_value": self.weight_min_value,
-                    "weight_max_value": self.weight_max_value,
-                    "granularity": self.granularity,
-                    "quant_status": self.quant_status,
-                    "quant_mode": self.quant_mode,
-                    "quant_T": "s8" if self.quant_T == tf.qint8 else "u8",
-                    "quant_round_mode": self.quant_round_mode,
-                    "quant_narrow_range": self.quant_narrow_range,
-                    "quant_axis": self.quant_axis,
-                }
-            )
-
-            return config
-
-else:
-
-    class QDepthwiseConv2D(DepthwiseConv):
-        """The custom quantized DepthwiseConv2D layer."""
-
-        def __init__(
-            self,
-            kernel_size,
-            strides=(1, 1),
-            padding="valid",
-            depth_multiplier=1,
-            data_format=None,
-            dilation_rate=(1, 1),
-            activation=None,
-            use_bias=True,
-            depthwise_initializer="glorot_uniform",
-            bias_initializer="zeros",
-            depthwise_regularizer=None,
-            bias_regularizer=None,
-            activity_regularizer=None,
-            depthwise_constraint=None,
-            bias_constraint=None,
-            act_min_value=None,
-            act_max_value=None,
-            weight_min_value=None,
-            weight_max_value=None,
-            granularity="per_tensor",
-            quant_status="calib",
-            quant_mode="SCALED",
-            quant_T="s8",
-            quant_round_mode="HALF_AWAY_FROM_ZERO",
-            quant_narrow_range=False,
-            quant_axis=None,
-            **kwargs
-        ):
-            """Initialize custom quantized DepthwiseConv2D layer."""
-            super().__init__(
-                2,
-                kernel_size=kernel_size,
-                strides=strides,
-                padding=padding,
-                depth_multiplier=depth_multiplier,
-                data_format=data_format,
-                dilation_rate=dilation_rate,
-                activation=activation,
-                use_bias=use_bias,
-                depthwise_initializer=depthwise_initializer,
-                bias_initializer=bias_initializer,
-                depthwise_regularizer=depthwise_regularizer,
-                bias_regularizer=bias_regularizer,
-                activity_regularizer=activity_regularizer,
-                depthwise_constraint=depthwise_constraint,
-                bias_constraint=bias_constraint,
-                **kwargs
-            )
-            T_map = {"s8": tf.qint8, "u8": tf.quint8}
-            self.weight_min_value = weight_min_value
-            self.weight_max_value = weight_max_value
-            self.act_min_value = act_min_value
-            self.act_max_value = act_max_value
-            self.granularity = granularity
-            self.quant_status = quant_status
-            self.quant_mode = quant_mode
-            self.quant_T = T_map[quant_T]
-            self.quant_round_mode = quant_round_mode
-            self.quant_narrow_range = quant_narrow_range
-            self.quant_axis = quant_axis
-
-        def call(self, inputs):
-            """The __call__ function of custom quantized DepthwiseConv2D layer."""
-            if self.quant_status == "calib":
-                if self.granularity == "per_tensor":
-                    self.act_min_value = tf.math.reduce_min(inputs)
-                    self.act_max_value = tf.math.reduce_max(inputs)
-                else:
-                    self.act_min_value = tf.math.reduce_min(inputs, axis=1)
-                    self.act_max_value = tf.math.reduce_max(inputs, axis=1)
-                depthwise_kernel = self.depthwise_kernel
-            elif self.quant_status == "quantize":
-                assert (
-                    self.act_min_value is not None
-                ), "Invalid activation min-max values, please check calibration process"
-                inputs, _, _ = tf.quantization.quantize(
-                    inputs,
-                    self.act_min_value,
-                    self.act_max_value,
-                    self.quant_T,
-                    mode=self.quant_mode,
-                    round_mode=self.quant_round_mode,
-                    narrow_range=self.quant_narrow_range,
-                    axis=self.quant_axis,
-                )
-                inputs = tf.quantization.dequantize(
-                    inputs,
-                    self.act_min_value,
-                    self.act_max_value,
-                    mode=self.quant_mode,
-                    narrow_range=self.quant_narrow_range,
-                    axis=self.quant_axis,
-                )
-
-                # add the Q/DQ here
-                depthwise_kernel, _, _ = tf.quantization.quantize(
-                    self.depthwise_kernel, self.weight_min_value, self.weight_max_value, tf.qint8, axis=3, mode="SCALED"
-                )
-                depthwise_kernel = tf.quantization.dequantize(
-                    depthwise_kernel,
-                    self.weight_min_value,
-                    self.weight_max_value,
-                    axis=3,
-                    mode="SCALED",
-                )
-
-            outputs = tf.keras.backend.depthwise_conv2d(
-                inputs,
-                depthwise_kernel,
-                strides=self.strides,
-                padding=self.padding,
-                data_format=self.data_format,
-                dilation_rate=self.dilation_rate,
-            )
-
-            if self.use_bias:
-                outputs = tf.keras.backend.bias_add(outputs, self.bias, data_format=self.data_format)
-
-            if self.activation is not None:
-                return self.activation(outputs)
-
-            return outputs
-
-        @classmethod
-        def from_config(cls, config):
-            """Deserialize this class from a config dict."""
-            return cls(**config)
-
-        def get_config(self):
-            """Serialize this class to a config dict."""
-            config = super(QDepthwiseConv2D, self).get_config()
-            config.update(
-                {
-                    "act_min_value": self.act_min_value,
-                    "act_max_value": self.act_max_value,
-                    "weight_min_value": self.weight_min_value,
-                    "weight_max_value": self.weight_max_value,
-                    "granularity": self.granularity,
-                    "quant_status": self.quant_status,
-                    "quant_mode": self.quant_mode,
-                    "quant_T": "s8" if self.quant_T == tf.qint8 else "u8",
-                    "quant_round_mode": self.quant_round_mode,
-                    "quant_narrow_range": self.quant_narrow_range,
-                    "quant_axis": self.quant_axis,
-                }
-            )
-
-            return config
-
-        @tf_utils.shape_type_conversion
-        def compute_output_shape(self, input_shape):
-            """Compute_output_shape."""
-            if self.data_format == "channels_first":
-                rows = input_shape[2]
-                cols = input_shape[3]
-                out_filters = input_shape[1] * self.depth_multiplier
-            elif self.data_format == "channels_last":
-                rows = input_shape[1]
-                cols = input_shape[2]
-                out_filters = input_shape[3] * self.depth_multiplier
-
-            rows = conv_utils.conv_output_length(
-                rows,
-                self.kernel_size[0],
-                self.padding,
-                self.strides[0],
-                self.dilation_rate[0],
-            )
-            cols = conv_utils.conv_output_length(
-                cols,
-                self.kernel_size[1],
-                self.padding,
-                self.strides[1],
-                self.dilation_rate[1],
-            )
-            if self.data_format == "channels_first":
-                return (input_shape[0], out_filters, rows, cols)
-            elif self.data_format == "channels_last":
-                return (input_shape[0], rows, cols, out_filters)
-
-
-def initialize_int8_depthwise_conv2d(fp32_layer, q_config):
-    """Initialize int8 depthwise conv2d."""
-    kwargs = fp32_layer.get_config()
-    q_name = fp32_layer.name
-
-    param_list = [
-        "name",
-        "kernel_size",
-        "strides",
-        "padding",
-        "depth_multiplier",
-        "data_format",
-        "dilation_rate",
-        "activation",
-        "use_bias",
-        "depthwise_initializer",
-        "bias_initializer",
-        "depthwise_regularizer",
-        "activity_regularizer",
-        "bias_regularizer",
-        "depthwise_constraint",
-        "bias_constraint",
-    ]
-    for p in param_list:  # pragma: no cover
-        if p in kwargs:
-            del kwargs[p]
-
-    return QDepthwiseConv2D(
-        name=q_name,
-        kernel_size=fp32_layer.kernel_size,
-        strides=fp32_layer.strides,
-        padding=fp32_layer.padding,
-        depth_multiplier=fp32_layer.depth_multiplier,
-        data_format=fp32_layer.data_format,
-        dilation_rate=fp32_layer.dilation_rate,
-        activation=fp32_layer.activation,
-        use_bias=fp32_layer.use_bias,
-        depthwise_initializer=fp32_layer.depthwise_initializer,
-        bias_initializer=fp32_layer.bias_initializer,
-        depthwise_regularizer=fp32_layer.depthwise_regularizer,
-        bias_regularizer=fp32_layer.bias_regularizer,
-        activity_regularizer=fp32_layer.activity_regularizer,
-        depthwise_constraint=fp32_layer.depthwise_constraint,
-        bias_constraint=fp32_layer.bias_constraint,
-        quant_T=q_config["T"],
-        granularity=q_config["granularity"],
-        **kwargs
-    )
diff --git a/neural_compressor/tensorflow/keras/layers/layer_initializer.py b/neural_compressor/tensorflow/keras/layers/layer_initializer.py
deleted file mode 100644
index c296e24741c..00000000000
--- a/neural_compressor/tensorflow/keras/layers/layer_initializer.py
+++ /dev/null
@@ -1,34 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Initialize layer initializer functions."""
-
-from neural_compressor.tensorflow.keras.layers.conv2d import initialize_int8_conv2d
-from neural_compressor.tensorflow.keras.layers.dense import initialize_int8_dense
-from neural_compressor.tensorflow.keras.layers.depthwise_conv2d import initialize_int8_depthwise_conv2d
-from neural_compressor.tensorflow.keras.layers.pool2d import initialize_int8_avgpool, initialize_int8_maxpool
-from neural_compressor.tensorflow.keras.layers.separable_conv2d import initialize_int8_separable_conv2d
-
-layer_initializer_dict = {
-    "QAvgPool2D": initialize_int8_avgpool,
-    "QAveragePooling2D": initialize_int8_avgpool,
-    "QMaxPool2D": initialize_int8_maxpool,
-    "QMaxPooling2D": initialize_int8_maxpool,
-    "QSeparableConv2D": initialize_int8_separable_conv2d,
-    "QDepthwiseConv2D": initialize_int8_depthwise_conv2d,
-    "QConv2D": initialize_int8_conv2d,
-    "QDense": initialize_int8_dense,
-}
diff --git a/neural_compressor/tensorflow/keras/layers/pool2d.py b/neural_compressor/tensorflow/keras/layers/pool2d.py
deleted file mode 100644
index 5554f8ff709..00000000000
--- a/neural_compressor/tensorflow/keras/layers/pool2d.py
+++ /dev/null
@@ -1,283 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Initialize custom pool2d layers for Keras quantization."""
-
-import json
-
-import tensorflow as tf
-from tensorflow.keras.layers import AveragePooling2D, MaxPooling2D
-
-from neural_compressor.tensorflow.utils import version1_gte_version2
-
-
-class QAvgPool2D(AveragePooling2D):
-    """The custom quantized AveragePooling2D layer."""
-
-    def __init__(
-        self,
-        name,
-        pool_size=(2, 2),
-        strides=None,
-        padding="valid",
-        data_format=None,
-        act_min_value=None,
-        act_max_value=None,
-        weight_min_value=None,
-        weight_max_value=None,
-        granularity="per_tensor",
-        quant_status="calib",
-        quant_mode="SCALED",
-        quant_T="s8",
-        quant_round_mode="HALF_AWAY_FROM_ZERO",
-        quant_narrow_range=False,
-        quant_axis=None,
-        **kwargs
-    ):
-        """Initialize custom quantized AveragePooling2D layer."""
-        super(QAvgPool2D, self).__init__(
-            name=name, pool_size=pool_size, strides=strides, padding=padding, data_format=data_format, **kwargs
-        )
-        T_map = {"s8": tf.qint8, "u8": tf.quint8}
-        self.weight_min_value = weight_min_value
-        self.weight_max_value = weight_max_value
-        self.act_min_value = act_min_value
-        self.act_max_value = act_max_value
-        self.granularity = granularity
-        self.quant_status = quant_status
-        self.quant_mode = quant_mode
-        self.quant_T = T_map[quant_T]
-        self.quant_round_mode = quant_round_mode
-        self.quant_narrow_range = quant_narrow_range
-        self.quant_axis = quant_axis
-
-    def __call__(self, inputs):
-        """The __call__ function of custom quantized AveragePooling2D layer."""
-        if self.quant_status == "calib" and not (
-            version1_gte_version2(tf.__version__, "2.16.1") and isinstance(inputs, tf.keras.KerasTensor)
-        ):
-            if self.granularity == "per_tensor":
-                self.act_min_value = tf.math.reduce_min(inputs)
-                self.act_max_value = tf.math.reduce_max(inputs)
-            else:
-                self.act_min_value = tf.math.reduce_min(inputs, axis=1)
-                self.act_max_value = tf.math.reduce_max(inputs, axis=1)
-        elif self.quant_status == "quantize":
-            inputs, _, _ = tf.quantization.quantize(
-                inputs,
-                self.act_min_value,
-                self.act_max_value,
-                self.quant_T,
-                mode=self.quant_mode,
-                round_mode=self.quant_round_mode,
-                narrow_range=self.quant_narrow_range,
-                axis=self.quant_axis,
-            )
-            inputs = tf.quantization.dequantize(
-                inputs,
-                self.act_min_value,
-                self.act_max_value,
-                mode=self.quant_mode,
-                narrow_range=self.quant_narrow_range,
-                axis=self.quant_axis,
-            )
-
-        return super(QAvgPool2D, self).__call__(inputs)
-
-    @classmethod
-    def from_config(cls, config):
-        """Deserialize this class from a config dict."""
-        return cls(**config)
-
-    def get_config(self):
-        """Serialize this class to a config dict."""
-        config = super(QAvgPool2D, self).get_config()
-        config.update(
-            {
-                "act_min_value": self.act_min_value,
-                "act_max_value": self.act_max_value,
-                "weight_min_value": self.weight_min_value,
-                "weight_max_value": self.weight_max_value,
-                "granularity": self.granularity,
-                "quant_status": self.quant_status,
-                "quant_mode": self.quant_mode,
-                "quant_T": "s8" if self.quant_T == tf.qint8 else "u8",
-                "quant_round_mode": self.quant_round_mode,
-                "quant_narrow_range": self.quant_narrow_range,
-                "quant_axis": self.quant_axis,
-            }
-        )
-
-        return config
-
-
-class QMaxPool2D(MaxPooling2D):
-    """The custom quantized MaxPooling2D layer."""
-
-    def __init__(
-        self,
-        name,
-        pool_size=(2, 2),
-        strides=None,
-        padding="valid",
-        data_format=None,
-        act_min_value=None,
-        act_max_value=None,
-        weight_min_value=None,
-        weight_max_value=None,
-        granularity="per_tensor",
-        quant_status="calib",
-        quant_mode="SCALED",
-        quant_T="s8",
-        quant_round_mode="HALF_AWAY_FROM_ZERO",
-        quant_narrow_range=False,
-        quant_axis=None,
-        **kwargs
-    ):
-        """Initialize custom quantized MaxPooling2D layer."""
-        super(QMaxPool2D, self).__init__(
-            name=name, pool_size=pool_size, strides=strides, padding=padding, data_format=data_format, **kwargs
-        )
-        T_map = {"s8": tf.qint8, "u8": tf.quint8}
-        self.weight_min_value = weight_min_value
-        self.weight_max_value = weight_max_value
-        self.act_min_value = act_min_value
-        self.act_max_value = act_max_value
-        self.granularity = granularity
-        self.quant_status = quant_status
-        self.quant_mode = quant_mode
-        self.quant_T = T_map[quant_T]
-        self.quant_round_mode = quant_round_mode
-        self.quant_narrow_range = quant_narrow_range
-        self.quant_axis = quant_axis
-
-    def __call__(self, inputs):
-        """The __call__ function of custom quantized MaxPooling2D layer."""
-        if self.quant_status == "calib" and not (
-            version1_gte_version2(tf.__version__, "2.16.1") and isinstance(inputs, tf.keras.KerasTensor)
-        ):
-            if self.granularity == "per_tensor":
-                self.act_min_value = tf.math.reduce_min(inputs)
-                self.act_max_value = tf.math.reduce_max(inputs)
-            else:
-                self.act_min_value = tf.math.reduce_min(inputs, axis=1)
-                self.act_max_value = tf.math.reduce_max(inputs, axis=1)
-        elif self.quant_status == "quantize":
-            assert self.act_min_value is not None, "Invalid activation min-max values, please check calibration process"
-            inputs, _, _ = tf.quantization.quantize(
-                inputs,
-                self.act_min_value,
-                self.act_max_value,
-                self.quant_T,
-                mode=self.quant_mode,
-                round_mode=self.quant_round_mode,
-                narrow_range=self.quant_narrow_range,
-                axis=self.quant_axis,
-            )
-            inputs = tf.quantization.dequantize(
-                inputs,
-                self.act_min_value,
-                self.act_max_value,
-                mode=self.quant_mode,
-                narrow_range=self.quant_narrow_range,
-                axis=self.quant_axis,
-            )
-
-        return super(QMaxPool2D, self).__call__(inputs)
-
-    @classmethod
-    def from_config(cls, config):
-        """Deserialize this class from a config dict."""
-        return cls(**config)
-
-    def get_config(self):
-        """Serialize this class to a config dict."""
-        config = super(QMaxPool2D, self).get_config()
-        config.update(
-            {
-                "act_min_value": self.act_min_value,
-                "act_max_value": self.act_max_value,
-                "weight_min_value": self.weight_min_value,
-                "weight_max_value": self.weight_max_value,
-                "granularity": self.granularity,
-                "quant_status": self.quant_status,
-                "quant_mode": self.quant_mode,
-                "quant_T": "s8" if self.quant_T == tf.qint8 else "u8",
-                "quant_round_mode": self.quant_round_mode,
-                "quant_narrow_range": self.quant_narrow_range,
-                "quant_axis": self.quant_axis,
-            }
-        )
-
-        return config
-
-
-def initialize_int8_avgpool(fp32_layer, q_config):
-    """Initialize int8 avgpool."""
-    kwargs = fp32_layer.get_config()
-
-    param_list = [
-        "name",
-        "pool_size",
-        "strides",
-        "padding",
-        "data_format",
-    ]
-    for p in param_list:  # pragma: no cover
-        if p in kwargs:
-            del kwargs[p]
-
-    q_layer = QAvgPool2D(
-        name=fp32_layer.name,
-        pool_size=fp32_layer.pool_size,
-        strides=fp32_layer.strides,
-        padding=fp32_layer.padding,
-        data_format=fp32_layer.data_format,
-        quant_T=q_config["T"],
-        granularity=q_config["granularity"],
-        **kwargs
-    )
-
-    return q_layer
-
-
-def initialize_int8_maxpool(fp32_layer, q_config):
-    """Initialize int8 maxpool."""
-    kwargs = fp32_layer.get_config()
-
-    param_list = [
-        "name",
-        "pool_size",
-        "strides",
-        "padding",
-        "data_format",
-    ]
-    for p in param_list:  # pragma: no cover
-        if p in kwargs:
-            del kwargs[p]
-
-    q_layer = QMaxPool2D(
-        name=fp32_layer.name,
-        pool_size=fp32_layer.pool_size,
-        strides=fp32_layer.strides,
-        padding=fp32_layer.padding,
-        data_format=fp32_layer.data_format,
-        quant_T=q_config["T"],
-        granularity=q_config["granularity"],
-        **kwargs
-    )
-
-    return q_layer
diff --git a/neural_compressor/tensorflow/keras/layers/separable_conv2d.py b/neural_compressor/tensorflow/keras/layers/separable_conv2d.py
deleted file mode 100644
index 05e23f97fb3..00000000000
--- a/neural_compressor/tensorflow/keras/layers/separable_conv2d.py
+++ /dev/null
@@ -1,431 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Initialize custom separable conv2d layers for Keras quantization."""
-
-import json
-
-import tensorflow as tf
-from tensorflow.keras import activations, constraints, initializers, regularizers
-
-from neural_compressor.tensorflow.utils import version1_gte_version2
-
-if version1_gte_version2(tf.__version__, "2.16.1"):
-    from keras.src import ops
-    from keras.src.layers.convolutional.base_separable_conv import BaseSeparableConv  # pylint: disable=E0401
-elif version1_gte_version2(tf.__version__, "2.13.0"):
-    from keras.src.layers.convolutional.base_separable_conv import SeparableConv  # pylint: disable=E0401
-    from keras.src.utils import conv_utils  # pylint: disable=E0401
-else:
-    from keras.layers.convolutional.base_separable_conv import SeparableConv  # pylint: disable=E0401
-    from keras.utils import conv_utils  # pylint: disable=E0401
-
-if version1_gte_version2(tf.__version__, "2.16.1"):  # pragma: no cover
-
-    class QSeparableConv2D(BaseSeparableConv):
-        """The custom quantized SeparableConv2D layer."""
-
-        def __init__(
-            self,
-            filters,
-            kernel_size,
-            strides=(1, 1),
-            padding="valid",
-            data_format=None,
-            dilation_rate=(1, 1),
-            depth_multiplier=1,
-            activation=None,
-            use_bias=True,
-            depthwise_initializer="glorot_uniform",
-            pointwise_initializer="glorot_uniform",
-            bias_initializer="zeros",
-            depthwise_regularizer=None,
-            pointwise_regularizer=None,
-            bias_regularizer=None,
-            activity_regularizer=None,
-            depthwise_constraint=None,
-            pointwise_constraint=None,
-            bias_constraint=None,
-            act_min_value=None,
-            act_max_value=None,
-            weight_min_value=None,
-            weight_max_value=None,
-            granularity="per_tensor",
-            quant_status="calib",
-            quant_mode="SCALED",
-            quant_T="s8",
-            quant_round_mode="HALF_AWAY_FROM_ZERO",
-            quant_narrow_range=False,
-            quant_axis=None,
-            **kwargs
-        ):
-            """Initialize custom quantized SeparableConv2D layer."""
-            super().__init__(
-                rank=2,
-                filters=filters,
-                kernel_size=kernel_size,
-                strides=strides,
-                padding=padding,
-                data_format=data_format,
-                dilation_rate=dilation_rate,
-                depth_multiplier=depth_multiplier,
-                activation=activations.get(activation),
-                use_bias=use_bias,
-                depthwise_initializer=initializers.get(depthwise_initializer),
-                pointwise_initializer=initializers.get(pointwise_initializer),
-                bias_initializer=initializers.get(bias_initializer),
-                depthwise_regularizer=regularizers.get(depthwise_regularizer),
-                pointwise_regularizer=regularizers.get(pointwise_regularizer),
-                bias_regularizer=regularizers.get(bias_regularizer),
-                activity_regularizer=regularizers.get(activity_regularizer),
-                depthwise_constraint=constraints.get(depthwise_constraint),
-                pointwise_constraint=constraints.get(pointwise_constraint),
-                bias_constraint=constraints.get(bias_constraint),
-                **kwargs
-            )
-
-            T_map = {"s8": tf.qint8, "u8": tf.quint8}
-            self.weight_min_value = weight_min_value
-            self.weight_max_value = weight_max_value
-            self.act_min_value = act_min_value
-            self.act_max_value = act_max_value
-            self.granularity = granularity
-            self.quant_status = quant_status
-            self.quant_mode = quant_mode
-            self.quant_T = T_map[quant_T]
-            self.quant_round_mode = quant_round_mode
-            self.quant_narrow_range = quant_narrow_range
-            self.quant_axis = quant_axis
-
-        def call(self, inputs):
-            """The __call__ function of custom quantized SeparableConv2D layer."""
-            if self.quant_status == "calib" and not isinstance(inputs, tf.keras.KerasTensor):
-                if self.granularity == "per_tensor":
-                    self.act_min_value = tf.math.reduce_min(inputs)
-                    self.act_max_value = tf.math.reduce_max(inputs)
-                else:
-                    self.act_min_value = tf.math.reduce_min(inputs, axis=1)
-                    self.act_max_value = tf.math.reduce_max(inputs, axis=1)
-                depthwise_kernel = self.depthwise_kernel
-            elif self.quant_status == "quantize":
-                assert (
-                    self.act_min_value is not None
-                ), "Invalid activation min-max values, please check calibration process"
-                inputs, _, _ = tf.quantization.quantize(
-                    inputs,
-                    self.act_min_value,
-                    self.act_max_value,
-                    self.quant_T,
-                    mode=self.quant_mode,
-                    round_mode=self.quant_round_mode,
-                    narrow_range=self.quant_narrow_range,
-                    axis=self.quant_axis,
-                )
-                inputs = tf.quantization.dequantize(
-                    inputs,
-                    self.act_min_value,
-                    self.act_max_value,
-                    mode=self.quant_mode,
-                    narrow_range=self.quant_narrow_range,
-                    axis=self.quant_axis,
-                )
-
-                # (TODO) it's ugly that we can't get the point_wise min/max here
-                depthwise_kernel, _, _ = tf.quantization.quantize(
-                    self.depthwise_kernel, self.weight_min_value, self.weight_max_value, tf.qint8, axis=3, mode="SCALED"
-                )
-                depthwise_kernel = tf.quantization.dequantize(
-                    depthwise_kernel,
-                    self.weight_min_value,
-                    self.weight_max_value,
-                    axis=3,
-                    mode="SCALED",
-                )
-
-            outputs = ops.separable_conv(
-                inputs,
-                depthwise_kernel,
-                self.pointwise_kernel,
-                strides=self.strides,
-                padding=self.padding,
-                dilation_rate=self.dilation_rate,
-                data_format=self.data_format,
-            )
-
-            if self.use_bias:
-                if self.data_format == "channels_last":
-                    bias_shape = (1,) * (self.rank + 1) + (self.filters,)
-                else:
-                    bias_shape = (1, self.filters) + (1,) * self.rank
-                bias = ops.reshape(self.bias, bias_shape)
-                outputs += bias
-
-            if self.activation is not None:
-                return self.activation(outputs)
-            return outputs
-
-        @classmethod
-        def from_config(cls, config):
-            """Deserialize this class from a config dict."""
-            return cls(**config)
-
-        def get_config(self):
-            """Serialize this class to a config dict."""
-            config = super(QSeparableConv2D, self).get_config()
-            config.update(
-                {
-                    "act_min_value": self.act_min_value,
-                    "act_max_value": self.act_max_value,
-                    "weight_min_value": self.weight_min_value,
-                    "weight_max_value": self.weight_max_value,
-                    "granularity": self.granularity,
-                    "quant_status": self.quant_status,
-                    "quant_mode": self.quant_mode,
-                    "quant_T": "s8" if self.quant_T == tf.qint8 else "u8",
-                    "quant_round_mode": self.quant_round_mode,
-                    "quant_narrow_range": self.quant_narrow_range,
-                    "quant_axis": self.quant_axis,
-                }
-            )
-
-            return config
-
-else:
-
-    class QSeparableConv2D(SeparableConv):
-        """The custom quantized SeparableConv2D layer."""
-
-        def __init__(
-            self,
-            filters,
-            kernel_size,
-            strides=(1, 1),
-            padding="valid",
-            data_format=None,
-            dilation_rate=(1, 1),
-            depth_multiplier=1,
-            activation=None,
-            use_bias=True,
-            depthwise_initializer="glorot_uniform",
-            pointwise_initializer="glorot_uniform",
-            bias_initializer="zeros",
-            depthwise_regularizer=None,
-            pointwise_regularizer=None,
-            bias_regularizer=None,
-            activity_regularizer=None,
-            depthwise_constraint=None,
-            pointwise_constraint=None,
-            bias_constraint=None,
-            act_min_value=None,
-            act_max_value=None,
-            weight_min_value=None,
-            weight_max_value=None,
-            granularity="per_tensor",
-            quant_status="calib",
-            quant_mode="SCALED",
-            quant_T="s8",
-            quant_round_mode="HALF_AWAY_FROM_ZERO",
-            quant_narrow_range=False,
-            quant_axis=None,
-            **kwargs
-        ):
-            """Initialize custom quantized SeparableConv2D layer."""
-            super().__init__(
-                rank=2,
-                filters=filters,
-                kernel_size=kernel_size,
-                strides=strides,
-                padding=padding,
-                data_format=data_format,
-                dilation_rate=dilation_rate,
-                depth_multiplier=depth_multiplier,
-                activation=activations.get(activation),
-                use_bias=use_bias,
-                depthwise_initializer=initializers.get(depthwise_initializer),
-                pointwise_initializer=initializers.get(pointwise_initializer),
-                bias_initializer=initializers.get(bias_initializer),
-                depthwise_regularizer=regularizers.get(depthwise_regularizer),
-                pointwise_regularizer=regularizers.get(pointwise_regularizer),
-                bias_regularizer=regularizers.get(bias_regularizer),
-                activity_regularizer=regularizers.get(activity_regularizer),
-                depthwise_constraint=constraints.get(depthwise_constraint),
-                pointwise_constraint=constraints.get(pointwise_constraint),
-                bias_constraint=constraints.get(bias_constraint),
-                **kwargs
-            )
-            T_map = {"s8": tf.qint8, "u8": tf.quint8}
-            self.weight_min_value = weight_min_value
-            self.weight_max_value = weight_max_value
-            self.act_min_value = act_min_value
-            self.act_max_value = act_max_value
-            self.granularity = granularity
-            self.quant_status = quant_status
-            self.quant_mode = quant_mode
-            self.quant_T = T_map[quant_T]
-            self.quant_round_mode = quant_round_mode
-            self.quant_narrow_range = quant_narrow_range
-            self.quant_axis = quant_axis
-
-        def call(self, inputs):
-            """The __call__ function of custom quantized SeparableConv2D layer."""
-            if self.quant_status == "calib":
-                if self.granularity == "per_tensor":
-                    self.act_min_value = tf.math.reduce_min(inputs)
-                    self.act_max_value = tf.math.reduce_max(inputs)
-                else:
-                    self.act_min_value = tf.math.reduce_min(inputs, axis=1)
-                    self.act_max_value = tf.math.reduce_max(inputs, axis=1)
-                depthwise_kernel = self.depthwise_kernel
-            elif self.quant_status == "quantize":
-                assert (
-                    self.act_min_value is not None
-                ), "Invalid activation min-max values, please check calibration process"
-                inputs, _, _ = tf.quantization.quantize(
-                    inputs,
-                    self.act_min_value,
-                    self.act_max_value,
-                    self.quant_T,
-                    mode=self.quant_mode,
-                    round_mode=self.quant_round_mode,
-                    narrow_range=self.quant_narrow_range,
-                    axis=self.quant_axis,
-                )
-                inputs = tf.quantization.dequantize(
-                    inputs,
-                    self.act_min_value,
-                    self.act_max_value,
-                    mode=self.quant_mode,
-                    narrow_range=self.quant_narrow_range,
-                    axis=self.quant_axis,
-                )
-
-                # (TODO) it's ugly that we can't get the point_wise min/max here
-                depthwise_kernel, _, _ = tf.quantization.quantize(
-                    self.depthwise_kernel, self.weight_min_value, self.weight_max_value, tf.qint8, axis=3, mode="SCALED"
-                )
-                depthwise_kernel = tf.quantization.dequantize(
-                    depthwise_kernel,
-                    self.weight_min_value,
-                    self.weight_max_value,
-                    axis=3,
-                    mode="SCALED",
-                )
-
-            if self.data_format == "channels_last":
-                strides = (1,) + self.strides + (1,)
-            else:
-                strides = (1, 1) + self.strides
-
-            outputs = tf.compat.v1.nn.separable_conv2d(
-                inputs,
-                depthwise_kernel,
-                self.pointwise_kernel,
-                strides=strides,
-                padding=self.padding.upper(),
-                rate=self.dilation_rate,
-                data_format=conv_utils.convert_data_format(self.data_format, ndim=4),
-            )
-
-            if self.use_bias:
-                outputs = tf.keras.backend.bias_add(outputs, self.bias, data_format=self.data_format)
-
-            if self.activation is not None:
-                return self.activation(outputs)
-
-            return outputs
-
-        @classmethod
-        def from_config(cls, config):
-            """Deserialize this class from a config dict."""
-            return cls(**config)
-
-        def get_config(self):
-            """Serialize this class to a config dict."""
-            config = super(QSeparableConv2D, self).get_config()
-            config.update(
-                {
-                    "act_min_value": self.act_min_value,
-                    "act_max_value": self.act_max_value,
-                    "weight_min_value": self.weight_min_value,
-                    "weight_max_value": self.weight_max_value,
-                    "granularity": self.granularity,
-                    "quant_status": self.quant_status,
-                    "quant_mode": self.quant_mode,
-                    "quant_T": "s8" if self.quant_T == tf.qint8 else "u8",
-                    "quant_round_mode": self.quant_round_mode,
-                    "quant_narrow_range": self.quant_narrow_range,
-                    "quant_axis": self.quant_axis,
-                }
-            )
-
-            return config
-
-
-def initialize_int8_separable_conv2d(fp32_layer, q_config):
-    """Initialize int8 separable conv2d."""
-    kwargs = fp32_layer.get_config()
-
-    param_list = [
-        "name",
-        "filters",
-        "kernel_size",
-        "strides",
-        "padding",
-        "data_format",
-        "dilation_rate",
-        "depth_multiplier",
-        "activation",
-        "use_bias",
-        "depthwise_initializer",
-        "bias_initializer",
-        "pointwise_initializer",
-        "depthwise_regularizer",
-        "activity_regularizer",
-        "bias_regularizer",
-        "pointwise_regularizer",
-        "depthwise_constraint",
-        "bias_constraint",
-        "pointwise_constraint",
-    ]
-    for p in param_list:  # pragma: no cover
-        if p in kwargs:
-            del kwargs[p]
-
-    return QSeparableConv2D(
-        name=fp32_layer.name,
-        filters=fp32_layer.filters,
-        kernel_size=fp32_layer.kernel_size,
-        strides=fp32_layer.strides,
-        padding=fp32_layer.padding,
-        data_format=fp32_layer.data_format,
-        dilation_rate=fp32_layer.dilation_rate,
-        depth_multiplier=fp32_layer.depth_multiplier,
-        activation=fp32_layer.activation,
-        use_bias=fp32_layer.use_bias,
-        depthwise_initializer=fp32_layer.depthwise_initializer,
-        pointwise_initializer=fp32_layer.pointwise_initializer,
-        bias_initializer=fp32_layer.bias_initializer,
-        depthwise_regularizer=fp32_layer.depthwise_regularizer,
-        pointwise_regularizer=fp32_layer.pointwise_regularizer,
-        bias_regularizer=fp32_layer.bias_regularizer,
-        activity_regularizer=fp32_layer.activity_regularizer,
-        depthwise_constraint=fp32_layer.depthwise_constraint,
-        pointwise_constraint=fp32_layer.pointwise_constraint,
-        bias_constraint=fp32_layer.bias_constraint,
-        quant_T=q_config["T"],
-        granularity=q_config["granularity"],
-        **kwargs
-    )
diff --git a/neural_compressor/tensorflow/keras/quantization/__init__.py b/neural_compressor/tensorflow/keras/quantization/__init__.py
deleted file mode 100644
index 4e52426c109..00000000000
--- a/neural_compressor/tensorflow/keras/quantization/__init__.py
+++ /dev/null
@@ -1,19 +0,0 @@
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Initialize configs for Keras quantization."""
-
-from neural_compressor.tensorflow.keras.quantization.config import (
-    StaticQuantConfig,
-    get_default_static_quant_config,
-)
diff --git a/neural_compressor/tensorflow/keras/quantization/config.py b/neural_compressor/tensorflow/keras/quantization/config.py
deleted file mode 100644
index 1cebc23b0e2..00000000000
--- a/neural_compressor/tensorflow/keras/quantization/config.py
+++ /dev/null
@@ -1,161 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""The configs of algorithms for Keras."""
-
-from __future__ import annotations
-
-from typing import Callable, Dict, List, NamedTuple, Optional, Tuple, Union
-
-import tensorflow as tf
-
-from neural_compressor.common import logger
-from neural_compressor.common.base_config import (
-    DEFAULT_WHITE_LIST,
-    OP_NAME_OR_MODULE_TYPE,
-    BaseConfig,
-    config_registry,
-    register_config,
-    register_supported_configs_for_fwk,
-)
-from neural_compressor.common.utils import STATIC_QUANT
-
-FRAMEWORK_NAME = "keras"
-
-
-class OperatorConfig(NamedTuple):
-    """The config for operator."""
-
-    config: BaseConfig
-    operators: List[Union[str, Callable]]
-    valid_func_list: List[Callable] = []
-
-
-@register_config(framework_name=FRAMEWORK_NAME, algo_name=STATIC_QUANT)
-class StaticQuantConfig(BaseConfig):
-    """Config class for keras static quantization."""
-
-    supported_configs: List[OperatorConfig] = []
-    params_list = [
-        "weight_dtype",
-        "weight_sym",
-        "weight_granularity",
-        "act_dtype",
-        "act_sym",
-        "act_granularity",
-    ]
-
-    name = STATIC_QUANT
-
-    def __init__(
-        self,
-        weight_dtype: str = "int8",
-        weight_sym: bool = True,
-        weight_granularity: str = "per_tensor",
-        act_dtype: str = "int8",
-        act_sym: bool = True,
-        act_granularity: str = "per_tensor",
-        white_list: Optional[List[OP_NAME_OR_MODULE_TYPE]] = DEFAULT_WHITE_LIST,
-    ):
-        """Init static quantization config.
-
-        Args:
-            weight_dtype (str): Data type for weights, default is "int".
-            weight_sym (bool): Indicates whether weights are symmetric, default is True.
-            weight_granularity (str): Calculate tensor-wise scales or channel-wise scales for weights.
-            act_dtype (str): Data type for activations, default is "int8".
-            act_sym (bool): Indicates whether activations are symmetric, default is True.
-            act_granularity (str): Calculate tensor-wise scales or channel-wise scales for activations.
-            white_list (list): A list of supported operators of this algorithm.
-        """
-        super().__init__(white_list=white_list)
-        self.weight_dtype = weight_dtype
-        self.weight_sym = weight_sym
-        self.weight_granularity = weight_granularity
-        self.act_dtype = act_dtype
-        self.act_sym = act_sym
-        self.act_granularity = act_granularity
-        self._post_init()
-
-    @classmethod
-    def register_supported_configs(cls) -> List[OperatorConfig]:
-        """Register supported configs."""
-        supported_configs = []
-        static_quant_config = StaticQuantConfig(
-            weight_dtype=["int8", "fp32"],
-            weight_sym=[True, False],
-            weight_granularity=["per_tensor", "per_channel"],
-            act_dtype=["int8", "fp32"],
-            act_sym=[True, False],
-            act_granularity=["per_tensor", "per_channel"],
-        )
-        operators = [
-            tf.keras.layers.Dense,
-            tf.keras.layers.Conv2D,
-            tf.keras.layers.DepthwiseConv2D,
-            tf.keras.layers.SeparableConv2D,
-            tf.keras.layers.AvgPool2D,
-            tf.keras.layers.MaxPool2D,
-            tf.keras.layers.AveragePooling2D,
-            tf.keras.layers.MaxPooling2D,
-        ]
-        supported_configs.append(OperatorConfig(config=static_quant_config, operators=operators))
-        cls.supported_configs = supported_configs
-
-    @staticmethod
-    def get_model_info(model) -> List[Tuple[str, Callable]]:
-        """Get concrete node names for supported operators."""
-        white_list = [
-            "Dense",
-            "Conv2D",
-            "DepthwiseConv2D",
-            "SeparableConv2D",
-            "AvgPool2D",
-            "AveragePooling2D",
-            "MaxPool2D",
-            "MaxPooling2D",
-        ]
-        filter_result = []
-
-        for layer in model.model.layers:
-            if layer.__class__.__name__ in white_list:
-                pair = (layer.name, layer.__class__.__name__)
-                filter_result.append(pair)
-        logger.debug(f"Get model info: {filter_result}")
-        return filter_result
-
-    @classmethod
-    def get_config_set_for_tuning(cls) -> Union[None, "StaticQuantConfig", List["StaticQuantConfig"]]:
-        """Get a default config set for tuning."""
-        return StaticQuantConfig(weight_sym=[True, False])
-
-
-register_supported_configs_for_fwk(fwk_name=FRAMEWORK_NAME)
-
-
-def get_all_registered_configs() -> Dict[str, BaseConfig]:
-    """Get all registered configs for keras framework."""
-    registered_configs = config_registry.get_cls_configs()
-    return registered_configs.get(FRAMEWORK_NAME, {})
-
-
-def get_default_static_quant_config() -> StaticQuantConfig:
-    """Generate the default static quant config.
-
-    Returns:
-        the default keras config.
-    """
-    return StaticQuantConfig()
diff --git a/neural_compressor/tensorflow/quantization/__init__.py b/neural_compressor/tensorflow/quantization/__init__.py
deleted file mode 100644
index 26909e4b9ab..00000000000
--- a/neural_compressor/tensorflow/quantization/__init__.py
+++ /dev/null
@@ -1,24 +0,0 @@
-# Copyright (c) 2023 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Intel Neural Compressor Tensorflow quantization API."""
-
-from neural_compressor.tensorflow.quantization.quantize import quantize_model
-from neural_compressor.tensorflow.quantization.autotune import autotune, get_all_config_set, TuningConfig
-from neural_compressor.tensorflow.quantization.algorithm_entry import static_quant_entry, smooth_quant_entry
-from neural_compressor.tensorflow.quantization.config import (
-    StaticQuantConfig,
-    SmoothQuantConfig,
-    get_default_sq_config,
-    get_default_static_quant_config,
-)
diff --git a/neural_compressor/tensorflow/quantization/algorithm_entry.py b/neural_compressor/tensorflow/quantization/algorithm_entry.py
deleted file mode 100644
index 5a71e197753..00000000000
--- a/neural_compressor/tensorflow/quantization/algorithm_entry.py
+++ /dev/null
@@ -1,89 +0,0 @@
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""The entry interface for algorithms."""
-
-from typing import Callable, Dict
-
-from neural_compressor.common.base_config import BaseConfig
-from neural_compressor.common.utils import SMOOTH_QUANT, STATIC_QUANT
-from neural_compressor.tensorflow.algorithms import KerasAdaptor, Tensorflow_ITEXAdaptor, TensorFlowAdaptor
-from neural_compressor.tensorflow.quantization.config import SmoothQuantConfig
-from neural_compressor.tensorflow.utils import BaseModel, KerasModel, TFConfig, register_algo, valid_keras_format
-
-
-@register_algo(name=STATIC_QUANT)
-def static_quant_entry(
-    model: BaseModel,
-    quant_config: BaseConfig,
-    calib_dataloader: Callable = None,
-    calib_iteration: int = 100,
-    calib_func: Callable = None,
-):
-    """The main entry to apply static quantization.
-
-    Args:
-        model: a fp32 model to be quantized.
-        quant_config: a quantization configuration.
-        calib_dataloader: a data loader for calibration.
-        calib_iteration: the iteration of calibration.
-        calib_func: the function used for calibration, should be a substitution for calib_dataloader
-        when the built-in calibration function of INC does not work for model inference.
-
-    Returns:
-        q_model: the quantized model.
-    """
-    if isinstance(model, KerasModel):
-        assert valid_keras_format(model.model), "Only Sequential or Functional models are supported now."
-        framework = KerasAdaptor
-    elif TFConfig.global_config["backend"] == "itex":
-        framework = Tensorflow_ITEXAdaptor
-    else:
-        framework = TensorFlowAdaptor
-
-    quantizer = framework(TFConfig.global_config)
-    q_model = quantizer.quantize(quant_config, model, calib_dataloader, calib_iteration, calib_func)
-    TFConfig.reset_global_config()
-
-    return q_model
-
-
-@register_algo(name=SMOOTH_QUANT)
-def smooth_quant_entry(
-    model: BaseModel,
-    smooth_quant_config: SmoothQuantConfig,
-    calib_dataloader: Callable = None,
-    calib_iteration: int = 100,
-    calib_func: Callable = None,
-):
-    """The main entry to apply smooth quantization.
-
-    Args:
-        model: a fp32 model to be quantized.
-        quant_config: a quantization configuration.
-        calib_dataloader: a data loader for calibration.
-        calib_iteration: the iteration of calibration.
-        calib_func: the function used for calibration, should be a substitution for calib_dataloader
-        when the built-in calibration function of INC does not work for model inference.
-
-    Returns:
-        q_model: the quantized model.
-    """
-    assert not isinstance(model, KerasModel), "INC don't support smooth quantization for Keras models now."
-
-    from neural_compressor.tensorflow.algorithms import SmoothQuant
-
-    converter = SmoothQuant(smooth_quant_config, calib_dataloader, calib_iteration, calib_func)
-    sq_model = converter(model)
-
-    return sq_model
diff --git a/neural_compressor/tensorflow/quantization/autotune.py b/neural_compressor/tensorflow/quantization/autotune.py
deleted file mode 100644
index 7f4c45595dd..00000000000
--- a/neural_compressor/tensorflow/quantization/autotune.py
+++ /dev/null
@@ -1,84 +0,0 @@
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Intel Neural Compressor Tensorflow quantization AutoTune API."""
-
-from copy import deepcopy
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
-
-import tensorflow as tf
-
-from neural_compressor.common import logger
-from neural_compressor.common.base_config import BaseConfig, get_all_config_set_from_config_registry
-from neural_compressor.common.base_tuning import EvaluationFuncWrapper, TuningConfig, init_tuning
-from neural_compressor.common.utils import call_counter, dump_elapsed_time
-from neural_compressor.tensorflow.quantization import quantize_model
-from neural_compressor.tensorflow.quantization.config import FRAMEWORK_NAME, StaticQuantConfig
-from neural_compressor.tensorflow.utils import BaseModel, Model, constants
-
-__all__ = [
-    "autotune",
-    "get_all_config_set",
-]
-
-
-def get_all_config_set() -> Union[BaseConfig, List[BaseConfig]]:
-    """Get all config set."""
-    return get_all_config_set_from_config_registry(fwk_name=FRAMEWORK_NAME)
-
-
-@dump_elapsed_time("Pass auto-tune")
-@call_counter
-def autotune(
-    model: Union[str, tf.keras.Model, BaseModel],
-    tune_config: TuningConfig,
-    eval_fn: Callable,
-    eval_args: Optional[Tuple[Any]] = None,
-    calib_dataloader: Callable = None,
-    calib_iteration: int = 100,
-    calib_func: Callable = None,
-) -> Optional[BaseModel]:
-    """The main entry of auto-tune."""
-    model = Model(model)
-    best_quant_model = None
-    eval_func_wrapper = EvaluationFuncWrapper(eval_fn, eval_args)
-    config_loader, tuning_logger, tuning_monitor = init_tuning(tuning_config=tune_config)
-    baseline: float = eval_func_wrapper.evaluate(model)
-    tuning_monitor.set_baseline(baseline)
-    tuning_logger.tuning_start()
-    for trial_index, quant_config in enumerate(config_loader, 1):
-        tuning_logger.trial_start(trial_index=trial_index)
-        tuning_logger.execution_start()
-        logger.info(quant_config.to_dict())
-        q_model = quantize_model(model, quant_config, calib_dataloader, calib_iteration, calib_func)
-        tuning_logger.execution_end()
-        tuning_logger.evaluation_start()
-        eval_result: float = eval_func_wrapper.evaluate(q_model)
-        tuning_logger.evaluation_end()
-        tuning_monitor.add_trial_result(trial_index, eval_result, quant_config)
-        tuning_logger.trial_end(trial_index)
-        if tuning_monitor.need_stop():
-            logger.info("Stopped tuning.")
-            best_trial_record = tuning_monitor.get_best_trial_record()
-            if best_trial_record.trial_index != trial_index:
-                logger.info("Re-quantizing with best quantization config...")
-                del q_model
-                best_quant_config: BaseConfig = best_trial_record.quant_config
-                best_quant_model = quantize_model(
-                    model, best_quant_config, calib_dataloader, calib_iteration, calib_func
-                )
-            else:
-                best_quant_model = q_model
-            break
-    tuning_logger.tuning_end()
-    return best_quant_model
diff --git a/neural_compressor/tensorflow/quantization/config.py b/neural_compressor/tensorflow/quantization/config.py
deleted file mode 100644
index 0aa4b6428f9..00000000000
--- a/neural_compressor/tensorflow/quantization/config.py
+++ /dev/null
@@ -1,297 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2023 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Intel Neural Compressor TF quantization config API."""
-
-from __future__ import annotations
-
-from enum import Enum
-from typing import Callable, Dict, List, NamedTuple, Optional, Tuple, Union
-
-import tensorflow as tf
-
-from neural_compressor.common import logger
-from neural_compressor.common.base_config import (
-    DEFAULT_WHITE_LIST,
-    OP_NAME_OR_MODULE_TYPE,
-    BaseConfig,
-    config_registry,
-    register_config,
-    register_supported_configs_for_fwk,
-)
-from neural_compressor.common.utils import SMOOTH_QUANT, STATIC_QUANT
-from neural_compressor.tensorflow.utils import DEFAULT_SQ_ALPHA_ARGS
-
-FRAMEWORK_NAME = "tensorflow"
-
-__all__ = [
-    "StaticQuantConfig",
-    "get_default_static_quant_config",
-    "SmoothQuantConfig",
-    "get_default_sq_config",
-]
-
-
-class OperatorConfig(NamedTuple):
-    """Configuration tuple describing operators and validation functions."""
-
-    config: BaseConfig
-    operators: List[Union[str, Callable]]
-    valid_func_list: List[Callable] = []
-
-
-@register_config(framework_name=FRAMEWORK_NAME, algo_name=STATIC_QUANT)
-class StaticQuantConfig(BaseConfig):
-    """Config class for tf static quantization."""
-
-    supported_configs: List[OperatorConfig] = []
-    params_list = [
-        "weight_dtype",
-        "weight_sym",
-        "weight_granularity",
-        "weight_algorithm",
-        "act_dtype",
-        "act_sym",
-        "act_granularity",
-        "act_algorithm",
-    ]
-
-    name = STATIC_QUANT
-
-    def __init__(
-        self,
-        weight_dtype: str = "int8",
-        weight_sym: bool = True,
-        weight_granularity: str = "per_tensor",
-        weight_algorithm: str = "minmax",
-        act_dtype: str = "int8",
-        act_sym: bool = True,
-        act_granularity: str = "per_tensor",
-        act_algorithm: str = "minmax",
-        white_list: Optional[List[OP_NAME_OR_MODULE_TYPE]] = DEFAULT_WHITE_LIST,
-    ):
-        """Init static quantization config.
-
-        Args:
-            weight_dtype (str): Data type for weights, default is "int".
-            weight_sym (bool): Indicates whether weights are symmetric, default is True.
-            weight_granularity (str): Calculate tensor-wise scales or channel-wise scales for weights.
-            weight_algorithm (str): Choose quantization algorithms for weights.
-            act_dtype (str): Data type for activations, default is "int8".
-            act_sym (bool): Indicates whether activations are symmetric, default is True.
-            act_granularity (str): Calculate tensor-wise scales or channel-wise scales for activations.
-            act_algorithm (str): Choose quantization algorithms for activations.
-            white_list (list): A list of supported operators of this algorithm.
-        """
-        super().__init__(white_list=white_list)
-        self.weight_dtype = weight_dtype
-        self.weight_sym = weight_sym
-        self.weight_granularity = weight_granularity
-        self.weight_algorithm = weight_algorithm
-        self.act_dtype = act_dtype
-        self.act_sym = act_sym
-        self.act_granularity = act_granularity
-        self.act_algorithm = act_algorithm
-        self._post_init()
-
-    @classmethod
-    def register_supported_configs(cls) -> List[OperatorConfig]:
-        """Register supported config."""
-        supported_configs = []
-        static_quant_config = StaticQuantConfig(
-            weight_dtype=["int8", "bf16", "fp32"],
-            weight_sym=[True, False],
-            weight_granularity=["per_tensor", "per_channel"],
-            weight_algorithm=["minmax", "kl"],
-            act_dtype=["int8", "bf16", "fp32"],
-            act_sym=[True, False],
-            act_granularity=["per_tensor"],
-            act_algorithm=["minmax", "kl"],
-        )
-        operators = [
-            tf.nn.conv2d,
-            tf.raw_ops.FusedBatchNormV3,
-            tf.nn.conv3d,
-            tf.raw_ops.MatMul,
-            tf.raw_ops.BatchMatMul,
-            tf.raw_ops.BatchMatMulV2,
-            tf.nn.depthwise_conv2d,
-            tf.raw_ops.ConcatV2,
-            tf.compat.v1.nn.fused_batch_norm,
-            tf.nn.max_pool,
-            tf.nn.avg_pool,
-            tf.compat.v1.nn.conv2d_backprop_input,
-            tf.raw_ops.Conv3DBackpropInputV2,
-        ]
-        supported_configs.append(OperatorConfig(config=static_quant_config, operators=operators))
-        cls.supported_configs = supported_configs
-
-    def get_model_info(self, model) -> List[Tuple[str, Callable]]:
-        """Get concrete node names for supported operators."""
-        white_list = [
-            "Conv2D",
-            "FusedBatchNormV3",
-            "Conv3D",
-            "_MklFusedInstanceNorm",
-            "MatMul",
-            "BatchMatMul",
-            "BatchMatMulV2",
-            "DepthwiseConv2dNative",
-            "ConcatV2",
-            "FusedBatchNorm",
-            "FusedBatchNormV2",
-            "MaxPool",
-            "MaxPool3D",
-            "AvgPool",
-            "Conv2DBackpropInput",
-            "Conv3DBackpropInputV2",
-        ]
-        for key in self._local_config.keys():
-            if key in white_list:
-                white_list.remove(key)
-        filter_result = []
-        for node in model.graph_def.node:
-            if node.op in white_list:
-                pair = (node.name, node.op)
-                filter_result.append(pair)
-        logger.debug(f"Get model info: {filter_result}")
-        return filter_result
-
-    @classmethod
-    def get_config_set_for_tuning(cls) -> Union[None, "StaticQuantConfig", List["StaticQuantConfig"]]:
-        """Get a default config set for tuning."""
-        return StaticQuantConfig(
-            weight_dtype=["int8", "fp32"],
-            weight_sym=[True, False],
-            weight_granularity=["per_tensor", "per_channel"],
-            weight_algorithm=["minmax", "kl"],
-            act_dtype=["int8", "fp32"],
-            act_sym=[True, False],
-            act_granularity=["per_tensor"],
-            act_algorithm=["minmax", "kl"],
-        )
-
-
-register_supported_configs_for_fwk(fwk_name="keras")
-
-
-def get_all_registered_configs() -> Dict[str, BaseConfig]:
-    """Get all registered configs for keras framework."""
-    registered_configs = config_registry.get_cls_configs()
-    return registered_configs.get(FRAMEWORK_NAME, {})
-
-
-def get_default_static_quant_config() -> StaticQuantConfig:
-    """Generate the default static quant config.
-
-    Returns:
-        the default tf config.
-    """
-    return StaticQuantConfig()
-
-
-@register_config(framework_name=FRAMEWORK_NAME, algo_name=SMOOTH_QUANT)
-class SmoothQuantConfig(BaseConfig):
-    """Config class for tf smooth quantization."""
-
-    supported_configs: List[OperatorConfig] = []
-    params_list = [
-        "alpha",
-        "folding",
-        "percentile",
-        "op_types",
-        "scales_per_op",
-        "record_max_info",
-        "weight_clip",
-        "auto_alpha_args",
-    ]
-    name = SMOOTH_QUANT
-
-    def __init__(
-        self,
-        alpha: float = 0.5,
-        folding: bool = False,
-        percentile: float = 99.999,
-        op_types: list = ["MatMul", "Conv2D"],
-        scales_per_op: bool = True,
-        record_max_info: bool = False,
-        weight_clip: bool = True,
-        auto_alpha_args: Dict = DEFAULT_SQ_ALPHA_ARGS,
-        white_list: Optional[List[OP_NAME_OR_MODULE_TYPE]] = DEFAULT_WHITE_LIST,
-    ):
-        """Init RTN weight-only quantization config.
-
-        Args:
-            alpha (float): Value to balance input and weight quantization error, between 0 and 1, default is 0.5.
-            folding (bool): Whether to fold mul into the previous layer, default is False.
-            percentile (float): percentile of calibration to remove outliers, default is 99.99.
-            op_types (list): The op types whose input tensor will be dumped, default is ["MatMul", "Conv2D"].
-            scales_per_op (bool): Whether to set individual scale for every op, default is True.
-            record_max_info (bool): whether record the max info in model for alpha tuning, default is False.
-            weight_clip: Whether to clip weight when calculating scales, default is True.
-            auto_alpha_args(dict) : Hyperparameters used to set the alpha search space in SQ auto-tuning,
-                                    by default the search space is 0.0-1.0 with step_size 0.1.
-            white_list (list): A list of supported operators of this algorithm.
-        """
-        super().__init__()
-        self.alpha = alpha
-        self.folding = folding
-        self.percentile = percentile
-        self.op_types = op_types
-        self.scales_per_op = scales_per_op
-        self.record_max_info = record_max_info
-        self.weight_clip = weight_clip
-        self.auto_alpha_args = auto_alpha_args
-        self.white_list = white_list
-        self._post_init()
-
-    @classmethod
-    def register_supported_configs(cls) -> List[OperatorConfig]:
-        """Register supported configs."""
-        supported_configs = []
-        smooth_quant_config = SmoothQuantConfig()
-        operators = ["MatMul", "Conv2D"]
-        supported_configs.append(OperatorConfig(config=smooth_quant_config, operators=operators))
-        cls.supported_configs = supported_configs
-
-    @staticmethod
-    def get_model_info(model) -> List[Tuple[str, Callable]]:
-        """Get concrete node names for supported operators."""
-        white_list = ["MatMul", "Conv2D"]
-        filter_result = []
-        for node in model.graph_def.node:
-            if node.op in white_list:
-                pair = (node.name, node.op)
-                filter_result.append(pair)
-        logger.debug(f"Get model info: {filter_result}")
-        return filter_result
-
-    @classmethod
-    def get_config_set_for_tuning(cls) -> Union[None, "SmoothQuantConfig", List["SmoothQuantConfig"]]:
-        """Get a default config set for tuning."""
-        return SmoothQuantConfig(alpha=0.5)
-
-
-SmoothQuantConfig.register_supported_configs()
-
-
-def get_default_sq_config() -> SmoothQuantConfig:
-    """Generate the default rtn config.
-
-    Returns:
-        the default smooth quant config.
-    """
-    return SmoothQuantConfig()
diff --git a/neural_compressor/tensorflow/quantization/quantize.py b/neural_compressor/tensorflow/quantization/quantize.py
deleted file mode 100644
index cf80b700895..00000000000
--- a/neural_compressor/tensorflow/quantization/quantize.py
+++ /dev/null
@@ -1,103 +0,0 @@
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Intel Neural Compressor Tensorflow quantization base API."""
-
-from typing import Any, Callable, Dict, Tuple, Union
-
-import tensorflow as tf
-
-from neural_compressor.common import logger
-from neural_compressor.common.base_config import BaseConfig, ComposableConfig, config_registry
-from neural_compressor.common.utils import STATIC_QUANT, log_process
-from neural_compressor.tensorflow.utils import BaseModel, KerasModel, Model, algos_mapping
-
-
-def need_apply(configs_mapping: Dict[Tuple[str, callable], BaseConfig], algo_name):
-    """Whether to apply the algorithm."""
-    return any(config.name == algo_name for config in configs_mapping.values())
-
-
-@log_process()
-def quantize_model(
-    model: Union[str, tf.keras.Model, BaseModel],
-    quant_config: Union[BaseConfig, list],
-    calib_dataloader: Callable = None,
-    calib_iteration: int = 100,
-    calib_func: Callable = None,
-):
-    """The main entry to quantize model.
-
-    Args:
-        model: a fp32 model to be quantized.
-        quant_config: single or lists of quantization configuration.
-        calib_dataloader: a data loader for calibration.
-        calib_iteration: the iteration of calibration.
-        calib_func: the function used for calibration, should be a substitution for calib_dataloader
-        when the built-in calibration function of INC does not work for model inference.
-
-    Returns:
-        q_model: the quantized model.
-    """
-    q_model = Model(model)
-    if isinstance(quant_config, list):
-        for config in quant_config:
-            q_model = quantize_model_with_single_config(q_model, config, calib_dataloader, calib_iteration, calib_func)
-    else:
-        q_model = quantize_model_with_single_config(
-            q_model, quant_config, calib_dataloader, calib_iteration, calib_func
-        )
-
-    return q_model
-
-
-def quantize_model_with_single_config(
-    q_model: BaseModel,
-    quant_config: BaseConfig,
-    calib_dataloader: Callable = None,
-    calib_iteration: int = 100,
-    calib_func: Callable = None,
-):
-    """Quantize model using single config.
-
-    Args:
-        model: a model wrapped by INC TF model class.
-        quant_config: a quantization configuration.
-        calib_dataloader: a data loader for calibration.
-        calib_iteration: the iteration of calibration.
-        calib_func: the function used for calibration, should be a substitution for calib_dataloader
-        when the built-in calibration function of INC does not work for model inference.
-
-    Returns:
-        q_model: the quantized model.
-    """
-    framework_name = "keras" if isinstance(q_model, KerasModel) else "tensorflow"
-    registered_configs = config_registry.get_cls_configs()
-    if isinstance(quant_config, dict):
-        quant_config = ComposableConfig.from_dict(quant_config, config_registry=registered_configs[framework_name])
-        logger.info(f"Parsed a config dict to construct the quantization config: {quant_config}.")
-    else:
-        assert isinstance(
-            quant_config, BaseConfig
-        ), f"Please pass a dict or config instance as the quantization configuration, but got {type(quant_config)}."
-    logger.info(f"Quantize model with config: \n {quant_config.to_json_string()} \n")
-    # select quantization algo according to config
-
-    model_info = quant_config.get_model_info(model=q_model)
-    configs_mapping = quant_config.to_config_mapping(model_info=model_info)
-    logger.debug(configs_mapping)
-    for algo_name, algo_func in algos_mapping.items():
-        if need_apply(configs_mapping, algo_name):
-            logger.info(f"Start to apply {algo_name} on the model.")
-            q_model = algo_func(q_model, configs_mapping, calib_dataloader, calib_iteration, calib_func)
-    return q_model
diff --git a/neural_compressor/tensorflow/quantization/utils/__init__.py b/neural_compressor/tensorflow/quantization/utils/__init__.py
deleted file mode 100644
index 0420d370f04..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/__init__.py
+++ /dev/null
@@ -1,14 +0,0 @@
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""The utils for TF quantization."""
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_converter.py b/neural_compressor/tensorflow/quantization/utils/graph_converter.py
deleted file mode 100644
index 01871f08e50..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_converter.py
+++ /dev/null
@@ -1,1006 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-#  Copyright (c) 2021 Intel Corporation
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-#
-"""Graph Converter Class."""
-
-import copy
-import logging
-import os
-import tempfile
-from collections import OrderedDict, UserDict
-
-import tensorflow as tf
-from tensorflow.core.framework import graph_pb2
-from tensorflow.python.platform import gfile
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.bf16.bf16_convert import BF16Convert
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.fold_batch_norm import (
-    FoldBatchNormNodesOptimizer,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.fuse_pad_with_conv import (
-    FusePadWithConv2DOptimizer,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.fuse_pad_with_fp32_conv import (
-    FusePadWithFP32Conv2DOptimizer,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.insert_print_node import (
-    InsertPrintMinMaxNode,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.remove_training_nodes import (
-    RemoveTrainingNodesOptimizer,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.strip_equivalent_nodes import (
-    StripEquivalentNodesOptimizer,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.strip_unused_nodes import (
-    StripUnusedNodesOptimizer,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.int8.freeze_fake_quant import (
-    FreezeFakeQuantOpOptimizer,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.int8.freeze_value import FreezeValueTransformer
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.int8.fuse_conv_redundant_dequantize import (
-    FuseConvRedundantDequantizeTransformer,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.int8.fuse_conv_requantize import (
-    FuseConvRequantizeTransformer,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.int8.fuse_matmul_redundant_dequantize import (
-    FuseMatMulRedundantDequantizeTransformer,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.int8.fuse_matmul_requantize import (
-    FuseMatMulRequantizeDequantizeNewAPITransformer,
-    FuseMatMulRequantizeDequantizeTransformer,
-    FuseMatMulRequantizeNewAPITransformer,
-    FuseMatMulRequantizeTransformer,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.int8.meta_op_optimizer import (
-    MetaInfoChangingMemOpOptimizer,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.int8.post_hostconst_converter import (
-    PostHostConstConverter,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.int8.post_quantized_op_cse import PostCseOptimizer
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.int8.scale_propagation import (
-    ScaleProPagationTransformer,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.qdq.insert_qdq_pattern import (
-    GenerateGraphWithQDQPattern,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.qdq.merge_duplicated_qdq import (
-    MergeDuplicatedQDQOptimizer,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.qdq.share_qdq_y_pattern import (
-    ShareQDQForItexYPatternOptimizer,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.quantization.utils.quantize_graph.qdq.optimize_qdq import OptimizeQDQGraph
-from neural_compressor.tensorflow.quantization.utils.quantize_graph.quantize_graph_for_intel_cpu import (
-    QuantizeGraphForIntel,
-)
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper
-from neural_compressor.tensorflow.quantization.utils.transform_graph.bias_correction import BiasCorrection
-from neural_compressor.tensorflow.quantization.utils.transform_graph.insert_logging import InsertLogging
-from neural_compressor.tensorflow.quantization.utils.transform_graph.rerange_quantized_concat import (
-    RerangeQuantizedConcat,
-)
-from neural_compressor.tensorflow.quantization.utils.utility import generate_feed_dict, iterator_sess_run
-from neural_compressor.tensorflow.utils import (
-    SPR_BASE_VERSIONS,
-    CaptureOutputToFile,
-    CpuInfo,
-    Model,
-    TensorflowSavedModelModel,
-    combine_histogram,
-    deep_get,
-    get_all_fp32_data,
-    get_tensor_histogram,
-    version1_eq_version2,
-    version1_gt_version2,
-    version1_gte_version2,
-    version1_lt_version2,
-    version1_lte_version2,
-)
-
-TF_SUPPORTED_MAX_VERSION = "2.16.1"
-TF_SUPPORTED_MIN_VERSION = "1.14.0"
-
-logger = logging.getLogger("neural_compressor")
-debug = bool(logger.level == logging.DEBUG)
-
-
-class GraphConverter:
-    """Graph Converter Class is used to generate the quantization graph."""
-
-    def __init__(
-        self,
-        model,
-        qt_config={},
-        recipes={},
-        int8_sequences={},
-        fp32_ops=[],
-        bf16_ops=[],
-        data_loader=None,
-        calib_func=None,
-        fake_quant=False,
-        itex_mode=False,
-        qdq_enabled=False,
-        new_api=False,
-        performance_only=False,
-        use_bf16=False,
-    ):
-        """Convert graph.
-
-        :param model: input tensorflow model.
-        :param qt_config: quantization configs, including iteration and op-wise quant config
-        :param fp32_ops: fall back to fp32 dtype op list
-        :param bf16_ops: fall back to bf16 dtype op list
-        :param data_loader: for calibration phase used dataloader
-        :param calib_func: for calibration phase used function
-        :param fake_quant: for quantization-aware training model conversion to default model
-        """
-        self.model = model
-        # (TODO) does it right to make the internal model format as graph_def
-        self.output_tensor_names = self.model.output_tensor_names
-        self.input_tensor_names = self.model.input_tensor_names
-        # quantize specific config
-        self.calib_iteration = qt_config["calib_iteration"] if not fake_quant else 0
-        self.op_wise_config = qt_config["op_wise_config"]
-        self.advance_config = deep_get(qt_config, "advance")
-        self.device = qt_config["device"] if "device" in qt_config else "cpu"
-        self.int8_sequences = int8_sequences
-        self.fp32_ops = fp32_ops
-        self.bf16_ops = bf16_ops
-        self.recipes = recipes
-        self.fake_quant = fake_quant
-        self.itex_mode = itex_mode
-        self.qdq_enabled = qdq_enabled
-        self.performance_only = performance_only
-        self.quantized_node_info = []
-        self._calibration_data = []
-        self._fp32_print_data = []
-        self.data_loader = data_loader
-        self.calib_func = calib_func
-        self._check_tf_version()
-        self._check_args()
-
-        if "backend" in self.model.kwargs:
-            self._fp32_model = Model(self.model._model, **self.model.kwargs)
-        else:
-            self._fp32_model = Model(
-                self.model._model,
-                **self.model.kwargs,
-                backend="itex" if itex_mode and not isinstance(self.model, TensorflowSavedModelModel) else "default"
-            )
-        self._fp32_model.graph_def = self.model.graph_def
-        self._fp32_model.output_tensor_names = self.output_tensor_names
-        self._fp32_model.input_tensor_names = self.input_tensor_names
-
-        self._gen_tmp_filenames()
-        self._kl_op_dict = {}
-        self._kl_keys = []
-        self._llm_weight_minmax = {}
-        self._print_node_mapping = {}
-        self._enable_kl_op_names = [k for k in self.op_wise_config if self.op_wise_config[k][1] == "kl"]
-        self.scale_info = {}
-        self.scale_info.update(qt_config)
-        self.scale_info.update({"recipes": self.recipes})
-        self.scale_info.update({"int8_sequences": self.int8_sequences})
-        self.scale_info.update({"bf16_ops": self.bf16_ops})
-        self.scale_info.update({"fp32_ops": self.fp32_ops})
-
-        if "backend" in self.model.kwargs:  # pragma: no cover
-            self._sampling_model = Model(self.model._model, **self.model.kwargs)
-        else:
-            self._sampling_model = Model(
-                self.model._model,
-                **self.model.kwargs,
-                backend="itex" if itex_mode and not isinstance(self.model, TensorflowSavedModelModel) else "default"
-            )
-        self._sampling_model.output_tensor_names = self.output_tensor_names
-        self._sampling_model.input_tensor_names = self.input_tensor_names
-
-        if self.performance_only:
-            # reuse the fp32 model for performance only mode
-            self._tmp_graph_def = self.model.graph_def
-        else:
-            self._tmp_graph_def = copy.deepcopy(self.model.graph_def)
-        self.new_api = new_api  # bool(version1_gte_version2(tf.version.VERSION, '2.8.0'))
-        self.use_bf16 = use_bf16
-        self.exclude_node_names = []
-
-    # pylint: disable=no-member
-    def _inference(self, model):
-        """Run the calibration on the input graph.
-
-        Args:
-            model(TensorflowBaseModel): input TensorflowBaseModel
-        """
-        if self.calib_func:
-            self.calib_func(model)
-            return
-
-        if model.model_type == "llm_saved_model":
-            self._inference_llm(model)
-            return
-
-        # ITEX optimization has broken INC calibration process.
-        # INC needs turn off ITEX optimization pass in calibration stage.
-        # TODO ITEX will provide API to replace setting environment variable.
-        os.environ["ITEX_REMAPPER"] = "0"
-        sess = model.sess
-        iter_op = model.iter_op
-        input_tensor = model.input_tensor
-        output_tensor = model.output_tensor
-        # TF table initialization: https://github.com/tensorflow/tensorflow/issues/8665
-        node_names = [node.name for node in sess.graph.as_graph_def().node]
-        if "init_all_tables" in node_names:  # pragma: no cover
-            init_table_op = sess.graph.get_operation_by_name("init_all_tables")
-            sess.run(init_table_op)
-
-        logger.info("Start sampling on calibration dataset.")
-        if hasattr(self.data_loader, "__len__") and len(self.data_loader) == 0:  # pragma: no cover
-            feed_dict = {}
-            _ = (
-                sess.run(output_tensor, feed_dict)
-                if iter_op == []
-                else iterator_sess_run(sess, iter_op, feed_dict, output_tensor, self.calib_iteration)
-            )
-        for idx, (inputs, labels) in enumerate(self.data_loader):
-            if len(input_tensor) == 1:
-                feed_dict = {}
-                if (
-                    isinstance(inputs, dict) or isinstance(inputs, OrderedDict) or isinstance(inputs, UserDict)
-                ):  # pragma: no cover
-                    for name in inputs:
-                        for tensor in input_tensor:
-                            pos = tensor.name.rfind(":")
-                            t_name = tensor.name if pos < 0 else tensor.name[:pos]
-                            if name == t_name:
-                                feed_dict[tensor] = inputs[name]
-                                break
-                else:
-                    feed_dict = {input_tensor[0]: inputs}  # get raw tensor using index [0]
-            else:  # pragma: no cover
-                assert len(input_tensor) == len(inputs), "inputs len must equal with input_tensor"
-                feed_dict = {}
-                if isinstance(inputs, dict) or isinstance(inputs, OrderedDict) or isinstance(inputs, UserDict):
-                    for name in inputs:
-                        for tensor in input_tensor:
-                            pos = tensor.name.rfind(":")
-                            t_name = tensor.name if pos < 0 else tensor.name[:pos]
-                            if name in [tensor.name, t_name]:
-                                feed_dict[tensor] = inputs[name]
-                                break
-                else:
-                    # sometimes the input_tensor is not the same order with inputs
-                    # we should check and pair them
-                    def check_shape(tensor, data):
-                        """Validate that a tensor shape matches the sample data."""
-                        # scalar or 1 dim default True
-                        if (
-                            tensor.shape is None
-                            or tensor.shape == tf.TensorShape(None)
-                            or len(tensor.shape.dims) == 1
-                            or not hasattr(data, "shape")
-                        ):
-                            return True
-                        tensor_shape = tuple(tensor.shape)
-                        data_shape = tuple(data.shape)
-                        for tensor_dim, data_dim in zip(tensor_shape, data_shape):
-                            if tensor_dim is not None and tensor_dim != data_dim:
-                                return False
-                        return True
-
-                    disorder_tensors = []
-                    disorder_inputs = []
-                    for idx, sort_tensor in enumerate(input_tensor):
-                        sort_input = inputs[idx]
-                        if check_shape(sort_tensor, sort_input):
-                            feed_dict.update({sort_tensor: sort_input})
-                        else:
-                            disorder_tensors.append(sort_tensor)
-                            disorder_inputs.append(sort_input)
-                    for i, dis_tensor in enumerate(disorder_tensors):
-                        for j, dis_input in enumerate(disorder_inputs):
-                            if check_shape(dis_tensor, dis_input):
-                                feed_dict.update({dis_tensor: dis_input})
-                                break
-            _ = (
-                sess.run(output_tensor, feed_dict)
-                if iter_op == []
-                else iterator_sess_run(sess, iter_op, feed_dict, output_tensor, self.calib_iteration)
-            )
-            if idx + 1 == self.calib_iteration:
-                break
-        os.environ["ITEX_REMAPPER"] = "1"
-
-    def _inference_llm(self, model):
-        """Run inference for large language models during calibration.
-
-        Args:
-            model: TensorFlow model wrapper with input_tensor_names and model signatures.
-        """
-        input_tensor_names = model.input_tensor_names
-        auto_trackable = model.model
-        infer = auto_trackable.signatures["serving_default"]
-        for idx, (inputs, _) in enumerate(self.data_loader):
-            feed_dict = {}
-            if len(input_tensor_names) == 1:
-                feed_dict[input_tensor_names[0]] = inputs
-            else:  # pragma: no cover
-                assert len(input_tensor_names) == len(inputs), "inputs len must equal with input_tensor"
-                for i, input_tensor_name in enumerate(input_tensor_names):
-                    feed_dict[input_tensor_name] = inputs[i]
-
-            _ = infer(**feed_dict)
-
-            if idx >= self.calib_iteration:
-                break
-
-    def _check_tf_version(self):  # pragma: no cover
-        """Check if the installed tensorflow version is supported."""
-        is_supported_version = False
-        is_sprbase_version = False
-        try:
-            from tensorflow import python
-
-            if hasattr(python, "pywrap_tensorflow") and hasattr(python.pywrap_tensorflow, "IsMklEnabled"):
-                from tensorflow.python.pywrap_tensorflow import IsMklEnabled
-            elif hasattr(python.util, "_pywrap_util_port"):
-                from tensorflow.python.util._pywrap_util_port import IsMklEnabled
-            else:
-                from tensorflow.python._pywrap_util_port import IsMklEnabled
-            if IsMklEnabled() and (version1_lte_version2(TF_SUPPORTED_MIN_VERSION, tf.version.VERSION)):
-                is_supported_version = True
-
-            if version1_gte_version2(tf.version.VERSION, "2.6.0") and os.getenv("TF_ENABLE_ONEDNN_OPTS") == "1":
-                is_supported_version = True
-
-            if version1_gte_version2(tf.version.VERSION, "2.9.0"):
-                is_supported_version = True
-
-            if tf.version.VERSION == "1.15.0-up3":  # pragma: no cover
-                is_supported_version = True
-
-            if tf.version.VERSION in SPR_BASE_VERSIONS:
-                is_supported_version = True
-                is_sprbase_version = True
-
-        except Exception as e:
-            raise ValueError(e)
-        finally:
-            if version1_gt_version2(tf.version.VERSION, TF_SUPPORTED_MAX_VERSION) and not is_sprbase_version:
-                logger.warning(
-                    str(
-                        "Please note the {} version of TensorFlow is not fully verified! "
-                        "Suggest to use the versions between {} and {} if meet problem."
-                    ).format(tf.version.VERSION, TF_SUPPORTED_MIN_VERSION, TF_SUPPORTED_MAX_VERSION)
-                )
-
-            if version1_eq_version2(tf.version.VERSION, "2.5.0") and os.getenv("TF_ENABLE_MKL_NATIVE_FORMAT") != "0":
-                logger.fatal(
-                    "Please set environment variable TF_ENABLE_MKL_NATIVE_FORMAT=0 " "when TensorFlow 2.5.0 installed."
-                )
-
-            if (
-                version1_gte_version2(tf.version.VERSION, "2.6.0")
-                and version1_lt_version2(tf.version.VERSION, "2.9.0")
-                and os.getenv("TF_ENABLE_ONEDNN_OPTS") != "1"
-            ):
-                logger.fatal(
-                    "Please set environment variable TF_ENABLE_ONEDNN_OPTS=1 "
-                    "when TensorFlow >= 2.6.0 and < 2.9.0 installed."
-                )
-
-            if not is_supported_version:
-                raise ValueError(
-                    str("Please install TensorFlow within version >={} and <={}.").format(
-                        TF_SUPPORTED_MIN_VERSION, TF_SUPPORTED_MAX_VERSION
-                    )
-                )
-
-    def _check_args(self):  # pragma: no cover
-        """Check model's arguments."""
-        if (
-            self.model.workspace_path
-            and not os.path.isdir(self.model.workspace_path)
-            and not os.path.exists(os.path.dirname(self.model.workspace_path))
-        ):
-            raise ValueError('"output_graph" directory does not exist.')
-        self._output_path = self.model.workspace_path
-
-    def _gen_tmp_filenames(self):
-        """Generate the temporary file names."""
-        self._int8_dynamic_range_model_path = os.path.join(self._output_path, "int8_dynamic_range_graph")
-        self._int8_logged_model_path = os.path.join(self._output_path, "int8_logged_graph")
-        self._fp32_logged_model_path = os.path.join(self._output_path, "fp32_logged_graph")
-        self._int8_frozen_range_model_path = os.path.join(self._output_path, "int8_frozen_range_graph")
-        self._bf16_mixed_precision_model_path = os.path.join(self._output_path, "int8_bf16_mixed_precision_graph")
-
-        self.output_graph = os.path.join(self._output_path, "int8_final_fused_graph")
-        if self.performance_only:
-            # reuse the fp32 model for performance only mode
-            self._tmp_model = self._fp32_model
-        else:
-            # to keep temp model
-            if "backend" in self.model.kwargs:  # pragma: no cover
-                self._tmp_model = Model(self.model._model, **self.model.kwargs)
-            else:
-                self._tmp_model = Model(
-                    self.model._model,
-                    **self.model.kwargs,
-                    backend=(
-                        "itex"
-                        if self.itex_mode and not isinstance(self.model, TensorflowSavedModelModel)
-                        else "default"
-                    )
-                )
-            self._tmp_model.graph_def = self.model.graph_def
-            self._tmp_model.output_tensor_names = self.output_tensor_names
-            self._tmp_model.input_tensor_names = self.input_tensor_names
-
-    def convert(self):
-        """Do conversion.
-
-        Including:
-            1) optimize fp32_frozen_graph,
-            2) quantize graph,
-            3) calibration,
-            4) fuse RequantizeOp with fused quantized conv, and so on.
-            5) bf16 convert if the self.bf16_ops is not empty
-
-        :return:
-        """
-        model = self._tmp_model
-        if len(self.op_wise_config) > 0:
-            if self.qdq_enabled:
-                model = self.quantize_with_qdq_pattern()
-            else:
-                model = self.quantize()
-
-        if self.itex_mode:  # pragma: no cover
-            host_const_graph_def = PostHostConstConverter(self._tmp_model.graph_def).do_transformation()
-            host_const_graph_def.library.CopyFrom(self.model.graph_def.library)
-            self._tmp_model.graph_def = host_const_graph_def
-
-            return self._tmp_model
-
-        if self.exclude_node_names:
-            self.bf16_ops.extend(self.exclude_node_names)
-
-        if (
-            len(self.bf16_ops) > 0
-            and (self.use_bf16 or self.performance_only)
-            and (CpuInfo().bf16 or os.getenv("FORCE_BF16") == "1")
-        ):
-            model = self.bf16_convert()
-
-        if self.new_api:
-            if self.performance_only:
-                model.graph_def = FuseConvRedundantDequantizeTransformer(model.graph_def).do_transformation()
-            post_optimize_graph_def = FuseMatMulRedundantDequantizeTransformer(model.graph_def).do_transformation()
-            post_optimize_graph_def.library.CopyFrom(self.model.graph_def.library)
-            model.graph_def = post_optimize_graph_def
-        post_cse_graph_def = PostCseOptimizer(model.graph_def).do_transformation()
-        post_hostconst_graph_def = PostHostConstConverter(post_cse_graph_def).do_transformation()
-        post_hostconst_graph_def.library.CopyFrom(self.model.graph_def.library)
-        model.graph_def = post_hostconst_graph_def
-
-        if debug:
-            model.save(self.output_graph)
-            logger.info("Save converted graph file to {}.".format(self.output_graph))
-        model.q_config = self.scale_info
-        return model
-
-    def _get_fp32_print_node_names(self, specified_op_list):
-        """Get the print node name of the fp32 graph."""
-        offset_map = {
-            "QuantizedConv2DWithBiasSumAndRelu": 3,
-            "QuantizedConv2DWithBiasAndRelu": 2,
-            "QuantizedConv2DWithBias": 1,
-        }
-        target_conv_op = []
-        sorted_graph = QuantizeGraphHelper().get_sorted_graph(
-            self._fp32_model.graph_def, self._fp32_model.input_node_names, self._fp32_model.output_node_names
-        )
-
-        node_name_mapping = {node.name: node for node in self._tmp_graph_def.node if node.op != "Const"}
-
-        for node in self._tmp_graph_def.node:
-            if node.op in offset_map:
-                target_conv_op.append(node.name.split("_eightbit_")[0])
-        fp32_node_name_mapping = {node.name: node for node in sorted_graph.node if node.op != "Const"}
-        sorted_node_names = [i.name for i in sorted_graph.node if i.op != "Const"]
-
-        output_node_names = []
-        for i in target_conv_op:
-            if specified_op_list and i not in specified_op_list:
-                continue
-            if (
-                node_name_mapping[i + "_eightbit_quantized_conv"].op == "QuantizedConv2DWithBiasSumAndRelu"
-            ):  # pragma: no cover
-                start_index = sorted_node_names.index(i)
-                for index, value in enumerate(sorted_node_names[start_index:]):
-                    if (
-                        fp32_node_name_mapping[value].op.startswith("Add")
-                        and fp32_node_name_mapping[sorted_node_names[start_index + index + 1]].op == "Relu"
-                    ):
-                        output_node_names.append(sorted_node_names[start_index + index + 1])
-                        self._print_node_mapping[sorted_node_names[start_index + index + 1]] = i
-
-            elif i in sorted_node_names:
-                start_index = sorted_node_names.index(i)
-                end_index = start_index + offset_map[node_name_mapping[i + "_eightbit_quantized_conv"].op]
-                output_node_names.append(sorted_node_names[end_index])
-                self._print_node_mapping[sorted_node_names[end_index]] = i
-
-        for i in output_node_names:
-            self._kl_keys.append(";" + i + "__print__;__KL")
-
-        fp32_graph_def = graph_pb2.GraphDef()
-        fp32_graph_def.CopyFrom(self._fp32_model.graph_def)
-        self._fp32_model.graph_def = InsertLogging(
-            self._fp32_model.graph_def, node_name_list=output_node_names, message="__KL:", summarize=-1, dump_fp32=True
-        ).do_transformation()
-
-        self._fp32_model.save(self._fp32_logged_model_path)
-        self._fp32_model.graph_def = fp32_graph_def
-        return self._fp32_model
-
-    def _search_y_pattern_for_itex(self):  # pragma: no cover
-        """Search the Y pattern for itex and return the op name."""
-        g = GraphAnalyzer()
-        g.graph = self._fp32_model.graph_def
-        g.parse_graph()
-        y_pattern = [["Conv2D", "MatMul"], ["BiasAdd"], ["Add", "AddV2", "AddN"], ("Relu",)]
-        y_pattern_variant = [["MaxPool", "AvgPool"], ["Add", "AddV2", "AddN"], ("Relu",)]
-        target_nodes = g.query_fusion_pattern_nodes(y_pattern)
-        target_nodes_variant = g.query_fusion_pattern_nodes(y_pattern_variant)
-
-        res = {}
-        for i in target_nodes:
-            if i[2] not in res:
-                res[i[2]] = 1
-            else:
-                res[i[2]] += 1
-        matched_add_nodes = [(i,) for i in res if res[i] == 2]
-        for i in res:
-            if res[i] == 1:
-                for j in target_nodes_variant:
-                    if j[1] == i:
-                        matched_add_nodes.append((i,))
-        return matched_add_nodes
-
-    def quantize(self):
-        """Quantize graph only (without optimizing fp32 graph).
-
-        Including:
-            1) quantize graph,
-            2) calibration,
-            3) fuse RequantizeOp with fused quantized conv, and so on.
-
-        :return:
-        """
-        try:
-            self._quantize_graph()
-            self.quantized_node_info = [tuple(i) for i in self.quantized_node_info]
-
-            if self.fake_quant:  # pragma: no cover
-                self._fuse_requantize_with_fused_quantized_node()
-            else:
-                if self._enable_kl_op_names:
-                    self._get_fp32_print_node_names(self._enable_kl_op_names)
-                    self._generate_calibration_data(self._fp32_logged_model_path, self._fp32_print_data, True)
-
-                output_tensor_names = copy.deepcopy(self.model.output_tensor_names)
-                sampling_graph_def = copy.deepcopy(self._fp32_model.graph_def)
-
-                # TODO: this is a workaround to make Min/Max node be completely eliminated in int8 graph
-                # after enabling pad+conv2d in new API.
-                non_pad_ops = list(list(set(self.fp32_ops).union(set(self.bf16_ops))))
-                sampling_graph_def = FusePadWithFP32Conv2DOptimizer(
-                    sampling_graph_def, non_pad_ops, self._tmp_model.input_node_names, self.op_wise_config, self.new_api
-                ).do_transformation()
-
-                for i in self.quantized_node_info:
-                    sampling_graph_def, output_names = InsertPrintMinMaxNode(
-                        sampling_graph_def, i[0], i[-1], self.new_api
-                    ).do_transformation()
-                    output_tensor_names.extend(output_names)
-                if self.quantized_node_info:
-                    sampling_graph_def.library.CopyFrom(self.model.graph_def.library)
-                    self._sampling_model.graph_def = sampling_graph_def
-                    self._sampling_model.output_tensor_names = output_tensor_names
-                    tmp_dump_file = tempfile.mkstemp(suffix=".log")[1]
-                    with CaptureOutputToFile(tmp_dump_file):
-                        self._inference(self._sampling_model)
-                    self._calibration_data = Helper.gen_valid_sampling_log(tmp_dump_file)
-
-                del output_tensor_names
-                del sampling_graph_def
-                del self._sampling_model
-                import gc
-
-                gc.collect()
-
-                if len(self._calibration_data) > 0:
-                    self._freeze_requantization_ranges(self._kl_op_dict)
-                    self._fuse_requantize_with_fused_quantized_node()
-
-        except ValueError as e:  # pragma: no cover
-            logger.error("Fail to quantize graph due to {}.".format(str(e)))
-            self._tmp_model = None
-            raise
-        except Exception as e:
-            import traceback
-
-            traceback.print_exc()
-            self._tmp_model = None
-            logger.error("Fail to quantize graph due to {}.".format(str(e)))
-            return self._tmp_model
-        finally:
-            if not debug:
-                self._post_clean()
-        return self._tmp_model
-
-    def bf16_convert(self):
-        """Convert fp32 nodes in bf16_node to bf16 dtype based on FP32 + INT8 mixed precision graph."""
-        try:
-            logger.info("Start BF16 conversion.")
-            self._tmp_model.graph_def = BF16Convert(
-                self._tmp_model.graph_def, self.fp32_ops, self.bf16_ops
-            ).do_transformation()
-
-        except Exception as e:
-            import traceback
-
-            traceback.print_exc()
-            self._tmp_model = None
-            logger.error("Fail to convert graph due to {}.".format(str(e)))
-        finally:
-            if debug:
-                self._tmp_model.save(self._bf16_mixed_precision_model_path)
-
-            return self._tmp_model
-
-    def _quantize_graph(self):
-        """Quantize graph."""
-        non_pad_ops = list(list(set(self.fp32_ops).union(set(self.bf16_ops))))
-
-        self._tmp_graph_def = FusePadWithConv2DOptimizer(
-            self._tmp_graph_def, non_pad_ops, self._tmp_model.input_node_names, self.op_wise_config, self.new_api
-        ).do_transformation()
-
-        self._tmp_graph_def = QuantizeGraphHelper().get_sorted_graph(
-            self._tmp_graph_def, self._tmp_model.input_node_names, self._tmp_model.output_node_names
-        )
-
-        self._tmp_graph_def, self.quantized_node_info, exclude_node_names = QuantizeGraphForIntel(
-            self._tmp_graph_def,
-            self._tmp_model.input_node_names,
-            self._tmp_model.output_node_names,
-            self.op_wise_config,
-            self.int8_sequences,
-            self.device,
-            self.fake_quant,
-            self.new_api,
-            self.performance_only,
-            self.itex_mode,
-        ).do_transform()
-        self.exclude_node_names = exclude_node_names
-        self._tmp_graph_def.library.CopyFrom(self.model.graph_def.library)
-        if debug and not self.performance_only:
-            self._tmp_model.graph_def = self._tmp_graph_def
-            self._tmp_model.save(self._int8_dynamic_range_model_path)
-
-    def _generate_calibration_data(self, tmp_path, output_data, enable_kl_algo=False):
-        """Generate the calibration data."""
-        tmp_dump_file = os.path.join(os.path.dirname(self.output_graph), "requant_min_max.log")
-
-        logger.debug("Generate calibration data and save to {}.".format(tmp_dump_file))
-
-        if "backend" in self._tmp_model.kwargs:
-            model = Model(tmp_path, **self._tmp_model.kwargs)
-        else:  # pragma: no cover
-            model = Model(
-                tmp_path,
-                **self._tmp_model.kwargs,
-                backend=(
-                    "itex"
-                    if self.itex_mode and not isinstance(self._tmp_model, TensorflowSavedModelModel)
-                    else "default"
-                )
-            )
-        model.output_tensor_names = self.output_tensor_names
-        model.input_tensor_names = self.input_tensor_names
-
-        with CaptureOutputToFile(tmp_dump_file):
-            self._inference(model)
-
-        with open(tmp_dump_file, errors="ignore") as f:
-            output_data.extend(f.readlines())
-
-        for line in output_data:
-            if enable_kl_algo and line.rsplit(":")[0] in self._kl_keys:
-                fp32_data = get_all_fp32_data(line.rsplit(":")[-1])
-                key = self._print_node_mapping[line[1:].split("__print")[0]] + "_eightbit_requant_range"
-                if key not in self._kl_op_dict:
-                    self._kl_op_dict[key] = get_tensor_histogram(fp32_data)
-                else:
-                    self._kl_op_dict[key] = combine_histogram(self._kl_op_dict[key], fp32_data)
-
-    def _freeze_requantization_ranges(self, additional_data=None):
-        """Freeze requantization ranges after doing quantization."""
-        self._tmp_graph_def, quantizev2_max = FreezeValueTransformer(
-            self._tmp_graph_def, self._calibration_data, "__max:", device=self.device
-        ).do_transformation()
-        self._tmp_graph_def, quantizev2_min = FreezeValueTransformer(
-            self._tmp_graph_def, self._calibration_data, "__min:", device=self.device
-        ).do_transformation()
-        self._tmp_graph_def, requant_min_max = FreezeValueTransformer(
-            self._tmp_graph_def,
-            self._calibration_data,
-            "__requant_min_max",
-            tensor_data=additional_data,
-            device=self.device,
-        ).do_transformation()
-
-        self.scale_info.update(quantizev2_max)
-        self.scale_info.update(quantizev2_min)
-        self.scale_info.update(requant_min_max)
-
-        if (
-            "scale_propagation_max_pooling" in self.recipes and self.recipes["scale_propagation_max_pooling"]
-        ):  # pragma: no cover
-            self._tmp_graph_def = ScaleProPagationTransformer(self._tmp_graph_def).do_transformation()
-
-        if debug and not self.new_api:
-            self._tmp_graph_def.library.CopyFrom(self.model.graph_def.library)
-            self._tmp_model.graph_def = self._tmp_graph_def
-            self._tmp_model.save(self._int8_frozen_range_model_path)
-
-    def _fuse_requantize_with_fused_quantized_node(self):
-        """Fuse the Requantize/Dequantize with fused quantized Ops."""
-        if self.fake_quant:  # pragma: no cover
-            self._tmp_graph_def = FreezeFakeQuantOpOptimizer(self._tmp_graph_def).do_transformation()
-
-        self._tmp_graph_def = FuseConvRequantizeTransformer(
-            self._tmp_graph_def, self.device, self.new_api
-        ).do_transformation()
-
-        if not self.fake_quant:
-            if self.qdq_enabled:
-                self._tmp_graph_def = FuseMatMulRequantizeNewAPITransformer(self._tmp_graph_def).do_transformation()
-
-                self._tmp_graph_def = FuseMatMulRequantizeDequantizeNewAPITransformer(
-                    self._tmp_graph_def
-                ).do_transformation()
-            else:
-                self._tmp_graph_def = FuseMatMulRequantizeTransformer(self._tmp_graph_def).do_transformation()
-
-                self._tmp_graph_def = FuseMatMulRequantizeDequantizeTransformer(self._tmp_graph_def).do_transformation()
-
-        self._tmp_graph_def = StripUnusedNodesOptimizer(
-            self._tmp_graph_def, self._tmp_model.input_node_names, self._tmp_model.output_node_names
-        ).do_transformation()
-
-        input_output_names = self._tmp_model.input_node_names + self._tmp_model.output_node_names
-        self._tmp_graph_def = RemoveTrainingNodesOptimizer(
-            self._tmp_graph_def, protected_nodes=input_output_names
-        ).do_transformation()
-
-        self._tmp_graph_def = FoldBatchNormNodesOptimizer(self._tmp_graph_def).do_transformation()
-
-        if self.performance_only or (
-            "scale_propagation_concat" in self.recipes and self.recipes["scale_propagation_concat"]
-        ):
-            self._tmp_graph_def = RerangeQuantizedConcat(
-                self._tmp_graph_def, self.device, performance_only=self.performance_only
-            ).do_transformation()
-
-        self._tmp_graph_def = MetaInfoChangingMemOpOptimizer(self._tmp_graph_def).do_transformation()
-
-        self._tmp_graph_def = StripEquivalentNodesOptimizer(
-            self._tmp_graph_def, self._tmp_model.output_node_names
-        ).do_transformation()
-
-        if self.advance_config is not None and deep_get(self.advance_config, "bias_correction") is not None:
-            self._tmp_graph_def = BiasCorrection(
-                self._tmp_graph_def, self.model.graph_def, self.new_api
-            ).do_transformation()
-
-        self._tmp_graph_def.library.CopyFrom(self.model.graph_def.library)
-
-        self._tmp_model.graph_def = self._tmp_graph_def
-
-    def _post_clean(self):  # pragma: no cover
-        """Delete the temporarily files generated during the quantization process.
-
-        :return: None
-        """
-        if os.path.exists(self._int8_logged_model_path) and os.path.isdir(self._int8_logged_model_path):
-            import shutil
-
-            shutil.rmtree(self._int8_logged_model_path)
-
-        elif gfile.Exists(self._int8_logged_model_path + ".pb"):
-            os.remove(self._int8_logged_model_path + ".pb")
-
-    def quantize_with_qdq_pattern(self):
-        """Quantize model by inserting QDQ.
-
-        step 1: insert QDQ pairs and update node info
-        step 2: convert Q-DQ-node-Q-DQ to Q-newAPI node-DQ
-        """
-        try:
-            self._insert_qdq_pairs()
-            self._convert_qdq()
-
-        except ValueError as e:  # pragma: no cover
-            logger.error("Fail to quantize graph due to {}.".format(str(e)))
-            self._tmp_model = None
-            raise
-        except Exception as e:
-            import traceback
-
-            traceback.print_exc()
-            self._tmp_model = None
-            logger.error("Fail to quantize graph due to {}.".format(str(e)))
-            return self._tmp_model
-        finally:
-            if not debug:
-                self._post_clean()
-        return self._tmp_model
-
-    def _insert_qdq_pairs(self):
-        """Insert QDQ pairs before Conv/MatMul/Pooling Ops."""
-        # Fuse Pad into Conv2D, Conv3D, DepthwiseConv2dNative
-        non_pad_ops = list(list(set(self.fp32_ops).union(set(self.bf16_ops))))
-        self._tmp_graph_def = FusePadWithConv2DOptimizer(
-            self._tmp_graph_def, non_pad_ops, self._tmp_model.input_node_names, self.op_wise_config, self.new_api, True
-        ).do_transformation()
-
-        # Sort graph
-        self._tmp_graph_def = QuantizeGraphHelper().get_sorted_graph(
-            self._tmp_graph_def, self._tmp_model.input_node_names, self._tmp_model.output_node_names
-        )
-
-        self._tmp_graph_def.library.CopyFrom(self.model.graph_def.library)
-
-        # Find out the quantized nodes
-        self.quantized_node_info = OptimizeQDQGraph(
-            self._tmp_graph_def,
-            self._tmp_model.input_node_names,
-            self._tmp_model.output_node_names,
-            self.op_wise_config,
-            self.int8_sequences,
-            self.device,
-            self.fake_quant,
-            self.new_api,
-            self.performance_only,
-            self.itex_mode,
-        ).get_quantized_nodes()
-
-        if self.itex_mode:  # pragma: no cover
-            self.quantized_node_info.extend(self._search_y_pattern_for_itex())
-
-        if self._enable_kl_op_names:  # pragma: no cover
-            self._get_fp32_print_node_names(self._enable_kl_op_names)
-            self._generate_calibration_data(self._fp32_logged_model_path, self._fp32_print_data, True)
-
-        # Calibration using sampling model
-        output_tensor_names = copy.deepcopy(self.model.output_tensor_names)
-        sampling_graph_def = copy.deepcopy(self._fp32_model.graph_def)
-        # TODO: this is a workaround to make Min/Max node be completely eliminated in int8 graph
-        # after enabling pad+conv2d in new API.
-        non_pad_ops = list(list(set(self.fp32_ops).union(set(self.bf16_ops))))
-        sampling_graph_def = FusePadWithFP32Conv2DOptimizer(
-            sampling_graph_def, non_pad_ops, self._tmp_model.input_node_names, self.op_wise_config, self.new_api, True
-        ).do_transformation()
-
-        for i in self.quantized_node_info:
-            sampling_graph_def, output_names = InsertPrintMinMaxNode(
-                sampling_graph_def, i[0], i[-1], self.new_api
-            ).do_transformation()
-            output_tensor_names.extend(output_names)
-
-        if self.quantized_node_info:
-            sampling_graph_def.library.CopyFrom(self.model.graph_def.library)
-            self._sampling_model.graph_def = sampling_graph_def
-            self._sampling_model.output_tensor_names = output_tensor_names
-            tmp_dump_file = tempfile.mkstemp(suffix=".log")[1]
-            with CaptureOutputToFile(tmp_dump_file):
-                self._inference(self._sampling_model)
-            self._calibration_data = Helper.gen_valid_sampling_log(tmp_dump_file)
-
-        if hasattr(self._sampling_model, "_weight_tensor_minmax_dict"):
-            self._llm_weight_minmax = self._sampling_model.weight_tensor_minmax_dict
-
-        del sampling_graph_def
-        del output_tensor_names
-        del self._sampling_model
-        import gc
-
-        gc.collect()
-
-        # Insert QDQ pattern
-        self._tmp_graph_def = GenerateGraphWithQDQPattern(
-            self._tmp_graph_def,
-            self._calibration_data,
-            self.op_wise_config,
-            self.fake_quant,
-            self.fp32_ops,
-            self.bf16_ops,
-            self.quantized_node_info,
-            self.device,
-            self.performance_only,
-            self.itex_mode,
-            self._llm_weight_minmax,
-        ).do_transformation()
-
-    def _convert_qdq(self):
-        """Convert Dequantize + Op + QuantizeV2 into QuantizedOps."""
-        if self.itex_mode:  # pragma: no cover
-            self._tmp_graph_def, quantizev2_max = FreezeValueTransformer(
-                self._tmp_graph_def, self._calibration_data, "__max:", self.itex_mode
-            ).do_transformation()
-            self._tmp_graph_def, quantizev2_min = FreezeValueTransformer(
-                self._tmp_graph_def, self._calibration_data, "__min:", self.itex_mode
-            ).do_transformation()
-            self._tmp_graph_def, requant_min_max = FreezeValueTransformer(
-                self._tmp_graph_def,
-                self._calibration_data,
-                "__requant_min_max",
-                tensor_data=self._kl_op_dict,
-                device=self.device,
-                itex_mode=self.itex_mode,
-            ).do_transformation()
-
-            self.scale_info.update(quantizev2_max)
-            self.scale_info.update(quantizev2_min)
-            self.scale_info.update(requant_min_max)
-
-            self._tmp_graph_def = StripUnusedNodesOptimizer(
-                self._tmp_graph_def, self._tmp_model.input_node_names, self._tmp_model.output_node_names
-            ).do_transformation()
-
-            self._tmp_graph_def = ShareQDQForItexYPatternOptimizer(self._tmp_graph_def).do_transformation()
-            self._tmp_graph_def = MergeDuplicatedQDQOptimizer(self._tmp_graph_def).do_transformation()
-
-            self._tmp_graph_def.library.CopyFrom(self.model.graph_def.library)
-            self._tmp_model.graph_def = self._tmp_graph_def
-            self._tmp_model.graph_def.library.CopyFrom(self.model.graph_def.library)
-        else:
-            self._tmp_graph_def, exclude_node_names = OptimizeQDQGraph(
-                self._tmp_graph_def,
-                self._tmp_model.input_node_names,
-                self._tmp_model.output_node_names,
-                self.op_wise_config,
-                self.int8_sequences,
-                self.device,
-                self.fake_quant,
-                self.new_api,
-                self.performance_only,
-                self.itex_mode,
-            ).do_transform()
-            self.exclude_node_names = exclude_node_names
-
-            if len(self._calibration_data) > 0:
-                self._freeze_requantization_ranges(self._kl_op_dict)
-                self._fuse_requantize_with_fused_quantized_node()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/__init__.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/__init__.py
deleted file mode 100644
index c38ca292ee3..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/__init__.py
+++ /dev/null
@@ -1,14 +0,0 @@
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""The utils for rewriting graph."""
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/bf16/__init__.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/bf16/__init__.py
deleted file mode 100644
index d567317f183..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/bf16/__init__.py
+++ /dev/null
@@ -1,17 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Tensorflow BF16 Graph Rewriter."""
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/bf16/bf16_convert.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/bf16/bf16_convert.py
deleted file mode 100644
index 8ab1d5231a7..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/bf16/bf16_convert.py
+++ /dev/null
@@ -1,290 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-#  Copyright (c) 2021 Intel Corporation
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-#
-"""Graph rewriter BF16 Converter Class."""
-
-from __future__ import absolute_import, division, print_function
-
-import copy
-import logging
-
-import tensorflow as tf
-from tensorflow.core.framework import attr_value_pb2
-from tensorflow.python.framework import dtypes, op_def_registry, tensor_util
-from tensorflow.python.framework.kernels import get_registered_kernels_for_op
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.bf16.dequantize_cast_optimizer import (
-    DequantizeCastOptimizer,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.graph_cse_optimizer import GraphCseOptimizer
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.graph_base import GraphRewriterBase
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import SPR_BASE_VERSIONS
-
-DT_FLOAT32 = attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum)
-DT_BFLOAT16 = attr_value_pb2.AttrValue(type=dtypes.bfloat16.as_datatype_enum)
-
-
-class BF16Convert(GraphRewriterBase):
-    """BF16 node convert transformation."""
-
-    def __init__(self, model, fp32_ops=[], bf16_ops=[]):
-        """Initialization.
-
-        Args: model: the model to be converted to BF16.
-              fp32_ops: keep with fp32 op list
-              bf16_ops: convert to bf16 op list
-        """
-        super().__init__(model)
-
-        self.cur_graph = GraphAnalyzer()
-        self.cur_graph.graph = self.model
-        self.fp32_ops = fp32_ops
-        self.bf16_ops = bf16_ops
-        self.converted_ops = []
-        self.device = ["CPU", "DEFAULT"]  # TODO support different device types, such as GPU
-
-    def _dtype(self, node):
-        """Get the dtype of the node."""
-        op_def = op_def_registry.get(node.op)
-        inputs_dt = []
-        outputs_dt = []
-        for i in op_def.input_arg:
-            inputs_num = node.attr[i.number_attr].i if i.number_attr else 1
-            for j in range(inputs_num):
-                if i.type:
-                    inputs_dt.append("")
-                else:
-                    inputs_dt.append(i.type_attr)
-        for i in op_def.output_arg:
-            outputs_num = node.attr[i.number_attr].i if i.number_attr else 1
-            for j in range(outputs_num):
-                if i.type:
-                    outputs_dt.append("")
-                else:
-                    outputs_dt.append(i.type_attr)
-        return inputs_dt, outputs_dt
-
-    def _dtype_val(self, node):
-        """Get the dtype value of the node."""
-        op_def = op_def_registry.get(node.op)
-        inputs_dt_val = []
-        outputs_dt_val = []
-        for i in op_def.input_arg:
-            inputs_num = node.attr[i.number_attr].i if i.number_attr else 1
-            for j in range(inputs_num):
-                if i.type:
-                    inputs_dt_val.append(copy.deepcopy(attr_value_pb2.AttrValue(type=i.type)))
-                else:
-                    inputs_dt_val.append(copy.deepcopy(node.attr[i.type_attr]))
-        for i in op_def.output_arg:
-            outputs_num = node.attr[i.number_attr].i if i.number_attr else 1
-            for j in range(outputs_num):
-                if i.type:
-                    outputs_dt_val.append(copy.deepcopy(attr_value_pb2.AttrValue(type=i.type)))
-                else:
-                    outputs_dt_val.append(copy.deepcopy(node.attr[i.type_attr]))
-        return inputs_dt_val, outputs_dt_val
-
-    def _allowed_dtype_val(self, node):
-        """Get the allowed dtype value of the node."""
-        op_def = op_def_registry.get(node.op)
-        allowed_dt_val = {}
-        for attr_def in op_def.attr:
-            if attr_def.type != "type":
-                continue
-            if attr_def.HasField("allowed_values"):
-                allowed_dt_val[attr_def.name] = attr_def.allowed_values.list.type
-        # The supported data type in op_def may be different with registered kernels.
-        # Use the registered one if exists.
-        registered_dt_val = {}
-        registered_kernels = get_registered_kernels_for_op(node.op)
-        for kernel in registered_kernels.kernel:
-            if kernel.device_type in self.device:
-                for constraint in kernel.constraint:
-                    if constraint.HasField("allowed_values"):
-                        if constraint.name not in registered_dt_val:
-                            registered_dt_val[constraint.name] = constraint.allowed_values.list.type
-                        else:
-                            registered_dt_val[constraint.name].extend(constraint.allowed_values.list.type)
-        for dt_val in registered_dt_val:
-            if registered_dt_val[dt_val] != []:
-                allowed_dt_val[dt_val] = registered_dt_val[dt_val]
-        return allowed_dt_val
-
-    def _bf16_convert(self, bf16_node_name):
-        """BF16 conversion for the model.
-
-        Args: bf16_node_name: nodes converted to BF16 op list
-        """
-        bf16_node_detail = self.cur_graph.node_name_details[bf16_node_name]
-        bf16_node = bf16_node_detail.node
-        bf16_node_outputs = copy.deepcopy(bf16_node_detail.outputs)
-
-        if bf16_node.name in self.converted_ops:
-            return
-        elif "Dequantize" in bf16_node.op:
-            return
-        else:
-            self.converted_ops.append(bf16_node.name)
-
-        inputs_dt, outputs_dt = self._dtype(bf16_node)
-        inputs_dt_val, outputs_dt_val = self._dtype_val(bf16_node)
-        allowed_dt_val = self._allowed_dtype_val(bf16_node)
-        for index, input_name in enumerate(bf16_node.input):
-            if input_name.startswith("^"):
-                continue
-
-            input_detail = self.cur_graph.node_name_details[Helper.node_name_from_input(input_name)]
-            input_node = input_detail.node
-            input_node_outputs = input_detail.outputs
-            if (
-                inputs_dt[index] in allowed_dt_val
-                and dtypes.bfloat16.as_datatype_enum not in allowed_dt_val[inputs_dt[index]]
-            ):
-                continue
-
-            if inputs_dt_val[index] != DT_FLOAT32:
-                continue
-            if (
-                input_node.op == "Cast"
-                and input_node.attr["SrcT"] == DT_BFLOAT16
-                and input_node.attr["DstT"] == DT_FLOAT32
-                and len(input_node_outputs) == 1
-            ):
-                parent_input_name = Helper.node_name_from_input(input_node.input[0])
-                bf16_node.input[index] = input_node.input[0]
-                outputs = self.cur_graph.node_name_details[parent_input_name].outputs
-                outputs = list(map(lambda x: x.replace(input_name, bf16_node.name), outputs))
-                self.cur_graph.remove_node(input_name)
-            elif input_node.op == "Cast" and input_node.attr["DstT"] == DT_FLOAT32 and len(input_node_outputs) == 1:
-                input_node.attr["DstT"].CopyFrom(DT_BFLOAT16)
-            elif input_node.op == "Const" and len(input_node_outputs) == 1:
-                fp32_value = tensor_util.MakeNdarray(input_node.attr.get("value").tensor)
-                Helper.set_attr_dtype(input_node, "dtype", dtypes.bfloat16)
-                input_node.attr["value"].CopyFrom(
-                    attr_value_pb2.AttrValue(
-                        tensor=tensor_util.make_tensor_proto(fp32_value, dtypes.bfloat16, fp32_value.shape)
-                    )
-                )
-            elif (
-                "Dequantize" == input_node.op
-                and len(input_node_outputs) == 1
-                and input_node.attr["mode"].s != b"MIN_FIRST"
-                and tf.version.VERSION in SPR_BASE_VERSIONS
-            ):
-                # Dequantize with mode MIN_FIRST does not support bf16 in both eigen and mkl
-                _, outputs_dt_input_node = self._dtype(input_node)
-                allowed_input_node_dt_val = self._allowed_dtype_val(input_node)
-                if (
-                    outputs_dt_input_node[0] in allowed_input_node_dt_val
-                    and dtypes.bfloat16.as_datatype_enum in allowed_input_node_dt_val[outputs_dt_input_node[0]]
-                ):
-                    input_node.attr[outputs_dt_input_node[0]].CopyFrom(DT_BFLOAT16)
-            # ResizeBilinear input can be of different types but output is always float
-            elif (
-                input_node.name in self.bf16_ops
-                and "Dequantize" not in input_node.op
-                and input_node.op != "ResizeBilinear"
-            ):
-                self._bf16_convert(input_node.name)
-            else:
-                cast_node_name = input_name.replace(":", "_") + "/" + bf16_node_name + "_FP32toBF16"
-                if cast_node_name not in list(self.cur_graph.node_name_details.keys()):
-                    input_cast_node = Helper.create_node("Cast", cast_node_name, [input_name])
-                    Helper.set_attr_dtype(input_cast_node, "DstT", dtypes.bfloat16)
-                    Helper.set_attr_dtype(input_cast_node, "SrcT", dtypes.float32)
-                    Helper.set_attr_bool(input_cast_node, "Truncate", False)
-                bf16_node.input[index] = cast_node_name
-                outputs = self.cur_graph.node_name_details[Helper.node_name_from_input(input_name)].outputs
-                outputs = list(map(lambda x: x.replace(bf16_node.name, cast_node_name), outputs))
-                self.cur_graph.add_node(input_cast_node, input_name, [bf16_node_name])
-
-            bf16_node.attr[inputs_dt[index]].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.bfloat16.as_datatype_enum))
-
-        for output_name in bf16_node_outputs:
-            if bf16_node.op == "ResizeBilinear":
-                continue
-            output_detail = self.cur_graph.node_name_details[output_name]
-            output_node = output_detail.node
-            inputs_dt_input_node, _ = self._dtype(output_node)
-            allowed_output_node_dt_val = self._allowed_dtype_val(output_node)
-
-            for i, input_name in enumerate(output_node.input):
-                if input_name.startswith("^"):
-                    continue
-
-                if bf16_node.name != input_name.split(":")[0]:
-                    continue
-
-                index = int(input_name.split(":")[-1]) if ":" in input_name else 0
-                if (
-                    outputs_dt[index] in allowed_dt_val
-                    and dtypes.bfloat16.as_datatype_enum not in allowed_dt_val[outputs_dt[index]]
-                ):
-                    continue
-                if outputs_dt_val[index] != DT_FLOAT32:
-                    continue
-
-                if output_node.op == "Cast":
-                    output_node.attr["SrcT"].CopyFrom(DT_BFLOAT16)
-                elif output_node.op == "QuantizeV2" and "dtype" in output_node.attr:
-                    if (
-                        "dtype" in allowed_output_node_dt_val
-                        and dtypes.bfloat16.as_datatype_enum in allowed_output_node_dt_val["dtype"]
-                    ):
-                        output_node.attr["dtype"].CopyFrom(DT_BFLOAT16)
-                elif (
-                    output_node.name not in self.bf16_ops
-                    or inputs_dt_input_node[i] in allowed_output_node_dt_val
-                    and dtypes.bfloat16.as_datatype_enum not in allowed_output_node_dt_val[inputs_dt_input_node[i]]
-                ):
-                    cast_node_name = bf16_node_name + "/" + output_node.name + "_BF16toFP32"
-                    if cast_node_name in self.cur_graph.node_name_details.keys():
-                        continue
-                    output_cast_node = Helper.create_node("Cast", cast_node_name, [input_name])
-                    Helper.set_attr_dtype(output_cast_node, "DstT", dtypes.float32)
-                    Helper.set_attr_dtype(output_cast_node, "SrcT", dtypes.bfloat16)
-                    Helper.set_attr_bool(output_cast_node, "Truncate", False)
-                    index = [i for i in output_node.input].index(input_name)
-                    output_node.input[index] = output_cast_node.name
-                    self.cur_graph.add_node(output_cast_node, bf16_node_name, [output_name])
-
-    def _model_bf16_convert(self):
-        """Convert model to BF16."""
-        logging.debug("start convert bf16 graph")
-        self.cur_graph.parse_graph()
-        for bf16_node_name in set(self.bf16_ops):
-            if bf16_node_name not in self.cur_graph.node_name_details:
-                self.bf16_ops.remove(bf16_node_name)
-        for bf16_node_name in sorted(list(set(self.bf16_ops))):
-            self._bf16_convert(bf16_node_name)
-        return self.cur_graph.dump_graph()
-
-    def do_transformation(self):
-        """Execute BF16 convert.
-
-        Returns: Transformed graph
-        """
-        converted_graph_def = self._model_bf16_convert()
-        # remove those ops which could be shared by Graph Cse optimizer
-        converted_graph_def = GraphCseOptimizer(converted_graph_def).do_transformation()
-        # remove cast and set dequantize dtype bf16 when all outputs of dequantize are bf16
-        converted_graph_def = DequantizeCastOptimizer(converted_graph_def).do_transformation()
-        converted_graph_def.library.CopyFrom(self.model.library)
-        return converted_graph_def
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/bf16/dequantize_cast_optimizer.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/bf16/dequantize_cast_optimizer.py
deleted file mode 100644
index 8e506ac10ef..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/bf16/dequantize_cast_optimizer.py
+++ /dev/null
@@ -1,79 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Dequantize Cast Graph Rerewriter."""
-
-import tensorflow as tf
-from tensorflow.core.framework import attr_value_pb2
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.graph_base import GraphRewriterBase
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.utils import SPR_BASE_VERSIONS, dump_elapsed_time
-
-
-class DequantizeCastOptimizer(GraphRewriterBase):
-    """Remove the Cast OP and set Dequantize output to B16 if the Cast OP output is BF16."""
-
-    @dump_elapsed_time("Pass DequantizeCastOptimizer")
-    def do_transformation(self):
-        """Remove the redundant Cast OP after Dequantize.
-
-        Args:
-            input_graph_def (graphdef): graphdef object
-
-        Returns:
-            [graphdef]: optimized graph
-        """
-        # stock TF _MklDequantize doesn't support BF16 currently.
-        # TODO remove this when spr-base upstream to stock TF.
-        if tf.version.VERSION not in SPR_BASE_VERSIONS:
-            return self.model
-
-        DT_BFLOAT16 = attr_value_pb2.AttrValue(type=dtypes.bfloat16.as_datatype_enum)
-        cur_graph = GraphAnalyzer()
-        cur_graph.graph = self.model
-        graph_info = cur_graph.parse_graph()
-        target_nodes = cur_graph.query_fusion_pattern_nodes([["Dequantize"], ["Cast"]])
-        for i in target_nodes:
-            dq_node = graph_info[i[0]].node
-            dq_outputs = graph_info[i[0]].outputs
-
-            if len(dq_outputs) > 1:
-                continue
-            cast_node = graph_info[i[1]].node
-            cast_outputs = graph_info[i[1]].outputs
-            all_cast_outputs_bf16 = True
-            for cast_output in cast_outputs:
-                cast_output_node = graph_info[cast_output].node
-                if cast_output_node.attr["T"] != DT_BFLOAT16:  # des dtype of the cast must be bfloat16
-                    all_cast_outputs_bf16 = False
-            if not all_cast_outputs_bf16:
-                continue
-            dq_node.attr["dtype"].CopyFrom(DT_BFLOAT16)
-            for cast_output in cast_outputs:
-                successor_node = graph_info[cast_output].node
-                replace_index = None
-                for index, value in enumerate(successor_node.input):
-                    if value == cast_node.name:
-                        replace_index = index
-                        break
-                successor_node.input[replace_index] = dq_node.name
-
-            # remove Cast node
-            cur_graph.remove_node(cast_node.name)
-
-        return cur_graph.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/__init__.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/__init__.py
deleted file mode 100644
index 7b9dd4d5e8f..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/__init__.py
+++ /dev/null
@@ -1,17 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Tensorflow Generic Graph Rewriters."""
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/convert_add_to_biasadd.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/convert_add_to_biasadd.py
deleted file mode 100644
index 0544019335c..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/convert_add_to_biasadd.py
+++ /dev/null
@@ -1,76 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Add OP to BiasAdd OP Graph Rewriter."""
-
-import numpy as np
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.graph_base import GraphRewriterBase
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import SPR_BASE_VERSIONS, dump_elapsed_time
-
-
-class ConvertAddToBiasAddOptimizer(GraphRewriterBase):
-    """Convert MatMul/Conv2D + Add(AddV2) to MatMul + BiasAdd."""
-
-    @dump_elapsed_time("Pass ConvertAddToBiasAddOptimizer")
-    def do_transformation(self):
-        """Execute conversion Add to BiasAdd."""
-        g = GraphAnalyzer()
-        g.graph = self.model
-        graph_info = g.parse_graph()
-
-        import tensorflow as tf
-
-        if tf.version.VERSION not in SPR_BASE_VERSIONS:
-            target_nodes = g.query_fusion_pattern_nodes([["MatMul", "Conv2D"], ["Add", "AddV2"]])
-        else:
-            target_nodes = g.query_fusion_pattern_nodes([["MatMul"], ["Add", "AddV2"]])
-        for i in target_nodes:
-            successor_node_names = graph_info[i[1]].outputs
-            matmul_input_name = graph_info[i[0]].node.input[0]
-            matmul_input_node = graph_info[Helper.node_name_from_input(matmul_input_name)].node
-            # Fixme below two lines was added due to MatMul kernel limitation for matmul input type
-            # should be quint8.
-            if matmul_input_node.op == "Const":
-                continue
-            add_second_input_name = graph_info[i[1]].node.input[1]
-            add_second_const_node = graph_info[add_second_input_name].node
-            if add_second_const_node.op != "Const":
-                continue
-            bias_tensor = tensor_util.MakeNdarray(add_second_const_node.attr["value"].tensor)
-
-            if bias_tensor.ndim > 2:
-                continue
-
-            new_bias_tensor = np.ravel(bias_tensor)
-
-            g.remove_node(i[1])
-
-            bias_node_name = i[1]
-            bias_const_node_name = add_second_const_node.name + "_flattern"
-
-            bias_const_node = Helper.create_constant_node(bias_const_node_name, new_bias_tensor, dtypes.float32)
-
-            bias_node = Helper.create_node("BiasAdd", bias_node_name, [i[0], bias_const_node_name])
-            Helper.set_attr_dtype(bias_node, "T", dtypes.float32)
-
-            g.add_node(bias_const_node, None, [bias_node_name])
-            g.replace_single_node(bias_node, [i[0]], i[1], successor_node_names, i[1])
-
-        return g.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/convert_layout.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/convert_layout.py
deleted file mode 100644
index d2a4cfe2c9a..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/convert_layout.py
+++ /dev/null
@@ -1,85 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert Layout Graph Rewriter."""
-
-import tensorflow as tf
-from tensorflow.core.protobuf import config_pb2, meta_graph_pb2, rewriter_config_pb2
-from tensorflow.python.grappler import tf_optimizer
-from tensorflow.python.training import saver as saver_lib
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.graph_base import GraphRewriterBase
-from neural_compressor.tensorflow.utils import dump_elapsed_time, version1_gt_version2
-
-
-class ConvertLayoutOptimizer(GraphRewriterBase):
-    """The layout conversion optimizer, convert NCHW to NHWC format.
-
-    It is executed only when NCHW node exists and tensorflow version is 2.4.0 and above.
-
-    Args: model: input graph_def
-          outputs: output name list
-
-    Return: converted graph_def
-    """
-
-    def __init__(self, model, outputs):
-        """Initialization."""
-        super().__init__(model)
-        self.outputs = outputs
-
-    @dump_elapsed_time("ConvertLayoutOptimizer")
-    def do_transformation(self):
-        """Execute converting layout."""
-        convert = False
-        for node in self.model.node:
-            if "Conv" in node.op and "data_format" in node.attr and node.attr["data_format"].s == b"NCHW":
-                convert = True
-                break
-        if convert and version1_gt_version2(tf.version.VERSION, "2.3.0"):
-            g = tf.Graph()
-            with g.as_default():  # pylint: disable=not-context-manager
-                g = tf.compat.v1.import_graph_def(self.model, name="")
-                meta_graph = saver_lib.export_meta_graph(graph_def=self.model, graph=g, clear_devices=False)
-                fetch_collection = meta_graph_pb2.CollectionDef()
-                for fetch in self.outputs:
-                    fetch_collection.node_list.value.append(fetch)  # pylint: disable=no-member
-                meta_graph.collection_def["train_op"].CopyFrom(  # pylint: disable=no-member
-                    fetch_collection
-                )  # pylint: disable=no-member
-
-            config = config_pb2.ConfigProto()
-            convert = rewriter_config_pb2.RewriterConfig.NCHW_TO_NHWC  # pylint: disable=no-member
-            config.graph_options.rewrite_options.CopyFrom(  # pylint: disable=no-member
-                rewriter_config_pb2.RewriterConfig(
-                    disable_model_pruning=True,
-                    constant_folding=rewriter_config_pb2.RewriterConfig.OFF,
-                    dependency_optimization=rewriter_config_pb2.RewriterConfig.OFF,
-                    memory_optimization=rewriter_config_pb2.RewriterConfig.NO_MEM_OPT,
-                    arithmetic_optimization=rewriter_config_pb2.RewriterConfig.OFF,
-                    shape_optimization=rewriter_config_pb2.RewriterConfig.OFF,
-                    loop_optimization=rewriter_config_pb2.RewriterConfig.OFF,
-                    function_optimization=rewriter_config_pb2.RewriterConfig.OFF,
-                    remapping=rewriter_config_pb2.RewriterConfig.OFF,
-                    implementation_selector=rewriter_config_pb2.RewriterConfig.OFF,
-                    cpu_layout_conversion=convert,
-                )
-            )
-
-            optimized_graph = tf_optimizer.OptimizeGraph(config, meta_graph)
-            return optimized_graph
-
-        return self.model
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/convert_leakyrelu.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/convert_leakyrelu.py
deleted file mode 100644
index f7cb7eec4a5..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/convert_leakyrelu.py
+++ /dev/null
@@ -1,78 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert LeakyRelu Graph Rewriter."""
-
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class ConvertLeakyReluOptimizer(GraphRewriterBase):
-    """Convert below subgraph to Node A + LeakyRelu.
-
-    Node A             Node A
-        |   x               |
-        |    x              |
-        |     Mul  --->     |
-        |     x             |
-        |   x               |
-        Maximum           LeakyRelu
-    Note, the coefficient of Mul should be less than 1 or the conversion is not valid.
-    """
-
-    @dump_elapsed_time("Pass ConvertLeakyReluOptimizer")
-    def do_transformation(self):
-        """Fuse small ops to LeakyRelu."""
-        g = GraphAnalyzer()
-        g.graph = self.model
-        graph_info = g.parse_graph()
-        target_nodes = g.query_fusion_pattern_nodes([["Mul"], ["Maximum"]])
-        for i in target_nodes:
-            successor_node_names = graph_info[i[1]].outputs
-
-            mul_input_names = list(graph_info[i[0]].node.input)
-            max_input_names = list(graph_info[i[1]].node.input)
-            common_input = list(set(mul_input_names).intersection(set(max_input_names)))
-
-            if len(common_input) != 1:
-                continue
-            mul_coeff_node_name = list(set(mul_input_names).difference(set(max_input_names)))[0]
-            mul_coeff_node = graph_info[mul_coeff_node_name].node
-            if mul_coeff_node.op != "Const":
-                continue
-            nd = tensor_util.MakeNdarray(mul_coeff_node.attr["value"].tensor).ndim
-            if nd > 1:
-                continue
-            alpha_value = float(tensor_util.MakeNdarray(mul_coeff_node.attr["value"].tensor))
-            if alpha_value > 1.0:
-                continue
-
-            leaky_relu_node_name = i[1] + "_leakyrelu"
-            leaky_relu_node = Helper.create_node("LeakyRelu", leaky_relu_node_name, common_input)
-            Helper.set_attr_dtype(leaky_relu_node, "T", dtypes.float32)
-            Helper.set_attr_float(leaky_relu_node, "alpha", alpha_value)
-
-            g.replace_single_node(leaky_relu_node, common_input, i[1], successor_node_names, i[1])
-            g.remove_node(i[1])
-            g.remove_node(i[0])
-            g.remove_node(mul_coeff_node_name)
-
-        return g.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/convert_nan_to_random.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/convert_nan_to_random.py
deleted file mode 100644
index 1ea158578af..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/convert_nan_to_random.py
+++ /dev/null
@@ -1,52 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert NAN to random Graph Rewriter."""
-
-import numpy as np
-from tensorflow.core.framework import attr_value_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-
-from ..graph_base import GraphRewriterBase
-
-
-class ConvertNanToRandom(GraphRewriterBase):
-    """Convert Const node which value consists of NAN to random data."""
-
-    def do_transformation(self):
-        """Execute convert NAN to random."""
-        cur_graph = GraphAnalyzer()
-        cur_graph.graph = self.model
-
-        graph_info = cur_graph.parse_graph()
-
-        target_nodes = cur_graph.query_fusion_pattern_nodes([["Const"]])
-
-        for i in target_nodes:
-            const_node = graph_info[i[0]].node
-            const_content = tensor_util.MakeNdarray(const_node.attr["value"].tensor)
-            if const_content.dtype == np.float32 and np.any(np.isnan(const_content)):
-                const_node.attr["value"].CopyFrom(
-                    attr_value_pb2.AttrValue(
-                        tensor=tensor_util.make_tensor_proto(
-                            np.random.rand(*const_content.shape), dtypes.float32, const_content.shape
-                        )
-                    )
-                )
-
-        return cur_graph.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/convert_placeholder_to_const.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/convert_placeholder_to_const.py
deleted file mode 100644
index 1908ed26bdd..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/convert_placeholder_to_const.py
+++ /dev/null
@@ -1,99 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert placeholder to const Graph Rewriter."""
-
-from tensorflow.core.framework import attr_value_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class ConvertPlaceholderToConst(GraphRewriterBase):
-    """Convert placeholder to const for removing training nodes."""
-
-    @dump_elapsed_time("Pass ConvertPlaceholderToConst")
-    def do_transformation(self):
-        """Rename the PlaceHolderWithDefault node to constant.
-
-        In a frozen graph, PlaceholderWithDefault nodes can be converted to
-        Constant op nodes with same value. This will help simplify the graph.
-
-        Args:
-            input_graph_def: A GraphDef containing a model.
-            nodes_to_convert: A list of PlaceholderWithDefault or Placeholder
-            nodes to be converted to Constants with their new value.
-
-        Returns:
-            modified graph with PlaceholderWithDefault node converted to Constant node
-        """
-        cur_graph = GraphAnalyzer()
-        cur_graph.graph = self.model
-
-        graph_info = cur_graph.parse_graph()
-
-        target_nodes = cur_graph.query_fusion_pattern_nodes([["PlaceholderWithDefault"]])
-        for i in target_nodes:
-            placeholder_node = graph_info[i[0]].node
-            new_node = node_def_pb2.NodeDef()
-            if dtypes.bool.as_datatype_enum == placeholder_node.attr["dtype"].type:
-                placeholder_input_node = None
-                if placeholder_node.input:
-                    placeholder_input_node = graph_info[Helper.node_name_from_input(placeholder_node.input[0])].node
-
-                if placeholder_input_node and placeholder_input_node.op != "Const":
-                    continue
-                if placeholder_input_node:
-                    new_val_str = placeholder_input_node.attr["value"].tensor.bool_val
-                else:
-                    continue
-
-                new_node.op = "Const"
-                new_node.name = placeholder_node.name + "_const"
-                new_node.attr["dtype"].CopyFrom(placeholder_node.attr["dtype"])
-                new_node.attr["value"].CopyFrom(
-                    attr_value_pb2.AttrValue(
-                        tensor=tensor_util.make_tensor_proto(self.strtobool(new_val_str), dtype=dtypes.bool, shape=[])
-                    )
-                )
-                cur_graph.add_node(new_node, None, graph_info[placeholder_node.name].outputs)
-                for each_output in graph_info[placeholder_node.name].outputs:
-                    for i, input_name in enumerate(graph_info[each_output].node.input):
-                        if input_name == placeholder_node.name:
-                            new_input = (
-                                graph_info[each_output].node.input[:i]
-                                + [new_node.name]
-                                + graph_info[each_output].node.input[i + 1 :]
-                            )
-                            graph_info[each_output].node.ClearField("input")
-                            graph_info[each_output].node.input.extend(new_input)
-                cur_graph.remove_node(placeholder_node.name)
-            else:
-                continue
-
-        return cur_graph.dump_graph()
-
-    def strtobool(self, val_str):
-        """Return boolean value of it's equivalent string representation."""
-        if val_str == [True]:
-            return True
-        if val_str == [False]:
-            return False
-        return False
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/dilated_contraction.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/dilated_contraction.py
deleted file mode 100644
index ecf4c79c88e..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/dilated_contraction.py
+++ /dev/null
@@ -1,89 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Dilated Contraction Graph Rewriter."""
-
-from tensorflow.core.framework import attr_value_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class DilatedContraction(GraphRewriterBase):
-    """Fuse the SpaceToBatchND + Conv + BatchToSpaceND pattern."""
-
-    @dump_elapsed_time("Pass DilatedContraction")
-    def do_transformation(self):
-        """Dilated Contraction fusion."""
-        cur_graph = GraphAnalyzer()
-        cur_graph.graph = self.model
-
-        graph_info = cur_graph.parse_graph()
-        target_nodes = cur_graph.query_fusion_pattern_nodes(
-            ["SpaceToBatchND", ["Conv2D", "DepthwiseConv2dNative"], "BatchToSpaceND"]
-        )
-
-        for node_combination in target_nodes:
-            stob_node = graph_info[node_combination[0]].node
-            contraction_node = graph_info[node_combination[1]].node
-            btos_node = graph_info[node_combination[2]].node
-            stob_padding_node = graph_info[stob_node.input[2]].node
-
-            block_shape_node = graph_info[btos_node.input[1]].node
-            crops_node = graph_info[btos_node.input[2]].node
-
-            block_value = [i for i in tensor_util.MakeNdarray(block_shape_node.attr["value"].tensor).flat]
-            new_dilation = [1, block_value[0], block_value[1], 1]
-            # if padding input of SpaceToBatchND can't be directly fetched, we continue
-            if stob_padding_node.op != "Const":
-                continue
-            padding_value = [i for i in tensor_util.MakeNdarray(stob_padding_node.attr["value"].tensor).flat]
-            crops_value = [i for i in tensor_util.MakeNdarray(crops_node.attr["value"].tensor).flat]
-
-            contraction_node.input[0] = stob_node.input[0]
-            Helper.set_attr_int_list(contraction_node, "dilations", new_dilation)
-
-            real_padding = [padding_value[i] - crops_value[i] for i in range(4)]
-            explict_padding = [0, 0, 0, 0, 0, 0, 0, 0]
-            data_format = contraction_node.attr["data_format"].s.decode()
-            if any(real_padding):
-                contraction_node.attr["padding"].s = "EXPLICIT".encode()
-                assert data_format in ("NHWC", "NCHW")
-                if data_format == "NHWC":
-                    explict_padding[2] = real_padding[0]
-                    explict_padding[3] = real_padding[1]
-                    explict_padding[4] = real_padding[2]
-                    explict_padding[5] = real_padding[3]
-                else:
-                    explict_padding[4] = real_padding[0]
-                    explict_padding[5] = real_padding[1]
-                    explict_padding[6] = real_padding[2]
-                    explict_padding[7] = real_padding[3]
-                Helper.set_attr_int_list(contraction_node, "explicit_paddings", explict_padding)
-
-            contraction_node.attr.pop("_output_shapes")
-            cur_graph.remove_node(stob_node.name)
-            following_node_name = graph_info[node_combination[2]].outputs[0]
-            following_node = graph_info[following_node_name].node
-
-            following_node.input[0] = btos_node.input[0]
-            cur_graph.remove_node(btos_node.name)
-
-        return cur_graph.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/dummy_biasadd.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/dummy_biasadd.py
deleted file mode 100644
index 077b62684a0..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/dummy_biasadd.py
+++ /dev/null
@@ -1,130 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Inject dummy BiasAdd Graph Rewriter."""
-
-import tensorflow as tf
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.graph_base import GraphRewriterBase
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-
-class InjectDummyBiasAddOptimizer(GraphRewriterBase):
-    """Inject dummy BiasAdd for MatMul, Conv2D for pattern fusion."""
-
-    def __init__(self, model, outputs):
-        """Initialization."""
-        super().__init__(model)
-        self.outputs = outputs
-
-    @dump_elapsed_time("Pass InjectDummyBiasAddOptimizer")
-    def do_transformation(self):
-        """Inject dummy BiasAdd if MatMul, Conv2D missing the valid add ops behind them."""
-        g = GraphAnalyzer()
-        g.graph = self.model
-        graph_info = g.parse_graph()
-        g.get_frame_info()
-        valid_ops = ("BiasAdd", "Add", "AddV2", "AddN")
-        target_nodes = g.query_fusion_pattern_nodes(
-            [
-                ["MatMul", "Conv2D"],
-            ]
-        )
-        for i in target_nodes:
-            # only apply this pass for tensorflow old quantization API, pre_optimize does this check
-            # use conv+dummy_biasadd+relu because TF do not support conv+relu now.
-            if i[0] in self.outputs:
-                continue
-            next_node_names = graph_info[i[0]].outputs
-            if (
-                next_node_names
-                and len(next_node_names) == 1
-                and graph_info[Helper.node_name_from_input(next_node_names[0])].node.op in valid_ops
-            ):
-                continue
-            bias_node_name = i[0] + "_dummy_biasadd"
-            bias_const_node_name = i[0] + "_dummy_biasadd_const"
-            matmul_a_node_name = Helper.node_name_from_input(graph_info[i[0]].node.input[0])
-            matmul_a_node = graph_info[matmul_a_node_name].node
-            matmul_b_node_name = Helper.node_name_from_input(graph_info[i[0]].node.input[1])
-            matmul_b_node = graph_info[matmul_b_node_name].node
-
-            if matmul_a_node.op == "Const" or matmul_b_node.op not in ["Const", "Enter"]:
-                continue
-            if matmul_b_node.op == "Enter":  # pragma: no cover
-                parent_node = graph_info[Helper.node_name_from_input(matmul_b_node.input[0])].node
-                if parent_node.op != "Const":
-                    continue
-                else:
-                    matmul_b_node = parent_node
-                    matmul_b_node_name = matmul_b_node.name
-
-            if graph_info[i[0]].node.op == "MatMul":
-                t_b_index = 0 if graph_info[i[0]].node.attr["transpose_b"].b else 1
-            elif graph_info[i[0]].node.op == "Conv2D" and graph_info[i[0]].node.attr["data_format"].s == b"NHWC":
-                t_b_index = 3
-            elif graph_info[i[0]].node.op == "Conv2D" and graph_info[i[0]].node.attr["data_format"].s == b"NCHW":
-                t_b_index = 1
-            else:
-                continue
-
-            bias_add_length = matmul_b_node.attr["value"].tensor.tensor_shape.dim[t_b_index].size
-
-            bias_add_content = [0.0] * bias_add_length
-
-            bias_const_node = Helper.create_constant_node(
-                bias_const_node_name, bias_add_content, dtypes.float32, shape=[bias_add_length]
-            )
-
-            if i[0] in g.parent_frame_details and g.parent_frame_details[i[0]]:  # pragma: no cover
-                bias_const_enter_node = Helper.create_node(
-                    "Enter", bias_const_node_name + "_enter", [bias_const_node_name]
-                )
-                Helper.set_attr_string(
-                    bias_const_enter_node, "frame_name", g.parent_frame_details[i[0]].attr["frame_name"].s
-                )
-                Helper.set_attr_dtype(bias_const_enter_node, "T", dtypes.float32)
-                Helper.set_attr_bool(bias_const_enter_node, "is_constant", True)
-                Helper.set_attr_int(
-                    bias_const_enter_node,
-                    "parallel_iterations",
-                    g.parent_frame_details[i[0]].attr["parallel_iterations"].i,
-                )
-
-            bias_node = Helper.create_node(
-                "BiasAdd",
-                bias_node_name,
-                [
-                    i[0],
-                    (
-                        bias_const_enter_node.name
-                        if i[0] in g.parent_frame_details and g.parent_frame_details[i[0]]
-                        else bias_const_node_name
-                    ),
-                ],
-            )
-            Helper.set_attr_dtype(bias_node, "T", dtypes.float32)
-            g.add_node(bias_node, i[0], next_node_names)
-            if i[0] in g.parent_frame_details and g.parent_frame_details[i[0]]:  # pragma: no cover
-                g.add_node(bias_const_node, None, [bias_const_enter_node.name])
-                g.add_node(bias_const_enter_node, bias_const_node_name, [bias_node_name])
-            else:
-                g.add_node(bias_const_node, None, [bias_node_name])
-
-        return g.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/expanddims_optimizer.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/expanddims_optimizer.py
deleted file mode 100644
index d79e2cead9a..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/expanddims_optimizer.py
+++ /dev/null
@@ -1,80 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""ExpandDims Graph Rewriter."""
-
-import numpy as np
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class ExpandDimsOptimizer(GraphRewriterBase):
-    """Calculate ExpandDims and remove it if its input is weight and next node is Conv2D."""
-
-    @dump_elapsed_time("Pass ExpandDimsOptimizer")
-    def do_transformation(self):
-        """Handle all ExpandDims ops whose input is weight and output is Conv2D.
-
-        Args:
-          input_graph_def (graphdef): graphdef object
-
-        Returns:
-           [graphdef]: optimized graph
-        """
-        cur_graph = GraphAnalyzer()
-        cur_graph.graph = self.model
-
-        graph_info = cur_graph.parse_graph()
-        target_nodes = cur_graph.query_fusion_pattern_nodes([["ExpandDims"]])
-
-        for node_combination in target_nodes:
-            expanddims_node = graph_info[node_combination[0]].node
-            dims_node = graph_info[expanddims_node.input[1]].node
-            next_node = graph_info[graph_info[node_combination[0]].outputs[0]].node
-            # to solve the case that input 0 of ExpandDims is a tensor, not a node
-            if expanddims_node.input[0] in graph_info:
-                weight_node = graph_info[expanddims_node.input[0]].node
-            else:
-                continue
-
-            if weight_node.op == "Const" and next_node.op == "Conv2D":
-                dims = Helper.values_from_const(dims_node)
-                weight_value = np.array(Helper.values_from_const(weight_node))
-                new_weight_value = np.expand_dims(weight_value, axis=dims)
-                cur_graph.remove_node(weight_node.name)
-                new_weight_node = Helper.create_constant_node(weight_node.name, new_weight_value, dtypes.float32)
-
-                for output in graph_info[node_combination[0]].outputs:
-                    successor_node = graph_info[output].node
-                    replace_index = None
-                    for index, value in enumerate(successor_node.input):
-                        if value == expanddims_node.name:
-                            replace_index = index
-                            break
-                    # weight->conv2d
-                    cur_graph.add_node(new_weight_node, None, [successor_node.name])
-                    successor_node.input[replace_index] = new_weight_node.name
-                # remove ExpandDims and weight_node
-                cur_graph.remove_node(expanddims_node.name)
-            else:
-                continue
-
-        return cur_graph.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fetch_weight_from_reshape.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fetch_weight_from_reshape.py
deleted file mode 100644
index 679098e20f3..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fetch_weight_from_reshape.py
+++ /dev/null
@@ -1,88 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Fetch Weight from Reshape Graph Rewriter."""
-
-import numpy as np
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class FetchWeightFromReshapeOptimizer(GraphRewriterBase):
-    """Handle the Pack + Reshape + Conv2D fusion pattern."""
-
-    @dump_elapsed_time("Pass FetchWeightFromReshapeOptimizer")
-    def do_transformation(self):
-        """Fetch weight of Conv2D from Pack+Reshape+Conv2D pattern.
-
-        Args:
-          input_graph_def (graphdef): graphdef object
-        Returns:
-           [graphdef]: optimized graph
-        """
-        cur_graph = GraphAnalyzer()
-        cur_graph.graph = self.model
-
-        graph_info = cur_graph.parse_graph()
-        target_nodes = cur_graph.query_fusion_pattern_nodes([["Pack"], ["Reshape"], ["Conv2D"]])
-
-        for i, node_combination in enumerate(target_nodes):
-            pack_node = graph_info[node_combination[0]].node
-            reshape_node = graph_info[node_combination[1]].node
-            shape_node = graph_info[reshape_node.input[1]].node
-            conv_node = graph_info[node_combination[2]].node
-            if not (pack_node.op == "Pack" and reshape_node.op == "Reshape" and conv_node.op == "Conv2D"):
-                continue
-            reshape_outputs_length = len(graph_info[node_combination[1]].outputs)
-            unpack_values = []
-            for index in range(pack_node.attr["N"].i):
-                values_node = graph_info[pack_node.input[index]].node
-                if values_node.op == "Const":
-                    unpack_values.append(Helper.values_from_const(values_node))
-            input_reshape = np.stack(unpack_values, axis=pack_node.attr["axis"].i)
-            if shape_node.op != "Const":
-                continue
-            shape = Helper.values_from_const(shape_node)
-            weight = np.reshape(input_reshape, shape)
-            weight_node = Helper.create_constant_node(
-                reshape_node.name + "/weight" + "_" + str(i), weight, dtypes.float32
-            )
-            if i > 0:
-                conv_node_j = graph_info[target_nodes[i - 1][2]].node
-                graph_info[node_combination[1]].outputs.remove(conv_node_j.name)
-            for output in graph_info[node_combination[1]].outputs:
-                successor_node = graph_info[output].node
-                replace_index = None
-                for index, value in enumerate(successor_node.input):
-                    if value == reshape_node.name or value == reshape_node.name + "/weight" + "_" + str(i - 1):
-                        replace_index = index
-                        break
-                # weight->conv2d
-                cur_graph.add_node(weight_node, None, [successor_node.name])
-                successor_node.input[replace_index] = weight_node.name
-
-            if i + 1 == reshape_outputs_length:
-                cur_graph.remove_node(reshape_node.name)
-                cur_graph.remove_node(values_node.name)
-                cur_graph.remove_node(shape_node.name)
-                cur_graph.remove_node(pack_node.name)
-
-        return cur_graph.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fold_batch_norm.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fold_batch_norm.py
deleted file mode 100644
index bff69330ec5..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fold_batch_norm.py
+++ /dev/null
@@ -1,271 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Folding BatchNorm Graph Rewriter."""
-
-import math
-
-import numpy as np
-from tensorflow.core.framework import attr_value_pb2, node_def_pb2
-from tensorflow.python.framework import tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class FoldBatchNormNodesOptimizer(GraphRewriterBase):
-    """Folding BatchNorm nodes into Conv."""
-
-    INPUT_ORDER = {
-        # Order of inputs for BatchNormWithGlobalNormalization.
-        "BatchNormWithGlobalNormalization": ["conv_op", "mean_op", "var_op", "beta_op", "gamma_op"],
-        # Order of inputs for FusedBatchNorm.
-        "FusedBatchNorm": ["conv_op", "gamma_op", "beta_op", "mean_op", "var_op"],
-        "FusedBatchNormV3": ["conv_op", "gamma_op", "beta_op", "mean_op", "var_op"],
-        "_FusedBatchNormEx": ["conv_op", "gamma_op", "beta_op", "mean_op", "var_op"],
-    }
-    # Name of the attribute epsilon value is stored in.
-    EPSILON_ATTR = {
-        "BatchNormWithGlobalNormalization": "variance_epsilon",
-        "FusedBatchNorm": "epsilon",
-        "FusedBatchNormV3": "epsilon",
-        "_FusedBatchNormEx": "epsilon",
-    }
-
-    def scale_after_normalization(self, node):
-        """Check the scale_after_normalization attribute if the node is BatchNormWithGlobalNormalization.
-
-        Args:
-            node (nodedef): input nodedef object
-
-        Returns:
-            bool: True if the node op is not BatchNormWithGlobalNormalization else it
-                    depends on the BatchNormWithGlobalNormalization attribute value of
-                    `scale_after_normalization`.
-        """
-        if node.op == "BatchNormWithGlobalNormalization":
-            return node.attr["scale_after_normalization"].b
-        return True
-
-    @dump_elapsed_time("Pass FoldBatchNormNodesOptimizer")
-    def do_transformation(self):
-        """Removes batch normalization ops by folding them into convolutions.
-
-        Batch normalization during training has multiple dynamic parameters that are
-        updated, but once the graph is finalized these become constants. That means
-        there's an opportunity to reduce the computations down to a scale and
-        addition, rather than the more expensive multiple ops, and even bake the
-        scaling into the convolution weights. This function identifies the typical
-        pattern of batch normalization subgraphs, and performs the transformation to
-        fold the computations down into a simpler form. It currently only spots batch
-        normalization that's performed by the BatchNormWithGlobalNormalization, FusedBatchNorm,
-        FusedBatchNormV3 and _FusedBatchNormEx ops, and will need to be extended in the future to handle the
-        newer style.
-
-        Returns:
-          Modified graph with BN ops removed, and modified weights.
-
-        Raises:
-          ValueError: If the graph is badly formed with duplicate node names.
-        """
-        cur_graph = GraphAnalyzer()
-        cur_graph.graph = self.model
-
-        graph_info = cur_graph.parse_graph()
-        target_nodes = cur_graph.query_fusion_pattern_nodes(
-            [
-                ["Conv2D", "DepthwiseConv2dNative"],
-                ("BiasAdd", "Add", "AddV2"),
-                ["BatchNormWithGlobalNormalization", "FusedBatchNorm", "FusedBatchNormV3", "_FusedBatchNormEx"],
-            ]
-        )
-        for node_combination in target_nodes:
-            matched_node = node_combination[:-1]
-            has_add_op = True if len(node_combination[-1]) == 3 else False
-            conv_node = graph_info[Helper.node_name_from_input(matched_node[0])].node
-            weights_node_name = graph_info[Helper.node_name_from_input(matched_node[0])].node.input[1]
-            weights_node = graph_info[Helper.node_name_from_input(weights_node_name)].node
-            bn_node = graph_info[Helper.node_name_from_input(matched_node[-1])].node
-
-            # oneDNN enabled _FusedBatchNormEx only supports num_side_inputs == 0
-            # and Relu/Identity activations.
-            if bn_node.op == "_FusedBatchNormEx":
-                if bn_node.attr["num_side_inputs"].i != 0:
-                    continue
-                if not (
-                    bn_node.attr["activation_mode"].s == b"Identity" or bn_node.attr["activation_mode"].s == b"Relu"
-                ):
-                    continue
-
-            if weights_node.op != "Const":
-                self.logger.warning(
-                    "Didn't find expected conv Constant input to '%s', "
-                    "found %s instead. Maybe freeze_graph wasn't "
-                    "run first?" % (bn_node.name, weights_node_name)
-                )
-                continue
-            weights = Helper.values_from_const(weights_node)
-
-            if conv_node.op == "Conv2D":
-                channel_count = weights.shape[3]
-            elif conv_node.op == "DepthwiseConv2dNative":
-                channel_count = weights.shape[2] * weights.shape[3]
-
-            mean_node_name = Helper.node_name_from_input(bn_node.input[self.INPUT_ORDER[bn_node.op].index("mean_op")])
-            mean_node = graph_info[mean_node_name].node
-
-            if mean_node.op != "Const":
-                continue
-
-            mean_value = Helper.values_from_const(mean_node)
-
-            if has_add_op:
-                bias_node_name = graph_info[Helper.node_name_from_input(matched_node[1])].node.input[1]
-                bias_node = graph_info[Helper.node_name_from_input(bias_node_name)].node
-                if bias_node.op != "Const":
-                    continue
-
-                if mean_value.shape != (channel_count,):
-                    continue
-
-                mean_value = mean_value - Helper.values_from_const(bias_node)
-                cur_graph.remove_node(bias_node.name)
-                cur_graph.remove_node(matched_node[1])
-
-            if mean_value.shape != (channel_count,):
-                self.logger.warning(
-                    "Incorrect shape for mean, found {}, expected {}, "
-                    "for node {}.".format(str(mean_value.shape), str((channel_count,)), conv_node.name)
-                )
-                continue
-            var_node_name = Helper.node_name_from_input(bn_node.input[self.INPUT_ORDER[bn_node.op].index("var_op")])
-            var_node = graph_info[var_node_name].node
-            if var_node.op != "Const":
-                continue
-            var_value = Helper.values_from_const(var_node)
-
-            if var_value.shape != (channel_count,):
-                continue
-
-            beta_node_name = Helper.node_name_from_input(bn_node.input[self.INPUT_ORDER[bn_node.op].index("beta_op")])
-            beta_node = graph_info[beta_node_name].node
-            if beta_node.op != "Const":
-                continue
-            beta_value = Helper.values_from_const(beta_node)
-
-            if beta_value.shape != (channel_count,):
-                continue
-
-            gamma_node_name = Helper.node_name_from_input(bn_node.input[self.INPUT_ORDER[bn_node.op].index("gamma_op")])
-            gamma_node = graph_info[gamma_node_name].node
-
-            if gamma_node.op != "Const":
-                continue
-            gamma_value = Helper.values_from_const(gamma_node)
-
-            if gamma_value.shape != (channel_count,):
-                continue
-
-            variance_epsilon_value = bn_node.attr[self.EPSILON_ATTR[bn_node.op]].f
-
-            if self.scale_after_normalization(bn_node):
-                scale_value = (1.0 / np.vectorize(math.sqrt)(var_value + variance_epsilon_value)) * gamma_value
-            else:
-                scale_value = 1.0 / np.vectorize(math.sqrt)(var_value + variance_epsilon_value)
-
-            offset_value = (-mean_value * scale_value) + beta_value
-
-            if conv_node.op == "Conv2D":
-                original_shape = weights.shape
-                tmp_shape = (original_shape[-1], int(weights.size / original_shape[-1]))
-                tmp_order = [weights.ndim - 1] + [i for i in range(weights.ndim - 1)]
-                scaled_weights = np.copy(weights).transpose(tmp_order).ravel().reshape(tmp_shape)
-                reshape_scale = np.array(scale_value).reshape(len(scale_value), 1)
-                scaled_weights = np.multiply(scaled_weights, reshape_scale).transpose().reshape(original_shape)
-            elif conv_node.op == "DepthwiseConv2dNative":
-                scaled_weights = np.copy(weights)
-                it = np.nditer(scaled_weights, flags=["multi_index"], op_flags=["readwrite"])
-                channel_multiplier = weights.shape[3]
-                while not it.finished:
-                    current_scale = scale_value[it.multi_index[2] * channel_multiplier + it.multi_index[3]]
-                    it[0] *= current_scale
-                    it.iternext()
-
-            scaled_weights_node = node_def_pb2.NodeDef()
-            scaled_weights_node.op = "Const"
-            scaled_weights_node.name = weights_node_name + "_bn_offset"
-            scaled_weights_node.attr["dtype"].CopyFrom(weights_node.attr["dtype"])
-            scaled_weights_node.attr["value"].CopyFrom(
-                attr_value_pb2.AttrValue(
-                    tensor=tensor_util.make_tensor_proto(scaled_weights, weights.dtype.type, weights.shape)
-                )
-            )
-            cur_graph.replace_const_node(scaled_weights_node, [conv_node.name], weights_node_name)
-
-            offset_node = node_def_pb2.NodeDef()
-            offset_node.op = "Const"
-            offset_node.name = conv_node.name + "_bn_offset"
-            offset_node.attr["dtype"].CopyFrom(mean_node.attr["dtype"])
-            offset_node.attr["value"].CopyFrom(
-                attr_value_pb2.AttrValue(
-                    tensor=tensor_util.make_tensor_proto(offset_value, mean_value.dtype.type, offset_value.shape)
-                )
-            )
-            bias_add_node = node_def_pb2.NodeDef()
-            bias_add_node.op = "BiasAdd"
-            bias_add_node.name = bn_node.name
-            bias_add_node.attr["T"].CopyFrom(conv_node.attr["T"])
-            bias_add_node.attr["data_format"].CopyFrom(conv_node.attr["data_format"])
-            bias_add_node.input.extend([conv_node.name, offset_node.name])
-            if bn_node.op == "_FusedBatchNormEx" and bn_node.attr["activation_mode"].s == b"Relu":
-                # Create Relu op which takes Bias-Add as input.
-                #  Conv2D/Depthwise-Conv2D                         Conv2D/Depthwise-Conv2D
-                #      |                                                 |
-                #  Bias-Add (originally _FusedBatchNormEx) <---->     Bias-Add
-                #      |                                              |       \
-                #   <some-node>                                  <some-node>   Relu
-                relu_node = node_def_pb2.NodeDef()
-                relu_node.op = "Relu"
-                relu_node.name = bn_node.name + "_bn_relu"
-                relu_node.attr["T"].CopyFrom(conv_node.attr["T"])
-                relu_node.input.extend([bias_add_node.name])
-
-            cur_graph.add_node(offset_node, [], [bias_add_node.name])
-            cur_graph.add_node(
-                bias_add_node, conv_node.name, graph_info[Helper.node_name_from_input(matched_node[-1])].outputs
-            )
-            if bn_node.op == "_FusedBatchNormEx" and bn_node.attr["activation_mode"].s == b"Relu":
-                matchd_node_outputs = graph_info[Helper.node_name_from_input(matched_node[-1])].outputs
-                cur_graph.add_node(offset_node, [], [bias_add_node.name])
-                cur_graph.add_node(bias_add_node, conv_node.name, [relu_node.name])
-                cur_graph.add_node(relu_node, bias_add_node.name, matchd_node_outputs)
-            else:
-                cur_graph.add_node(offset_node, [], [bias_add_node.name])
-                cur_graph.add_node(
-                    bias_add_node, conv_node.name, graph_info[Helper.node_name_from_input(matched_node[-1])].outputs
-                )
-            cur_graph.replace_const_node(scaled_weights_node, [conv_node.name], weights_node_name)
-
-            cur_graph.remove_node(weights_node_name)
-            cur_graph.remove_node(mean_node_name)
-            cur_graph.remove_node(var_node_name)
-            cur_graph.remove_node(beta_node_name)
-            cur_graph.remove_node(gamma_node_name)
-
-        return cur_graph.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fold_constant.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fold_constant.py
deleted file mode 100644
index 575a837d469..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fold_constant.py
+++ /dev/null
@@ -1,182 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Folding Const Graph Rewriter."""
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.python.platform import tf_logging
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer, GraphRewriterHelper
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class GraphFoldConstantOptimizer(GraphRewriterBase):
-    """Folding all the sequences only consist of const and self.supported_op_type."""
-
-    supported_op_type = ["Add", "AddV2", "Const", "Mul", "Rsqrt", "Sub"]
-
-    def __init__(self, model=None):
-        """Initialization."""
-        super().__init__(model)
-        self.graph_analyzer = GraphAnalyzer()
-        self.graph_analyzer.graph = self.model
-
-        self.graph_info = self.graph_analyzer.parse_graph()
-
-    def _fold_value(self, end_node_name):
-        """Calculate values of end node of constant node sequence.
-
-        there may be layers whose inputs are all constant in the graph, like:
-          const
-                > add
-          const
-        the value of add can be calculated in advance.
-
-        Args:
-          end_node_name: name of the end node of the sequence. e.g. add in the above examples.
-
-        Returns:
-          values of end node.
-
-        Raises:
-          ValueError: If the graph contains tensors which can't be broadcast.
-        """
-        end_node = self.graph_info[end_node_name].node
-
-        def can_broadcast(s1, s2):
-            """Check whether two tensor shapes can be broadcast together."""
-            if s1.shape and s2.shape:
-                s1a = np.asarray(s1.shape)
-                s2a = np.asarray(s2.shape)
-                return ((s1a == 1) | (s2a == 1) | (s2a == s1a)).all()
-
-            return True
-
-        if self.graph_info[end_node_name].node.input:
-            if end_node.op == "Mul":
-                first_value = self._fold_value(list(end_node.input)[0])
-                first_type = first_value.dtype
-                fold_value = np.array(1.0).astype(first_type)
-                for index, input in enumerate(end_node.input):
-                    # broadcast if needed
-                    input_value = self._fold_value(input)
-                    input_type = input_value.dtype
-                    if can_broadcast(fold_value, input_value):
-                        fold_value = fold_value * input_value
-                    else:
-                        raise ValueError("input {} of node {} can't be broadcast".format(input.name, end_node.name))
-                return fold_value.astype(first_type)
-            elif end_node.op == "Add" or end_node.op == "AddV2":
-                first_value = self._fold_value(list(end_node.input)[0])
-                first_type = first_value.dtype
-                fold_value = np.array(0.0).astype(first_type).reshape(())
-                for index, input in enumerate(end_node.input):
-                    # broadcast if needed
-                    input_value = self._fold_value(input)
-                    if can_broadcast(fold_value, input_value):
-                        fold_value = fold_value + input_value
-                    else:
-                        raise ValueError("input {} of node {} can't be broadcast".format(input.name, end_node.name))
-                return fold_value.astype(first_type)
-            elif end_node.op == "Rsqrt":
-                return 1 / np.sqrt(self._fold_value(end_node.input[0]))
-            elif end_node.op == "Sub":
-                first_value = self._fold_value(list(end_node.input)[0])
-                first_type = first_value.dtype
-                fold_value = np.array(0.0, dtype=first_type)
-                for index, input in enumerate(end_node.input):
-                    # broadcast if needed
-                    input_value = self._fold_value(input)
-                    if first_type != input_value.dtype:
-                        raise ValueError(
-                            "input of node {} must be in same dtype but get {}and {}".format(
-                                input.name, first_type, input_value.dtype
-                            )
-                        )
-                    if can_broadcast(fold_value, input_value):
-                        fold_value = fold_value + (-1) ** index * input_value
-                    else:
-                        raise ValueError("input {} of node {} can't be broadcast".format(input.name, end_node.name))
-                return fold_value.astype(first_type)
-            else:
-                tf_logging.info(
-                    "Currently fold-constant only support limited ops {} but face {}".format(
-                        self.supported_op_type, end_node.op
-                    )
-                )
-        else:
-            return GraphRewriterHelper.values_from_const(end_node)
-
-    def check_all_folded(self):
-        """Check the node has been folded completely.
-
-        Returns:
-            bool: True if the node has been folded else False.
-        """
-        for node_name, _ in self.graph_info.items():
-            if self.check_const_inputs(node_name):
-                return False
-        return True
-
-    def check_const_inputs(self, node_name):
-        """Check the node has the const input.
-
-        Args:
-            node_name (string): node name
-
-        Returns:
-            bool: True if the node has the const input else False
-        """
-        if node_name not in self.graph_info:
-            return False
-        node_op = self.graph_info[node_name].node.op
-        if node_op == "Placeholder" or node_op == "Const":
-            return False
-        if node_op not in self.supported_op_type:
-            return False
-        constant_flag = True
-        for input_name in self.graph_info[node_name].node.input:
-            input_name = GraphRewriterHelper.node_name_from_input(input_name)
-            input_node = self.graph_info[input_name].node
-            constant_flag &= input_node.op == "Const" and not input_node.input
-        return constant_flag
-
-    @dump_elapsed_time("Pass GraphFoldConstantOptimizer")
-    def do_transformation(self):
-        """Fold all the sequences only consist of const and self.supported_op_type.
-
-        Args:
-          input_graph_def (graphdef): graphdef object
-
-        Returns:
-           [graphdef]: optimized graph
-        """
-        while not self.check_all_folded():
-            for node_name, _ in self.graph_info.copy().items():
-                if self.check_const_inputs(node_name):
-                    fold_value = self._fold_value(node_name)
-                    fold_type = tf.as_dtype(fold_value.dtype)
-                    new_constant_node = GraphRewriterHelper.create_constant_node(
-                        node_name + "_const", fold_value, fold_type
-                    )
-                    self.graph_analyzer.replace_constant_graph_with_constant_node(new_constant_node, node_name)
-
-        output_graph_def = self.graph_analyzer.dump_graph()
-
-        return output_graph_def
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_biasadd_add.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_biasadd_add.py
deleted file mode 100644
index e391d334cf5..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_biasadd_add.py
+++ /dev/null
@@ -1,75 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Fuse BiasAdd and Add Graph Rewriter."""
-
-import tensorflow as tf
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-
-from ..graph_base import GraphRewriterBase
-
-
-class FuseBiasAddAndAddOptimizer(GraphRewriterBase):
-    """Fuse Biasadd + Add into BiasAdd when the second input of Add is const node."""
-
-    def do_transformation(self):
-        """Fuse Biasadd + Add into BiasAdd for pattern fusion."""
-        cur_graph = GraphAnalyzer()
-        cur_graph.graph = self.model
-
-        graph_info = cur_graph.parse_graph()
-
-        target_nodes = cur_graph.query_fusion_pattern_nodes(
-            [["Conv2D", "Conv3D"], "BiasAdd", ["Add", "AddV2"], ["Relu", "Relu6", "swish_f32"], ["Mul"], ["Mul"]]
-        )
-
-        for i in target_nodes:
-            biasadd_const_name = graph_info[i[1]].node.input[1]
-            biasadd_const_node = graph_info[biasadd_const_name].node
-
-            if len(graph_info[i[1]].outputs) > 1:
-                continue
-
-            another_node_index = None
-            for index, value in enumerate(graph_info[i[2]].node.input):
-                if value != i[1]:
-                    another_node_index = index
-                    break
-            add_node_const_name = graph_info[i[2]].node.input[another_node_index]
-
-            add_const_node = graph_info[add_node_const_name].node
-
-            if add_const_node.op != "Const":
-                continue
-            value = tensor_util.MakeNdarray(biasadd_const_node.attr["value"].tensor)
-            add_value = tensor_util.MakeNdarray(add_const_node.attr["value"].tensor)
-
-            new_bias_tensor = value + add_value
-            fused_const_node = Helper.create_constant_node(i[2] + "_fused", new_bias_tensor, dtypes.float32)
-            cur_graph.remove_node(graph_info[i[1]].node.input[1])
-
-            graph_info[i[1]].node.input[1] = i[2] + "_fused"
-
-            cur_graph.remove_node(add_node_const_name)
-
-            cur_graph.remove_node(i[2])
-            graph_info[i[3]].node.input[0] = i[1]
-            cur_graph.add_node(fused_const_node, None, [i[1]])
-
-        return cur_graph.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_column_wise_mul.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_column_wise_mul.py
deleted file mode 100644
index 2fc7dbee586..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_column_wise_mul.py
+++ /dev/null
@@ -1,86 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Fuse Columnwise Mul Graph Rewriter."""
-
-from tensorflow.core.framework import attr_value_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class FuseColumnWiseMulOptimizer(GraphRewriterBase):
-    """Fuse Mul op into Conv2D/DepthwiseConv2dNative/MatMul."""
-
-    @dump_elapsed_time("Pass FuseColumnWiseMulOptimizer")
-    def do_transformation(self):
-        """Fuse Mul + Conv2D/DepthwiseConv2dNative/MatMul --> Conv2D/DepthwiseConv2dNative/MatMul."""
-        cur_graph = GraphAnalyzer()
-        cur_graph.graph = self.model
-
-        graph_info = cur_graph.parse_graph()
-        target_nodes = cur_graph.query_fusion_pattern_nodes([["Conv2D", "DepthwiseConv2dNative", "MatMul"], "Mul"])
-
-        for node_combination in target_nodes:
-            upper_node = graph_info[node_combination[0]].node
-            mul_node = graph_info[node_combination[1]].node
-            if graph_info[Helper.node_name_from_input(mul_node.input[1])].node.op != "Const":
-                continue
-            weights_node = graph_info[graph_info[node_combination[0]].node.input[1]].node
-            mul_value_node = graph_info[graph_info[node_combination[1]].node.input[1]].node
-            upper_node_type = upper_node.op
-
-            if upper_node_type == "Conv2D":
-                weights_col = weights_node.attr["value"].tensor.tensor_shape.dim[3].size
-            elif upper_node_type == "DepthwiseConv2dNative":
-                weights_col = (
-                    weights_node.attr["value"].tensor.tensor_shape.dim[2].size
-                    * weights_node.attr["value"].tensor.tensor_shape.dim[3].size
-                )
-            else:
-                weights_col = weights_node.attr["value"].tensor.tensor_shape.dim[1].size
-
-            mul_value_node_tensor = mul_value_node.attr["value"].tensor
-            weights_node_tensor = weights_node.attr["value"].tensor
-            if (
-                len(mul_value_node_tensor.tensor_shape.dim) != 1
-                or mul_value_node_tensor.tensor_shape.dim[0].size != weights_col
-            ):
-                self.logger.warning("Invalid Mul OP fusion.")
-                return self.model
-
-            mul_value_node_list = [i for i in tensor_util.MakeNdarray(mul_value_node_tensor).flat]
-            new_weights = []
-            for index, i in enumerate(tensor_util.MakeNdarray(weights_node_tensor).flat):
-                new_weights_value = i * mul_value_node_list[index % len(mul_value_node_list)]
-                new_weights.append(new_weights_value)
-
-            weights_node.attr["value"].CopyFrom(
-                attr_value_pb2.AttrValue(
-                    tensor=tensor_util.make_tensor_proto(
-                        new_weights, dtypes.float32, tensor_util.MakeNdarray(weights_node_tensor).shape
-                    )
-                )
-            )
-
-            cur_graph.remove_node_with_single_input_output(mul_node.name)
-            cur_graph.remove_node(mul_node.input[1])
-
-        return cur_graph.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_conv_with_math.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_conv_with_math.py
deleted file mode 100644
index 173a6df2525..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_conv_with_math.py
+++ /dev/null
@@ -1,111 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Fuse Conv with Math Graph Rewriter."""
-
-import numpy as np
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class FuseConvWithMathOptimizer(GraphRewriterBase):
-    """Convert below subgraph to Conv2D + BiasAdd by eliminating math ops.
-
-    Conv2D            Conv2D
-      |                  |
-      Sub                 |
-      |       ---->      |
-    RealDiv              |
-      |                  |
-      Mul                 |
-      |                  |
-    BiasAdd           BiasAdd
-    """
-
-    @dump_elapsed_time("Pass FuseConvWithMathOptimizer")
-    def do_transformation(self):
-        """Fuse Conv + Sub + RealDiv + Mul + BiasAdd to Conv + BiasAdd."""
-        g = GraphAnalyzer()
-        g.graph = self.model
-        graph_info = g.parse_graph()
-        pattern_definition = [["Conv2D"], ["Sub"], ["RealDiv"], ["Mul"], ["BiasAdd"]]
-        target_nodes = g.query_fusion_pattern_nodes(pattern_definition)
-        for i in target_nodes:
-            weights_node_name = graph_info[i[0]].node.input[1]
-            weights_node = graph_info[weights_node_name].node
-
-            sub_input_names = list(graph_info[i[1]].node.input)
-            sub_content_node_name = list(set(sub_input_names).difference([i[0]]))[0]
-            sub_content_node = graph_info[sub_content_node_name].node
-            sub_tensor = tensor_util.MakeNdarray(sub_content_node.attr["value"].tensor)
-
-            real_div_input_names = list(graph_info[i[2]].node.input)
-            real_div_content_node_name = list(set(real_div_input_names).difference([i[1]]))[0]
-            real_div_node = graph_info[real_div_content_node_name].node
-            real_div_tensor = tensor_util.MakeNdarray(real_div_node.attr["value"].tensor)
-
-            mul_input_names = list(graph_info[i[3]].node.input)
-            mul_content_node_name = list(set(mul_input_names).difference([i[2]]))[0]
-            mul_content_node = graph_info[mul_content_node_name].node
-            mul_tensor = tensor_util.MakeNdarray(mul_content_node.attr["value"].tensor)
-
-            bias_input_names = list(graph_info[i[4]].node.input)
-            bias_content_node_name = list(set(bias_input_names).difference([i[3]]))[0]
-            bias_content_node = graph_info[bias_content_node_name].node
-            bias_tensor = tensor_util.MakeNdarray(bias_content_node.attr["value"].tensor)
-
-            bias_offset_value = bias_tensor - sub_tensor * mul_tensor / real_div_tensor
-            weights_offset = mul_tensor / real_div_tensor
-
-            weights = Helper.values_from_const(weights_node)
-            original_shape = weights.shape
-            tmp_shape = (original_shape[-1], int(weights.size / original_shape[-1]))
-            tmp_order = [weights.ndim - 1] + [i for i in range(weights.ndim - 1)]
-
-            scaled_weights = np.copy(weights).transpose(tmp_order).ravel().reshape(tmp_shape)
-            reshape_scale = np.array(weights_offset).reshape(len(weights_offset), 1)
-            scaled_weights = np.multiply(scaled_weights, reshape_scale).transpose().reshape(original_shape)
-            scaled_weight_name = weights_node_name + "_conv_math_offset"
-            scaled_weights_node = Helper.create_constant_node(
-                scaled_weight_name, scaled_weights, dtypes.float32, shape=weights.shape
-            )
-
-            g.add_node(scaled_weights_node, None, [i[0]])
-            g.replace_const_node(scaled_weights_node, [i[0]], weights_node_name)
-
-            offset_node = Helper.create_constant_node(i[0] + "_biasadd_math_offset", bias_offset_value, dtypes.float32)
-            g.add_node(offset_node, None, [i[4]])
-            graph_info[i[4]].node.input[0] = i[0]
-
-            graph_info[i[4]].node.input[1] = offset_node.name
-
-            g.remove_node(i[1])
-            g.remove_node(sub_content_node_name)
-
-            g.remove_node(i[2])
-            g.remove_node(real_div_content_node_name)
-
-            g.remove_node(i[3])
-            g.remove_node(mul_content_node_name)
-
-            g.remove_node(bias_content_node_name)
-
-        return g.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_decomposed_bn.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_decomposed_bn.py
deleted file mode 100644
index c6347af00a6..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_decomposed_bn.py
+++ /dev/null
@@ -1,400 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Fuse Decomposed BatchNorm Graph Rewriter."""
-
-import collections
-import math
-import re
-
-import numpy as np
-from tensorflow.compat.v1 import graph_util
-from tensorflow.core.framework import attr_value_pb2, graph_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-from tensorflow.python.platform import flags as flags_lib
-from tensorflow.python.platform import tf_logging
-from tensorflow.python.tools import strip_unused_lib
-
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-
-class FuseDecomposedBNOptimizer:
-    """Fuse decomposed small ops to BatchNormalization."""
-
-    def __init__(self, input_graph_def):
-        """Initialization."""
-        self.input_graph_def = input_graph_def
-
-    @dump_elapsed_time("Pass FuseDecomposedBNOptimizer")
-    def do_transformation(self):
-        """Fuse individual ops in batch normalization to FusedBatchNorm.
-
-        In some models, the batch normalizatin is performed via a group of individual
-        ops instead of using single FusedBatchNorm op. This function identifies a
-        pattern of batch normalization subgraph which is made of multiple ops and
-        transforms the graph by replacing those individual ops with FusedBatchNorm op.
-        This will provide the opportunity to further fold the FusedBatchNorm with
-        convolution ops to reduce the computation steps during inference.
-        This function currently recognizes batch normalization patterns described
-        below, this could be extended if newer patterns are seen. Also, the fusion
-        is only attempted if the input graph is in NHWC format or has no format set.
-        Computation function:
-            (X * multiplier) + (Beta - Mean * multiplier)
-            where multiplier = rsqrt (Variance + Epsilon) * Gamma
-                            OR = rsqrt (Variance + Epsilon) when Gamma is 1
-        Subgraph:
-        {"Add"
-            {{"Mul"  // mul_0
-                {{"*"},  // input to apply batchnorm
-                {"Mul"  // mul_1, same op is used inside the Sub block
-                    {{"Rsqrt"
-                        {"Add"
-                            {{"Const" | "Reshape(Const)"},  // Variance
-                            {"Const"}  // Epsilon
-                            }
-                        }
-                        },  // end - Rsqrt
-                        {"Const" | "Reshape(Const)"}  // Gamma
-                    }
-                    }  // end - mul_1
-                }
-            },  // end - mul_0
-            {"Sub"
-                {{"Const" | "Reshape(Const)"},  // Beta
-                {"Mul"  // mul_3
-                    {{"Const" | "Reshape(Const)"},  // Mean
-                    {"Mul"  // same mul_1 op as in previous block
-                        {{"Rsqrt"
-                            {"Add"
-                                {{"Const" | "Reshape(Const)"},  // Variance
-                                {"Const"}  // Epsilon
-                                }
-                            }
-                        },  // end - Rsqrt
-                        {"Const" | "Reshape(Const)"}  // Gamma
-                        }
-                        }  // end - mul_1
-                    }
-                    }  // end - mul_3
-                }
-                }  // end - Sub
-            }
-        }  // end - Add
-        Subgraph pattern when gamma value is 1 and the gamma scaling Mul is skipped
-        {"Add"
-            {{"Mul"  // mul_0
-                {{"*"},  // input to apply batchnorma
-                {"Rsqrt"  // same Rsqrt op used in Sub block
-                    {"Add"
-                        {{"Const" | "Reshape(Const)"},  // Variance
-                        {"Const"}  // Epsilon
-                        }
-                    }
-                    }  // end - Rsqrt
-                }
-                },  // end - mul_0
-                {"Sub"
-                {{"Const" | "Reshape(Const)"},  // Beta
-                {"Mul"  // mul_1
-                    {{"Const" | "Reshape(Const)"},  // Mean
-                    {"Rsqrt"  // same Rsqrt op as in previous mul_0 block
-                        {"Add"
-                            {{"Const" | "Reshape(Const)"},  // Variance
-                            {"Const"}  // Epsilon
-                            }
-                        }
-                        }  // end - Rsqrt
-                    }
-                }  // end - mul_1
-                }
-                }  // end - Sub
-            }
-        }  // end - Add
-        Args:
-            input_graph_def: A GraphDef containing a model.
-
-        Returns:
-            Modified graph with individual ops that made up of batch normalization
-            fused to FusedBatchNorm.
-
-        Raises:
-            ValueError: If the graph is badly formed with duplicate node names.
-        """
-        input_node_map = {}
-        for node in self.input_graph_def.node:
-            if node.name not in input_node_map:
-                input_node_map[node.name] = node
-            else:
-                raise ValueError("Duplicate node names detected for ", node.name)
-
-        # Check format and only proceed if graph is in NHWC or has no format set.
-        data_format = None
-        for node in self.input_graph_def.node:
-            if "data_format" in node.attr.keys():
-                data_format = node.attr["data_format"]
-            if data_format is not None and data_format.s != b"NHWC":
-                tf_logging.warn("%s in %s format, not candidate for batchnorm fusion." % (node.name, data_format.s))
-                return self.input_graph_def
-            else:
-                continue
-
-        nodes_to_skip = {}
-        new_ops = []
-        for node in self.input_graph_def.node:
-            if node.op != "Add":
-                continue
-
-            # Add (Mul, Sub) or Add (Sub, Mul)
-            input0_op = node_from_map(input_node_map, node.input[0])
-            input1_op = node_from_map(input_node_map, node.input[1])
-
-            if input0_op.op == "Mul" and input1_op.op == "Sub":
-                data_scale_mul_op = input0_op
-                bias_mean_sub_op = input1_op
-            elif input0_op.op == "Sub" and input1_op.op == "Mul":
-                bias_mean_sub_op = input0_op
-                data_scale_mul_op = input1_op
-            else:
-                continue
-
-            # Mul (input, Mul)
-            input_data_op = node_from_map(input_node_map, data_scale_mul_op.input[0])
-            # Workaround for model ava-person-vehicle-detection-stage2-2_0_0
-            # FusedBatchNorm requires a 4D Tensor for input data,
-            # but the MatMul before FusedBatchNorm only support 2D output.
-            # Don't fuse the small ops to FusedBatchNorm when the upstream has MatMul.
-            if input_data_op.op == "MatMul":
-                continue
-
-            # Workaround for DIEN_Deep-Interest-Evolution-Network
-            if input_data_op.op == "ConcatV2" and input_data_op.name == "concat_8":
-                continue
-
-            if input_data_op.input:
-                ancestor_input_data_op = node_from_map(input_node_map, input_data_op.input[0])
-                if ancestor_input_data_op.op == "MatMul":
-                    continue
-
-            scale_op = node_from_map(input_node_map, data_scale_mul_op.input[1])
-
-            if scale_op.op == "Rsqrt":
-                gamma_op = None
-                gamma_reshape_op = None
-                rsqrt_op = scale_op
-            elif scale_op.op == "Mul":
-                # Mul (Rsqrt, Constant_gamma)
-                rsqrt_op = node_from_map(input_node_map, scale_op.input[0])
-                gamma_op, gamma_reshape_op = bypass_reshape(input_node_map, scale_op.input[1])
-                if rsqrt_op.op != "Rsqrt":
-                    continue
-                if gamma_op.op != "Const" or get_const_dim_count(gamma_op) != 1:
-                    continue
-            else:
-                continue
-
-            # Sub (Constant_beta, Mul)
-            beta_op, beta_reshape_op = bypass_reshape(input_node_map, bias_mean_sub_op.input[0])
-            mean_scale_mul_op = node_from_map(input_node_map, bias_mean_sub_op.input[1])
-            if mean_scale_mul_op.op != "Mul":
-                continue
-            if beta_op.op != "Const" or get_const_dim_count(beta_op) != 1:
-                continue
-
-            # Common scale applies to both input and running mean
-            if scale_op != node_from_map(input_node_map, mean_scale_mul_op.input[1]):
-                continue
-
-            mean_op, mean_reshape_op = bypass_reshape(input_node_map, mean_scale_mul_op.input[0])
-            if mean_op.op != "Const" or get_const_dim_count(mean_op) != 1:
-                continue
-
-            # Add (Constant_variance, Constant_epsilon)
-            variance_epsilon_add_op = node_from_map(input_node_map, rsqrt_op.input[0])
-            if variance_epsilon_add_op.op != "Add":
-                continue
-
-            variance_op, variance_reshape_op = bypass_reshape(input_node_map, variance_epsilon_add_op.input[0])
-            epsilon_op = node_from_map(input_node_map, variance_epsilon_add_op.input[1])
-            if epsilon_op.op != "Const" or get_const_dim_count(epsilon_op) != 0:
-                continue
-            if variance_op.op != "Const" or get_const_dim_count(variance_op) != 1:
-                continue
-
-            epsilon = values_from_const(epsilon_op)
-
-            nodes_to_skip[node.name] = True
-            nodes_to_skip[data_scale_mul_op.name] = True
-            nodes_to_skip[bias_mean_sub_op.name] = True
-            nodes_to_skip[mean_scale_mul_op.name] = True
-            nodes_to_skip[scale_op.name] = True
-            if scale_op.op != "Rsqrt":
-                nodes_to_skip[rsqrt_op.name] = True
-            nodes_to_skip[variance_epsilon_add_op.name] = True
-            if gamma_reshape_op is not None:
-                nodes_to_skip[gamma_reshape_op.name] = True
-            if beta_reshape_op is not None:
-                nodes_to_skip[beta_reshape_op.name] = True
-            if mean_reshape_op is not None:
-                nodes_to_skip[mean_reshape_op.name] = True
-            if variance_reshape_op is not None:
-                nodes_to_skip[variance_reshape_op.name] = True
-
-            if gamma_op is None:
-                gamma_op = node_def_pb2.NodeDef()
-                gamma_op.op = "Const"
-                # Assign name with same root of Rsqrt op's name plus "gamma"
-                m = re.search(r"(.*)/(.*)", scale_op.name)
-                if m:
-                    gamma_op.name = m.group(1) + "/gamma"
-                else:
-                    gamma_op.name = scale_op.name + "/gamma"
-                gamma_op.attr["dtype"].CopyFrom(beta_op.attr["dtype"])
-                beta_value = values_from_const(beta_op)
-                gamma_op.attr["value"].CopyFrom(
-                    attr_value_pb2.AttrValue(
-                        tensor=tensor_util.make_tensor_proto(
-                            1, beta_value.dtype.type, beta_value.shape, allow_broadcast=True
-                        )
-                    )
-                )
-                new_ops.append(gamma_op)
-
-            new_fused_batchnorm_op = node_def_pb2.NodeDef()
-            new_fused_batchnorm_op.op = "FusedBatchNorm"
-            new_fused_batchnorm_op.name = node.name
-            new_fused_batchnorm_op.attr["T"].CopyFrom(node.attr["T"])
-            new_fused_batchnorm_op.attr["is_training"].CopyFrom(attr_value_pb2.AttrValue(b=False))
-            new_fused_batchnorm_op.attr["epsilon"].CopyFrom(attr_value_pb2.AttrValue(f=epsilon.tolist()))
-            if data_format is not None:
-                new_fused_batchnorm_op.attr["data_format"].CopyFrom(data_format)
-            new_fused_batchnorm_op.input.extend(
-                [input_data_op.name, gamma_op.name, beta_op.name, mean_op.name, variance_op.name]
-            )
-
-            new_ops.append(new_fused_batchnorm_op)
-
-        result_graph_def = graph_pb2.GraphDef()
-        for node in self.input_graph_def.node:
-            if node.name in nodes_to_skip:
-                continue
-            new_node = node_def_pb2.NodeDef()
-            new_node.CopyFrom(node)
-            retained_input = []
-            for input_node in new_node.input:
-                if not input_node.startswith("^") or input_node[1:] not in nodes_to_skip:
-                    retained_input.append(input_node)
-            new_node.input[:] = retained_input
-            result_graph_def.node.append(new_node)
-
-        result_graph_def.node.extend(new_ops)
-        result_graph_def.versions.CopyFrom(self.input_graph_def.versions)
-        return result_graph_def
-
-
-def node_name_from_input(node_name):
-    """Strips off ports and other decorations to get the underlying node name."""
-    if node_name.startswith("^"):
-        node_name = node_name[1:]
-    m = re.search(r"(.*):\d+$", node_name)
-    if m:
-        node_name = m.group(1)
-    return node_name
-
-
-def node_from_map(node_map, name):
-    """Pulls a node def from a dictionary for a given name.
-
-    Args:
-        node_map: Dictionary containing an entry indexed by name for every node.
-        name: Identifies the node we want to find.
-
-    Returns:
-        NodeDef of the node with the given name.
-
-    Raises:
-        ValueError: If the node isn't present in the dictionary.
-    """
-    stripped_name = node_name_from_input(name)
-    if stripped_name not in node_map:
-        raise ValueError("No node named '%s' found in map." % name)
-    return node_map[stripped_name]
-
-
-def values_from_const(node_def):
-    """Extracts the values from a const NodeDef as a numpy ndarray.
-
-    Args:
-        node_def: Const NodeDef that has the values we want to access.
-
-    Returns:
-        Numpy ndarray containing the values.
-
-    Raises:
-        ValueError: If the node isn't a Const.
-    """
-    if node_def.op != "Const":
-        raise ValueError("Can not extract constant value from a node that is not Const. Got:\n" f"{node_def}")
-    input_tensor = node_def.attr["value"].tensor
-    tensor_value = tensor_util.MakeNdarray(input_tensor)
-    return tensor_value
-
-
-def valid_reshape_inputs(reshape_in0_ndef, reshape_in1_ndef):
-    """Check if the inputs of the Reshape are valid."""
-    if reshape_in0_ndef.op != "Const" or reshape_in1_ndef.op != "Const" or get_const_dim_count(reshape_in0_ndef) != 1:
-        return False
-    input0_vec_size = values_from_const(reshape_in0_ndef).shape[0]
-    const_value = values_from_const(reshape_in1_ndef)
-    shape_ndims = const_value.ndim
-    if shape_ndims != 1:
-        raise ValueError("Num of dims of the shape must be 1, got {}.".format(shape_ndims))
-    for value in const_value.tolist()[:-1]:
-        if value != 1:
-            return False
-    if const_value.tolist()[-1] != input0_vec_size:
-        return False
-    return True
-
-
-def bypass_reshape(input_node_map, input_name):
-    """Get Reshape input nodes."""
-    reshape_ndef = None
-    maybe_reshape_ndef = node_from_map(input_node_map, input_name)
-    input_ndef = maybe_reshape_ndef
-    if maybe_reshape_ndef.op == "Reshape":
-        reshpae_input0_ndef = node_from_map(input_node_map, maybe_reshape_ndef.input[0])
-        reshpae_input1_ndef = node_from_map(input_node_map, maybe_reshape_ndef.input[1])
-        if (
-            reshpae_input0_ndef.op == "Const"
-            and reshpae_input1_ndef.op == "Const"
-            and valid_reshape_inputs(reshpae_input0_ndef, reshpae_input1_ndef)
-        ):
-            input_ndef = reshpae_input0_ndef
-            reshape_ndef = maybe_reshape_ndef
-    return input_ndef, reshape_ndef
-
-
-def get_const_dim_count(node_def):
-    """Get the number of dimensions for a Const node.
-
-    Args:
-        node_def: Const NodeDef.
-
-    Returns:
-        Number of dimensions for the Const node.
-    """
-    const_value = values_from_const(node_def)
-    return const_value.ndim
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_decomposed_in.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_decomposed_in.py
deleted file mode 100644
index be15a745b5b..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_decomposed_in.py
+++ /dev/null
@@ -1,369 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Fuse Decomposed InstanceNorm Graph Rewriter."""
-
-import re
-
-from tensorflow.core.framework import attr_value_pb2, graph_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-from tensorflow.python.platform import tf_logging
-
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper as helper
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-
-class FuseDecomposedINOptimizer:  # pragma: no cover
-    """Fuse decomposed small ops into InstanceNorm."""
-
-    def __init__(self, input_graph_def):
-        """Initialization."""
-        self.input_graph_def = input_graph_def
-
-    @dump_elapsed_time("Pass FuseDecomposedINOptimizer")
-    def do_transformation(self):
-        """Find a group of ops that make up an instance/layer normalization pattern for fusion.
-
-        In some models, the instance normalizatin is performed via a group of individual
-        ops instead of using single InstanceNormalization op. This function identifies a
-        pattern of instance normalization subgraph which is made of multiple ops and
-        transforms the graph by replacing those individual ops with InstanceNormalization op.
-        This will provide the opportunity to further fold the InstanceNormalization with
-        convolution ops to reduce the computation steps during inference.
-        This function currently recognizes instance normalization patterns described
-        below, this could be extended if newer patterns are seen. Also, the fusion
-        is only attempted if the input graph is in NHWC format or has no format set.
-
-        The following pattern will be searched in the graph with additional
-        constraints. Here * means any type of op.
-        clang-format off
-                     Subgraph for fusion
-                     -------------------
-          *(input)
-           x    x x____________
-           x    x              x
-           x    x             Mean1                                      FusedOp
-           x    x            x    x                                      -------
-           x    x           x      x                           *(input)  Const  Const
-           x    x          x        x                              x    (gamma) (beta)
-           x    x         x          x                              x     x     x
-           x    x        x           x                _MklFusedInstanceNorm/_MklLayerNorm
-           x    x       x            x
-           x   SquaredDiff  Const    x
-            x      x      x          x
-             x      x    x           x
-              x     Mean0  Const     x
-               x      x    x         x
-                x  AddV2|Add         x
-                 x       x    Const  x
-                  x    Rsqrt (gamma) x
-                   x        x x      x
-                    x       Mul1     x
-                     x      x   x    x
-                      x     x    x   x
-                       x    x     x  x
-                        x   x Constx x
-                         x  x (beta)Mul2
-                          x x    x  x
-                          Mul0   Sub
-                             x   x
-                         AddV2|Add(output)
-        Args:
-            input_graph_def: A GraphDef containing a model.
-
-        Returns:
-            Modified graph with individual ops that made up of instance normalization
-            fused to InstanceNormalization.
-
-        Raises:
-            ValueError: If the graph is badly formed with duplicate node names.
-        """
-        input_node_map = {}
-        for node in self.input_graph_def.node:
-            if node.name not in input_node_map:
-                input_node_map[node.name] = node
-            else:
-                raise ValueError("Duplicate node names detected for ", node.name)
-
-        nodes_to_skip = {}
-        new_ops = []
-        for node in self.input_graph_def.node:
-            if node.op != "Add" and node.op != "AddV2":
-                continue
-
-            # Add (Mul0, Sub) or Add (Sub, Mul0)
-            input0_op = node_from_map(input_node_map, node.input[0])
-            input1_op = node_from_map(input_node_map, node.input[1])
-
-            if input0_op.op == "Mul" and input1_op.op == "Sub":
-                data_scale_mul_op = input0_op
-                bias_mean_sub_op = input1_op
-            elif input0_op.op == "Sub" and input1_op.op == "Mul":
-                bias_mean_sub_op = input0_op
-                data_scale_mul_op = input1_op
-            else:
-                continue
-
-            # Mul0 (*input, Mul1)
-            input_data_op = node_from_map(input_node_map, data_scale_mul_op.input[0])
-            scale_op = node_from_map(input_node_map, data_scale_mul_op.input[1])
-
-            # Mul1 (Rsqrt, Constant_gamma)
-            if scale_op.op == "Mul":
-                rsqrt_op = node_from_map(input_node_map, scale_op.input[0])
-                gamma_op, gamma_reshape_op = bypass_reshape(input_node_map, scale_op.input[1])
-                if rsqrt_op.op != "Rsqrt":
-                    continue
-                if gamma_op.op != "Const":
-                    continue
-            else:
-                continue
-
-            # Sub (Constant_beta, Mul2)
-            beta_op, beta_reshape_op = bypass_reshape(input_node_map, bias_mean_sub_op.input[0])
-            mean_scale_mul_op = node_from_map(input_node_map, bias_mean_sub_op.input[1])
-            if mean_scale_mul_op.op != "Mul":
-                continue
-            if beta_op.op != "Const":
-                continue
-
-            # Common scale applies to both input and running mean
-            if scale_op != node_from_map(input_node_map, mean_scale_mul_op.input[1]):
-                continue
-
-            mean_op, mean_reshape_op = bypass_reshape(input_node_map, mean_scale_mul_op.input[0])
-            if mean_op.op != "Mean":
-                continue
-
-            # Add (variance-mean0, Constant_epsilon)
-            variance_epsilon_add_op = node_from_map(input_node_map, rsqrt_op.input[0])
-            if variance_epsilon_add_op.op != "Add" and variance_epsilon_add_op.op != "AddV2":
-                continue
-
-            variance_op, variance_reshape_op = bypass_reshape(input_node_map, variance_epsilon_add_op.input[0])
-            epsilon_op = node_from_map(input_node_map, variance_epsilon_add_op.input[1])
-            if epsilon_op.op != "Const":
-                continue
-            if variance_op.op != "Mean":
-                continue
-
-            epsilon = values_from_const(epsilon_op)
-
-            # Mean (SquaredDifference, Constant_r_indices0)
-            squared_diff_op, squared_reshape_op = bypass_reshape(input_node_map, variance_op.input[0])
-            r_indices0_op = node_from_map(input_node_map, variance_op.input[1])
-            if squared_diff_op.op != "SquaredDifference":
-                continue
-            if r_indices0_op.op != "Const":
-                continue
-
-            if input_data_op != node_from_map(input_node_map, squared_diff_op.input[0]):
-                continue
-
-            if mean_op != node_from_map(input_node_map, squared_diff_op.input[1]):
-                continue
-
-            if input_data_op != node_from_map(input_node_map, mean_op.input[0]):
-                continue
-
-            r_indices1_op = node_from_map(input_node_map, mean_op.input[1])
-            if r_indices1_op.op != "Const":
-                continue
-
-            r_indices1 = values_from_const(r_indices1_op)
-            if (
-                r_indices1.tolist() != [1, 2]
-                and r_indices1.tolist() != [2, 3]
-                and r_indices1.tolist() != [1, 2, 3]
-                and r_indices1.tolist() != [2, 3, 4]
-            ):
-                continue
-
-            nodes_to_skip[node.name] = True
-            nodes_to_skip[data_scale_mul_op.name] = True
-            nodes_to_skip[bias_mean_sub_op.name] = True
-            nodes_to_skip[mean_scale_mul_op.name] = True
-            nodes_to_skip[scale_op.name] = True
-            nodes_to_skip[rsqrt_op.name] = True
-            nodes_to_skip[variance_epsilon_add_op.name] = True
-            nodes_to_skip[squared_diff_op.name] = True
-            nodes_to_skip[mean_op.name] = True
-            nodes_to_skip[variance_op.name] = True
-            if gamma_reshape_op is not None:
-                nodes_to_skip[gamma_reshape_op.name] = True
-            if beta_reshape_op is not None:
-                nodes_to_skip[beta_reshape_op.name] = True
-            if mean_reshape_op is not None:
-                nodes_to_skip[mean_reshape_op.name] = True
-            if variance_reshape_op is not None:
-                nodes_to_skip[variance_reshape_op.name] = True
-
-            if gamma_op is None:
-                gamma_op = node_def_pb2.NodeDef()
-                gamma_op.op = "Const"
-                # Assign name with same root of Rsqrt op's name plus "gamma"
-                m = re.search(r"(.*)/(.*)", scale_op.name)
-                if m:
-                    gamma_op.name = m.group(1) + "/gamma"
-                else:
-                    gamma_op.name = scale_op.name + "/gamma"
-                gamma_op.attr["dtype"].CopyFrom(beta_op.attr["dtype"])
-                beta_value = values_from_const(beta_op)
-                gamma_op.attr["value"].CopyFrom(
-                    attr_value_pb2.AttrValue(
-                        tensor=tensor_util.make_tensor_proto(
-                            1, beta_value.dtype.type, beta_value.shape, allow_broadcast=True
-                        )
-                    )
-                )
-                new_ops.append(gamma_op)
-
-            new_fused_instancenorm_op = node_def_pb2.NodeDef()
-            new_fused_instancenorm_op.op = "_MklFusedInstanceNorm"
-            new_fused_instancenorm_op.name = node.name
-            new_fused_instancenorm_op.attr["T"].CopyFrom(node.attr["T"])
-            new_fused_instancenorm_op.attr["epsilon"].CopyFrom(attr_value_pb2.AttrValue(f=epsilon.tolist()))
-            list_value = attr_value_pb2.AttrValue.ListValue(i=r_indices1.flatten())
-            new_fused_instancenorm_op.attr["reduction_axes"].CopyFrom(attr_value_pb2.AttrValue(list=list_value))
-
-            # Mean and variance values will be computed at runtime for fp32 & bf16 input.
-            # Pass a "dummy" node for mean and variance.
-            mean_variance_dim = tensor_util.MakeNdarray(gamma_op.attr["value"].tensor).shape[-1]
-            dummy_mean_node = helper.create_constant_node(
-                node.name + "_dummy_mean", [0.0] * mean_variance_dim, dtypes.float32
-            )
-            dummy_variance_node = helper.create_constant_node(
-                node.name + "_dummy_variance", [1.0] * mean_variance_dim, dtypes.float32
-            )
-            new_fused_instancenorm_op.input.extend(
-                [input_data_op.name, gamma_op.name, beta_op.name, dummy_mean_node.name, dummy_variance_node.name]
-            )
-            new_ops.append(dummy_mean_node)
-            new_ops.append(dummy_variance_node)
-            new_ops.append(new_fused_instancenorm_op)
-
-        result_graph_def = graph_pb2.GraphDef()
-        for node in self.input_graph_def.node:
-            if node.name in nodes_to_skip:
-                continue
-            new_node = node_def_pb2.NodeDef()
-            new_node.CopyFrom(node)
-            retained_input = []
-            for input_node in new_node.input:
-                if not input_node.startswith("^") or input_node[1:] not in nodes_to_skip:
-                    retained_input.append(input_node)
-            new_node.input[:] = retained_input
-            result_graph_def.node.append(new_node)
-
-        result_graph_def.node.extend(new_ops)
-        result_graph_def.versions.CopyFrom(self.input_graph_def.versions)
-        return result_graph_def
-
-
-def node_name_from_input(node_name):
-    """Strips off ports and other decorations to get the underlying node name."""
-    if node_name.startswith("^"):
-        node_name = node_name[1:]
-    m = re.search(r"(.*):\d+$", node_name)
-    if m:
-        node_name = m.group(1)
-    return node_name
-
-
-def node_from_map(node_map, name):
-    """Pulls a node def from a dictionary for a given name.
-
-    Args:
-        node_map: Dictionary containing an entry indexed by name for every node.
-        name: Identifies the node we want to find.
-
-    Returns:
-        NodeDef of the node with the given name.
-
-    Raises:
-        ValueError: If the node isn't present in the dictionary.
-    """
-    stripped_name = node_name_from_input(name)
-    if stripped_name not in node_map:
-        raise ValueError("No node named '%s' found in map." % name)
-    return node_map[stripped_name]
-
-
-def values_from_const(node_def):
-    """Extracts the values from a const NodeDef as a numpy ndarray.
-
-    Args:
-        node_def: Const NodeDef that has the values we want to access.
-
-    Returns:
-        Numpy ndarray containing the values.
-
-    Raises:
-        ValueError: If the node isn't a Const.
-    """
-    if node_def.op != "Const":
-        raise ValueError("Can not extract constant value from a node that is not Const. Got:\n" f"{node_def}")
-    input_tensor = node_def.attr["value"].tensor
-    tensor_value = tensor_util.MakeNdarray(input_tensor)
-    return tensor_value
-
-
-def valid_reshape_inputs(reshape_in0_ndef, reshape_in1_ndef):
-    """Check if the inputs of the Reshape are valid."""
-    if reshape_in0_ndef.op != "Const" or reshape_in1_ndef.op != "Const" or get_const_dim_count(reshape_in0_ndef) != 1:
-        return False
-    input0_vec_size = values_from_const(reshape_in0_ndef).shape[0]
-    const_value = values_from_const(reshape_in1_ndef)
-    shape_ndims = const_value.ndim
-    if shape_ndims != 1:
-        raise ValueError("Num of dims of the shape must be 1, got {}.".format(shape_ndims))
-    for value in const_value.tolist()[:-1]:
-        if value != 1:
-            return False
-    if const_value.tolist()[-1] != input0_vec_size:
-        return False
-    return True
-
-
-def bypass_reshape(input_node_map, input_name):
-    """Get Reshape input nodes."""
-    reshape_ndef = None
-    maybe_reshape_ndef = node_from_map(input_node_map, input_name)
-    input_ndef = maybe_reshape_ndef
-    if maybe_reshape_ndef.op == "Reshape":
-        reshpae_input0_ndef = node_from_map(input_node_map, maybe_reshape_ndef.input[0])
-        reshpae_input1_ndef = node_from_map(input_node_map, maybe_reshape_ndef.input[1])
-        if (
-            reshpae_input0_ndef.op == "Const"
-            and reshpae_input1_ndef.op == "Const"
-            and valid_reshape_inputs(reshpae_input0_ndef, reshpae_input1_ndef)
-        ):
-            input_ndef = reshpae_input0_ndef
-            reshape_ndef = maybe_reshape_ndef
-    return input_ndef, reshape_ndef
-
-
-def get_const_dim_count(node_def):
-    """Get the number of dimensions for a Const node.
-
-    Args:
-        node_def: Const NodeDef.
-
-    Returns:
-        Number of dimensions for the Const node.
-    """
-    const_value = values_from_const(node_def)
-    return const_value.ndim
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_gelu.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_gelu.py
deleted file mode 100644
index ac963c63ce9..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_gelu.py
+++ /dev/null
@@ -1,227 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Fuse small ops to Gelu Graph Rewriter."""
-
-import tensorflow as tf
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.graph_base import GraphRewriterBase
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-
-
-class FuseGeluOptimizer(GraphRewriterBase):  # pragma: no cover
-    """Fuse Sqrt + RealDiv + Erf + AddV2 + Mul + Mul into Gelu op."""
-
-    def do_transformation(self):
-        """Execute the fusion from small ops to Gelu."""
-        if tf.version.VERSION not in ("1.15.0-up2", "1.15.0-up3"):
-            return self.model
-
-        cur_graph = GraphAnalyzer()
-        cur_graph.graph = self.model
-
-        graph_info = cur_graph.parse_graph()
-        # Below code is relative to expression on
-        # https://github.com/IntelAI/models/blob/master/models/language_modeling/tensorflow/
-        # bert_large/inference/generic_ops.py#L105
-        target_nodes = cur_graph.query_fusion_pattern_nodes(
-            [["Pow"], ["Mul"], ["AddV2"], ["Mul"], ["Tanh"], ["AddV2"], ["Mul"], ["Mul"]]
-        )
-
-        if not target_nodes:
-            target_nodes = cur_graph.query_fusion_pattern_nodes(
-                [["Pow"], ["Mul"], ["AddV2"], ["Mul"], ["Tanh"], ["AddV2"], ["Mul"]]
-            )
-
-        for node_combination in target_nodes:
-            match_node_length = len(node_combination)
-            pow_node = graph_info[node_combination[0]].node
-            mul_1_node = graph_info[node_combination[1]].node
-            addv2_1_node = graph_info[node_combination[2]].node
-            mul_2_node = graph_info[node_combination[3]].node
-            tanh_node = graph_info[node_combination[4]].node
-            addv2_2_node = graph_info[node_combination[5]].node
-            if match_node_length == 8:
-                mul_3_node = graph_info[node_combination[6]].node
-            else:
-                mul_3_node = graph_info[node_combination[7]].node
-
-            gelu_input_name = None
-            pow_const_node_name = None
-            pow_value = None
-
-            for i in pow_node.input:
-                node_name = Helper.node_name_from_input(i)
-                if graph_info[node_name].node.op != "Const":
-                    gelu_input_name = i
-
-                if graph_info[node_name].node.op == "Const":
-                    pow_const_node_name = i
-                    pow_value = graph_info[node_name].node.attr["value"].tensor.float_val[0]
-                    break
-
-            if pow_value != 3:
-                continue
-            mul_1_value = None
-            mul_1_const_node_name = None
-            for i in mul_1_node.input:
-                i = Helper.node_name_from_input(i)
-                if i != pow_node.name and graph_info[i].node.op == "Const":
-                    mul_1_const_node_name = i
-                    mul_1_value = graph_info[i].node.attr["value"].tensor.float_val[0]
-                    break
-            if mul_1_value != 0.044714998453855515:
-                continue
-
-            mul_2_value = None
-            mul_2_const_node_name = None
-            for i in mul_2_node.input:
-                i = Helper.node_name_from_input(i)
-                if i != addv2_1_node.name and graph_info[i].node.op == "Const":
-                    mul_2_const_node_name = i
-                    mul_2_value = graph_info[i].node.attr["value"].tensor.float_val[0]
-                    break
-            if mul_2_value != 0.7978845834732056:
-                continue
-
-            addv2_2_value = None
-            addv2_2_const_node_name = None
-            for i in addv2_2_node.input:
-                i = Helper.node_name_from_input(i)
-                if i != tanh_node.name and graph_info[i].node.op == "Const":
-                    addv2_2_const_node_name = i
-                    addv2_2_value = graph_info[i].node.attr["value"].tensor.float_val[0]
-                    break
-            if addv2_2_value != 1:
-                continue
-
-            rest_mul_node = None
-            if match_node_length == 8:
-                for i in mul_3_node.input:
-                    i = Helper.node_name_from_input(i)
-                    if i != addv2_2_node.name:
-                        rest_mul_node = graph_info[i].node
-                        break
-
-                if not rest_mul_node or rest_mul_node.op != "Mul":
-                    continue
-            else:
-                rest_mul_node = graph_info[node_combination[6]].node
-
-            rest_mul_valid = False
-            rest_mul_const_node_name = None
-            for i in rest_mul_node.input:
-                i = Helper.node_name_from_input(i)
-                if graph_info[i].node.op == "Const" and graph_info[i].node.attr["value"].tensor.float_val[0] == 0.5:
-                    rest_mul_const_node_name = i
-                    rest_mul_valid = True
-                    break
-
-            if not rest_mul_valid:
-                continue
-
-            cur_graph.remove_node(pow_const_node_name)
-            cur_graph.remove_node(pow_node.name)
-            cur_graph.remove_node(mul_1_node.name)
-            cur_graph.remove_node(mul_1_const_node_name)
-            cur_graph.remove_node(addv2_1_node.name)
-            cur_graph.remove_node(mul_2_node.name)
-            cur_graph.remove_node(mul_2_const_node_name)
-            cur_graph.remove_node(tanh_node.name)
-            cur_graph.remove_node(addv2_2_node.name)
-            cur_graph.remove_node(addv2_2_const_node_name)
-            cur_graph.remove_node(rest_mul_node.name)
-            cur_graph.remove_node(rest_mul_const_node_name)
-
-            original_last = graph_info[mul_3_node.name].outputs
-            cur_graph.remove_node(mul_3_node.name)
-            gelu_node = Helper.create_node("Gelu", mul_3_node.name, [gelu_input_name])
-            Helper.set_attr_bool(gelu_node, "approximate", True)
-            Helper.set_attr_dtype(gelu_node, "T", dtypes.float32)
-
-            cur_graph.add_node(gelu_node, gelu_input_name, original_last)
-
-        target_nodes = cur_graph.query_fusion_pattern_nodes(
-            [["Sqrt"], ["RealDiv"], ["Erf"], ["AddV2"], ["Mul"], ["Mul"]]
-        )
-
-        for node_combination in target_nodes:
-            sqrt_node = graph_info[node_combination[0]].node
-            realdiv_node = graph_info[node_combination[1]].node
-            erf_node = graph_info[node_combination[2]].node
-            addv2_node = graph_info[node_combination[3]].node
-            mul1_node = graph_info[node_combination[4]].node
-            mul2_node = graph_info[node_combination[5]].node
-
-            sqrt_input_name = Helper.node_name_from_input(sqrt_node.input[0])
-            sqrt_value = graph_info[sqrt_input_name].node.attr["value"].tensor.float_val[0]
-
-            if sqrt_value != 2:
-                continue
-
-            addv2_value = None
-            mul1_value = None
-            gelu_input_name = None
-
-            for i in realdiv_node.input:
-                i = Helper.node_name_from_input(i)
-                if i != sqrt_node.name:
-                    gelu_input_name = i
-                    break
-
-            addv2_const_name = None
-            for i in addv2_node.input:
-                i = Helper.node_name_from_input(i)
-                if i != erf_node.name:
-                    addv2_value = graph_info[i].node.attr["value"].tensor.float_val[0]
-                    addv2_const_name = i
-                    break
-
-            if addv2_value != 1:
-                continue
-
-            mul1_const_name = None
-            for i in mul1_node.input:
-                i = Helper.node_name_from_input(i)
-                if i != addv2_node.name:
-                    mul1_value = graph_info[i].node.attr["value"].tensor.float_val[0]
-                    mul1_const_name = i
-                    break
-
-            if mul1_value != 0.5:
-                continue
-
-            cur_graph.remove_node(sqrt_node.input[0])
-            cur_graph.remove_node(sqrt_node.name)
-            cur_graph.remove_node(realdiv_node.name)
-            cur_graph.remove_node(erf_node.name)
-            cur_graph.remove_node(addv2_node.name)
-            cur_graph.remove_node(mul1_node.name)
-            cur_graph.remove_node(addv2_const_name)
-            cur_graph.remove_node(sqrt_input_name)
-            cur_graph.remove_node(mul1_const_name)
-
-            original_last = graph_info[mul2_node.name].outputs
-            cur_graph.remove_node(mul2_node.name)
-            gelu_node = Helper.create_node("Gelu", mul2_node.name, [gelu_input_name])
-            Helper.set_attr_bool(gelu_node, "approximate", False)
-            Helper.set_attr_dtype(gelu_node, "T", dtypes.float32)
-
-            cur_graph.add_node(gelu_node, gelu_input_name, original_last)
-
-        return cur_graph.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_layer_norm.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_layer_norm.py
deleted file mode 100644
index 4ad5cece7c8..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_layer_norm.py
+++ /dev/null
@@ -1,244 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Fuse small ops to LayerNorm Graph Rewriter."""
-
-import re
-
-from tensorflow.core.framework import attr_value_pb2, graph_pb2, node_def_pb2
-from tensorflow.python.framework import tensor_util
-
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-
-class FuseLayerNormOptimizer:  # pragma: no cover
-    """Remap smaller ops into fused LayerNorm.
-
-    Current fusion is only for the case, when LayerNormalization uses FusedBatcNormV3.
-    And further restrict it to only 2D or 3D tensor inputs to keras LayerNormalization api.
-    """
-
-    def __init__(self, input_graph_def):
-        """Constructor."""
-        self.input_graph_def = input_graph_def
-
-    @dump_elapsed_time("Pass FuseLayerNormOptimizer")
-    def do_transformation(self):
-        """The following pattern will be searched in the graph with additional constraints.
-
-        Here * means any type of op.
-        Subgraph:
-                *(input)  *  * Const  *  Const                       FusedOp
-                     x    |   x  |    |  x        Const              -------
-                      x   |    x |    | x  Const   x
-                      Reshape  Fill   Fill  x     x         *(input) *(gamma)  *(beta)
-                         x      x      x   x     x                x     |      x
-                          x    x      x   x     x                  x    |     x
-                     F u s e d B a t c h N o r m V 3              _MklLayerNorm
-                            x
-                             x   *
-                              x x
-                           Reshape
-                               x   *(gamma)
-                                x x
-                                Mul
-                        *(beta) x
-                           x   x
-                         AddV2(output)
-        Args:
-            input_graph_def: A GraphDef containing a model.
-
-        Returns:
-            Modified graph with individual ops that made up of layer normalization
-            fused to LayerNorm.
-
-        Raises:
-            ValueError: If the graph is badly formed with duplicate node names.
-        """
-        input_node_map = {}
-        for node in self.input_graph_def.node:
-            if node.name not in input_node_map:
-                input_node_map[node.name] = node
-            else:
-                raise ValueError("Duplicate node names detected for ", node.name)
-
-        nodes_to_skip = {}
-        new_ops = []
-        for node in self.input_graph_def.node:
-            if node.op != "AddV2":
-                continue
-
-            # AddV2 (Mul, beta) or AddV2 (beta, Mul)
-            input0_op = node_from_map(input_node_map, node.input[0])
-            input1_op = node_from_map(input_node_map, node.input[1])
-
-            if input0_op.op == "Mul":
-                data_scale_mul_op = input0_op
-                beta_op = input1_op
-            elif input1_op.op == "Mul":
-                beta_op = input0_op
-                data_scale_mul_op = input1_op
-            else:
-                continue
-
-            # Mul (Reshape, *gamma)
-            input0_op = node_from_map(input_node_map, data_scale_mul_op.input[0])
-            input1_op = node_from_map(input_node_map, data_scale_mul_op.input[1])
-            if input0_op.op == "Reshape":
-                post_reshape_op = input0_op
-                gamma_op = input1_op
-            elif input1_op.op == "Reshape":
-                post_reshape_op = input1_op
-                gamma_op = input0_op
-            else:
-                continue
-
-            # Reshape (FusedBatchNormV3, *post_shape)
-            input0_op = node_from_map(input_node_map, post_reshape_op.input[0])
-            input1_op = node_from_map(input_node_map, post_reshape_op.input[1])
-            if input0_op.op == "FusedBatchNormV3":
-                fused_batch_norm_op = input0_op
-                post_shape_op = input1_op
-            elif input1_op.op == "FusedBatchNormV3":
-                fused_batch_norm_op = input1_op
-                post_shape_op = input0_op
-            else:
-                continue
-
-            # LayerNorm uses FusedBatchNorm in training mode.
-            if fused_batch_norm_op.attr["is_training"] == attr_value_pb2.AttrValue(b=False):
-                continue
-
-            # FusedBatchNormV3(Reshape, Fill, Fill, Mean, Variance)
-            pre_reshape_op = node_from_map(input_node_map, fused_batch_norm_op.input[0])
-            if pre_reshape_op.op != "Reshape":
-                continue
-            fill_scale_op = node_from_map(input_node_map, fused_batch_norm_op.input[1])
-            if fill_scale_op.op != "Fill":
-                continue
-            fill_offset_op = node_from_map(input_node_map, fused_batch_norm_op.input[2])
-            if fill_offset_op.op != "Fill":
-                continue
-
-            # FusedBatchNorm node should have mean/variance as empty constant
-            mean_op = node_from_map(input_node_map, fused_batch_norm_op.input[3])
-            if mean_op.op != "Const":
-                continue
-            variance_op = node_from_map(input_node_map, fused_batch_norm_op.input[4])
-            if variance_op.op != "Const":
-                continue
-            mean_value = values_from_const(mean_op)
-            if mean_value.any():
-                continue
-            variance_value = values_from_const(variance_op)
-            if variance_value.any():
-                continue
-
-            # Reshape (*input, *pre_shape)
-            input_op = node_from_map(input_node_map, pre_reshape_op.input[0])
-            pre_shape_op = node_from_map(input_node_map, pre_reshape_op.input[1])
-
-            # Fill Scale(*dims_fill_scale, unit_gamma)
-            dims_fill_scale_op = node_from_map(input_node_map, fill_scale_op.input[0])
-            unit_gamma_op = node_from_map(input_node_map, fill_scale_op.input[1])
-            if unit_gamma_op.op != "Const":
-                continue
-
-            # Fill Offset(*dims_fill_scale, unit_gamma)
-            dims_fill_offset_op = node_from_map(input_node_map, fill_offset_op.input[0])
-            zero_beta_op = node_from_map(input_node_map, fill_offset_op.input[1])
-            if zero_beta_op.op != "Const":
-                continue
-
-            nodes_to_skip[node.name] = True
-            nodes_to_skip[data_scale_mul_op.name] = True
-            nodes_to_skip[post_reshape_op.name] = True
-            nodes_to_skip[fused_batch_norm_op.name] = True
-            nodes_to_skip[fill_scale_op.name] = True
-            nodes_to_skip[fill_offset_op.name] = True
-
-            new_fused_layernorm_op = node_def_pb2.NodeDef()
-            new_fused_layernorm_op.op = "_MklLayerNorm"
-            new_fused_layernorm_op.name = node.name
-            new_fused_layernorm_op.attr["T"].CopyFrom(node.attr["T"])
-            new_fused_layernorm_op.input.extend([input_op.name, gamma_op.name, beta_op.name])
-
-            new_ops.append(new_fused_layernorm_op)
-
-        result_graph_def = graph_pb2.GraphDef()
-        for node in self.input_graph_def.node:
-            if node.name in nodes_to_skip:
-                continue
-            new_node = node_def_pb2.NodeDef()
-            new_node.CopyFrom(node)
-            retained_input = []
-            for input_node in new_node.input:
-                if not input_node.startswith("^") or input_node[1:] not in nodes_to_skip:
-                    retained_input.append(input_node)
-            new_node.input[:] = retained_input
-            result_graph_def.node.append(new_node)
-
-        result_graph_def.node.extend(new_ops)
-        result_graph_def.versions.CopyFrom(self.input_graph_def.versions)
-        return result_graph_def
-
-
-def node_name_from_input(node_name):  # pragma: no cover
-    """Strips off ports and other decorations to get the underlying node name."""
-    if node_name.startswith("^"):
-        node_name = node_name[1:]
-    m = re.search(r"(.*):\d+$", node_name)
-    if m:
-        node_name = m.group(1)
-    return node_name
-
-
-def node_from_map(node_map, name):  # pragma: no cover
-    """Pulls a node def from a dictionary for a given name.
-
-    Args:
-        node_map: Dictionary containing an entry indexed by name for every node.
-        name: Identifies the node we want to find.
-
-    Returns:
-        NodeDef of the node with the given name.
-
-    Raises:
-        ValueError: If the node isn't present in the dictionary.
-    """
-    stripped_name = node_name_from_input(name)
-    if stripped_name not in node_map:
-        raise ValueError("No node named '%s' found in map." % name)
-    return node_map[stripped_name]
-
-
-def values_from_const(node_def):  # pragma: no cover
-    """Extracts the values from a const NodeDef as a numpy ndarray.
-
-    Args:
-        node_def: Const NodeDef that has the values we want to access.
-
-    Returns:
-        Numpy ndarray containing the values.
-
-    Raises:
-        ValueError: If the node isn't a Const.
-    """
-    if node_def.op != "Const":
-        raise ValueError("Can not extract constant value from a node that is not Const. Got:\n" f"{node_def}")
-    input_tensor = node_def.attr["value"].tensor
-    tensor_value = tensor_util.MakeNdarray(input_tensor)
-    return tensor_value
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_pad_with_conv.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_pad_with_conv.py
deleted file mode 100644
index e894ee8d3cb..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_pad_with_conv.py
+++ /dev/null
@@ -1,125 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Fuse Pad into Conv Graph Rewriter."""
-
-import tensorflow as tf
-from tensorflow.python.framework import tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.graph_base import GraphRewriterBase
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import version1_gt_version2
-
-
-class FusePadWithConv2DOptimizer(GraphRewriterBase):
-    """Fuse Pad op into Conv2D/DepthwiseConv2dNative/Conv3D."""
-
-    def __init__(self, model, excluded_op_names, inputs, cfg, new_api, itex_qdq_mode=False):
-        """Initialization."""
-        super().__init__(model)
-        self.excluded_conv = excluded_op_names
-        self.inputs = inputs
-        self.cfg = cfg
-        self.new_api = new_api
-        self.itex_qdq_mode = itex_qdq_mode
-
-    def do_transformation(self):
-        """Fuse Pad + Conv2D/DepthwiseConv2dNative/Conv3D --> Conv2D/DepthwiseConv2dNative/Conv3D."""
-        cur_graph = GraphAnalyzer()
-        cur_graph.graph = self.model
-
-        graph_info = cur_graph.parse_graph()
-
-        target_nodes = cur_graph.query_fusion_pattern_nodes(
-            [["Pad"], ["Conv2D", "Conv3D", "DepthwiseConv2dNative"], ("BiasAdd", "Add", "AddV2")]
-        )
-
-        padding_tensor_dict = {}
-        for node_combination in target_nodes:
-            conv_name = node_combination[1]
-
-            pattern = node_combination[-1]
-
-            if conv_name not in self.cfg:
-                continue
-
-            is_perchannel = self.cfg[conv_name][0]
-
-            # Line 55 to line 65 should be removed once the TFDO enabling the single quantized
-            # conv2D supporting.
-            if len(pattern) == 2:
-                # TODO we need to enable single quantizedconv2d with s8 input.
-                if not is_perchannel and not cur_graph.has_positive_input(conv_name):
-                    continue
-                # TFDO has the limitation that the single QuantizedConv2DPerchannel doesn't
-                # support padding_list filed.
-                if is_perchannel:
-                    continue
-
-            if conv_name in self.excluded_conv:
-                continue
-
-            padding_tensor = None
-            pad_node = None
-            if node_combination[0] not in padding_tensor_dict:
-                pad_node = graph_info[node_combination[0]].node
-                if graph_info[pad_node.input[1]].node.op != "Const":
-                    input_node = graph_info[pad_node.input[1]].node
-                    if input_node.op == "DataFormatVecPermute":
-                        parent_input_node = graph_info[input_node.input[0]].node
-                        if parent_input_node.op == "Const":
-                            padding_tensor = tensor_util.MakeNdarray(parent_input_node.attr["value"].tensor).flatten()
-                        else:
-                            continue
-                    else:
-                        continue
-                else:
-                    padding_tensor = tensor_util.MakeNdarray(
-                        graph_info[pad_node.input[1]].node.attr["value"].tensor
-                    ).flatten()
-                padding_tensor_dict[node_combination[0]] = padding_tensor
-            else:
-                padding_tensor = padding_tensor_dict[node_combination[0]]
-
-            if self.itex_qdq_mode:
-                enabled_pad_conv2d = bool(
-                    tf.version.VERSION == "1.15.0-up3" or version1_gt_version2(tf.version.VERSION, "2.7")
-                )
-            else:
-                enabled_pad_conv2d = bool(tf.version.VERSION == "1.15.0-up3" or self.new_api)
-
-            if any(padding_tensor) and not enabled_pad_conv2d:  # pragma: no cover
-                continue
-
-            if pad_node:
-                if graph_info[pad_node.input[1]].node.op != "Const":
-                    cur_graph.node_name_details[pad_node.name].node.input.remove(pad_node.input[1])
-                    cur_graph.remove_node_with_single_input_output(pad_node.name)
-                else:
-                    cur_graph.remove_node_with_single_input_output(pad_node.name)
-                    cur_graph.remove_node(pad_node.input[1])
-            conv_node = graph_info[node_combination[1]].node
-            if self.itex_qdq_mode:
-                if any(padding_tensor) and enabled_pad_conv2d:  # pragma: no cover
-                    Helper.set_attr_string(conv_node, "padding", b"EXPLICIT")
-                    Helper.set_attr_int_list(conv_node, "explicit_paddings", padding_tensor)
-            else:
-                Helper.set_attr_int_list(conv_node, "padding_list", padding_tensor)
-                if any(padding_tensor) and enabled_pad_conv2d:  # pragma: no cover
-                    Helper.set_attr_string(conv_node, "padding", b"EXPLICIT")
-
-        return cur_graph.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_pad_with_fp32_conv.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_pad_with_fp32_conv.py
deleted file mode 100644
index c3cf5a4b62c..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_pad_with_fp32_conv.py
+++ /dev/null
@@ -1,128 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Fuse Pad into Conv Graph Rewriter."""
-
-import tensorflow as tf
-from tensorflow.python.framework import tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.graph_base import GraphRewriterBase
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import version1_gt_version2
-
-
-class FusePadWithFP32Conv2DOptimizer(GraphRewriterBase):
-    """Fuse Pad op into Conv."""
-
-    def __init__(self, model, excluded_op_names, inputs, cfg, new_api, itex_qdq_mode=False):
-        """Initialization."""
-        super().__init__(model)
-        self.excluded_conv = excluded_op_names
-        self.inputs = inputs
-        self.cfg = cfg
-        self.new_api = new_api
-        self.itex_qdq_mode = itex_qdq_mode
-
-    def do_transformation(self):
-        """Fuse Pad op into Conv2D/DepthwiseConv2dNative/Conv3D."""
-        cur_graph = GraphAnalyzer()
-        cur_graph.graph = self.model
-
-        graph_info = cur_graph.parse_graph()
-
-        target_nodes = cur_graph.query_fusion_pattern_nodes(
-            [["Pad"], ["Conv2D", "DepthwiseConv2dNative"], ("BiasAdd", "Add", "AddV2")]
-        )
-
-        padding_tensor_dict = {}
-        for node_combination in target_nodes:
-            conv_name = node_combination[1]
-
-            pattern = node_combination[-1]
-
-            if conv_name not in self.cfg:
-                continue
-
-            is_perchannel = self.cfg[conv_name][0]
-
-            # Line 55 to line 65 should be removed once the TFDO enabling the single quantized
-            # conv2D supporting.
-            if len(pattern) == 2:
-                # TODO we need to enable single quantizedconv2d with s8 input.
-                if not is_perchannel and not cur_graph.has_positive_input(conv_name):
-                    continue
-                # TFDO has the limitation that the single QuantizedConv2DPerchannel doesn't
-                # support padding_list filed.
-                if is_perchannel:
-                    continue
-
-            if conv_name in self.excluded_conv:
-                continue
-
-            padding_tensor = None
-            pad_node = None
-            if node_combination[0] not in padding_tensor_dict:
-                pad_node = graph_info[node_combination[0]].node
-                if graph_info[pad_node.input[1]].node.op != "Const":
-                    input_node = graph_info[pad_node.input[1]].node
-                    if input_node.op == "DataFormatVecPermute":
-                        parent_input_node = graph_info[input_node.input[0]].node
-                        if parent_input_node.op == "Const":
-                            padding_tensor = tensor_util.MakeNdarray(parent_input_node.attr["value"].tensor).flatten()
-                        else:
-                            continue
-                    else:
-                        continue
-                else:
-                    padding_tensor = tensor_util.MakeNdarray(
-                        graph_info[pad_node.input[1]].node.attr["value"].tensor
-                    ).flatten()
-                padding_tensor_dict[node_combination[0]] = padding_tensor
-            else:
-                padding_tensor = padding_tensor_dict[node_combination[0]]
-
-            if self.itex_qdq_mode:
-                enabled_pad_conv2d = bool(
-                    tf.version.VERSION == "1.15.0-up3" or version1_gt_version2(tf.version.VERSION, "2.7")
-                )
-            else:
-                enabled_pad_conv2d = bool(tf.version.VERSION == "1.15.0-up3" or self.new_api)
-
-            if any(padding_tensor) and not enabled_pad_conv2d:  # pragma: no cover
-                continue
-
-            if pad_node:
-                if graph_info[pad_node.input[1]].node.op != "Const":
-                    cur_graph.node_name_details[pad_node.name].node.input.remove(pad_node.input[1])
-                    cur_graph.remove_node_with_single_input_output(pad_node.name)
-                else:
-                    cur_graph.remove_node_with_single_input_output(pad_node.name)
-                    cur_graph.remove_node(pad_node.input[1])
-            conv_node = graph_info[node_combination[1]].node
-            # Helper.set_attr_int_list(conv_node, "padding_list", padding_tensor)
-            # only when padding attr is explicit, the explicit_paddings is not empty
-
-            if self.itex_qdq_mode:
-                if any(padding_tensor) and enabled_pad_conv2d:  # pragma: no cover
-                    Helper.set_attr_string(conv_node, "padding", b"EXPLICIT")
-                    Helper.set_attr_int_list(conv_node, "explicit_paddings", padding_tensor)
-            else:
-                if any(padding_tensor) and enabled_pad_conv2d:  # pragma: no cover
-                    Helper.set_attr_string(conv_node, "padding", b"EXPLICIT")
-                    Helper.set_attr_int_list(conv_node, "explicit_paddings", padding_tensor)
-
-        return cur_graph.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_reshape_transpose.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_reshape_transpose.py
deleted file mode 100644
index 85ef97f8628..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/fuse_reshape_transpose.py
+++ /dev/null
@@ -1,126 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Fuse Transpose and Reshape Graph Rewriter."""
-
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class FuseTransposeReshapeOptimizer(GraphRewriterBase):
-    """Fuse Transpose + Reshape + MatMul/Conv ==> MatMul/Conv."""
-
-    @dump_elapsed_time("Pass FuseTransposeReshapeOptimizer")
-    def do_transformation(self):
-        """Execute Transpose + Reshape + MatMul/Conv fusion."""
-        g = GraphAnalyzer()
-        g.graph = self.model
-        graph_info = g.parse_graph()
-
-        patterns = [
-            ["Transpose"],
-            ["Reshape"],
-            ["MatMul", "DepthwiseConv2dNative", "Conv2D", "BatchMatMul", "BatchMatMulV2"],
-        ]
-
-        matched_nodes = g.query_fusion_pattern_nodes(patterns)
-
-        valid_match = []
-        for i in matched_nodes:
-            transpose_input_node_name = graph_info[i[0]].node.input[0]
-            transpose_input_node = graph_info[transpose_input_node_name].node
-            if transpose_input_node.op == "Const":
-                valid_match.append(i)
-            elif transpose_input_node.op == "Enter":
-                if transpose_input_node.input:
-                    enter_input_node_name = transpose_input_node.input[0]
-                    enter_input_node = graph_info[enter_input_node_name].node
-                    if enter_input_node.op == "Const":
-                        valid_match.append(i)
-            else:
-                continue
-
-        for i in valid_match:
-            transpose_node = graph_info[i[0]].node
-            transpose_input_node = graph_info[transpose_node.input[0]].node
-            transpose_input_perm = graph_info[transpose_node.input[1]].node
-            reshape_node = graph_info[i[1]].node
-            reshape_shape_node = graph_info[reshape_node.input[1]].node
-            if transpose_input_node.op == "Const":
-                transpose_input_node_content = tensor_util.MakeNdarray(transpose_input_node.attr["value"].tensor)
-            elif transpose_input_node.op == "Enter":
-                enter_input_node_name = transpose_input_node.input[0]
-                enter_input_node = graph_info[enter_input_node_name].node
-                transpose_input_node_content = tensor_util.MakeNdarray(enter_input_node.attr["value"].tensor)
-            else:
-                continue
-
-            if transpose_input_perm.op == "Const":
-                transpose_perm_node_content = tensor_util.MakeNdarray(transpose_input_perm.attr["value"].tensor)
-            elif transpose_input_perm.op == "Enter":
-                enter_transpose_input_perm = transpose_input_perm.input[0]
-                enter_transpose_input_perm_node = graph_info[enter_transpose_input_perm].node
-                transpose_perm_node_content = tensor_util.MakeNdarray(
-                    enter_transpose_input_perm_node.attr["value"].tensor
-                )
-            else:
-                continue
-
-            if reshape_shape_node.op == "Const":
-                reshape_shape_node_content = tensor_util.MakeNdarray(reshape_shape_node.attr["value"].tensor)
-            elif reshape_shape_node.op == "Enter":
-                enter_reshape_shape = reshape_shape_node.input[0]
-                enter_reshape_shape_node = graph_info[enter_reshape_shape].node
-                reshape_shape_node_content = tensor_util.MakeNdarray(enter_reshape_shape_node.attr["value"].tensor)
-            else:
-                continue
-
-            converted_node = transpose_input_node_content.transpose(transpose_perm_node_content).reshape(
-                reshape_shape_node_content
-            )
-            g.remove_node(i[0])
-            if transpose_input_node.op == "Const":
-                g.remove_node(transpose_input_node.name)
-                g.remove_node(transpose_input_perm.name)
-                new_node_name = transpose_input_node.name + "_converted"
-                new_node = Helper.create_constant_node(
-                    new_node_name, converted_node, dtype=dtypes.float32, shape=converted_node.shape
-                )
-                g.replace_const_node(new_node, [i[2]], i[1])
-                g.remove_node(i[1])
-                g.remove_node(reshape_shape_node.name)
-            else:
-                g.remove_node(enter_input_node.name)
-                g.remove_node(transpose_input_perm.name)
-                new_node_name = enter_input_node.name + "_converted"
-
-                new_node = Helper.create_constant_node(
-                    new_node_name, converted_node, dtype=dtypes.float32, shape=converted_node.shape
-                )
-                g.add_node(new_node, [], [transpose_input_node.name])
-                transpose_input_node.input[0] = new_node.name
-                for index, node_name in enumerate(graph_info[i[2]].node.input):
-                    if node_name == i[1]:
-                        graph_info[i[2]].node.input[index] = transpose_input_node.name
-                g.remove_node(i[1])
-                g.remove_node(reshape_shape_node.name)
-
-        return g.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/graph_cse_optimizer.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/graph_cse_optimizer.py
deleted file mode 100644
index b706e5cce5d..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/graph_cse_optimizer.py
+++ /dev/null
@@ -1,145 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""CSE Graph Rewriter."""
-
-from tensorflow.core.framework import graph_pb2
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class GraphCseOptimizer(GraphRewriterBase):
-    """We introduce the CSE optimizer to optimize the nodes that contains identical op type.
-
-    Case 1. Node A has three output nodes(B,C,D) and those child nodes has their own outputs
-            (B1/C1C2/D1).
-            Node A
-            x    x    x
-            x    x     x
-    NODE B   NODE C  NODE D
-    x        x   x     x
-    B1       C1  C2    D1
-    If Node B/C/D have the identical memory-bound op, like relu/relu6. The graph will be
-    converted as below.
-    We removed the Node C & Node D, updated the B as the input of C1/C2/D1.
-            Node A
-            x
-            Node B
-            x x  x  x
-            x  x   x  x
-        x   x    x  x
-        B1  C1   C2  D1
-    Case 2.  Node A has three output nodes(B,C,D) and those child nodes has their own outputs
-            (B1/C1C2/D1).
-            Node A
-            x   x    x
-            x    x     x
-    NODE B   NODE C  NODE D
-        x      x   x     x
-        B1     C1  C2    D1
-    If Node B and C have the identical memory-bound op, like relu/relu6. The graph will be
-    converted as below.
-    We removed the Node C, updated the B as the input of C1/C2.
-                Node A
-                x     x
-            Node B  Node D
-            x   x  x    x
-            x   |   x    x
-            x   |    x    x
-            B1   C1    C2   D1
-
-    Returns:
-        [graphdef]: A optimized graphdef object.
-    """
-
-    computational_op_type = ("Conv2D", "Conv3D", "DepthwiseConv2dNative", "MatMul")
-
-    @dump_elapsed_time("Pass GraphCseOptimizer")
-    def do_transformation(self):
-        """Optimize the graph contains multi output nodes.
-
-        If those nodes' type are identical, those nodes should be elimated.
-        Currently, we supported memory bound ops only.
-
-        Args:
-            input_graph_def (graphdef): graphdef object
-
-        Returns:
-            [graphdef]: optimized graph
-        """
-        GraphAnalyzer().graph = self.model
-
-        graph_info = GraphAnalyzer().parse_graph()
-
-        need_to_update_node = []
-        # TODO Enhance below code snippet by using recursive method.
-        for _, i in graph_info.items():
-            candidate_node = [
-                graph_info[child_name].node
-                for child_name in i.outputs
-                if graph_info[child_name].node.op not in self.computational_op_type
-            ]
-            candidate_node_unique_type = set([i.op for i in candidate_node])
-            if len(candidate_node_unique_type) == len(candidate_node):
-                # it means each sub node has their own type.
-                continue
-            node_type_name_mapping = {}
-            # Created dict which key is op type and value is node has identical op type.
-            for each_node in candidate_node:
-                node_type = each_node.op
-                node_name = each_node.name
-                if node_type not in node_type_name_mapping:
-                    node_type_name_mapping[node_type] = [node_name]
-                else:
-                    node_type_name_mapping[node_type].append(node_name)
-
-            for _, node_names in node_type_name_mapping.items():
-                # ignore unique op type and node with multi-outputs
-                if len(node_names) == 1 or len(graph_info[node_names[0]].outputs) > 1:
-                    continue
-                # TODO Need to enhance below algorithm before golden.
-                filter_node = [node_names[0]]
-                for sub_node_name in node_names[1:]:
-                    if not Helper.compare_node_attr(graph_info[node_names[0]].node, graph_info[sub_node_name].node):
-                        continue
-                    filter_node.append(sub_node_name)
-
-                need_to_update_node.append({i.node.name: filter_node})
-
-        for node_pair in need_to_update_node:
-            for upper_node_name, lower_node_name in node_pair.items():
-                keep_sub_node_name = lower_node_name[0]
-                for removeable_node_name in lower_node_name[1:]:
-                    graph_info[upper_node_name].outputs.remove(removeable_node_name)
-                    for grand_child_node_name in graph_info[removeable_node_name].outputs:
-                        filter_input_name = [
-                            Helper.node_name_from_input(i) for i in graph_info[grand_child_node_name].node.input
-                        ]
-                        replace_index = filter_input_name.index(removeable_node_name)
-                        graph_info[grand_child_node_name].node.input[replace_index] = keep_sub_node_name
-                        graph_info[grand_child_node_name].node.input[replace_index] = keep_sub_node_name
-                    graph_info.pop(removeable_node_name)
-
-        output_graph_def = graph_pb2.GraphDef()
-
-        for _, node_info in graph_info.items():
-            output_graph_def.node.extend([node_info.node])
-
-        return output_graph_def
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/grappler_pass.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/grappler_pass.py
deleted file mode 100644
index aee3790f0ba..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/grappler_pass.py
+++ /dev/null
@@ -1,69 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Tensorflow Grappler Graph Rewriter."""
-
-import tensorflow as tf
-from tensorflow.core.protobuf import config_pb2, meta_graph_pb2
-from tensorflow.python.grappler import tf_optimizer
-from tensorflow.python.training import saver
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.graph_base import GraphRewriterBase
-from neural_compressor.tensorflow.utils import dump_elapsed_time, version1_gt_version2
-
-
-class GrapplerOptimizer(GraphRewriterBase):
-    """A python wrapper that leverages the built-in tensorflow grappler API to optimize the graph."""
-
-    def __init__(self, model, input_output_names, opt_cfg):
-        """Initialization."""
-        super().__init__(model)
-        self.input_output_names = input_output_names
-        self.opt_cfg = opt_cfg
-        self.generic_optimizer = ("pruning", "shape", "dependency", "debug_stripper", "loop")
-        self.tf_2_optimizer = ("constfold", "arithmetic", "min_graph_nodes")
-
-    @dump_elapsed_time("Pass GrapplerOptimizer")
-    def do_transformation(self):
-        """Apply tensorflow Grappler optimization."""
-        try:
-            g = tf.Graph()
-            with g.as_default():
-                g = tf.compat.v1.import_graph_def(self.model, name="")
-                meta_graph = saver.export_meta_graph(graph_def=self.model, graph=g, clear_devices=True)
-                fetch_collection = meta_graph_pb2.CollectionDef()
-                for fetch in self.input_output_names:
-                    fetch_collection.node_list.value.append(fetch)
-                meta_graph.collection_def["train_op"].CopyFrom(fetch_collection)
-                config = config_pb2.ConfigProto()
-                rewriter_config = config.graph_options.rewrite_options
-                for optimizer in self.generic_optimizer:
-                    if optimizer in self.opt_cfg and self.opt_cfg[optimizer]:
-                        rewriter_config.optimizers.append(optimizer)
-
-                if version1_gt_version2(tf.version.VERSION, "2.2.0"):
-                    for optimizer in self.tf_2_optimizer:
-                        if optimizer in self.opt_cfg and self.opt_cfg[optimizer]:
-                            rewriter_config.optimizers.append(optimizer)
-
-                rewriter_config.min_graph_nodes = -1
-
-                optimized_graph = tf_optimizer.OptimizeGraph(config, meta_graph)
-
-            return optimized_graph
-        except Exception as e:
-            self.logger.warning("Fail to run grappler pass due to {}.".format(str(e)))
-            return self.model
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/insert_print_node.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/insert_print_node.py
deleted file mode 100644
index a60fbb701e3..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/insert_print_node.py
+++ /dev/null
@@ -1,223 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Insert print node Graph Rewriter."""
-
-import tensorflow as tf
-from tensorflow.core.framework import attr_value_pb2
-from tensorflow.python.framework import dtypes
-from tensorflow.python.framework import tensor_util as tu
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.graph_base import GraphRewriterBase
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import version1_gt_version2
-
-
-class InsertPrintMinMaxNode(GraphRewriterBase):
-    """InsertPrintMinMaxNode Pass for tensorflow sampling."""
-
-    def __init__(self, model, pre_node_name, post_node_name, new_api):
-        """Initialization."""
-        super().__init__(model)
-        self.pre_node_name = pre_node_name
-        self.post_node_name = post_node_name
-        self.signature = pre_node_name + post_node_name
-        self.new_api = new_api
-
-    def do_transformation(self):
-        """Insert print node in the graph to do the calibration."""
-        cur_graph = GraphAnalyzer()
-        cur_graph.graph = self.model
-
-        graph_info = cur_graph.parse_graph()
-        insert_node_pairs = []
-        top_node = graph_info[self.pre_node_name].node
-        if top_node.op == "ConcatV2":
-            for i in range(top_node.attr["N"].i):
-                insert_node_pairs.append([top_node.input[i], self.post_node_name])
-        elif top_node.op in ("BatchMatMul", "BatchMatMulV2"):
-            insert_node_pairs.append([top_node.input[0], self.post_node_name])
-            if graph_info[top_node.input[1]].node.op != "Const":
-                insert_node_pairs.append([top_node.input[1], self.post_node_name])
-        elif top_node.op in ("Conv2DBackpropInput", "Conv3DBackpropInputV2"):
-            insert_node_pairs.append([top_node.input[2], self.post_node_name])
-        else:
-            refresh_pre_node_name = graph_info[self.pre_node_name].node.input[0]
-            # Check the Conv2D could be fused with previous Pad or not.
-            # If so, we need to update the pre-node name correspondingly.
-            refresh_pre_node = graph_info[Helper.node_name_from_input(refresh_pre_node_name)].node
-            if refresh_pre_node.op == "Pad" and top_node.op in ("Conv2D", "Conv3D"):
-                pad_const_node_name = refresh_pre_node.input[1]
-                pad_const_node = graph_info[pad_const_node_name].node
-                padding_tensor = None
-                if graph_info[pad_const_node_name].node.op != "Const":
-                    if pad_const_node.op == "DataFormatVecPermute":
-                        parent_input_node = graph_info[pad_const_node.input[0]].node
-                        if parent_input_node.op == "Const":
-                            padding_tensor = tu.MakeNdarray(parent_input_node.attr["value"].tensor).flatten()
-                else:
-                    padding_tensor = tu.MakeNdarray(pad_const_node.attr["value"].tensor).flatten()
-                if not any(padding_tensor) or (
-                    any(padding_tensor) and (tf.version.VERSION == "1.15.0-up3" or self.new_api)
-                ):
-                    insert_node_pairs.append([refresh_pre_node_name, self.post_node_name])
-                    refresh_pre_node_name = refresh_pre_node.input[0]
-
-            insert_node_pairs.append([refresh_pre_node_name, self.post_node_name])
-
-        output_names = []
-        for node_pair_names in insert_node_pairs:
-            for index, each_node_name in enumerate(node_pair_names):
-                name_with_sig = each_node_name + self.signature
-                node_name_prefix = name_with_sig.replace(":", "__port__").replace("^", "__hat__")
-                reshape_dims_name = node_name_prefix + "_reshape_dims"
-                reduction_dims_name = node_name_prefix + "_reduction_dims"
-
-                reshape_dims_node = Helper.create_constant_node(reshape_dims_name, -1, dtypes.int32, [1])
-
-                reduction_dims_node = Helper.create_constant_node(reduction_dims_name, 0, dtypes.int32, [1])
-
-                # the training input QueueDequeueManyV2 has issue with implicit dependency
-                # skip the input node of show_and_tell model
-                if not (
-                    Helper.node_name_from_input(each_node_name) == "batch_and_pad"
-                    and graph_info[Helper.node_name_from_input(each_node_name)].node.op == "QueueDequeueManyV2"
-                ):
-                    reshape_dims_node.input.append("^" + Helper.node_name_from_input(each_node_name))
-                    reduction_dims_node.input.append("^" + Helper.node_name_from_input(each_node_name))
-
-                reshape_input_name = node_name_prefix + "_reshape_"
-
-                reshape_input_node = Helper.create_node(
-                    "Reshape", reshape_input_name, [each_node_name, reshape_dims_name]
-                )
-
-                min_input_name = node_name_prefix + "_min"
-                min_input_node = Helper.create_node("Min", min_input_name, [reshape_input_name, reduction_dims_name])
-                Helper.set_attr_dtype(min_input_node, "Tidx", dtypes.int32)
-                Helper.set_attr_bool(min_input_node, "keep_dims", False)
-
-                max_input_name = node_name_prefix + "_max"
-                max_input_node = Helper.create_node("Max", max_input_name, [reshape_input_name, reduction_dims_name])
-                Helper.set_attr_dtype(max_input_node, "Tidx", dtypes.int32)
-                Helper.set_attr_bool(max_input_node, "keep_dims", False)
-
-                max_print_node = Helper.create_node(
-                    "Print",
-                    node_name_prefix + "_print_max__{}".format(index),
-                    [max_input_name + ":0", max_input_name + ":0"],
-                )
-                min_print_node = Helper.create_node(
-                    "Print",
-                    node_name_prefix + "_print_min__{}".format(index),
-                    [min_input_name + ":0", min_input_name + ":0"],
-                )
-
-                if index == 0:
-                    max_msg = ";{}_eightbit_max_{}__print__;__max:".format(self.pre_node_name, each_node_name)
-                    min_msg = ";{}_eightbit_min_{}__print__;__min:".format(self.pre_node_name, each_node_name)
-                    # workaround for swish_f32, attribute T is not in the op definition
-                    if "swish_f32" in graph_info[self.pre_node_name].node.name:
-                        src_dt = attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum)
-                    else:
-                        src_dt = graph_info[self.pre_node_name].node.attr["T"]
-                else:
-                    max_msg = ";{}_eightbit_requant_range__print__;__requant_max:".format(self.pre_node_name)
-                    min_msg = ";{}_eightbit_requant_range__print__;__requant_min:".format(self.pre_node_name)
-                    # workaround for swish_f32, attribute T is not in the op definition
-                    if "swish_f32" in graph_info[each_node_name].node.op:
-                        src_dt = attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum)
-                    else:
-                        src_dt = graph_info[each_node_name].node.attr["T"]
-
-                reshape_input_node.attr["T"].CopyFrom(src_dt)
-                min_input_node.attr["T"].CopyFrom(src_dt)
-                min_print_node.attr["T"].CopyFrom(src_dt)
-                max_input_node.attr["T"].CopyFrom(src_dt)
-                max_print_node.attr["T"].CopyFrom(src_dt)
-
-                min_print_node.attr["message"].s = min_msg.encode()
-                min_print_node.attr["first_n"].i = -1
-                min_print_node.attr["summarize"].i = 1024
-
-                max_print_node.attr["message"].s = max_msg.encode()
-                max_print_node.attr["first_n"].i = -1
-                max_print_node.attr["summarize"].i = 1024
-
-                attr_u = [dtypes.as_dtype(src_dt.type).as_datatype_enum]
-                min_print_node.attr["U"].list.CopyFrom(attr_value_pb2.AttrValue.ListValue(type=attr_u))
-                max_print_node.attr["U"].list.CopyFrom(attr_value_pb2.AttrValue.ListValue(type=attr_u))
-                post_node_names = graph_info[Helper.node_name_from_input(each_node_name)].outputs
-                if post_node_names:
-                    for post_node_name in post_node_names:
-                        post_node = graph_info[post_node_name].node
-                        if each_node_name not in post_node.input:
-                            continue
-                        if (
-                            post_node.op == "FusedBatchNormV3"
-                            and "_print_identity"
-                            not in graph_info[Helper.node_name_from_input(post_node.name)].node.input[0]
-                        ):
-                            identity_node = Helper.create_node(
-                                "Identity",
-                                post_node.name + "_print_identity",
-                                [graph_info[Helper.node_name_from_input(post_node.name)].node.input[0]],
-                            )
-                            identity_node.attr["T"].CopyFrom(src_dt)
-                            cur_graph.add_node(
-                                identity_node,
-                                graph_info[Helper.node_name_from_input(post_node.name)].node.input[0],
-                                [post_node.name],
-                            )
-                            identity_node.input.append("^" + min_print_node.name)
-                            identity_node.input.append("^" + max_print_node.name)
-                        else:
-                            post_node.input.append("^" + min_print_node.name)
-                            post_node.input.append("^" + max_print_node.name)
-
-                    cur_graph.add_node(reshape_dims_node, None, [reshape_input_name])
-                    cur_graph.add_node(reduction_dims_node, None, [max_input_name, min_input_name])
-                    cur_graph.add_node(reshape_input_node, each_node_name, [max_input_name, min_input_name])
-                    cur_graph.add_node(max_input_node, reshape_input_name, [max_print_node.name])
-                    cur_graph.add_node(min_input_node, reshape_input_name, [min_print_node.name])
-
-                    cur_graph.add_node(min_print_node, min_input_name, [])
-                    cur_graph.add_node(max_print_node, max_input_name, [])
-                else:
-                    identity_node0 = Helper.create_node(
-                        "Identity", min_print_node.name + "_identity", [min_print_node.name]
-                    )
-                    identity_node0.attr["T"].CopyFrom(src_dt)
-                    identity_node1 = Helper.create_node(
-                        "Identity", max_print_node.name + "_identity", [max_print_node.name]
-                    )
-                    identity_node1.attr["T"].CopyFrom(src_dt)
-
-                    cur_graph.add_node(reshape_dims_node, None, [reshape_input_name])
-                    cur_graph.add_node(reduction_dims_node, None, [max_input_name, min_input_name])
-                    cur_graph.add_node(reshape_input_node, each_node_name, [max_input_name, min_input_name])
-                    cur_graph.add_node(max_input_node, reshape_input_name, [max_print_node.name])
-                    cur_graph.add_node(min_input_node, reshape_input_name, [min_print_node.name])
-                    cur_graph.add_node(min_print_node, min_input_name, [identity_node0.name])
-                    cur_graph.add_node(max_print_node, max_input_name, [identity_node1.name])
-                    cur_graph.add_node(identity_node0, min_print_node.name, [])
-                    cur_graph.add_node(identity_node1, max_print_node.name, [])
-                    # identity_node0.input.append("^" + min_print_node.name)
-                    # identity_node1.input.append("^" + max_print_node.name)
-                    output_names.append(identity_node0.name)
-                    output_names.append(identity_node1.name)
-        return cur_graph.dump_graph(), output_names
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/move_squeeze_after_relu.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/move_squeeze_after_relu.py
deleted file mode 100644
index 6b072617202..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/move_squeeze_after_relu.py
+++ /dev/null
@@ -1,123 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Move Squeeze after Relu Graph Rewriter."""
-
-import copy
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class MoveSqueezeAfterReluOptimizer(GraphRewriterBase):
-    """Move Squeeze op after Relu op for match fusion pattern."""
-
-    def __init__(self, model):
-        """Initialization."""
-        super().__init__(model)
-        self.op_list = ["Relu", "Sigmoid", "Relu6", "LeakyRelu", "Elu"]
-
-    @dump_elapsed_time("Pass MoveSqueezeAfterReluOptimizer")
-    def do_transformation(self):
-        """Move Squeeze/Reshape after Relu."""
-        g = GraphAnalyzer()
-        g.graph = self.model
-        graph_info = g.parse_graph()
-        # For pattern Conv + Squeeze + BiasAdd + Relu(Sigmoid, Relu6, LeakyRelu, Elu)
-        for node in self.model.node:
-            if (
-                node.op in self.op_list
-                and node.input[0] in graph_info
-                and graph_info[node.input[0]].node.op == "BiasAdd"
-            ):
-                biasadd_node = graph_info[node.input[0]].node
-                biasadd_input = graph_info[biasadd_node.name].node.input[0]
-                squeeze_node = graph_info[biasadd_input].node
-                relu_output = graph_info[node.name].outputs
-                if squeeze_node.op == "Squeeze":
-                    # biasadd
-                    for i, input in enumerate(biasadd_node.input):
-                        if input == biasadd_input:
-                            new_input = biasadd_node.input[:i] + [squeeze_node.input[0]] + biasadd_node.input[i + 1 :]
-                            graph_info[biasadd_node.name].node.ClearField("input")
-                            graph_info[biasadd_node.name].node.input.extend(new_input)
-                            graph_info[squeeze_node.name].outputs.remove(biasadd_node.name)
-                    # conv output
-                    conv = squeeze_node.input[0]
-                    conv_outputs = graph_info[conv].outputs
-                    for i, output in enumerate(conv_outputs):
-                        if output == squeeze_node.name:
-                            graph_info[conv].outputs.remove(squeeze_node.name)
-                            graph_info[conv].outputs.append(biasadd_node.name)
-                    # squeeze input
-                    squeeze_node.ClearField("input")
-                    squeeze_node.input.extend([node.name])
-                    # expand input,squeeze output
-                    for output in relu_output:
-                        for i, input in enumerate(graph_info[output].node.input):
-                            if input == node.name:
-                                new_input = (
-                                    graph_info[output].node.input[:i]
-                                    + [squeeze_node.name]
-                                    + graph_info[output].node.input[i + 1 :]
-                                )
-                                graph_info[squeeze_node.name].outputs.append(output)
-                                graph_info[output].node.ClearField("input")
-                                graph_info[output].node.input.extend(new_input)
-
-            # For pattern x + Reshape + Relu(Sigmoid, Relu6, LeakyRelu, Elu)
-            if (
-                node.op in self.op_list
-                and node.input[0] in graph_info
-                and graph_info[node.input[0]].node.op == "Reshape"
-            ):
-                reshape_node = graph_info[node.input[0]].node
-                reshape_input = graph_info[reshape_node.name].node.input[0]
-                x_node = graph_info[reshape_input].node
-                relu_output = copy.deepcopy(graph_info[node.name].outputs)
-
-                if len(graph_info[x_node.name].outputs) != 1:
-                    continue
-                if len(graph_info[reshape_node.name].outputs) > 1:
-                    continue
-                # relu---->reshape
-                for i, input in enumerate(reshape_node.input):
-                    if input == reshape_input:
-                        new_input = reshape_node.input[:i] + [node.name] + reshape_node.input[i + 1 :]
-                        graph_info[reshape_node.name].node.ClearField("input")
-                        graph_info[reshape_node.name].node.input.extend(new_input)
-                        graph_info[x_node.name].outputs.remove(reshape_node.name)
-                        graph_info[x_node.name].outputs.append(node.name)
-                # x----->relu
-                node.ClearField("input")
-                node.input.extend([reshape_input])
-                # expand input,squeeze output
-                for output in relu_output:
-                    for i, input in enumerate(graph_info[output].node.input):
-                        if input == node.name:
-                            new_input = (
-                                graph_info[output].node.input[:i]
-                                + [reshape_node.name]
-                                + graph_info[output].node.input[i + 1 :]
-                            )
-                            graph_info[reshape_node.name].outputs.append(output)
-                            graph_info[output].node.ClearField("input")
-                            graph_info[output].node.input.extend(new_input)
-                            graph_info[node.name].outputs.remove(output)
-                            graph_info[node.name].outputs.append(reshape_node.name)
-        return g.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/pre_optimize.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/pre_optimize.py
deleted file mode 100644
index beac92c1b8d..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/pre_optimize.py
+++ /dev/null
@@ -1,310 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Pre Optimization Entrance."""
-
-import copy
-import logging
-
-import tensorflow as tf
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.utils import (
-    dump_elapsed_time,
-    version1_eq_version2,
-    version1_gte_version2,
-    version1_lt_version2,
-)
-
-from .convert_add_to_biasadd import ConvertAddToBiasAddOptimizer
-from .convert_layout import ConvertLayoutOptimizer
-from .convert_leakyrelu import ConvertLeakyReluOptimizer
-from .convert_nan_to_random import ConvertNanToRandom
-from .convert_placeholder_to_const import ConvertPlaceholderToConst
-from .dilated_contraction import DilatedContraction
-from .dummy_biasadd import InjectDummyBiasAddOptimizer
-from .expanddims_optimizer import ExpandDimsOptimizer
-from .fetch_weight_from_reshape import FetchWeightFromReshapeOptimizer
-from .fold_batch_norm import FoldBatchNormNodesOptimizer
-from .fold_constant import GraphFoldConstantOptimizer
-from .fuse_biasadd_add import FuseBiasAddAndAddOptimizer
-from .fuse_column_wise_mul import FuseColumnWiseMulOptimizer
-from .fuse_conv_with_math import FuseConvWithMathOptimizer
-from .fuse_decomposed_bn import FuseDecomposedBNOptimizer
-from .fuse_decomposed_in import FuseDecomposedINOptimizer
-from .fuse_gelu import FuseGeluOptimizer
-from .fuse_layer_norm import FuseLayerNormOptimizer
-from .fuse_reshape_transpose import FuseTransposeReshapeOptimizer
-from .graph_cse_optimizer import GraphCseOptimizer
-from .grappler_pass import GrapplerOptimizer
-from .move_squeeze_after_relu import MoveSqueezeAfterReluOptimizer
-from .remove_training_nodes import RemoveTrainingNodesOptimizer
-from .rename_batch_norm import RenameBatchNormOptimizer
-from .split_shared_input import SplitSharedInputOptimizer
-from .strip_equivalent_nodes import StripEquivalentNodesOptimizer
-from .strip_unused_nodes import StripUnusedNodesOptimizer
-from .switch_optimizer import SwitchOptimizer
-
-
-class PreOptimization:
-    """Pre optimization for the FP32 models."""
-
-    def __init__(self, model, new_api, device):
-        """Initialization."""
-        self.model = model
-        if version1_gte_version2(tf.version.VERSION, "2.1.0") or version1_eq_version2(tf.version.VERSION, "1.15.0-up3"):
-            self.optimization = {
-                "pruning": True,
-                "shape": True,
-                "constfold": False,
-                "arithmetic": False,
-                "dependency": True,
-                "debug_stripper": True,
-                "loop": True,
-            }
-        else:  # pragma: no cover
-            self.optimization = {
-                "pruning": True,
-                "shape": True,
-                "dependency": True,
-                "debug_stripper": True,
-                "loop": True,
-            }
-        # Table initialization should disable grappler dependency and pruning pass
-        node_names = [node.name for node in model.graph_def.node]
-        if "init_all_tables" in node_names:  # pragma: no cover
-            self.optimization["dependency"] = False
-            self.optimization["pruning"] = False
-        self.new_api = new_api
-        self.device = device
-        self.analyzer = GraphAnalyzer()
-        self.analyzer.graph = model.graph_def
-        self.analyzer.parse_graph()
-        self._tmp_graph_def = None
-        self._excluded_node_names = []
-
-    def get_excluded_node_names(self):
-        """Get the excluded node name.
-
-        Returns:
-            string list: the excluded ops' name
-        """
-        return self._excluded_node_names
-
-    @dump_elapsed_time("Pass Pre Optimization")
-    def get_optimized_model(self, itex_mode=False):
-        """Executed the non-precision dependent graph optimization.
-
-        The input graph will be optimized with following passes:
-        1. Remove the training nodes like Identity Op.
-        2. Split the shared nodes like weights node for multi-Conv2d.
-        3. Fold Constant Nodes as less as possible.
-        4. Fuse the Mul node into the previous Conv2D/MatMul if possible.
-        5. Strip the useless nodes.
-        6. Do the Common sequence elimation optimization on the graph.
-        7. Fold the BN node into the previous Conv2D if possible.
-
-        Returns:
-            [graphdef]: the optimized graphdef object.
-        """
-        from neural_compressor.tensorflow.utils import Model
-
-        origin_model = Model(self.model._model, **self.model.kwargs, backend="itex" if itex_mode else "default")
-        origin_model.name = self.model.name
-        origin_model.model_type = self.model.model_type
-        origin_model.output_tensor_names = self.model.output_tensor_names
-        origin_model.input_tensor_names = self.model.input_tensor_names
-        origin_model.workspace_path = self.model.workspace_path
-
-        output_node_names = self.model.output_node_names
-        input_node_names = self.model.input_node_names
-        input_output_names = output_node_names + input_node_names
-
-        # Add device info before convert layout
-        # Google in layout optimizer where all nodes in the graph are expected to have their device
-        # information set (earlier version < 2.10.0 this was not needed).
-        if version1_gte_version2(tf.version.VERSION, "2.10.0"):
-            cur_graph = GraphAnalyzer()
-            cur_graph.graph = self.model.graph_def
-            graph_info = cur_graph.parse_graph()
-
-            if self.device == "cpu":
-                cpus = tf.config.list_physical_devices("CPU")
-                node_device = cpus[0].name.replace("physical_device:", "")
-            else:  # pragma: no cover
-                gpus = tf.config.list_physical_devices("GPU")
-                if len(gpus) == 0:
-                    xpus = tf.config.list_physical_devices("XPU")
-                    if len(xpus) == 0:
-                        cpus = tf.config.list_physical_devices("CPU")
-                        node_device = cpus[0].name.replace("physical_device:", "")
-                    else:
-                        node_device = xpus[0].name.replace("physical_device:", "")
-                else:
-                    node_device = gpus[0].name.replace("physical_device:", "")
-            for node_name in list(graph_info.keys()):
-                node = graph_info[node_name].node
-                node.device = node_device
-            self._tmp_graph_def = cur_graph.dump_graph()
-
-            self._tmp_graph_def = ConvertLayoutOptimizer(self._tmp_graph_def, output_node_names).do_transformation()
-        else:
-            self._tmp_graph_def = ConvertLayoutOptimizer(self.model.graph_def, output_node_names).do_transformation()
-
-        self._tmp_graph_def = ConvertPlaceholderToConst(self._tmp_graph_def).do_transformation()
-
-        self._tmp_graph_def = SwitchOptimizer(self._tmp_graph_def).do_transformation()
-
-        self._tmp_graph_def = GrapplerOptimizer(
-            self._tmp_graph_def, input_output_names, self.optimization
-        ).do_transformation()
-
-        self._tmp_graph_def = StripUnusedNodesOptimizer(
-            self._tmp_graph_def, input_node_names, output_node_names
-        ).do_transformation()
-
-        self._tmp_graph_def = RemoveTrainingNodesOptimizer(
-            self._tmp_graph_def, protected_nodes=input_output_names
-        ).do_transformation()
-
-        self._tmp_graph_def = SplitSharedInputOptimizer(self._tmp_graph_def).do_transformation()
-
-        # Put FuseDecomposedBNOptimizer before GraphFoldConstantOptimizer
-        # The 'Sub' op in the small decomposed ops of BN will be converted to const by GraphFoldConstantOptimizer.
-        # Then the FuseDecomposedBNOptimizer can't fuse the small decomposed ops to BN.
-        if self.new_api:
-            self._tmp_graph_def = FuseDecomposedBNOptimizer(self._tmp_graph_def).do_transformation()
-            self._tmp_graph_def = FuseDecomposedINOptimizer(self._tmp_graph_def).do_transformation()
-            self._tmp_graph_def = FuseLayerNormOptimizer(self._tmp_graph_def).do_transformation()
-
-        self._tmp_graph_def = GraphFoldConstantOptimizer(self._tmp_graph_def).do_transformation()
-
-        if not self.new_api:
-            self._tmp_graph_def = FuseDecomposedBNOptimizer(self._tmp_graph_def).do_transformation()
-
-        self._tmp_graph_def = FuseColumnWiseMulOptimizer(self._tmp_graph_def).do_transformation()
-
-        self._tmp_graph_def = StripUnusedNodesOptimizer(
-            self._tmp_graph_def, input_node_names, output_node_names
-        ).do_transformation()
-
-        self._tmp_graph_def = FuseGeluOptimizer(self._tmp_graph_def).do_transformation()
-
-        self._tmp_graph_def = GraphCseOptimizer(self._tmp_graph_def).do_transformation()
-
-        self._tmp_graph_def = FoldBatchNormNodesOptimizer(self._tmp_graph_def).do_transformation()
-
-        self._tmp_graph_def = RenameBatchNormOptimizer(self._tmp_graph_def).do_transformation()
-
-        self._tmp_graph_def = ConvertLeakyReluOptimizer(self._tmp_graph_def).do_transformation()
-
-        self._tmp_graph_def = ConvertAddToBiasAddOptimizer(self._tmp_graph_def).do_transformation()
-
-        self._tmp_graph_def = FuseTransposeReshapeOptimizer(self._tmp_graph_def).do_transformation()
-
-        self._tmp_graph_def = FuseConvWithMathOptimizer(self._tmp_graph_def).do_transformation()
-
-        self._tmp_graph_def = ExpandDimsOptimizer(self._tmp_graph_def).do_transformation()
-
-        self._tmp_graph_def = FetchWeightFromReshapeOptimizer(self._tmp_graph_def).do_transformation()
-
-        self._tmp_graph_def = MoveSqueezeAfterReluOptimizer(self._tmp_graph_def).do_transformation()
-
-        if not self.new_api and not itex_mode:
-            # TODO we need to remove below optimizer once the TF enabled the single
-            # matmul op quantization
-            self._tmp_graph_def = InjectDummyBiasAddOptimizer(
-                self._tmp_graph_def, output_node_names
-            ).do_transformation()
-
-        self._tmp_graph_def = FuseBiasAddAndAddOptimizer(self._tmp_graph_def).do_transformation()
-
-        self._tmp_graph_def = ConvertNanToRandom(self._tmp_graph_def).do_transformation()
-
-        self._tmp_graph_def = StripEquivalentNodesOptimizer(self._tmp_graph_def, output_node_names).do_transformation()
-
-        if self.new_api or itex_mode:
-            self._tmp_graph_def = DilatedContraction(self._tmp_graph_def).do_transformation()
-
-        # node device info will be removed by GrapplerOptimizer, insert it again.
-        if version1_lt_version2(tf.version.VERSION, "2.0.0"):  # pragma: no cover
-            from tensorflow._api.v1.config import experimental
-
-            list_physical_devices = experimental.list_physical_devices
-        else:
-            list_physical_devices = tf.config.list_physical_devices
-        cur_graph = GraphAnalyzer()
-        cur_graph.graph = self._tmp_graph_def
-        graph_info = cur_graph.parse_graph()
-
-        if self.device == "cpu":
-            cpus = list_physical_devices("CPU")
-            node_device = cpus[0].name.replace("physical_device:", "")
-        else:  # pragma: no cover
-            gpus = list_physical_devices("GPU")
-            if len(gpus) == 0:
-                xpus = list_physical_devices("XPU")
-                if len(xpus) == 0:
-                    cpus = list_physical_devices("CPU")
-                    node_device = cpus[0].name.replace("physical_device:", "")
-                else:
-                    node_device = xpus[0].name.replace("physical_device:", "")
-            else:
-                node_device = gpus[0].name.replace("physical_device:", "")
-        for node_name in list(graph_info.keys()):
-            node = graph_info[node_name].node
-            node.device = node_device
-        self._tmp_graph_def = cur_graph.dump_graph()
-
-        self._tmp_graph_def.library.CopyFrom(self.model.graph_def.library)
-
-        for function_def in self.model.graph_def.library.function:
-            if function_def.signature.name == "swish_f32":  # pragma: no cover
-                self._tmp_graph_def.library.function.extend([copy.deepcopy(function_def)])
-
-        origin_model.graph_def = self._tmp_graph_def
-        return origin_model
-
-    def get_matched_nodes(self, patterns):
-        """Search the matched nodes with the specified patterns.
-
-        Args:
-            patterns ([string list]): The patterns should be illustrated as below.
-                [['MatMul'], ("BiasAdd"), ("Relu",)]
-
-        Returns:
-            [string list]: It will return the list that contains the matched nodes name
-                and pattern. ['matched_node_a_name', 'matched_node_a_name',['MatMul','BiasAdd']]
-        """
-        self.analyzer.graph = self._tmp_graph_def
-        self.analyzer.parse_graph()
-        res = []
-
-        for sub_pattern in patterns:
-            res.extend([i for i in self.analyzer.query_fusion_pattern_nodes(sub_pattern) if i not in res])
-        return res
-
-    def has_positive_input(self, node_name):
-        """Check the specified node has the positive input or not.
-
-        Args:
-            node_name ([string]): node's name
-
-        Returns:
-            [bool]: True if the node has the positive input data,
-                    False if the node has the negative input data.
-        """
-        return self.analyzer.has_positive_input(node_name)
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/remove_training_nodes.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/remove_training_nodes.py
deleted file mode 100644
index 76d83bea651..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/remove_training_nodes.py
+++ /dev/null
@@ -1,66 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Remove training nodes Graph Rewriter."""
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class RemoveTrainingNodesOptimizer(GraphRewriterBase):
-    """Remove training nodes optimizer."""
-
-    def __init__(self, model, protected_nodes=[], types_to_splice=["Identity", "CheckNumerics", "StopGradient"]):
-        """Initilizaiton."""
-        super().__init__(model)
-        self.protected_nodes = protected_nodes
-        self.types_to_splice = types_to_splice
-
-    @dump_elapsed_time("Pass RemoveTrainingNodesOptimizer")
-    def do_transformation(self):
-        """Remove tranining nodes which has no control edge inputs."""
-        graph_handle = GraphAnalyzer()
-        graph_handle.graph = self.model
-
-        graph_info = graph_handle.parse_graph()
-        # input_nodes = input_graph.node
-
-        control_input_names = set()
-        node_names_with_control_input = set()
-        names_to_splice = {}
-
-        for node_name, v in graph_info.items():
-            for node_input in v.node.input:
-                if "^" in node_input:
-                    control_input_names.add(node_input.replace("^", ""))
-                    node_names_with_control_input.add(node_name)
-
-        for node_name, v in graph_info.items():
-            if v.node.op in self.types_to_splice and v.node.name not in self.protected_nodes:
-                # We don't want to remove nodes that have control edge inputs, because
-                # they might be involved in subtle dependency issues that removing them
-                # will jeopardize.
-                if node_name not in node_names_with_control_input:
-                    names_to_splice[node_name] = v.node.input[0]
-
-        # We also don't want to remove nodes which are used as control edge inputs.
-        names_to_splice = {name: value for name, value in names_to_splice.items() if name not in control_input_names}
-        for k, _ in names_to_splice.items():
-            graph_handle.remove_node_with_single_input_output(k)
-
-        return graph_handle.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/rename_batch_norm.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/rename_batch_norm.py
deleted file mode 100644
index 8e7cbc076df..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/rename_batch_norm.py
+++ /dev/null
@@ -1,60 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Rename FusedBatchNorm op to FusedBatchNormV2 Graph Rewriter."""
-
-import math
-
-import numpy as np
-from tensorflow.core.framework import attr_value_pb2, node_def_pb2
-from tensorflow.python.framework import tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class RenameBatchNormOptimizer(GraphRewriterBase):
-    """Rename FusedBatchNorm op to FusedBatchNormV2."""
-
-    @dump_elapsed_time("Pass RenameBatchNormOptimizer")
-    def do_transformation(self):
-        """Rename FusedBatchNorm op to FusedBatchNormV2.
-
-        This pass is needed for bf16 conversion. Due to TensorFlow historical reason,
-        FusedBatchNorm is not a bf16 op but FusedBatchNormV2 is. As the latter is compatible
-        with the former, changing FusedBatchNorm op to FusedBatchNormV2 op will be able to
-        convert to bf16 op on the platforms supporting VNNI_BF16 and AMX instructions.
-
-        Returns:
-          Modified graph with BN ops renamed.
-
-        Raises:
-          ValueError: If the graph is badly formed.
-        """
-        cur_graph = GraphAnalyzer()
-        cur_graph.graph = self.model
-        graph_details = cur_graph.parse_graph()
-
-        for _, v in graph_details.items():
-            # for node in cur_graph.graph.node:
-            if v.node.op == "FusedBatchNorm" or v.node.op == "FusedBatchNormV2":
-                v.node.op = "FusedBatchNormV3"
-                v.node.attr["U"].CopyFrom(v.node.attr["T"])
-
-        return cur_graph.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/split_shared_input.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/split_shared_input.py
deleted file mode 100644
index 0386a3a8514..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/split_shared_input.py
+++ /dev/null
@@ -1,60 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Split shared input Graph Rewriter."""
-
-from tensorflow.core.framework import node_def_pb2
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class SplitSharedInputOptimizer(GraphRewriterBase):
-    """Split the shared input if the input node is shared and const."""
-
-    @dump_elapsed_time("Pass SplitSharedInputOptimizer")
-    def do_transformation(self):
-        """Execute splitting the shared input."""
-        cur_graph = GraphAnalyzer()
-        cur_graph.graph = self.model
-
-        graph_info = cur_graph.parse_graph()
-
-        is_shared_input = False
-        # map of: input_name - op_name
-        input_map = {}
-        for node_name in list(graph_info.keys()):
-            node = graph_info[node_name].node
-            for _, input_node_name in enumerate(node.input):
-                if input_node_name.startswith("^"):
-                    continue
-                if graph_info[Helper.node_name_from_input(input_node_name)].node.op == "Const":
-                    # is shared and current node is not the first one
-                    # sharing the input
-                    if input_node_name in input_map:
-                        is_shared_input = True
-                        input_map[input_node_name].append(node.name)
-                        new_input_node = node_def_pb2.NodeDef()
-                        new_input_node.CopyFrom(graph_info[input_node_name].node)
-                        new_input_node.name = input_node_name + "_nc_share_" + str(len(input_map[input_node_name]))
-                        cur_graph.replace_const_node(new_input_node, [node.name], input_node_name, False)
-                    else:
-                        input_map[input_node_name] = [node.name]
-
-        return cur_graph.dump_graph() if is_shared_input else self.model
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/strip_equivalent_nodes.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/strip_equivalent_nodes.py
deleted file mode 100644
index 53090ae55f3..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/strip_equivalent_nodes.py
+++ /dev/null
@@ -1,50 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Strip Equivalent Nodes Graph Rewriter."""
-
-from neural_compressor.common import logger
-from neural_compressor.tensorflow.quantization.utils.utility import fix_ref_type_of_graph_def, strip_equivalent_nodes
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class StripEquivalentNodesOptimizer(GraphRewriterBase):
-    """Remove the equivalent nodes which have the same inputs and attributes."""
-
-    def __init__(self, model, output_node_names):
-        """Initialization."""
-        super().__init__(model)
-        self.output_node_names = output_node_names
-
-    @dump_elapsed_time("Pass StripEquivalentNodesOptimizer")
-    def do_transformation(self):
-        """Strip the equivalent nodes in the graph."""
-        self.model = fix_ref_type_of_graph_def(self.model)
-        iter_num = 0
-        replaced_nodes_type = True
-        all_replaced_nodes_type = {}
-        while replaced_nodes_type:
-            self.model, replaced_nodes_type = strip_equivalent_nodes(self.model, self.output_node_names)
-            for k, v in replaced_nodes_type.items():
-                all_replaced_nodes_type[k] = all_replaced_nodes_type.get(k, 0) + v
-            iter_num += 1
-            logger.debug(
-                f"StripEquivalentNodes[Iter-{iter_num}]-Replaced equivalent node types are {replaced_nodes_type}"
-            )
-        logger.warning("All replaced equivalent node types are {}".format(all_replaced_nodes_type))
-        return self.model
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/strip_unused_nodes.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/strip_unused_nodes.py
deleted file mode 100644
index e59a81a4b75..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/strip_unused_nodes.py
+++ /dev/null
@@ -1,42 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Strip unused nodes Graph Rewriter."""
-
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class StripUnusedNodesOptimizer(GraphRewriterBase):
-    """Remove the unused nodes in the graph."""
-
-    def __init__(self, model, input_node_names, output_node_names):
-        """Initialization."""
-        super().__init__(model)
-        self.input_node_names = input_node_names
-        self.output_node_names = output_node_names
-
-    @dump_elapsed_time("Pass StripUnusedNodesOptimizer")
-    def do_transformation(self):
-        """Execute stripping unused nodes."""
-        from neural_compressor.tensorflow.quantization.utils.utility import (
-            fix_ref_type_of_graph_def,
-            strip_unused_nodes,
-        )
-
-        self.model = fix_ref_type_of_graph_def(self.model)
-        return strip_unused_nodes(self.model, self.input_node_names, self.output_node_names)
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/switch_optimizer.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/switch_optimizer.py
deleted file mode 100644
index e6b21556ff2..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/generic/switch_optimizer.py
+++ /dev/null
@@ -1,84 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Switch Graph Rewriter."""
-
-from tensorflow.python.framework import tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class SwitchOptimizer(GraphRewriterBase):
-    """Remove switch op if the input condition is true."""
-
-    @dump_elapsed_time("Pass SwitchOptimizer")
-    def do_transformation(self):
-        """Replace all enter ops whose output is matmul with const.
-
-        Args:
-          input_graph_def (graphdef): graphdef object
-
-        Returns:
-           [graphdef]: optimized graph
-        """
-        cur_graph = GraphAnalyzer()
-        cur_graph.graph = self.model
-
-        graph_info = cur_graph.parse_graph()
-        target_nodes = cur_graph.query_fusion_pattern_nodes([["Switch"]])
-
-        for node_combination in target_nodes:
-            switch_node = graph_info[node_combination[0]].node
-            pred_node = graph_info[switch_node.input[1]].node
-            if (
-                pred_node.op == "Const"
-                and tensor_util.MakeNdarray(graph_info[pred_node.name].node.attr["value"].tensor)
-            ) or (
-                pred_node.op == "PlaceholderWithDefault"
-                and tensor_util.MakeNdarray(graph_info[pred_node.input[0]].node.attr["value"].tensor)
-            ):
-                condition = []
-                for output in graph_info[node_combination[0]].outputs:
-                    successor_node = graph_info[output].node
-                    for index, value in enumerate(successor_node.input):
-                        if value == node_combination[0] + ":1":
-                            condition.append(True)
-                        elif value == node_combination[0] + ":0":
-                            condition.append(False)
-
-                if not all(condition):
-                    continue
-
-                for output in graph_info[node_combination[0]].outputs:
-                    successor_node = graph_info[output].node
-                    replace_index = None
-                    for index, value in enumerate(successor_node.input):
-                        if value == node_combination[0] + ":1":
-                            replace_index = index
-                            break
-                    if not replace_index:
-                        break
-                    successor_node.input[replace_index] = switch_node.input[0]
-                    switch_node_outputs = list(graph_info[node_combination[0]].outputs)
-                    if switch_node_outputs.index(output) == len(switch_node_outputs) - 1:
-                        cur_graph.remove_node_with_single_input_output(node_combination[0])
-            else:
-                continue
-
-        return cur_graph.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/graph_base.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/graph_base.py
deleted file mode 100644
index 72de4f351c1..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/graph_base.py
+++ /dev/null
@@ -1,40 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Graph Rewrite Base Class."""
-
-import logging
-from abc import abstractmethod
-
-
-class GraphRewriterBase:
-    """Graph Rewrite Base class.
-
-    We abstract this base class and define the interface only.
-
-    Args:
-        object (model): the input model to be converted.
-    """
-
-    def __init__(self, model):
-        """Initialization."""
-        self.model = model
-        self.logger = logging.getLogger("neural_compressor")
-
-    @abstractmethod
-    def do_transformation(self):
-        """Base Interface that need to be implemented by each sub class."""
-        raise NotImplementedError
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/__init__.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/__init__.py
deleted file mode 100644
index 65a492f99b9..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/__init__.py
+++ /dev/null
@@ -1,17 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Tensorflow INT8 Graph Rewriters."""
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/freeze_fake_quant.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/freeze_fake_quant.py
deleted file mode 100644
index f308a1ad6f2..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/freeze_fake_quant.py
+++ /dev/null
@@ -1,151 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Freeze FakeQuant op Graph Rewriter."""
-
-import ast
-
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer, GraphRewriterHelper
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class FreezeFakeQuantOpOptimizer(GraphRewriterBase):  # pragma: no cover
-    """Freeze fake_quant op to the following Quantize op and prioring Dequantize op."""
-
-    def __init__(self, model):
-        """Initialization."""
-        super().__init__(model)
-
-        self.graph_analyzer = GraphAnalyzer()
-        self.graph_analyzer.graph = self.model
-
-        self.graph_info = self.graph_analyzer.parse_graph()
-
-        self.freeze_patterns = {
-            str(
-                [["Requantize", "RequantizePerChannel"], ["Dequantize"], ["FakeQuantWithMinMaxVars"]]
-            ): self._freeze_requant_dequant_fakequant,
-            str([["FakeQuantWithMinMaxVars"], ["QuantizeV2"]]): self._freeze_fakequant_quant,
-            str(
-                [["FakeQuantWithMinMaxVars"], ["Shape"], ["StridedSlice"], ["Pack"], ["Reshape"], ["QuantizeV2"]]
-            ): self._freeze_fakequant_metaop_quant,
-        }
-
-    def _freeze_requant_dequant_fakequant(self, pattern_nodes):
-        """Freeze Requantize Dequantize FakeQuant fusion."""
-        requant_node_name = pattern_nodes[0]
-        requant_node = self.graph_info[requant_node_name].node
-        fake_quant_node_name = pattern_nodes[2]
-        fake_quant_node = self.graph_info[fake_quant_node_name].node
-
-        # set the third input "requested_output_min" of RequantizePerChannel or Requantize op.
-        requested_output_min_node = self.graph_info[requant_node.input[3]].node
-        min_node = self.graph_info[fake_quant_node.input[1]].node
-        GraphRewriterHelper.set_attr_tensor(
-            requested_output_min_node, "value", min_node.attr["value"].tensor, dtypes.float32
-        )
-        # set the fourth input "requested_output_max" of RequantizePerChannel or Requantize op.
-        requested_output_max_node = self.graph_info[requant_node.input[4]].node
-        max_node = self.graph_info[fake_quant_node.input[2]].node
-        GraphRewriterHelper.set_attr_tensor(
-            requested_output_max_node, "value", max_node.attr["value"].tensor, dtypes.float32
-        )
-
-    def _freeze_fakequant_quant(self, pattern_nodes):
-        """Freeze FakeQuant QuantizeV2 fusion."""
-        fake_quant_node_name = pattern_nodes[0]
-        fake_quant_node = self.graph_info[fake_quant_node_name].node
-        quant_node_name = pattern_nodes[1]
-        quant_node = self.graph_info[quant_node_name].node
-
-        # set the second input "min_range" of QuantizeV2 op.
-        min_node = self.graph_info[fake_quant_node.input[1]].node
-        min_range_node = self.graph_info[quant_node.input[1]].node
-        GraphRewriterHelper.set_attr_tensor(min_range_node, "value", min_node.attr["value"].tensor, dtypes.float32)
-        # set the third input "max_range" of QuantizeV2 op.
-        max_node = self.graph_info[fake_quant_node.input[2]].node
-        max_range_node = self.graph_info[quant_node.input[2]].node
-        GraphRewriterHelper.set_attr_tensor(max_range_node, "value", max_node.attr["value"].tensor, dtypes.float32)
-
-    def _freeze_fakequant_metaop_quant(self, pattern_nodes):
-        """Freeze FakeQuant Meta ops QuantizeV2 fusion."""
-        fake_quant_node_name = pattern_nodes[0]
-        fake_quant_node = self.graph_info[fake_quant_node_name].node
-        quant_node_name = pattern_nodes[5]
-        quant_node = self.graph_info[quant_node_name].node
-
-        # set the second input "min_range" of QuantizeV2 op.
-        min_node = self.graph_info[fake_quant_node.input[1]].node
-        min_range_node = self.graph_info[quant_node.input[1]].node
-        GraphRewriterHelper.set_attr_tensor(min_range_node, "value", min_node.attr["value"].tensor, dtypes.float32)
-        # set the third input "max_range" of QuantizeV2 op.
-        max_node = self.graph_info[fake_quant_node.input[2]].node
-        max_range_node = self.graph_info[quant_node.input[2]].node
-        GraphRewriterHelper.set_attr_tensor(max_range_node, "value", max_node.attr["value"].tensor, dtypes.float32)
-
-    def _remove_all_fake_quants(self):
-        """Remove all the fake quants."""
-        _const_node = []
-
-        for node_name in list(self.graph_info.keys()):
-            node = self.graph_info[node_name].node
-            if node.op == "FakeQuantWithMinMaxVars":
-                origin_outputs = list(self.graph_info[node_name].outputs)
-                min_node_name = self.graph_info[node.input[1]].node.name
-                max_node_name = self.graph_info[node.input[2]].node.name
-                _const_node.append(min_node_name)
-                _const_node.append(max_node_name)
-
-                self.graph_analyzer.remove_node_with_single_input_output(node_name)
-
-                for j in origin_outputs[1:]:
-                    output_node = self.graph_info[j].node
-                    if (
-                        len(output_node.input) == 1
-                        and output_node.op == "Const"
-                        and output_node.input[0] == "^" + node.name
-                    ):
-                        self.graph_info[j].node.ClearField("input")
-                    elif output_node.op == "NoOp":
-                        new_noop_input = [
-                            noop_input for noop_input in output_node.input if noop_input != "^" + node.name
-                        ]
-                        output_node.ClearField("input")
-                        output_node.input.extend(new_noop_input)
-
-        # remove those left const nodes used by FakeQuantWithMinMaxVars
-        for node_name in list(self.graph_info.keys()):
-            if node_name in _const_node:
-                self.graph_analyzer.remove_node(node_name)
-
-    @dump_elapsed_time("Pass FreezeFakeQuantOpOptimizer")
-    def do_transformation(self):
-        """Execute freeze FakeQuant optimization."""
-        for _pattern, _handler in self.freeze_patterns.items():
-            _match_pattern_nodes = self.graph_analyzer.query_fusion_pattern_nodes(ast.literal_eval(_pattern))
-            if len(_match_pattern_nodes) == 0:
-                continue
-
-            for _pattern_nodes in _match_pattern_nodes:
-                _handler(_pattern_nodes)
-
-        self._remove_all_fake_quants()
-
-        return GraphAnalyzer().dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/freeze_value.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/freeze_value.py
deleted file mode 100644
index 20325ea7f42..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/freeze_value.py
+++ /dev/null
@@ -1,396 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Freeze value with calibration Graph Rewriter."""
-
-import re
-
-import numpy as np
-from tensorflow.core.framework import attr_value_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-
-from ..graph_base import GraphRewriterBase
-
-
-class FreezeValueTransformer(GraphRewriterBase):
-    """Freeze Value with calibration."""
-
-    def __init__(self, model, max_min_data, postfix, tensor_data=None, th=1, device="gpu", itex_mode=False):
-        """Free Max/Min value into QuantizeV2 op.
-
-        Args:
-            model (graphdef): input model
-            max_min_data (string list): the string context contains max/min values.
-            postfix (string): the specified postfix to locate value.
-            tensor_data(dict): key is the op name while the value is the max/min values
-                                which calculated by KL.
-            th (float, optional): The percentage of overall data.Defaults to 0.95.
-            device (string, optional): The hardware device type, 'cpu' or 'gpu'.
-            itex_mode: itex mode.
-        """
-        super().__init__(model)
-        self.data = max_min_data
-        if 0.0 < th <= 1.0:
-            self.threshold = th
-        else:
-            self.logger.warning("The threshold value for clipping is invalid, " "Reset it to 0.95 by default.")
-            self.threshold = 0.95
-        self.postfix = postfix
-        self.device = device
-        self.itex_mode = itex_mode
-        self.tensor_data = tensor_data
-        self.cur_graph = GraphAnalyzer()
-        self.cur_graph.graph = self.model
-
-        self.graph_info = self.cur_graph.parse_graph()
-        self.cur_graph.get_frame_info()
-
-        self.quantizeV2_min_max = {}
-        self.requant_min_max = {}
-        self.scale_info = {}
-
-    def _get_valid_log(self):
-        """Get valid sampling log.
-
-        :return: get the valid sampling log output.
-        """
-        output = []
-
-        target_lines = [i.strip() for i in self.data if i.strip().find(";") != -1]
-        for i in target_lines:
-            semi_count = i.count(";")
-            if semi_count == 2:
-                output.append(i)
-            elif semi_count % 2 != 0:
-                self.logger.warning("Invalid line.")
-            else:  # pragma: no cover
-                loop_times = int(semi_count / 2)
-                semi_index = [index for index, value in enumerate(i) if value == ";"]
-                for index in range(loop_times - 1):
-                    output.append(i[semi_index[index * 2] : semi_index[index * 2 + 2]])
-                output.append(i[semi_index[loop_times * 2 - 2] :])
-        return output
-
-    def _parse_max_min_log(self):
-        """Parse the max_ming log file.
-
-        :return: get the node name and value mapping
-        """
-        print_suffix = "__print__"
-        lines = self._get_valid_log()
-
-        res = {}
-        temp = {}
-        pattern_def = r"{};{}\[\-?\d+\.?\d*e?-?\+?\d*\]".format(print_suffix, self.postfix)
-        for i in lines:
-            if not re.search(pattern_def, i):
-                continue
-
-            max_line_data = i.split(";")
-            name = max_line_data[1][: -len(print_suffix)]
-            value = max_line_data[-1].split("[")[-1].split("]")[0]
-            if "eightbit" in name and name not in temp:
-                temp[name] = []
-            if "eightbit" in name:
-                temp[name].append(float(value))
-        for key in temp:
-            target_index = int(len(temp[key]) * self.threshold)
-            if target_index > len(temp[key]) - 1:
-                target_index = len(temp[key]) - 1
-            if self.postfix == "__min:":
-                res[key] = sorted(temp[key], reverse=True)[target_index]
-            else:
-                res[key] = sorted(temp[key])[target_index]
-        return res
-
-    def _parse_requantization_ranges(self):
-        """Parse the max_min log to get requantization values.
-
-        :return: dict saved the result
-        """
-        res = {}
-
-        print_suffix = "__print__"
-        lines = self._get_valid_log()
-        temp_min = {}
-        temp_max = {}
-        pattern_def = r"{};{}:\[\-?\d+\.?\d*e?-?\+?\d*\]".format(print_suffix, self.postfix)
-        for i in lines:
-            if not re.search(pattern_def, i):
-                continue
-
-            max_line_data = i.split(print_suffix + ";" + self.postfix)[-1]
-            min_value = max_line_data.split("][")[0].split("[")[1]
-            max_value = max_line_data.split("][")[1].split("]")[0]
-            name = i.split(";")[1].strip()[: -len(print_suffix)]
-            if name not in temp_min:
-                temp_min[name] = []
-            if name not in temp_max:
-                temp_max[name] = []
-
-            temp_min[name].append(float(min_value))
-            temp_max[name].append(float(max_value))
-
-        for key in temp_min:
-            target_min_index = int(np.ceil(len(temp_min[key]) * (1 - self.threshold)))
-
-            if key not in res:
-                res[key] = []
-
-            if target_min_index > len(temp_min[key]) - 1:
-                target_min_index = len(temp_min[key]) - 1
-            res[key].append(sorted(temp_min[key])[target_min_index])
-
-        for key in temp_max:
-            target_max_index = int(np.floor(len(temp_max[key]) * self.threshold)) - 1
-
-            if target_max_index > len(temp_max[key]) - 1:
-                target_max_index = len(temp_max[key]) - 1
-
-            res[key].append(sorted(temp_max[key])[target_max_index])
-
-        if self.tensor_data:  # pragma: no cover
-            for k, v in self.tensor_data.items():
-                if k in res:
-                    self.logger.debug("Update node {} min to {}, max to {}.".format(k, v[2], v[3]))
-                    res[k] = [v[2], v[3]]
-        return res
-
-    def generate_output_graph(self, max_name_value):
-        """Generate transformed graph for freeze_max/freeze_min transformation.
-
-        :param max_name_value: target values
-        :return: transformed graph
-        """
-        for node_name, value in max_name_value.items():
-            node_name = node_name.replace(":", "__port__").replace("^", "__hat__")
-            if node_name not in self.graph_info:
-                continue
-            new_node = node_def_pb2.NodeDef()
-            new_node.op = "Const"
-            new_node_postfix = "/frozen_{}_only".format("".join([x for x in self.postfix if x.isalpha()]))
-            new_node.name = node_name + new_node_postfix
-            new_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-            new_node.attr["value"].CopyFrom(
-                attr_value_pb2.AttrValue(tensor=tensor_util.make_tensor_proto(float(value), dtypes.float32, []))
-            )
-            output_node_name = self.graph_info[node_name].outputs[0]
-
-            if (
-                not self.itex_mode
-                and node_name in self.cur_graph.parent_frame_details
-                and self.cur_graph.parent_frame_details[node_name]
-            ):  # pragma: no cover
-                new_node_enter_node = Helper.create_node("Enter", new_node.name + "_enter", [new_node.name])
-                Helper.set_attr_string(
-                    new_node_enter_node,
-                    "frame_name",
-                    self.cur_graph.parent_frame_details[node_name].attr["frame_name"].s,
-                )
-                Helper.set_attr_dtype(new_node_enter_node, "T", dtypes.float32)
-                Helper.set_attr_bool(new_node_enter_node, "is_constant", True)
-                Helper.set_attr_int(
-                    new_node_enter_node,
-                    "parallel_iterations",
-                    self.cur_graph.parent_frame_details[node_name].attr["parallel_iterations"].i,
-                )
-
-                self.cur_graph.add_node(new_node, None, [new_node_enter_node.name])
-                # self.cur_graph.add_node(new_node_enter_node, new_node.name,
-                #        [Helper.node_name_from_input(output_node_name)])
-                self.cur_graph.replace_const_node(
-                    new_node_enter_node, [Helper.node_name_from_input(output_node_name)], node_name
-                )
-                self.cur_graph.remove_node(node_name)
-            else:
-                self.cur_graph.replace_const_node(new_node, [Helper.node_name_from_input(output_node_name)], node_name)
-                self.cur_graph.remove_node(node_name)
-
-            self.quantizeV2_min_max[node_name] = tensor_util.MakeNdarray(new_node.attr["value"].tensor)
-        self.scale_info[self.postfix[:-1]] = self.quantizeV2_min_max
-
-        return GraphAnalyzer().dump_graph(), self.scale_info
-
-    def generate_output_graph_ranges(self, max_name_value):
-        """Generate transformed graph for freeze_max/freeze_min transformation.
-
-        :param max_name_value: target values
-        :return: transformed graph
-        """
-        for node_name, value in max_name_value.items():
-            bn_node_name = node_name.replace("eightbit_requant_range", "eightbit_quantized_bn")
-            in_node_name = node_name.replace("eightbit_requant_range", "eightbit_quantized_in")
-            if not self.graph_info.get(bn_node_name) or not bn_node_name.endswith("_eightbit_quantized_bn"):
-                bn_node_name = None
-            if not self.graph_info.get(in_node_name) or not in_node_name.endswith("_eightbit_quantized_in"):
-                in_node_name = None
-
-            if self.itex_mode and "BatchNorm" in node_name:  # pragma: no cover
-                bn_node_name = node_name[: -len("_eightbit_requant_range")]
-                if bn_node_name not in self.graph_info:
-                    bn_node_name = None
-                else:
-                    if "FusedBatchNorm" not in self.graph_info[bn_node_name].node.op:
-                        bn_node_name = None
-
-            if (
-                node_name not in self.graph_info
-                and bn_node_name not in self.graph_info
-                and in_node_name not in self.graph_info
-            ):
-                continue
-
-            min_node = node_def_pb2.NodeDef()
-            min_node.op = "Const"
-            min_node_postfix = "/frozen_min"
-            if bn_node_name:
-                min_node.name = bn_node_name + "/frozen_bn_output_min"
-            elif in_node_name:
-                min_node.name = in_node_name + "/frozen_in_output_min"
-            else:
-                min_node.name = node_name + min_node_postfix
-            min_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-            min_node.attr["value"].CopyFrom(
-                attr_value_pb2.AttrValue(tensor=tensor_util.make_tensor_proto(float(value[0]), dtypes.float32, []))
-            )
-
-            max_node = node_def_pb2.NodeDef()
-            max_node.op = "Const"
-            max_node_postfix = "/frozen_max"
-            if bn_node_name:
-                max_node.name = bn_node_name + "/frozen_bn_output_max"
-            elif in_node_name:
-                max_node.name = in_node_name + "/frozen_in_output_max"
-            else:
-                max_node.name = node_name + max_node_postfix
-            max_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-            max_node.attr["value"].CopyFrom(
-                attr_value_pb2.AttrValue(tensor=tensor_util.make_tensor_proto(float(value[1]), dtypes.float32, []))
-            )
-
-            if bn_node_name:  # pragma: no cover
-                if self.itex_mode:
-                    self.cur_graph.replace_const_node(
-                        min_node,
-                        [Helper.node_name_from_input(bn_node_name + "_eightbit_quantize_bn")],
-                        bn_node_name + "_eightbit_input7_output_min",
-                    )
-                    self.cur_graph.replace_const_node(
-                        max_node,
-                        [Helper.node_name_from_input(bn_node_name + "_eightbit_quantize_bn")],
-                        bn_node_name + "_eightbit_input8_output_max",
-                    )
-                else:
-                    self.cur_graph.replace_const_node(
-                        min_node, [Helper.node_name_from_input(bn_node_name)], bn_node_name + "_input7_output_min"
-                    )
-                    self.cur_graph.replace_const_node(
-                        max_node, [Helper.node_name_from_input(bn_node_name)], bn_node_name + "_input8_output_max"
-                    )
-            elif in_node_name:
-                self.cur_graph.replace_const_node(
-                    min_node, [Helper.node_name_from_input(in_node_name)], in_node_name + "_input7_output_min"
-                )
-                self.cur_graph.replace_const_node(
-                    max_node, [Helper.node_name_from_input(in_node_name)], in_node_name + "_input8_output_max"
-                )
-            elif (
-                not self.itex_mode
-                and node_name in self.cur_graph.parent_frame_details
-                and self.cur_graph.parent_frame_details[node_name]
-            ):  # pragma: no cover
-                output_node_name = self.graph_info[node_name].outputs[0]
-                min_node_enter_node = Helper.create_node("Enter", min_node.name + "_enter", [min_node.name])
-                Helper.set_attr_string(
-                    min_node_enter_node,
-                    "frame_name",
-                    self.cur_graph.parent_frame_details[node_name].attr["frame_name"].s,
-                )
-                Helper.set_attr_dtype(min_node_enter_node, "T", dtypes.float32)
-                Helper.set_attr_bool(min_node_enter_node, "is_constant", True)
-                Helper.set_attr_int(
-                    min_node_enter_node,
-                    "parallel_iterations",
-                    self.cur_graph.parent_frame_details[node_name].attr["parallel_iterations"].i,
-                )
-
-                self.cur_graph.add_node(min_node, None, [min_node_enter_node.name])
-                # self.cur_graph.add_node(min_node_enter_node, min_node.name,
-                #            [Helper.node_name_from_input(output_node_name)])
-                self.cur_graph.replace_const_node(
-                    min_node_enter_node, [Helper.node_name_from_input(output_node_name)], node_name + ":0"
-                )
-
-                max_node_enter_node = Helper.create_node("Enter", max_node.name + "_enter", [max_node.name])
-                Helper.set_attr_string(
-                    max_node_enter_node,
-                    "frame_name",
-                    self.cur_graph.parent_frame_details[node_name].attr["frame_name"].s,
-                )
-                Helper.set_attr_dtype(max_node_enter_node, "T", dtypes.float32)
-                Helper.set_attr_bool(max_node_enter_node, "is_constant", True)
-                Helper.set_attr_int(
-                    max_node_enter_node,
-                    "parallel_iterations",
-                    self.cur_graph.parent_frame_details[node_name].attr["parallel_iterations"].i,
-                )
-
-                self.cur_graph.add_node(max_node, None, [max_node_enter_node.name])
-                # self.cur_graph.add_node(max_node_enter_node, max_node.name,
-                #              [Helper.node_name_from_input(output_node_name)])
-                self.cur_graph.replace_const_node(
-                    max_node_enter_node, [Helper.node_name_from_input(output_node_name)], node_name + ":1"
-                )
-
-                self.cur_graph.remove_node(node_name)
-            else:
-                output_node_name = self.graph_info[node_name].outputs[0]
-                self.cur_graph.replace_const_node(
-                    min_node, [Helper.node_name_from_input(output_node_name)], node_name + ":0"
-                )
-                self.cur_graph.replace_const_node(
-                    max_node, [Helper.node_name_from_input(output_node_name)], node_name + ":1"
-                )
-                self.cur_graph.remove_node(node_name)
-
-                self.requant_min_max[node_name] = [
-                    tensor_util.MakeNdarray(min_node.attr["value"].tensor),
-                    tensor_util.MakeNdarray(max_node.attr["value"].tensor),
-                ]
-
-        self.scale_info[self.postfix] = self.requant_min_max
-        # {
-        #    "__requant_min_max":
-        #                {requant_range_name:[min,max],}
-        #    "__min":
-        #                {node_name_min:[min]}
-        #    "__max":
-        #                {node_name_max:[max]}
-        # }
-        return GraphAnalyzer().dump_graph(), self.scale_info
-
-    def do_transformation(self):
-        """Apply the transformation of freeze value."""
-        if self.postfix == "__requant_min_max":
-            range_data = self._parse_requantization_ranges()
-
-            return self.generate_output_graph_ranges(range_data)
-
-        max_name_value = self._parse_max_min_log()
-        return self.generate_output_graph(max_name_value)
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/fuse_conv_redundant_dequantize.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/fuse_conv_redundant_dequantize.py
deleted file mode 100644
index ba338fea1fa..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/fuse_conv_redundant_dequantize.py
+++ /dev/null
@@ -1,152 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Fuse QuantizedConv QuantizedDeConv with redundant Dequantize Graph Rewriter."""
-
-import ast
-
-from tensorflow.core.framework import attr_value_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-
-from ..graph_base import GraphRewriterBase
-
-
-class FuseConvRedundantDequantizeTransformer(GraphRewriterBase):
-    """Fuse _QuantizedConv/_QuantizedDeConv with the successor Dequantize Op."""
-
-    fuse_patterns = [
-        [
-            "_FusedQuantizedConv3D",
-            "_FusedQuantizedConv2D",
-            "_FusedQuantizedDepthwiseConv2D",
-            "_FusedQuantizedDeconv2D",
-            "_FusedQuantizedDeconv3D",
-        ],
-        ["Dequantize"],
-    ]
-
-    fuse_sum_op_types_str = (
-        str([b"BiasAdd", b"Sum", b"Requantize"]),
-        str([b"BiasAdd", b"Sum", b"Relu", b"Requantize"]),
-        str([b"BiasAdd", b"Sum", b"LeakyRelu", b"Requantize"]),
-        str([b"BiasAdd", b"Relu", b"Sum", b"Requantize"]),
-        str([b"BiasAdd", b"LeakyRelu", b"Sum", b"Requantize"]),
-    )
-
-    def __init__(self, model, device="cpu"):
-        """Initialization."""
-        super().__init__(model)
-        self.device = device
-        self.graph_analyzer = GraphAnalyzer()
-        self.graph_analyzer.graph = self.model
-        self.graph_info = self.graph_analyzer.parse_graph()
-
-    def do_transformation(self):
-        """Fuse the _QuantizedConv Op with the following Dequantize op.
-
-        The output of _QuantizedConv or is fp32 or bf16.
-
-        Returns:
-            [graphdef]: the optimized graphdef object
-        """
-        dtype_map_dict = {
-            dtypes.qint8.as_datatype_enum: dtypes.qint8,
-            dtypes.quint8.as_datatype_enum: dtypes.quint8,
-            dtypes.float32.as_datatype_enum: dtypes.float32,
-            dtypes.qint32.as_datatype_enum: dtypes.qint32,
-            dtypes.bfloat16.as_datatype_enum: dtypes.bfloat16,
-        }
-        target_nodes = self.graph_analyzer.query_fusion_pattern_nodes(self.fuse_patterns)
-
-        for i in target_nodes:
-            quantized_node_name = i[0]
-            quantized_node = self.graph_info[quantized_node_name].node
-            dequantize_node_name = i[1]
-            dequantize_node = self.graph_info[dequantize_node_name].node
-
-            if len(self.graph_info[quantized_node_name].outputs) > 3:
-                continue
-
-            # QuantizedConv doesn't support {"BiasAdd", "Sum", "Activation", "Dequantize"},
-            # {"BiasAdd", "Activation", "Sum", "Dequantize"} and {"BiasAdd", "Sum", "Dequantize"}
-            if str(quantized_node.attr["fused_ops"].list.s) in self.fuse_sum_op_types_str:
-                continue
-
-            new_node = node_def_pb2.NodeDef()
-            new_node.op = quantized_node.op
-            fused_ops = str(quantized_node.attr["fused_ops"].list.s).replace("Requantize", "Dequantize")
-            new_node.name = quantized_node.name + "_dequantize"
-            for _, value in enumerate(quantized_node.input):
-                new_node.input.append(value)
-
-            if "Tinput" in quantized_node.attr:
-                new_node.attr["Tinput"].CopyFrom(quantized_node.attr["Tinput"])
-            if "Tfilter" in quantized_node.attr:
-                new_node.attr["Tfilter"].CopyFrom(quantized_node.attr["Tfilter"])
-            if "strides" in quantized_node.attr:
-                new_node.attr["strides"].CopyFrom(quantized_node.attr["strides"])
-            if "padding" in quantized_node.attr:
-                new_node.attr["padding"].CopyFrom(quantized_node.attr["padding"])
-            if "alpha" in quantized_node.attr:
-                new_node.attr["alpha"].CopyFrom(quantized_node.attr["alpha"])
-            if "Tbias" in quantized_node.attr:
-                new_node.attr["Tbias"].CopyFrom(quantized_node.attr["Tbias"])
-            if "data_format" in quantized_node.attr:
-                new_node.attr["data_format"].CopyFrom(quantized_node.attr["data_format"])
-            if "is_filter_const" in quantized_node.attr:
-                new_node.attr["is_filter_const"].CopyFrom(quantized_node.attr["is_filter_const"])
-            if "is_bias_const" in quantized_node.attr:
-                new_node.attr["is_bias_const"].CopyFrom(quantized_node.attr["is_bias_const"])
-            if "dilations" in quantized_node.attr:
-                new_node.attr["dilations"].CopyFrom(quantized_node.attr["dilations"])
-            if "explicit_paddings" in quantized_node.attr:
-                new_node.attr["explicit_paddings"].CopyFrom(quantized_node.attr["explicit_paddings"])
-            if "Tdevice_inputs" in quantized_node.attr:
-                new_node.attr["Tdevice_inputs"].CopyFrom(quantized_node.attr["Tdevice_inputs"])
-            if "Tdevice_outputs" in quantized_node.attr:
-                new_node.attr["Tdevice_outputs"].CopyFrom(quantized_node.attr["Tdevice_outputs"])
-            if "Thost_inputs" in quantized_node.attr:
-                new_node.attr["Thost_inputs"].CopyFrom(quantized_node.attr["Thost_inputs"])
-            Helper.set_attr_type_list(new_node, "Thost_outputs", [dequantize_node.attr["dtype"].type])
-            new_node.attr["out_type"].CopyFrom(attr_value_pb2.AttrValue(type=dequantize_node.attr["dtype"].type))
-            Helper.set_attr_string_list(new_node, "fused_ops", ast.literal_eval(fused_ops))
-            if "Tsummand" in quantized_node.attr:
-                Helper.set_attr_dtype(new_node, "Tsummand", dtype_map_dict[dequantize_node.attr["dtype"].type])
-
-            top_node_name = Helper.node_name_from_input(quantized_node.input[0])
-            if self.graph_info[dequantize_node_name].outputs:
-                self.graph_analyzer.replace_single_node(
-                    new_node,
-                    [top_node_name],
-                    quantized_node_name,
-                    self.graph_info[dequantize_node_name].outputs,
-                    dequantize_node_name,
-                )
-                self.graph_analyzer.remove_node(dequantize_node_name)
-            else:
-                self.graph_analyzer.remove_node(dequantize_node_name)
-
-                new_node.name = dequantize_node_name
-                self.graph_analyzer.replace_single_node(
-                    new_node, [top_node_name], quantized_node_name, [], dequantize_node_name
-                )
-
-            self.graph_analyzer.remove_node(quantized_node_name)
-
-        return self.graph_analyzer.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/fuse_conv_requantize.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/fuse_conv_requantize.py
deleted file mode 100644
index 799973e5c4c..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/fuse_conv_requantize.py
+++ /dev/null
@@ -1,819 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Fuse QuantizedConv Requantize/Dequantize Graph Rewriter."""
-
-import tensorflow as tf
-from tensorflow.core.framework import attr_value_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-
-from ..graph_base import GraphRewriterBase
-
-
-class FuseConvRequantizeTransformer(GraphRewriterBase):
-    """Fuse Quantized Conv Op with the successor Requantize Op."""
-
-    fuse_patterns = [
-        [
-            "QuantizedConv2DWithBiasAndRelu",
-            "QuantizedDepthwiseConv2DWithBiasAndRelu",
-            "QuantizedConv2DWithBias",
-            "QuantizedDepthwiseConv2DWithBias",
-            "_FusedQuantizedConv2D",
-            "_FusedQuantizedDepthwiseConv2D",
-            "_FusedQuantizedConv3D",
-            "_FusedQuantizedDeconv2D",
-            "_FusedQuantizedDeconv3D",
-        ],
-        ["RequantizePerChannel", "Requantize"],
-        ("Dequantize",),
-    ]
-
-    fuse_sum_op_types = (
-        [b"BiasAdd", b"Sum"],
-        [b"BiasAdd", b"Sum", b"Relu"],
-        [b"BiasAdd", b"Sum", b"LeakyRelu"],
-        [b"BiasAdd", b"Relu", b"Sum"],
-        [b"BiasAdd", b"LeakyRelu", b"Sum"],
-    )
-
-    sum_pattern = [
-        [
-            "QuantizedConv2DWithBiasSumAndRelu",
-            "QuantizedConv2DWithBiasReluAndSum",
-            "_FusedQuantizedDepthwiseConv2D",
-            "_FusedQuantizedConv2D",
-            "_FusedQuantizedConv3D",
-        ],
-        ["RequantizePerChannel", "Requantize"],
-    ]
-
-    def __init__(self, model, device="cpu", new_api=False):
-        """Initialization."""
-        super().__init__(model)
-        self.device = device
-        self.graph_analyzer = GraphAnalyzer()
-        self.graph_analyzer.graph = self.model
-        self.graph_info = self.graph_analyzer.parse_graph()
-        self.fused_ops = []
-        self.output_types = []
-        self.new_api = new_api
-
-    def do_transformation(self):
-        """Fuse the quantized op with the following requantize op.
-
-        The transformation has two stages, the first step is to fuse the patterns
-        defined in self.fuse_patterns and the last step is to fuse the self.sum_patterns.
-
-        Returns:
-            [graphdef]: the optimized graphdef object
-        """
-        int8_type = dtypes.qint8.as_datatype_enum
-        uint8_type = dtypes.quint8.as_datatype_enum
-        float32_type = dtypes.float32.as_datatype_enum
-        qint32_type = dtypes.qint32.as_datatype_enum
-        dtype_map_dict = {
-            dtypes.qint8.as_datatype_enum: dtypes.qint8,
-            dtypes.quint8.as_datatype_enum: dtypes.quint8,
-            dtypes.float32.as_datatype_enum: dtypes.float32,
-            dtypes.qint32.as_datatype_enum: dtypes.qint32,
-        }
-        target_nodes = self.graph_analyzer.query_fusion_pattern_nodes(self.fuse_patterns)
-
-        for i in target_nodes:
-            quantized_node_name = i[0]
-            quantized_node = self.graph_info[quantized_node_name].node
-            if not self.new_api and quantized_node.op == "QuantizedDepthwiseConv2DWithBias":
-                continue
-            if i[-1][0] in (
-                "_FusedQuantizedDepthwiseConv2D",
-                "_FusedQuantizedConv2D",
-                "_FusedQuantizedConv3D",
-                "_FusedQuantizedDeconv2D",
-                "_FusedQuantizedDeconv3D",
-            ):
-                if str(quantized_node.attr["fused_ops"].list.s).find("Sum") != -1:
-                    continue
-                # else:
-                #   print(quantized_node.attr['fused_ops'].list.s)
-            requantize_node_name = i[1]
-            requantize_node = self.graph_info[requantize_node_name].node
-            if (
-                i[-1][-1] == "Dequantize"
-                and self.new_api
-                and i[0]
-                in (
-                    "_FusedQuantizedDepthwiseConv2D",
-                    "_FusedQuantizedConv2D",
-                    "_FusedQuantizedConv3D",
-                    "_FusedQuantizedDeconv2D",
-                    "_FusedQuantizedDeconv3D",
-                )
-            ):
-                dequantize_node_name = i[2]
-            else:
-                dequantize_node_name = None
-            requested_output_min_name = requantize_node.input[3]
-            requested_output_max_name = requantize_node.input[4]
-
-            quantized_node_op = i[-1][0]
-
-            new_node = node_def_pb2.NodeDef()
-            if self.new_api:
-                if i[-1][0] == "QuantizedConv2DWithBiasAndRelu":
-                    new_node.op = "_FusedQuantizedConv2D"
-                    self.fused_ops = [b"BiasAdd", b"Relu", b"Requantize"]
-                    self.output_types = [
-                        requantize_node.attr["out_type"].type,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ]
-                elif i[-1][0] == "QuantizedConv2DWithBias":
-                    new_node.op = "_FusedQuantizedConv2D"
-                    self.fused_ops = [b"BiasAdd", b"Requantize"]
-                    self.output_types = [
-                        requantize_node.attr["out_type"].type,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ]
-                elif i[-1][0] == "QuantizedDepthwiseConv2DWithBias":
-                    new_node.op = "_FusedQuantizedDepthwiseConv2D"
-                    self.fused_ops = [b"BiasAdd", b"Requantize"]
-                    self.output_types = [
-                        requantize_node.attr["out_type"].type,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ]
-                elif i[-1][0] == "QuantizedDepthwiseConv2DWithBiasAndRelu":
-                    new_node.op = "_FusedQuantizedDepthwiseConv2D"
-                    self.fused_ops = [b"BiasAdd", b"Relu", b"Requantize"]
-                    self.output_types = [
-                        requantize_node.attr["out_type"].type,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ]
-                elif quantized_node_op == "_FusedQuantizedConv2D":
-                    new_node.op = "_FusedQuantizedConv2D"
-                elif quantized_node_op == "_FusedQuantizedDepthwiseConv2D":
-                    new_node.op = "_FusedQuantizedDepthwiseConv2D"
-                elif quantized_node_op == "_FusedQuantizedConv3D":
-                    new_node.op = "_FusedQuantizedConv3D"
-                elif quantized_node_op == "_FusedQuantizedDeconv2D":
-                    new_node.op = "_FusedQuantizedDeconv2D"
-                elif quantized_node_op == "_FusedQuantizedDeconv3D":
-                    new_node.op = "_FusedQuantizedDeconv3D"
-            else:
-                new_node.op = quantized_node_op + "AndRequantize"
-            new_node.name = requantize_node_name
-            for _, value in enumerate(quantized_node.input):
-                new_node.input.append(value)
-
-            if "Tinput" in quantized_node.attr:
-                new_node.attr["Tinput"].CopyFrom(quantized_node.attr["Tinput"])
-            if "Tfilter" in quantized_node.attr:
-                new_node.attr["Tfilter"].CopyFrom(quantized_node.attr["Tfilter"])
-            if "strides" in quantized_node.attr:
-                new_node.attr["strides"].CopyFrom(quantized_node.attr["strides"])
-            if "padding" in quantized_node.attr:
-                new_node.attr["padding"].CopyFrom(quantized_node.attr["padding"])
-            if "alpha" in quantized_node.attr:
-                new_node.attr["alpha"].CopyFrom(quantized_node.attr["alpha"])
-            if "Tsummand" in quantized_node.attr:
-                new_node.attr["Tsummand"].CopyFrom(quantized_node.attr["Tsummand"])
-            if "data_format" in quantized_node.attr:
-                new_node.attr["data_format"].CopyFrom(quantized_node.attr["data_format"])
-
-            parent_node_name = Helper.node_name_from_input(quantized_node.input[0])
-            if new_node.op in ("_FusedQuantizedDeconv2D", "_FusedQuantizedDeconv3D"):
-                max_filter_node = self.graph_info[new_node.input[-3]].node
-                min_filter_node = self.graph_info[new_node.input[-4]].node
-            else:
-                max_filter_node = self.graph_info[new_node.input[-1]].node
-                min_filter_node = self.graph_info[new_node.input[-2]].node
-            last_node = self.graph_info[new_node.input[0]].node
-            new_node.input.append(requested_output_min_name)
-            new_node.input.append(requested_output_max_name)
-
-            if (
-                last_node.op.find("Requantize") != -1
-                or ((last_node.op.find("QuantizeV2") != -1 or last_node.op.find("QuantizedConv2D") != -1))
-            ) and len(quantized_node.attr["fused_ops"].list.s) > 0:
-                bias_node = self.graph_info[new_node.input[2]].node
-                max_input_node = self.graph_info[last_node.input[-1]].node
-                min_input_node = self.graph_info[last_node.input[-2]].node
-                min_input = (min_input_node.attr["value"].tensor.float_val)[0]
-                max_input = (max_input_node.attr["value"].tensor.float_val)[0]
-                if "Depthwise" in quantized_node_op or requantize_node.op.find("PerChannel") != -1:
-                    channel_size = max_filter_node.attr["value"].tensor.tensor_shape.dim[0].size
-                    max_filter_tensor = tensor_util.MakeNdarray(min_filter_node.attr["value"].tensor)
-                    min_filter_tensor = tensor_util.MakeNdarray(min_filter_node.attr["value"].tensor)
-                else:
-                    channel_size = 1
-                    max_filter_tensor = []
-                    min_filter_tensor = []
-                    max_filter_tensor.append((max_filter_node.attr["value"].tensor.float_val)[0])
-                    min_filter_tensor.append((min_filter_node.attr["value"].tensor.float_val)[0])
-                bias_tensor = tensor_util.MakeNdarray(self.graph_info[new_node.input[2]].node.attr["value"].tensor)
-
-                activation_range = 127.0 if new_node.attr["Tinput"].type == dtypes.qint8 else 255.0
-
-                int32_bias = Helper.generate_int32_bias_for_conv(
-                    bias_tensor,
-                    channel_size,
-                    max_input,
-                    min_input,
-                    max_filter_tensor,
-                    min_filter_tensor,
-                    activation_range,
-                )
-
-                bias_node.attr["dtype"].CopyFrom(
-                    attr_value_pb2.AttrValue(type=float32_type if self.device == "gpu" else qint32_type)
-                )
-
-                bias_node.attr["value"].CopyFrom(
-                    attr_value_pb2.AttrValue(
-                        tensor=tensor_util.make_tensor_proto(
-                            bias_tensor if self.device == "gpu" else int32_bias,
-                            dtypes.float32 if self.device == "gpu" else dtypes.int32,
-                            bias_tensor.shape,
-                        )
-                    )
-                )
-
-                bias_node.attr["value"].tensor.dtype = float32_type if self.device == "gpu" else qint32_type
-                new_node.attr["Tbias"].CopyFrom(
-                    attr_value_pb2.AttrValue(type=float32_type if self.device == "gpu" else qint32_type)
-                )
-            else:
-                new_node.attr["Tbias"].CopyFrom(attr_value_pb2.AttrValue(type=float32_type))
-            # in tf 2.10, the "padding_list" attr name changes to explicit_paddings
-            if "padding_list" in quantized_node.attr:
-                if not self.new_api:
-                    new_node.attr["padding_list"].CopyFrom(quantized_node.attr["padding_list"])
-                elif quantized_node.attr["padding"].s == b"EXPLICIT":
-                    new_node.attr["explicit_paddings"].CopyFrom(quantized_node.attr["padding_list"])
-            elif "explicit_paddings" in quantized_node.attr:
-                new_node.attr["explicit_paddings"].CopyFrom(quantized_node.attr["explicit_paddings"])
-            if "dilations" in quantized_node.attr:
-                new_node.attr["dilations"].CopyFrom(quantized_node.attr["dilations"])
-
-            if self.new_api and new_node.op in (
-                "_FusedQuantizedConv2D",
-                "_FusedQuantizedDepthwiseConv2D",
-                "_FusedQuantizedDeconv2D",
-                "_FusedQuantizedDeconv3D",
-            ):
-                input_data_type = dtypes.qint8 if new_node.attr["Tinput"].type == dtypes.qint8 else dtypes.quint8
-                if new_node.op in ("_FusedQuantizedDeconv2D", "_FusedQuantizedDeconv3D"):
-                    Helper.set_attr_type_list(
-                        new_node,
-                        "Thost_inputs",
-                        [
-                            dtypes.int32.as_datatype_enum,
-                            dtypes.qint8.as_datatype_enum,
-                            input_data_type.as_datatype_enum,
-                            (
-                                dtypes.float32.as_datatype_enum
-                                if new_node.attr["Tbias"].type == dtypes.float32
-                                else dtypes.qint32.as_datatype_enum
-                            ),
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                        ],
-                    )
-                else:
-                    Helper.set_attr_type_list(
-                        new_node,
-                        "Thost_inputs",
-                        [
-                            input_data_type.as_datatype_enum,
-                            dtypes.qint8.as_datatype_enum,
-                            (
-                                dtypes.float32.as_datatype_enum
-                                if new_node.attr["Tbias"].type == dtypes.float32
-                                else dtypes.qint32.as_datatype_enum
-                            ),
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                        ],
-                    )
-
-                if quantized_node_op not in (
-                    "_FusedQuantizedConv2D",
-                    "_FusedQuantizedDepthwiseConv2D",
-                    "_FusedQuantizedDeconv2D",
-                    "_FusedQuantizedDeconv3D",
-                ):
-                    Helper.set_attr_type_list(new_node, "Thost_outputs", self.output_types)
-                    new_node.attr["Tsummand"].CopyFrom(attr_value_pb2.AttrValue(type=self.output_types[0]))
-                else:
-                    if str(quantized_node.attr["fused_ops"].list.s) == str([b"BiasAdd", b"_FusedHardSwish"]):
-                        self.fused_ops = [b"BiasAdd", b"_FusedHardSwish", b"Requantize"]
-                        Helper.set_attr_type_list(
-                            new_node,
-                            "Thost_outputs",
-                            [
-                                requantize_node.attr["out_type"].type,
-                                dtypes.float32.as_datatype_enum,
-                                dtypes.float32.as_datatype_enum,
-                            ],
-                        )
-                        Helper.set_attr_dtype(
-                            new_node, "out_type", dtype_map_dict[requantize_node.attr["out_type"].type]
-                        )
-                        Helper.set_attr_dtype(
-                            new_node, "Tsummand", dtype_map_dict[requantize_node.attr["out_type"].type]
-                        )
-                    elif str(quantized_node.attr["fused_ops"].list.s) == str([b"BiasAdd", b"_FusedSwish"]):
-                        self.fused_ops = [b"BiasAdd", b"_FusedSwish", b"Requantize"]
-                        Helper.set_attr_type_list(
-                            new_node,
-                            "Thost_outputs",
-                            [
-                                requantize_node.attr["out_type"].type,
-                                dtypes.float32.as_datatype_enum,
-                                dtypes.float32.as_datatype_enum,
-                            ],
-                        )
-                        Helper.set_attr_dtype(
-                            new_node, "out_type", dtype_map_dict[requantize_node.attr["out_type"].type]
-                        )
-                        Helper.set_attr_dtype(
-                            new_node, "Tsummand", dtype_map_dict[requantize_node.attr["out_type"].type]
-                        )
-                    elif str(quantized_node.attr["fused_ops"].list.s) == str([b"BiasAdd", b"Relu"]):
-                        self.fused_ops = [b"BiasAdd", b"Relu", b"Requantize"]
-                        Helper.set_attr_type_list(
-                            new_node,
-                            "Thost_outputs",
-                            [
-                                requantize_node.attr["out_type"].type,
-                                dtypes.float32.as_datatype_enum,
-                                dtypes.float32.as_datatype_enum,
-                            ],
-                        )
-                        Helper.set_attr_dtype(
-                            new_node, "out_type", dtype_map_dict[requantize_node.attr["out_type"].type]
-                        )
-                        Helper.set_attr_dtype(
-                            new_node, "Tsummand", dtype_map_dict[requantize_node.attr["out_type"].type]
-                        )
-                    elif str(quantized_node.attr["fused_ops"].list.s) == str([b"BiasAdd", b"LeakyRelu"]):
-                        self.fused_ops = [b"BiasAdd", b"LeakyRelu", b"Requantize"]
-                        Helper.set_attr_type_list(
-                            new_node,
-                            "Thost_outputs",
-                            [
-                                requantize_node.attr["out_type"].type,
-                                dtypes.float32.as_datatype_enum,
-                                dtypes.float32.as_datatype_enum,
-                            ],
-                        )
-                        Helper.set_attr_dtype(
-                            new_node, "out_type", dtype_map_dict[requantize_node.attr["out_type"].type]
-                        )
-                        Helper.set_attr_dtype(
-                            new_node, "Tsummand", dtype_map_dict[requantize_node.attr["out_type"].type]
-                        )
-                    elif str(quantized_node.attr["fused_ops"].list.s) == str([b"BiasAdd", b"Elu"]):
-                        self.fused_ops = [b"BiasAdd", b"Elu", b"Requantize"]
-                        Helper.set_attr_type_list(
-                            new_node,
-                            "Thost_outputs",
-                            [
-                                requantize_node.attr["out_type"].type,
-                                dtypes.float32.as_datatype_enum,
-                                dtypes.float32.as_datatype_enum,
-                            ],
-                        )
-                        Helper.set_attr_dtype(
-                            new_node, "out_type", dtype_map_dict[requantize_node.attr["out_type"].type]
-                        )
-                        Helper.set_attr_dtype(
-                            new_node, "Tsummand", dtype_map_dict[requantize_node.attr["out_type"].type]
-                        )
-                    elif str(quantized_node.attr["fused_ops"].list.s) == str([b"BiasAdd", b"Sigmoid"]):
-                        self.fused_ops = [b"BiasAdd", b"Sigmoid", b"Requantize"]
-                        Helper.set_attr_type_list(
-                            new_node,
-                            "Thost_outputs",
-                            [
-                                requantize_node.attr["out_type"].type,
-                                dtypes.float32.as_datatype_enum,
-                                dtypes.float32.as_datatype_enum,
-                            ],
-                        )
-                        Helper.set_attr_dtype(
-                            new_node, "out_type", dtype_map_dict[requantize_node.attr["out_type"].type]
-                        )
-                        Helper.set_attr_dtype(
-                            new_node, "Tsummand", dtype_map_dict[requantize_node.attr["out_type"].type]
-                        )
-                    elif str(quantized_node.attr["fused_ops"].list.s) == str([b"BiasAdd"]):
-                        self.fused_ops = [b"BiasAdd", b"Requantize"]
-                        Helper.set_attr_type_list(
-                            new_node,
-                            "Thost_outputs",
-                            [
-                                requantize_node.attr["out_type"].type,
-                                dtypes.float32.as_datatype_enum,
-                                dtypes.float32.as_datatype_enum,
-                            ],
-                        )
-                        Helper.set_attr_dtype(
-                            new_node, "out_type", dtype_map_dict[requantize_node.attr["out_type"].type]
-                        )
-                        if new_node.op not in ("_FusedQuantizedDeconv2D", "_FusedQuantizedDeconv3D"):
-                            Helper.set_attr_dtype(
-                                new_node, "Tsummand", dtype_map_dict[requantize_node.attr["out_type"].type]
-                            )
-                    elif len(quantized_node.attr["fused_ops"].list.s) == 0:
-                        if new_node.op in ("_FusedQuantizedDeconv2D", "_FusedQuantizedDeconv3D"):
-                            Helper.set_attr_type_list(
-                                new_node,
-                                "Thost_inputs",
-                                [
-                                    dtypes.int32.as_datatype_enum,
-                                    dtypes.qint8.as_datatype_enum,
-                                    input_data_type.as_datatype_enum,
-                                    dtypes.float32.as_datatype_enum,
-                                    dtypes.float32.as_datatype_enum,
-                                    dtypes.float32.as_datatype_enum,
-                                    dtypes.float32.as_datatype_enum,
-                                    dtypes.float32.as_datatype_enum,
-                                    dtypes.float32.as_datatype_enum,
-                                ],
-                            )
-                        else:
-                            Helper.set_attr_type_list(
-                                new_node,
-                                "Thost_inputs",
-                                [
-                                    input_data_type.as_datatype_enum,
-                                    dtypes.qint8.as_datatype_enum,
-                                    # dtypes.float32.as_datatype_enum if new_node.attr["Tbias"].type == dtypes.float32 \
-                                    # else dtypes.qint32.as_datatype_enum,
-                                    dtypes.float32.as_datatype_enum,
-                                    dtypes.float32.as_datatype_enum,
-                                    dtypes.float32.as_datatype_enum,
-                                    dtypes.float32.as_datatype_enum,
-                                    dtypes.float32.as_datatype_enum,
-                                    dtypes.float32.as_datatype_enum,
-                                ],
-                            )
-                        self.fused_ops = [b"Requantize"]
-                        Helper.set_attr_type_list(
-                            new_node,
-                            "Thost_outputs",
-                            [
-                                requantize_node.attr["out_type"].type,
-                                dtypes.float32.as_datatype_enum,
-                                dtypes.float32.as_datatype_enum,
-                            ],
-                        )
-                        Helper.set_attr_dtype(
-                            new_node, "out_type", dtype_map_dict[requantize_node.attr["out_type"].type]
-                        )
-                        if new_node.op not in ("_FusedQuantizedDeconv2D", "_FusedQuantizedDeconv3D"):
-                            Helper.set_attr_dtype(
-                                new_node, "Tsummand", dtype_map_dict[requantize_node.attr["out_type"].type]
-                            )
-                Helper.set_attr_string_list(new_node, "fused_ops", self.fused_ops)
-
-            if "_kernel" in quantized_node.attr:
-                new_node.attr["_kernel"].CopyFrom(quantized_node.attr["_kernel"])
-
-            if new_node.op in ("_FusedQuantizedConv3D"):
-                input_data_type = dtypes.qint8 if new_node.attr["Tinput"].type == dtypes.qint8 else dtypes.quint8
-                if len(quantized_node.attr["fused_ops"].list.s) == 0:
-                    Helper.set_attr_string_list(new_node, "fused_ops", [b"Requantize"])
-                    Helper.set_attr_type_list(
-                        new_node,
-                        "Thost_inputs",
-                        [
-                            input_data_type.as_datatype_enum,
-                            dtypes.qint8.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                        ],
-                    )
-                elif str(quantized_node.attr["fused_ops"].list.s) == str([b"BiasAdd"]):
-                    Helper.set_attr_string_list(new_node, "fused_ops", [b"BiasAdd", b"Requantize"])
-                    Helper.set_attr_type_list(
-                        new_node,
-                        "Thost_inputs",
-                        [
-                            input_data_type.as_datatype_enum,
-                            dtypes.qint8.as_datatype_enum,
-                            (
-                                dtypes.float32.as_datatype_enum
-                                if new_node.attr["Tbias"].type == dtypes.float32
-                                else dtypes.qint32.as_datatype_enum
-                            ),
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                        ],
-                    )
-                elif str(quantized_node.attr["fused_ops"].list.s) == str([b"BiasAdd", b"Relu"]):
-                    Helper.set_attr_string_list(new_node, "fused_ops", [b"BiasAdd", b"Relu", b"Requantize"])
-                    Helper.set_attr_type_list(
-                        new_node,
-                        "Thost_inputs",
-                        [
-                            input_data_type.as_datatype_enum,
-                            dtypes.qint8.as_datatype_enum,
-                            (
-                                dtypes.float32.as_datatype_enum
-                                if new_node.attr["Tbias"].type == dtypes.float32
-                                else dtypes.qint32.as_datatype_enum
-                            ),
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                        ],
-                    )
-                elif str(quantized_node.attr["fused_ops"].list.s) == str([b"BiasAdd", b"LeakyRelu"]):
-                    Helper.set_attr_string_list(new_node, "fused_ops", [b"BiasAdd", b"LeakyRelu", b"Requantize"])
-                    Helper.set_attr_type_list(
-                        new_node,
-                        "Thost_inputs",
-                        [
-                            input_data_type.as_datatype_enum,
-                            dtypes.qint8.as_datatype_enum,
-                            (
-                                dtypes.float32.as_datatype_enum
-                                if new_node.attr["Tbias"].type == dtypes.float32
-                                else dtypes.qint32.as_datatype_enum
-                            ),
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                        ],
-                    )
-                elif str(quantized_node.attr["fused_ops"].list.s) == str([b"BiasAdd", b"Elu"]):
-                    Helper.set_attr_string_list(new_node, "fused_ops", [b"BiasAdd", b"Elu", b"Requantize"])
-                    Helper.set_attr_type_list(
-                        new_node,
-                        "Thost_inputs",
-                        [
-                            input_data_type.as_datatype_enum,
-                            dtypes.qint8.as_datatype_enum,
-                            (
-                                dtypes.float32.as_datatype_enum
-                                if new_node.attr["Tbias"].type == dtypes.float32
-                                else dtypes.qint32.as_datatype_enum
-                            ),
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                        ],
-                    )
-
-                Helper.set_attr_type_list(
-                    new_node,
-                    "Thost_outputs",
-                    [
-                        requantize_node.attr["out_type"].type,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                Helper.set_attr_dtype(new_node, "out_type", dtype_map_dict[requantize_node.attr["out_type"].type])
-                Helper.set_attr_dtype(new_node, "Tsummand", dtype_map_dict[requantize_node.attr["out_type"].type])
-
-            if (
-                quantized_node.op == "QuantizedConv2D"
-                or quantized_node.op == "QuantizedConv2DWithBias"
-                or quantized_node.op == "QuantizedDepthwiseConv2D"
-                or quantized_node.op == "QuantizedDepthwiseConv2DWithBias"
-                or ("alpha" in quantized_node.attr and quantized_node.attr["alpha"].f > 0)
-            ):
-                new_node.attr["out_type"].CopyFrom(attr_value_pb2.AttrValue(type=int8_type))
-            elif (
-                quantized_node.op == "QuantizedConv2DWithBiasAndRelu"
-                or quantized_node.op == "QuantizedDepthwiseConv2DWithBiasAndRelu"
-            ):
-                new_node.attr["out_type"].CopyFrom(attr_value_pb2.AttrValue(type=uint8_type))
-            elif new_node.op not in (
-                "_FusedQuantizedConv2D",
-                "_FusedQuantizedDepthwiseConv2D",
-                "_FusedQuantizedConv3D",
-                "_FusedQuantizedDeconv2D",
-                "_FusedQuantizedDeconv3D",
-            ):
-                new_node.attr["out_type"].CopyFrom(attr_value_pb2.AttrValue(type=uint8_type))
-            elif new_node.op in ("_FusedQuantizedDeconv2D", "_FusedQuantizedDeconv3D"):
-                new_node.attr["out_type"].CopyFrom(attr_value_pb2.AttrValue(type=int8_type))
-            old_input_name = dequantize_node_name if dequantize_node_name else requantize_node_name
-            self.graph_analyzer.replace_single_node(
-                new_node,
-                [parent_node_name],
-                quantized_node_name,
-                self.graph_info[old_input_name].outputs,
-                old_input_name,
-            )
-            self.graph_analyzer.remove_node(quantized_node_name)
-
-        target_nodes = self.graph_analyzer.query_fusion_pattern_nodes(self.sum_pattern)
-        for i in target_nodes:
-            quantized_node_name = i[0]
-            quantized_node = self.graph_info[quantized_node_name].node
-            if i[-1][0] in ("_FusedQuantizedDepthwiseConv2D", "_FusedQuantizedConv2D", "_FusedQuantizedConv3D"):
-                if quantized_node.attr["fused_ops"].list.s not in self.fuse_sum_op_types:
-                    continue
-                # else:
-                #   print(quantized_node.attr['fused_ops'].list.s)
-
-            requantize_node_name = i[1]
-            requantize_node = self.graph_info[requantize_node_name].node
-            requested_output_min_name = requantize_node.input[3]
-            requested_output_max_name = requantize_node.input[4]
-
-            quantized_node_op = i[-1][0]
-
-            new_node = node_def_pb2.NodeDef()
-
-            if self.new_api:
-                if i[-1][0] in ("QuantizedConv2DWithBiasSumAndRelu",):
-                    new_node.op = "_FusedQuantizedConv2D"
-                    self.fused_ops = [b"BiasAdd", b"Sum", b"Relu", b"Requantize"]
-                elif i[-1][0] == "_FusedQuantizedConv2D":
-                    new_node.op = "_FusedQuantizedConv2D"
-                elif quantized_node_op == "_FusedQuantizedDepthwiseConv2D":
-                    new_node.op = "_FusedQuantizedDepthwiseConv2D"
-                elif i[-1][0] == "_FusedQuantizedConv3D":
-                    new_node.op = "_FusedQuantizedConv3D"
-            else:
-                new_node.op = quantized_node_op + "AndRequantize"
-
-            new_node.name = requantize_node_name
-
-            for _, value in enumerate(quantized_node.input[:-1]):
-                new_node.input.append(value)
-
-            new_node.attr["Tinput"].CopyFrom(quantized_node.attr["Tinput"])
-            new_node.attr["Tfilter"].CopyFrom(quantized_node.attr["Tfilter"])
-            new_node.attr["strides"].CopyFrom(quantized_node.attr["strides"])
-            new_node.attr["padding"].CopyFrom(quantized_node.attr["padding"])
-            # new_node.attr["Tsummand"].CopyFrom(quantized_node.attr['Tsummand'])
-
-            new_node.input.append(requested_output_min_name)
-            new_node.input.append(requested_output_max_name)
-            deq_node = self.graph_info[Helper.node_name_from_input(quantized_node.input[-1])].node
-            if deq_node.op != "Dequantize" or deq_node.op.find("Quantize") != -1:
-                continue
-
-            if deq_node.op == "Dequantize":
-                original_summand_node = self.graph_info[Helper.node_name_from_input(deq_node.input[0])].node
-            else:
-                original_summand_node = deq_node
-            summand_op_type = uint8_type if dtypes.as_dtype(deq_node.attr["T"].type) == uint8_type else int8_type
-
-            for j in range(3):
-                new_node.input.append(original_summand_node.name + ":{}".format(j))
-            # in tf 2.10, the "padding_list" attr name changes to explicit_paddings
-            if "padding_list" in quantized_node.attr:
-                if not self.new_api:
-                    new_node.attr["padding_list"].CopyFrom(quantized_node.attr["padding_list"])
-                elif quantized_node.attr["padding"].s == b"EXPLICIT":
-                    new_node.attr["explicit_paddings"].CopyFrom(quantized_node.attr["padding_list"])
-            elif "explicit_paddings" in quantized_node.attr:
-                new_node.attr["explicit_paddings"].CopyFrom(quantized_node.attr["explicit_paddings"])
-
-            if "dilations" in quantized_node.attr:
-                new_node.attr["dilations"].CopyFrom(quantized_node.attr["dilations"])
-
-            if "alpha" in quantized_node.attr and quantized_node.attr["alpha"].f > 0:
-                new_node.attr["out_type"].CopyFrom(attr_value_pb2.AttrValue(type=int8_type))
-            else:
-                new_node.attr["out_type"].CopyFrom(attr_value_pb2.AttrValue(type=uint8_type))
-
-            new_node.attr["Tbias"].CopyFrom(attr_value_pb2.AttrValue(type=float32_type))
-            new_node.attr["Tsummand"].CopyFrom(attr_value_pb2.AttrValue(type=summand_op_type))
-
-            if new_node.op in ("_FusedQuantizedConv2D", "_FusedQuantizedDepthwiseConv2D", "_FusedQuantizedConv3D"):
-                original_input = list(new_node.input)
-                new_input = []
-                new_input.extend(original_input[:3])
-                new_input.append(original_input[-3])
-                new_input.extend(original_input[3:7])
-                new_input.extend(original_input[-2:])
-                new_input.extend(original_input[-5:-3])
-                new_node.ClearField("input")
-                new_node.input.extend(new_input)
-                input_data_type = dtypes.qint8 if new_node.attr["Tinput"].type == dtypes.qint8 else dtypes.quint8
-                Helper.set_attr_type_list(
-                    new_node,
-                    "Thost_inputs",
-                    [
-                        input_data_type.as_datatype_enum,
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        (
-                            dtypes.quint8.as_datatype_enum
-                            if summand_op_type != int8_type
-                            else dtypes.qint8.as_datatype_enum
-                        ),
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                Helper.set_attr_dtype(
-                    new_node, "Tsummand", dtypes.quint8 if summand_op_type != int8_type else dtypes.qint8
-                )
-                if str(quantized_node.attr["fused_ops"].list.s) == str([b"BiasAdd", b"Sum", b"Relu"]):
-                    self.fused_ops = [b"BiasAdd", b"Sum", b"Relu", b"Requantize"]
-                elif str(quantized_node.attr["fused_ops"].list.s) == str([b"BiasAdd", b"Sum", b"LeakyRelu"]):
-                    self.fused_ops = [b"BiasAdd", b"Sum", b"LeakyRelu", b"Requantize"]
-                elif str(quantized_node.attr["fused_ops"].list.s) == str([b"BiasAdd", b"LeakyRelu", b"Sum"]):
-                    self.fused_ops = [b"BiasAdd", b"LeakyRelu", b"Sum", b"Requantize"]
-                elif str(quantized_node.attr["fused_ops"].list.s) == str([b"BiasAdd", b"Relu", b"Sum"]):
-                    self.fused_ops = [b"BiasAdd", b"Relu", b"Sum", b"Requantize"]
-                    # Current fusion requires summand has same dtype as output if output is qint8
-                    Helper.set_attr_dtype(new_node, "Tsummand", dtype_map_dict[requantize_node.attr["out_type"].type])
-                elif str(quantized_node.attr["fused_ops"].list.s) == str([b"BiasAdd", b"Sum"]):
-                    self.fused_ops = [b"BiasAdd", b"Sum", b"Requantize"]
-                    # Current fusion requires summand has same dtype as output if output is qint8
-                    Helper.set_attr_dtype(new_node, "Tsummand", dtype_map_dict[requantize_node.attr["out_type"].type])
-                Helper.set_attr_type_list(
-                    new_node,
-                    "Thost_outputs",
-                    [
-                        requantize_node.attr["out_type"].type,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                Helper.set_attr_dtype(new_node, "out_type", dtype_map_dict[requantize_node.attr["out_type"].type])
-                Helper.set_attr_string_list(new_node, "fused_ops", self.fused_ops)
-
-            if not self.new_api:
-                if quantized_node_op == "QuantizedConv2DWithBiasReluAndSum":
-                    new_node.op = "QuantizedConv2DWithBiasReluAndSumAndRequantize"
-                    if "alpha" in quantized_node.attr:
-                        new_node.attr["alpha"].CopyFrom(quantized_node.attr["alpha"])
-
-                elif summand_op_type == int8_type:
-                    new_node.op = "QuantizedConv2DWithBiasSignedSumAndReluAndRequantize"
-
-            self.graph_analyzer.replace_single_node(
-                new_node,
-                [quantized_node.input[0], original_summand_node.name],
-                quantized_node.name,
-                self.graph_info[requantize_node_name].outputs,
-                requantize_node_name,
-            )
-            self.graph_analyzer.remove_node(quantized_node_name)
-
-            if deq_node.op == "Dequantize":
-                self.graph_analyzer.remove_node_with_single_input_output(deq_node.name)
-
-        return self.graph_analyzer.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/fuse_matmul_redundant_dequantize.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/fuse_matmul_redundant_dequantize.py
deleted file mode 100644
index 66e071509e2..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/fuse_matmul_redundant_dequantize.py
+++ /dev/null
@@ -1,160 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Fuse QuantizedMatMul with redundant Dequantize Graph Rewriter."""
-
-import ast
-
-from tensorflow.core.framework import attr_value_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-
-from ..graph_base import GraphRewriterBase
-
-
-class FuseMatMulRedundantDequantizeTransformer(GraphRewriterBase):
-    """Fuse _QuantizedMatMul with the successor Dequantize Op."""
-
-    fuse_patterns = [["_QuantizedMatMul", "_QuantizedBatchMatMul"], ["Dequantize", "Cast"]]
-
-    def __init__(self, model, device="cpu"):
-        """Initialization."""
-        super().__init__(model)
-        self.device = device
-        self.graph_analyzer = GraphAnalyzer()
-        self.graph_analyzer.graph = self.model
-        self.graph_info = self.graph_analyzer.parse_graph()
-
-    def do_transformation(self):
-        """Fuse the _QuantizedMatMul with the following Dequantize op.
-
-        The output of _QuantizedMatMul or is fp32 or bf16.
-
-        Returns:
-            [graphdef]: the optimized graphdef object
-        """
-        target_nodes = self.graph_analyzer.query_fusion_pattern_nodes(self.fuse_patterns)
-
-        for i in target_nodes:
-            quantized_node_name = i[0]
-            quantized_node = self.graph_info[quantized_node_name].node
-            dequantize_node_name = i[1]
-            dequantize_node = self.graph_info[dequantize_node_name].node
-
-            if len(self.graph_info[quantized_node_name].outputs) > 3:  # pragma: no cover
-                need_drop = False
-                for output in self.graph_info[quantized_node_name].outputs:
-                    if self.graph_info[output].node.op != "Dequantize":
-                        need_drop = True
-                        break
-                if need_drop:
-                    continue
-
-            # ignore shared output case for license-plate-recognition-barrier-0007 model
-            if (
-                len(self.graph_info[dequantize_node_name].outputs) == 2
-                and self.graph_info[self.graph_info[dequantize_node_name].outputs[0]].node.op == "Reshape"
-                and self.graph_info[self.graph_info[dequantize_node_name].outputs[1]].node.op == "Shape"
-            ):
-                continue
-
-            new_node = node_def_pb2.NodeDef()
-            new_node.op = quantized_node.op
-
-            if dequantize_node.op == "Dequantize":
-                fused_ops = str(quantized_node.attr["fused_ops"].list.s).replace("Requantize", "Dequantize")
-            new_node.name = quantized_node.name + "_dequantize"
-
-            for _, value in enumerate(quantized_node.input):
-                new_node.input.append(value)
-
-            if "input_quant_mode" in quantized_node.attr:
-                new_node.attr["input_quant_mode"].CopyFrom(quantized_node.attr["input_quant_mode"])
-            if "output_quant_mode" in quantized_node.attr:
-                new_node.attr["output_quant_mode"].CopyFrom(quantized_node.attr["output_quant_mode"])
-            if "leakyrelu_alpha" in quantized_node.attr:
-                new_node.attr["leakyrelu_alpha"].CopyFrom(quantized_node.attr["leakyrelu_alpha"])
-            if "T1" in quantized_node.attr:
-                new_node.attr["T1"].CopyFrom(quantized_node.attr["T1"])
-            if "T2" in quantized_node.attr:
-                new_node.attr["T2"].CopyFrom(quantized_node.attr["T2"])
-            if "U" in quantized_node.attr:
-                new_node.attr["U"].CopyFrom(quantized_node.attr["U"])
-            if "is_weight_const" in quantized_node.attr:
-                new_node.attr["is_weight_const"].CopyFrom(quantized_node.attr["is_weight_const"])
-            if "is_bias_const" in quantized_node.attr:
-                new_node.attr["is_bias_const"].CopyFrom(quantized_node.attr["is_bias_const"])
-            if "transpose_a" in quantized_node.attr:
-                new_node.attr["transpose_a"].CopyFrom(quantized_node.attr["transpose_a"])
-            if "transpose_b" in quantized_node.attr:
-                new_node.attr["transpose_b"].CopyFrom(quantized_node.attr["transpose_b"])
-            if "Tdevice_inputs" in quantized_node.attr:
-                new_node.attr["Tdevice_inputs"].CopyFrom(quantized_node.attr["Tdevice_inputs"])
-            if "Tdevice_outputs" in quantized_node.attr:
-                new_node.attr["Tdevice_outputs"].CopyFrom(quantized_node.attr["Tdevice_outputs"])
-            if "Thost_inputs" in quantized_node.attr:
-                new_node.attr["Thost_inputs"].CopyFrom(quantized_node.attr["Thost_inputs"])
-            if "Tbias" in quantized_node.attr:
-                new_node.attr["Tbias"].CopyFrom(quantized_node.attr["Tbias"])
-            if "adj_x" in quantized_node.attr:
-                new_node.attr["adj_x"].CopyFrom(quantized_node.attr["adj_x"])
-            if "adj_y" in quantized_node.attr:
-                new_node.attr["adj_y"].CopyFrom(quantized_node.attr["adj_y"])
-            if "input_quant_mode" in quantized_node.attr:
-                new_node.attr["input_quant_mode"].CopyFrom(quantized_node.attr["input_quant_mode"])
-            if "output_quant_mode" in quantized_node.attr:
-                new_node.attr["output_quant_mode"].CopyFrom(quantized_node.attr["output_quant_mode"])
-            if "fused_ops" in quantized_node.attr:
-                new_node.attr["fused_ops"].CopyFrom(quantized_node.attr["fused_ops"])
-
-            # update Tbias for single MatMul without bias case, same as Tout.
-            if dequantize_node.op == "Dequantize":
-                Helper.set_attr_type_list(new_node, "Thost_outputs", [dequantize_node.attr["dtype"].type])
-                new_node.attr["Tout"].CopyFrom(attr_value_pb2.AttrValue(type=dequantize_node.attr["dtype"].type))
-                if new_node.op == "_QuantizedBatchMatMul":
-                    new_node.attr["U"].CopyFrom(attr_value_pb2.AttrValue(type=dequantize_node.attr["DstT"].type))
-                if str(quantized_node.attr["fused_ops"].list.s) == str([b"Requantize"]):
-                    new_node.attr["Tbias"].CopyFrom(attr_value_pb2.AttrValue(type=dequantize_node.attr["dtype"].type))
-                Helper.set_attr_string_list(new_node, "fused_ops", ast.literal_eval(fused_ops))
-            else:
-                Helper.set_attr_type_list(new_node, "Thost_outputs", [dequantize_node.attr["DstT"].type])
-                new_node.attr["Tout"].CopyFrom(attr_value_pb2.AttrValue(type=dequantize_node.attr["DstT"].type))
-                if new_node.op == "_QuantizedBatchMatMul":
-                    new_node.attr["U"].CopyFrom(attr_value_pb2.AttrValue(type=dequantize_node.attr["DstT"].type))
-
-            top_node_name = Helper.node_name_from_input(quantized_node.input[0])
-            if self.graph_info[dequantize_node_name].outputs:
-                self.graph_analyzer.replace_single_node(
-                    new_node,
-                    [top_node_name],
-                    quantized_node_name,
-                    self.graph_info[dequantize_node_name].outputs,
-                    dequantize_node_name,
-                )
-                self.graph_analyzer.remove_node(dequantize_node_name)
-            else:
-                self.graph_analyzer.remove_node(dequantize_node_name)
-
-                new_node.name = dequantize_node_name
-                self.graph_analyzer.replace_single_node(
-                    new_node, [top_node_name], quantized_node_name, [], dequantize_node_name
-                )
-
-            self.graph_analyzer.remove_node(quantized_node_name)
-
-        return self.graph_analyzer.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/fuse_matmul_requantize.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/fuse_matmul_requantize.py
deleted file mode 100644
index 2fef260b500..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/fuse_matmul_requantize.py
+++ /dev/null
@@ -1,908 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Fuse QuantizedMatMul with Requantize/Dequantize Graph Rewriter."""
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.core.framework import attr_value_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import version1_gt_version2, version1_lt_version2
-
-from ..graph_base import GraphRewriterBase
-
-
-class FuseMatMulRequantizeDequantizeTransformer(GraphRewriterBase):
-    """Fuse QuantizedMatMul + Requantize + Dequantize into QuantizedMatMulWithBiasAndDequantize."""
-
-    def __init__(self, model, device="cpu"):
-        """Initialization."""
-        super().__init__(model)
-        self.device = device
-        self.graph_analyzer = GraphAnalyzer()
-        self.graph_analyzer.graph = self.model
-
-        self.graph_info = self.graph_analyzer.parse_graph()
-
-        self.eps = 1e-5
-
-    def do_transformation(self):
-        """Apply the fusion of QuantizedMatMul + Requantize + Dequantize."""
-        fuse_pattern = []
-        if tf.version.VERSION in ("1.15.0-up2", "1.15.0-up3") or version1_gt_version2(tf.version.VERSION, "2.1.0"):
-            fuse_pattern = [["QuantizedMatMulWithBias"], ["Requantize"], ["Dequantize"], ("Softmax",)]
-        float32_type = dtypes.float32.as_datatype_enum
-        qint32_type = dtypes.qint32.as_datatype_enum
-        target_nodes = self.graph_analyzer.query_fusion_pattern_nodes(fuse_pattern)
-        for i in target_nodes:
-            # TODO Remove below checker once the TF's limitation removed.
-            if len(i) == 5 and version1_lt_version2(tf.__version__, "2.6.0"):
-                continue
-
-            quantized_node_name = i[0]
-            quantized_node = self.graph_info[quantized_node_name].node
-            requantize_node_name = i[1]
-            requantize_node = self.graph_info[requantize_node_name].node
-            requested_output_min_name = requantize_node.input[3]
-            requested_output_max_name = requantize_node.input[4]
-            deq_node_name = i[2]
-
-            quantized_node_op = i[-1][0]
-
-            new_node = node_def_pb2.NodeDef()
-
-            new_node.op = quantized_node_op + "AndDequantize"
-            new_node.name = requantize_node_name
-            for _, value in enumerate(quantized_node.input):
-                new_node.input.append(value)
-
-            new_node.input.append(requested_output_min_name)
-            new_node.input.append(requested_output_max_name)
-            if "T1" in quantized_node.attr:
-                new_node.attr["T1"].CopyFrom(quantized_node.attr["T1"])
-            if "T2" in quantized_node.attr:
-                new_node.attr["T2"].CopyFrom(quantized_node.attr["T2"])
-
-            top_node_name = Helper.node_name_from_input(quantized_node.input[0])
-            max_filter_node = self.graph_info[new_node.input[6]].node
-            min_filter_node = self.graph_info[new_node.input[5]].node
-            last_node = self.graph_info[new_node.input[0]].node
-
-            weight_node = self.graph_info[Helper.node_name_from_input(new_node.input[1])].node
-            bias_node = self.graph_info[Helper.node_name_from_input(new_node.input[2])].node
-            max_input_node = self.graph_info[last_node.input[-1]].node
-            min_input_node = self.graph_info[last_node.input[-2]].node
-
-            if max_input_node.op == "Enter":  # pragma: no cover
-                min_input_parent_name = Helper.node_name_from_input(min_input_node.input[0])
-                max_input_parent_name = Helper.node_name_from_input(max_input_node.input[0])
-                min_input_parent_node = self.graph_info[min_input_parent_name].node
-                max_input_parent_node = self.graph_info[max_input_parent_name].node
-                if min_input_parent_node.op != "Const" or max_input_parent_node.op != "Const":
-                    continue
-                min_input_node = min_input_parent_node
-                max_input_node = max_input_parent_node
-            if max_filter_node.op == "Enter":  # pragma: no cover
-                min_filter_parent_name = Helper.node_name_from_input(min_filter_node.input[0])
-                max_filter_parent_name = Helper.node_name_from_input(max_filter_node.input[0])
-                min_filter_parent_node = self.graph_info[min_filter_parent_name].node
-                max_filter_parent_node = self.graph_info[max_filter_parent_name].node
-                if min_filter_parent_node.op != "Const" or max_filter_parent_node.op != "Const":
-                    continue
-                min_filter_node = min_filter_parent_node
-                max_filter_node = max_filter_parent_node
-            if weight_node.op == "Enter":  # pragma: no cover
-                weight_parent_name = Helper.node_name_from_input(weight_node.input[0])
-                weight_parent_node = self.graph_info[weight_parent_name].node
-                if weight_parent_node.op != "Const":
-                    continue
-                weight_node = weight_parent_node
-            bias_enter_node = None
-            if bias_node.op == "Enter":  # pragma: no cover
-                bias_enter_node = bias_node
-                bias_parent_name = Helper.node_name_from_input(bias_node.input[0])
-                bias_parent_node = self.graph_info[bias_parent_name].node
-                if bias_parent_node.op != "Const":
-                    continue
-                bias_node = bias_parent_node
-
-            if max_filter_node.op == "Const":
-                min_input_value = (min_input_node.attr["value"].tensor.float_val)[0]
-                max_input_value = (max_input_node.attr["value"].tensor.float_val)[0]
-
-                max_filter_value = (max_filter_node.attr["value"].tensor.float_val)[0]
-                min_filter_value = (min_filter_node.attr["value"].tensor.float_val)[0]
-
-                weights_tensor = tensor_util.MakeNdarray(weight_node.attr["value"].tensor)
-                bias_tensor = tensor_util.MakeNdarray(bias_node.attr["value"].tensor)
-                is_min_first = bool(quantized_node.attr["input_quant_mode"].s == b"MIN_FIRST")
-                input_range = (
-                    max_input_value - min_input_value
-                    if is_min_first
-                    else max(abs(max_input_value), abs(min_input_value))
-                )
-
-                if -self.eps <= input_range <= self.eps:
-                    input_range += self.eps
-
-                if -self.eps <= max_input_value - min_input_value <= self.eps:
-                    max_input_value += self.eps
-                int32_bias = Helper.generate_int32_bias_for_matmul(
-                    bias_tensor,
-                    weights_tensor,
-                    input_range,
-                    max_input_value,
-                    min_input_value,
-                    max_filter_value,
-                    min_filter_value,
-                )
-
-                bias_node.attr["dtype"].CopyFrom(
-                    attr_value_pb2.AttrValue(type=float32_type if self.device == "gpu" else qint32_type)
-                )
-                bias_node.attr["value"].CopyFrom(
-                    attr_value_pb2.AttrValue(
-                        tensor=tensor_util.make_tensor_proto(
-                            bias_tensor if self.device == "gpu" else int32_bias,
-                            dtypes.float32 if self.device == "gpu" else dtypes.int32,
-                            bias_tensor.shape,
-                        )
-                    )
-                )
-
-                bias_node.attr["value"].tensor.dtype = float32_type if self.device == "gpu" else qint32_type
-                new_node.attr["Tbias"].CopyFrom(
-                    attr_value_pb2.AttrValue(type=float32_type if self.device == "gpu" else qint32_type)
-                )
-                if bias_enter_node:
-                    bias_enter_node.attr["T"].CopyFrom(
-                        attr_value_pb2.AttrValue(type=float32_type if self.device == "gpu" else qint32_type)
-                    )
-            else:
-                new_node.attr["Tbias"].CopyFrom(attr_value_pb2.AttrValue(type=float32_type))
-            new_node.attr["Toutput"].CopyFrom(attr_value_pb2.AttrValue(type=float32_type))
-
-            self.graph_analyzer.remove_node(requantize_node_name)
-
-            if self.graph_info[deq_node_name].outputs:
-                self.graph_analyzer.replace_single_node(
-                    new_node,
-                    [top_node_name],
-                    quantized_node_name,
-                    self.graph_info[deq_node_name].outputs,
-                    deq_node_name,
-                )
-                self.graph_analyzer.remove_node(deq_node_name)
-            else:
-                self.graph_analyzer.remove_node(deq_node_name)
-
-                new_node.name = deq_node_name
-                self.graph_analyzer.replace_single_node(
-                    new_node, [top_node_name], quantized_node_name, [], deq_node_name
-                )
-
-            self.graph_analyzer.remove_node(quantized_node_name)
-
-        return self.graph_analyzer.dump_graph()
-
-
-class FuseMatMulRequantizeTransformer(GraphRewriterBase):
-    """Fuse Quantized MatMul Op with the successor Requantize Op."""
-
-    def __init__(self, model, device="cpu"):
-        """Initialization."""
-        super().__init__(model)
-        self.device = device
-        self.graph_analyzer = GraphAnalyzer()
-        self.graph_analyzer.graph = self.model
-        self.eps = 1e-05
-        self.graph_info = self.graph_analyzer.parse_graph()
-
-    def do_transformation(self):
-        """Fuse the quantized op with the following requantize op.
-
-        Returns:
-            [graphdef]: the optimized graphdef object
-        """
-        uint8_type = dtypes.quint8.as_datatype_enum
-        float32_type = dtypes.float32.as_datatype_enum
-        qint32_type = dtypes.qint32.as_datatype_enum
-
-        while True:
-            target_nodes = self.graph_analyzer.query_fusion_pattern_nodes(
-                [["QuantizedMatMulWithBiasAndRelu"], ["Requantize"]]
-            )
-            if len(target_nodes) == 0:
-                break
-
-            i = target_nodes[0]
-            quantized_node_name = i[0]
-            quantized_node = self.graph_info[quantized_node_name].node
-            requantize_node_name = i[1]
-            requantize_node = self.graph_info[requantize_node_name].node
-            requested_output_min_name = requantize_node.input[3]
-            requested_output_max_name = requantize_node.input[4]
-
-            quantized_node_op = i[-1][0]
-
-            new_node = node_def_pb2.NodeDef()
-
-            new_node.op = quantized_node_op + "AndRequantize"
-            new_node.name = requantize_node_name
-            for _, value in enumerate(quantized_node.input):
-                new_node.input.append(value)
-            new_node.input.append(requested_output_min_name)
-            new_node.input.append(requested_output_max_name)
-            if "T1" in quantized_node.attr:
-                new_node.attr["T1"].CopyFrom(quantized_node.attr["T1"])
-            if "T2" in quantized_node.attr:
-                new_node.attr["T2"].CopyFrom(quantized_node.attr["T2"])
-
-            parent_node_name = Helper.node_name_from_input(quantized_node.input[0])
-            max_filter_node = self.graph_info[new_node.input[6]].node
-            min_filter_node = self.graph_info[new_node.input[5]].node
-            last_node = self.graph_info[new_node.input[0]].node
-
-            is_min_first = bool(quantized_node.attr["input_quant_mode"].s == b"MIN_FIRST")
-
-            weight_node = self.graph_info[new_node.input[1]].node
-            bias_node = self.graph_info[new_node.input[2]].node
-
-            max_input_node = None
-            min_input_node = None
-            if last_node.op.find("Requantize") != -1 or last_node.op.find("QuantizeV2") != -1:
-                max_input_node = self.graph_info[last_node.input[-1]].node
-                min_input_node = self.graph_info[last_node.input[-2]].node
-
-            if max_input_node and max_input_node.op == "Enter":  # pragma: no cover
-                min_input_parent_name = Helper.node_name_from_input(min_input_node.input[0])
-                max_input_parent_name = Helper.node_name_from_input(max_input_node.input[0])
-                min_input_parent_node = self.graph_info[min_input_parent_name].node
-                max_input_parent_node = self.graph_info[max_input_parent_name].node
-                if min_input_parent_node.op != "Const" or max_input_parent_node.op != "Const":
-                    continue
-                min_input_node = min_input_parent_node
-                max_input_node = max_input_parent_node
-            if max_filter_node.op == "Enter":  # pragma: no cover
-                min_filter_parent_name = Helper.node_name_from_input(min_filter_node.input[0])
-                max_filter_parent_name = Helper.node_name_from_input(max_filter_node.input[0])
-                min_filter_parent_node = self.graph_info[min_filter_parent_name].node
-                max_filter_parent_node = self.graph_info[max_filter_parent_name].node
-                if min_filter_parent_node.op != "Const" or max_filter_parent_node.op != "Const":
-                    continue
-                min_filter_node = min_filter_parent_node
-                max_filter_node = max_filter_parent_node
-            if weight_node.op == "Enter":  # pragma: no cover
-                weight_parent_name = Helper.node_name_from_input(weight_node.input[0])
-                weight_parent_node = self.graph_info[weight_parent_name].node
-                if weight_parent_node.op != "Const":
-                    continue
-                weight_node = weight_parent_node
-            bias_enter_node = None
-            if bias_node.op == "Enter":  # pragma: no cover
-                bias_enter_node = bias_node
-                bias_parent_name = Helper.node_name_from_input(bias_node.input[0])
-                bias_parent_node = self.graph_info[bias_parent_name].node
-                if bias_parent_node.op != "Const":
-                    continue
-                bias_node = bias_parent_node
-
-            if last_node.op.find("Requantize") != -1 or last_node.op.find("QuantizeV2") != -1:
-                min_input_value = (min_input_node.attr["value"].tensor.float_val)[0]
-                max_input_value = (max_input_node.attr["value"].tensor.float_val)[0]
-
-                max_filter_value = (max_filter_node.attr["value"].tensor.float_val)[0]
-                min_filter_value = (min_filter_node.attr["value"].tensor.float_val)[0]
-
-                weights_tensor = tensor_util.MakeNdarray(weight_node.attr["value"].tensor)
-                bias_tensor = tensor_util.MakeNdarray(bias_node.attr["value"].tensor)
-
-                input_range = (
-                    max_input_value - min_input_value
-                    if is_min_first
-                    else max(abs(max_input_value), abs(min_input_value))
-                )
-
-                if -self.eps <= input_range <= self.eps:
-                    input_range += self.eps
-
-                if -self.eps <= max_input_value - min_input_value <= self.eps:
-                    max_input_value += self.eps
-                int32_bias = Helper.generate_int32_bias_for_matmul(
-                    bias_tensor,
-                    weights_tensor,
-                    input_range,
-                    max_input_value,
-                    min_input_value,
-                    max_filter_value,
-                    min_filter_value,
-                )
-                bias_node.attr["dtype"].CopyFrom(
-                    attr_value_pb2.AttrValue(type=float32_type if self.device == "gpu" else qint32_type)
-                )
-                bias_node.attr["value"].CopyFrom(
-                    attr_value_pb2.AttrValue(
-                        tensor=tensor_util.make_tensor_proto(
-                            bias_tensor if self.device == "gpu" else int32_bias,
-                            dtypes.float32 if self.device == "gpu" else dtypes.int32,
-                            bias_tensor.shape,
-                        )
-                    )
-                )
-
-                bias_node.attr["value"].tensor.dtype = float32_type if self.device == "gpu" else qint32_type
-                new_node.attr["Tbias"].CopyFrom(
-                    attr_value_pb2.AttrValue(type=float32_type if self.device == "gpu" else qint32_type)
-                )
-
-                new_node.attr["Toutput"].CopyFrom(attr_value_pb2.AttrValue(type=uint8_type))
-                # TODO enabled below commit once the graph refactor pre_optimize committed.
-                if quantized_node_op.find("Relu") == -1:
-                    deq_node_name = self.graph_info[requantize_node_name].outputs[0]
-                    deq_node = self.graph_info[deq_node_name].node
-                    deq_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=uint8_type))
-                if bias_enter_node:
-                    bias_enter_node.attr["T"].CopyFrom(
-                        attr_value_pb2.AttrValue(type=float32_type if self.device == "gpu" else qint32_type)
-                    )
-            else:
-                new_node.attr["Tbias"].CopyFrom(attr_value_pb2.AttrValue(type=float32_type))
-
-            self.graph_analyzer.replace_single_node(
-                new_node,
-                [parent_node_name],
-                quantized_node_name,
-                [self.graph_info[requantize_node_name].outputs[0]],
-                requantize_node_name,
-            )
-            self.graph_analyzer.remove_node(quantized_node_name)
-
-        return self.graph_analyzer.dump_graph()
-
-
-class FuseMatMulRequantizeDequantizeNewAPITransformer(GraphRewriterBase):  # pragma: no cover
-    """Fuse _QuantizedMatMul + Requantize + Dequantize into _QuantizedMatMul."""
-
-    def __init__(self, model, device="cpu"):
-        """Initialization."""
-        super().__init__(model)
-        self.device = device
-        self.graph_analyzer = GraphAnalyzer()
-        self.graph_analyzer.graph = self.model
-
-        self.graph_info = self.graph_analyzer.parse_graph()
-
-        self.eps = 1e-5
-
-    def do_transformation(self):
-        """Apply the fusion of QuantizedMatMul + Requantize + Dequantize."""
-        fuse_pattern = [["_QuantizedMatMul"], ["Requantize", "RequantizePerChannel"], ["Dequantize"], ("Softmax",)]
-
-        uint8_type = dtypes.quint8.as_datatype_enum
-        int8_type = dtypes.qint8.as_datatype_enum
-        float32_type = dtypes.float32.as_datatype_enum
-        qint32_type = dtypes.qint32.as_datatype_enum
-        target_nodes = self.graph_analyzer.query_fusion_pattern_nodes(fuse_pattern)
-        for i in target_nodes:
-            quantized_node_name = i[0]
-            quantized_node = self.graph_info[quantized_node_name].node
-            requantize_node_name = i[1]
-            requantize_node = self.graph_info[requantize_node_name].node
-            requested_output_min_name = requantize_node.input[3]
-            requested_output_max_name = requantize_node.input[4]
-            deq_node_name = i[2]
-
-            quantized_node_op = i[-1][0]
-
-            # "BiasAdd" + "Add" only supports "Dequantize"
-            attr_fused_ops = "".join(
-                x
-                for x in quantized_node.attr["fused_ops"].SerializeToString().decode("UTF-8", "ignore").strip()
-                if x.isprintable()
-            )
-            if "BiasAddAdd" not in attr_fused_ops:
-                continue
-
-            new_node = node_def_pb2.NodeDef()
-
-            new_node.op = quantized_node_op
-            new_node.name = requantize_node_name
-            for _, value in enumerate(quantized_node.input):
-                new_node.input.append(value)
-
-            new_node.input.append(requested_output_min_name)
-            new_node.input.append(requested_output_max_name)
-            if "T1" in quantized_node.attr:
-                new_node.attr["T1"].CopyFrom(quantized_node.attr["T1"])
-            if "T2" in quantized_node.attr:
-                new_node.attr["T2"].CopyFrom(quantized_node.attr["T2"])
-            if "U" in quantized_node.attr:
-                new_node.attr["U"].CopyFrom(quantized_node.attr["U"])
-            if "transpose_b" in quantized_node.attr:
-                new_node.attr["transpose_b"].CopyFrom(quantized_node.attr["transpose_b"])
-            if "transpose_a" in quantized_node.attr:
-                new_node.attr["transpose_a"].CopyFrom(quantized_node.attr["transpose_a"])
-            if "input_quant_mode" in quantized_node.attr:
-                new_node.attr["input_quant_mode"].CopyFrom(quantized_node.attr["input_quant_mode"])
-            if "output_quant_mode" in quantized_node.attr:
-                new_node.attr["output_quant_mode"].CopyFrom(quantized_node.attr["output_quant_mode"])
-
-            top_node_name = Helper.node_name_from_input(quantized_node.input[0])
-            max_filter_node = None
-            min_filter_node = None
-
-            # MatMul + BiasAdd + Add
-            # The Min and Max of non-const weight node are from QuantizeV2's output, not valid nodes.
-            # Add check here for excluding this case.
-            if ":2" not in new_node.input[7]:
-                max_filter_node = self.graph_info[new_node.input[7]].node
-            if ":1" not in new_node.input[6]:
-                min_filter_node = self.graph_info[new_node.input[6]].node
-            last_node = self.graph_info[new_node.input[0]].node
-            weight_node = self.graph_info[Helper.node_name_from_input(new_node.input[1])].node
-            bias_node = self.graph_info[Helper.node_name_from_input(new_node.input[2])].node
-            if not last_node.op == "QuantizedConcatV2":
-                max_input_node = self.graph_info[last_node.input[-1]].node
-                min_input_node = self.graph_info[last_node.input[-2]].node
-
-            type_bias = float32_type
-            if not last_node.op == "QuantizedConcatV2" and max_input_node.op == "Enter":  # pragma: no cover
-                min_input_parent_name = Helper.node_name_from_input(min_input_node.input[0])
-                max_input_parent_name = Helper.node_name_from_input(max_input_node.input[0])
-                min_input_parent_node = self.graph_info[min_input_parent_name].node
-                max_input_parent_node = self.graph_info[max_input_parent_name].node
-                if min_input_parent_node.op != "Const" or max_input_parent_node.op != "Const":
-                    continue
-                min_input_node = min_input_parent_node
-                max_input_node = max_input_parent_node
-            if max_filter_node and min_filter_node and max_filter_node.op == "Enter":  # pragma: no cover
-                min_filter_parent_name = Helper.node_name_from_input(min_filter_node.input[0])
-                max_filter_parent_name = Helper.node_name_from_input(max_filter_node.input[0])
-                min_filter_parent_node = self.graph_info[min_filter_parent_name].node
-                max_filter_parent_node = self.graph_info[max_filter_parent_name].node
-                if min_filter_parent_node.op != "Const" or max_filter_parent_node.op != "Const":
-                    continue
-                min_filter_node = min_filter_parent_node
-                max_filter_node = max_filter_parent_node
-            if weight_node.op == "Enter":  # pragma: no cover
-                weight_parent_name = Helper.node_name_from_input(weight_node.input[0])
-                weight_parent_node = self.graph_info[weight_parent_name].node
-                if weight_parent_node.op != "Const":
-                    continue
-                weight_node = weight_parent_node
-            bias_enter_node = None
-            if bias_node.op == "Enter":  # pragma: no cover
-                bias_enter_node = bias_node
-                bias_parent_name = Helper.node_name_from_input(bias_node.input[0])
-                bias_parent_node = self.graph_info[bias_parent_name].node
-                if bias_parent_node.op != "Const":
-                    continue
-                bias_node = bias_parent_node
-
-            if (
-                max_filter_node
-                and min_filter_node
-                and max_filter_node.op == "Const"
-                and weight_node.op == "Const"
-                and not last_node.op == "QuantizedConcatV2"
-            ):
-                min_input_value = (min_input_node.attr["value"].tensor.float_val)[0]
-                max_input_value = (max_input_node.attr["value"].tensor.float_val)[0]
-                if requantize_node.op.find("PerChannel") != -1:  # pragma: no cover
-                    max_filter_tensor = tensor_util.MakeNdarray(max_filter_node.attr["value"].tensor)  # get tensor
-                    min_filter_tensor = tensor_util.MakeNdarray(min_filter_node.attr["value"].tensor)  # get tensor
-                else:
-                    max_filter_value = (max_filter_node.attr["value"].tensor.float_val)[0]
-                    min_filter_value = (min_filter_node.attr["value"].tensor.float_val)[0]
-
-                weights_tensor = tensor_util.MakeNdarray(weight_node.attr["value"].tensor)
-                bias_tensor = tensor_util.MakeNdarray(bias_node.attr["value"].tensor)
-                is_min_first = bool(quantized_node.attr["input_quant_mode"].s == b"MIN_FIRST")
-                input_range = (
-                    max_input_value - min_input_value
-                    if is_min_first
-                    else max(abs(max_input_value), abs(min_input_value))
-                )
-
-                if -self.eps <= input_range <= self.eps:
-                    input_range += self.eps
-
-                if -self.eps <= max_input_value - min_input_value <= self.eps:
-                    max_input_value += self.eps
-                if requantize_node.op.find("PerChannel") != -1:  # pragma: no cover
-                    int32_bias = Helper.generate_int32_bias_for_matmul_per_channel(
-                        bias_tensor,
-                        weights_tensor,
-                        max_input_value,
-                        min_input_value,
-                        max_filter_tensor,
-                        min_filter_tensor,
-                    )
-                else:
-                    int32_bias = Helper.generate_int32_bias_for_matmul(
-                        bias_tensor,
-                        weights_tensor,
-                        input_range,
-                        max_input_value,
-                        min_input_value,
-                        max_filter_value,
-                        min_filter_value,
-                    )
-
-                bias_node.attr["dtype"].CopyFrom(
-                    attr_value_pb2.AttrValue(type=float32_type if self.device == "gpu" else qint32_type)
-                )
-                bias_node.attr["value"].CopyFrom(
-                    attr_value_pb2.AttrValue(
-                        tensor=tensor_util.make_tensor_proto(
-                            bias_tensor if self.device == "gpu" else int32_bias,
-                            dtypes.float32 if self.device == "gpu" else dtypes.int32,
-                            bias_tensor.shape,
-                        )
-                    )
-                )
-
-                bias_node.attr["value"].tensor.dtype = float32_type if self.device == "gpu" else qint32_type
-                type_bias = float32_type if self.device == "gpu" else qint32_type
-                if bias_enter_node:
-                    bias_enter_node.attr["T"].CopyFrom(
-                        attr_value_pb2.AttrValue(type=float32_type if self.device == "gpu" else qint32_type)
-                    )
-            else:
-                type_bias = float32_type
-
-            new_node.attr["Tbias"].CopyFrom(attr_value_pb2.AttrValue(type=type_bias))
-
-            Helper.set_attr_string_list(new_node, "fused_ops", [b"BiasAdd", b"Add", b"Dequantize"])
-            Helper.set_attr_type_list(
-                new_node,
-                "Thost_inputs",
-                [
-                    uint8_type,
-                    int8_type,
-                    type_bias,
-                    float32_type,
-                    float32_type,
-                    float32_type,
-                    float32_type,
-                    float32_type,
-                    float32_type,
-                    float32_type,
-                ],
-            )
-
-            Helper.set_attr_type_list(new_node, "Thost_outputs", [float32_type])
-            new_node.attr["Tout"].CopyFrom(attr_value_pb2.AttrValue(type=float32_type))
-
-            self.graph_analyzer.remove_node(requantize_node_name)
-
-            if self.graph_info[deq_node_name].outputs:
-                self.graph_analyzer.replace_single_node(
-                    new_node,
-                    [top_node_name],
-                    quantized_node_name,
-                    self.graph_info[deq_node_name].outputs,
-                    deq_node_name,
-                )
-                self.graph_analyzer.remove_node(deq_node_name)
-            else:
-                self.graph_analyzer.remove_node(deq_node_name)
-
-                new_node.name = deq_node_name
-                self.graph_analyzer.replace_single_node(
-                    new_node, [top_node_name], quantized_node_name, [], deq_node_name
-                )
-
-            self.graph_analyzer.remove_node(quantized_node_name)
-
-        return self.graph_analyzer.dump_graph()
-
-
-class FuseMatMulRequantizeNewAPITransformer(GraphRewriterBase):
-    """Fuse newAPI Quantized MatMul Op with the successor Requantize Op."""
-
-    def __init__(self, model, device="cpu"):
-        """Initialization."""
-        super().__init__(model)
-        self.device = device
-        self.graph_analyzer = GraphAnalyzer()
-        self.graph_analyzer.graph = self.model
-        self.eps = 1e-05
-        self.graph_info = self.graph_analyzer.parse_graph()
-
-    def do_transformation(self):
-        """Fuse the quantized op with the following requantize op.
-
-        Returns:
-            [graphdef]: the optimized graphdef object
-        """
-        uint8_type = dtypes.quint8.as_datatype_enum
-        int8_type = dtypes.qint8.as_datatype_enum
-        float32_type = dtypes.float32.as_datatype_enum
-        qint32_type = dtypes.qint32.as_datatype_enum
-
-        target_nodes = self.graph_analyzer.query_fusion_pattern_nodes(
-            [["_QuantizedMatMul"], ["Requantize", "RequantizePerChannel"]]
-        )
-        for i in target_nodes:
-            quantized_node_name = i[0]
-            quantized_node = self.graph_info[quantized_node_name].node
-            requantize_node_name = i[1]
-            requantize_node = self.graph_info[requantize_node_name].node
-            requested_output_min_name = requantize_node.input[3]
-            requested_output_max_name = requantize_node.input[4]
-
-            quantized_node_op = i[-1][0]
-            attr_fused_ops = "".join(
-                x
-                for x in quantized_node.attr["fused_ops"].SerializeToString().decode("UTF-8", "ignore").strip()
-                if x.isprintable()
-            )
-            # "Requantize"
-            # "BiasAdd", "Requantize"
-            # "BiasAdd", "Activation", "Requantize"
-            if "BiasAddAdd" in attr_fused_ops:
-                continue
-            new_node = node_def_pb2.NodeDef()
-
-            new_node.op = quantized_node_op
-            new_node.name = requantize_node_name
-            for _, value in enumerate(quantized_node.input):
-                new_node.input.append(value)
-            new_node.input.append(requested_output_min_name)
-            new_node.input.append(requested_output_max_name)
-
-            if "transpose_b" in quantized_node.attr:
-                new_node.attr["transpose_b"].CopyFrom(quantized_node.attr["transpose_b"])
-            if "transpose_a" in quantized_node.attr:
-                new_node.attr["transpose_a"].CopyFrom(quantized_node.attr["transpose_a"])
-            if "T1" in quantized_node.attr:
-                new_node.attr["T1"].CopyFrom(quantized_node.attr["T1"])
-            if "T2" in quantized_node.attr:
-                new_node.attr["T2"].CopyFrom(quantized_node.attr["T2"])
-            if "U" in quantized_node.attr:
-                new_node.attr["U"].CopyFrom(quantized_node.attr["U"])
-            if "input_quant_mode" in quantized_node.attr:
-                new_node.attr["input_quant_mode"].CopyFrom(quantized_node.attr["input_quant_mode"])
-            if "output_quant_mode" in quantized_node.attr:
-                new_node.attr["output_quant_mode"].CopyFrom(quantized_node.attr["output_quant_mode"])
-
-            parent_node_name = Helper.node_name_from_input(quantized_node.input[0])
-            max_filter_node = None
-            min_filter_node = None
-            # The Min and Max of non-const weight node are from QuantizeV2's output, not valid nodes.
-            # Add check here for excluding this case.
-            if len(attr_fused_ops) == 0:  # single matmul case
-                if ":2" not in new_node.input[5]:
-                    max_filter_node = self.graph_info[new_node.input[5]].node
-                if ":1" not in new_node.input[4]:
-                    min_filter_node = self.graph_info[new_node.input[4]].node
-            else:
-                if ":2" not in new_node.input[6]:
-                    max_filter_node = self.graph_info[new_node.input[6]].node
-                if ":1" not in new_node.input[5]:
-                    min_filter_node = self.graph_info[new_node.input[5]].node
-            last_node = self.graph_info[new_node.input[0]].node
-            is_min_first = bool(quantized_node.attr["input_quant_mode"].s == b"MIN_FIRST")
-            weight_node = self.graph_info[new_node.input[1]].node
-            bias_node = None
-            if "BiasAdd" in attr_fused_ops:
-                bias_node = self.graph_info[new_node.input[2]].node
-            if not last_node.op == "QuantizedConcatV2":
-                max_input_node = self.graph_info[last_node.input[-1]].node
-                min_input_node = self.graph_info[last_node.input[-2]].node
-
-            if not last_node.op == "QuantizedConcatV2" and max_input_node.op == "Enter":  # pragma: no cover
-                min_input_parent_name = Helper.node_name_from_input(min_input_node.input[0])
-                max_input_parent_name = Helper.node_name_from_input(max_input_node.input[0])
-                min_input_parent_node = self.graph_info[min_input_parent_name].node
-                max_input_parent_node = self.graph_info[max_input_parent_name].node
-                if min_input_parent_node.op != "Const" or max_input_parent_node.op != "Const":
-                    continue
-                min_input_node = min_input_parent_node
-                max_input_node = max_input_parent_node
-            if (
-                max_filter_node
-                and min_filter_node
-                and min_filter_node.input
-                and max_filter_node.input
-                and max_filter_node.op == "Enter"
-            ):  # pragma: no cover
-                min_filter_parent_name = Helper.node_name_from_input(min_filter_node.input[0])
-                max_filter_parent_name = Helper.node_name_from_input(max_filter_node.input[0])
-                min_filter_parent_node = self.graph_info[min_filter_parent_name].node
-                max_filter_parent_node = self.graph_info[max_filter_parent_name].node
-                if min_filter_parent_node.op != "Const" or max_filter_parent_node.op != "Const":
-                    continue
-                min_filter_node = min_filter_parent_node
-                max_filter_node = max_filter_parent_node
-            if weight_node.op == "Enter":  # pragma: no cover
-                weight_parent_name = Helper.node_name_from_input(weight_node.input[0])
-                weight_parent_node = self.graph_info[weight_parent_name].node
-                if weight_parent_node.op != "Const":
-                    continue
-                weight_node = weight_parent_node
-            bias_enter_node = None
-            if bias_node and bias_node.op == "Enter":  # pragma: no cover
-                bias_enter_node = bias_node
-                bias_parent_name = Helper.node_name_from_input(bias_node.input[0])
-                bias_parent_node = self.graph_info[bias_parent_name].node
-                if bias_parent_node.op != "Const":
-                    continue
-                bias_node = bias_parent_node
-
-            if bias_node and (
-                last_node.op.find("_QuantizedMatMul") != -1
-                or last_node.op.find("QuantizeV2") != -1
-                and max_filter_node
-                and min_filter_node
-            ):
-                min_input_value = (min_input_node.attr["value"].tensor.float_val)[0]
-                max_input_value = (max_input_node.attr["value"].tensor.float_val)[0]
-                if requantize_node.op.find("PerChannel") != -1:  # pragma: no cover
-                    max_filter_tensor = tensor_util.MakeNdarray(max_filter_node.attr["value"].tensor)  # get tensor
-                    min_filter_tensor = tensor_util.MakeNdarray(min_filter_node.attr["value"].tensor)  # get tensor
-                else:
-                    max_filter_value = (max_filter_node.attr["value"].tensor.float_val)[0]
-                    min_filter_value = (min_filter_node.attr["value"].tensor.float_val)[0]
-
-                weights_tensor = tensor_util.MakeNdarray(weight_node.attr["value"].tensor)
-                bias_tensor = tensor_util.MakeNdarray(bias_node.attr["value"].tensor)
-
-                input_range = (
-                    max_input_value - min_input_value
-                    if is_min_first
-                    else max(abs(max_input_value), abs(min_input_value))
-                )
-                if -self.eps <= input_range <= self.eps:
-                    input_range += self.eps
-
-                if -self.eps <= max_input_value - min_input_value <= self.eps:
-                    max_input_value += self.eps
-                if requantize_node.op.find("PerChannel") != -1:  # pragma: no cover
-                    int32_bias = Helper.generate_int32_bias_for_matmul_per_channel(
-                        bias_tensor,
-                        weights_tensor,
-                        max_input_value,
-                        min_input_value,
-                        max_filter_tensor,
-                        min_filter_tensor,
-                    )
-                else:
-                    int32_bias = Helper.generate_int32_bias_for_matmul(
-                        bias_tensor,
-                        weights_tensor,
-                        input_range,
-                        max_input_value,
-                        min_input_value,
-                        max_filter_value,
-                        min_filter_value,
-                    )
-                bias_node.attr["dtype"].CopyFrom(
-                    attr_value_pb2.AttrValue(type=float32_type if self.device == "gpu" else qint32_type)
-                )
-                bias_node.attr["value"].CopyFrom(
-                    attr_value_pb2.AttrValue(
-                        tensor=tensor_util.make_tensor_proto(
-                            bias_tensor if self.device == "gpu" else int32_bias,
-                            dtypes.float32 if self.device == "gpu" else dtypes.int32,
-                            bias_tensor.shape,
-                        )
-                    )
-                )
-
-                bias_node.attr["value"].tensor.dtype = float32_type if self.device == "gpu" else qint32_type
-                if bias_enter_node:
-                    bias_enter_node.attr["T"].CopyFrom(
-                        attr_value_pb2.AttrValue(type=float32_type if self.device == "gpu" else qint32_type)
-                    )
-                new_node.attr["Tbias"].CopyFrom(
-                    attr_value_pb2.AttrValue(type=float32_type if self.device == "gpu" else qint32_type)
-                )
-
-                deq_node_name = self.graph_info[requantize_node_name].outputs[0]
-                deq_node = self.graph_info[deq_node_name].node
-                deq_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=uint8_type))
-
-                Helper.set_attr_type_list(
-                    new_node,
-                    "Thost_inputs",
-                    [
-                        uint8_type,
-                        int8_type,
-                        float32_type if self.device == "gpu" else qint32_type,
-                        float32_type,
-                        float32_type,
-                        float32_type,
-                        float32_type,
-                        float32_type,
-                        float32_type,
-                    ],
-                )
-            else:
-                new_node.attr["Tbias"].CopyFrom(attr_value_pb2.AttrValue(type=float32_type))
-                deq_node_name = self.graph_info[requantize_node_name].outputs[0]
-                deq_node = self.graph_info[deq_node_name].node
-                deq_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=uint8_type))
-                if bias_node:
-                    Helper.set_attr_type_list(
-                        new_node,
-                        "Thost_inputs",
-                        [
-                            uint8_type,
-                            int8_type,
-                            float32_type,
-                            float32_type,
-                            float32_type,
-                            float32_type,
-                            float32_type,
-                            float32_type,
-                            float32_type,
-                        ],
-                    )
-                else:
-                    Helper.set_attr_type_list(
-                        new_node,
-                        "Thost_inputs",
-                        [
-                            uint8_type,
-                            int8_type,
-                            float32_type,
-                            float32_type,
-                            float32_type,
-                            float32_type,
-                            float32_type,
-                            float32_type,
-                        ],
-                    )
-
-            Helper.set_attr_type_list(new_node, "Thost_outputs", [uint8_type, float32_type, float32_type])
-
-            if "GeluApproximate" in attr_fused_ops:
-                Helper.set_attr_string_list(new_node, "fused_ops", [b"BiasAdd", b"GeluApproximate", b"Requantize"])
-            elif "GeluExact" in attr_fused_ops:
-                Helper.set_attr_string_list(new_node, "fused_ops", [b"BiasAdd", b"GeluExact", b"Requantize"])
-            elif "Elu" in attr_fused_ops:
-                Helper.set_attr_string_list(new_node, "fused_ops", [b"BiasAdd", b"Elu", b"Requantize"])
-            elif "LeakyRelu" in attr_fused_ops:
-                Helper.set_attr_string_list(new_node, "fused_ops", [b"BiasAdd", b"LeakyRelu", b"Requantize"])
-            elif "Relu6" in attr_fused_ops:
-                Helper.set_attr_string_list(new_node, "fused_ops", [b"BiasAdd", b"Relu6", b"Requantize"])
-            elif "Tanh" in attr_fused_ops:
-                Helper.set_attr_string_list(new_node, "fused_ops", [b"BiasAdd", b"Tanh", b"Requantize"])
-            elif "Sigmoid" in attr_fused_ops:
-                Helper.set_attr_string_list(new_node, "fused_ops", [b"BiasAdd", b"Sigmoid", b"Requantize"])
-            elif "Relu" in attr_fused_ops:
-                Helper.set_attr_string_list(new_node, "fused_ops", [b"BiasAdd", b"Relu", b"Requantize"])
-            elif "BiasAdd" in attr_fused_ops:
-                Helper.set_attr_string_list(new_node, "fused_ops", [b"BiasAdd", b"Requantize"])
-            else:
-                Helper.set_attr_string_list(new_node, "fused_ops", [b"Requantize"])
-            new_node.attr["Tout"].CopyFrom(attr_value_pb2.AttrValue(type=uint8_type))
-
-            self.graph_analyzer.replace_single_node(
-                new_node,
-                [parent_node_name],
-                quantized_node_name,
-                [self.graph_info[requantize_node_name].outputs[0]],
-                requantize_node_name,
-            )
-            self.graph_analyzer.remove_node(quantized_node_name)
-
-        return self.graph_analyzer.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/meta_op_optimizer.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/meta_op_optimizer.py
deleted file mode 100644
index db1e343f3a8..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/meta_op_optimizer.py
+++ /dev/null
@@ -1,115 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Meta OP Graph Rewriter."""
-
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class MetaInfoChangingMemOpOptimizer(GraphRewriterBase):
-    """Fuse the pattern like Dequantize + MetaOp + Quantize into MetaOp(set its type to int8).
-
-    With such changes, the Quantize and Dequantize OP will removed for better performance.
-    """
-
-    def __init__(self, model):
-        """Initialization."""
-        super().__init__(model)
-
-        self.graph_analyzer = GraphAnalyzer()
-        self.graph_analyzer.graph = self.model
-
-        self.graph_info = self.graph_analyzer.parse_graph()
-
-    @dump_elapsed_time("Pass MetaOpOptimizer")
-    def do_transformation(self):
-        """Apply the fusion of Dequantize + MetaOp + QuantizeV2."""
-        target_nodes = self.graph_analyzer.query_fusion_pattern_nodes(
-            [["Dequantize"], ("Squeeze", "Reshape"), ("Squeeze", "Reshape"), ["QuantizeV2"]]
-        )
-        for i in target_nodes:
-            if len(i[-1]) == 2:
-                continue
-
-            dequantize_node_name = i[0]
-            if len(i[-1]) == 3:
-                quantize_node_name = i[2]
-            else:
-                quantize_node_name = i[3]
-                dequantize_node_name = i[0]
-                if self.graph_info[i[1]].node.op == self.graph_info[i[2]].node.op:
-                    continue
-            deq_node = self.graph_info[dequantize_node_name].node
-            quant_node = self.graph_info[quantize_node_name].node
-            if len(self.graph_info[dequantize_node_name].outputs) != 1:
-                continue
-
-            if quant_node.attr["mode"].s.decode() == deq_node.attr["mode"].s.decode():
-                deq_min_range = self.graph_info[dequantize_node_name].node.input[1]
-                deq_max_range = self.graph_info[dequantize_node_name].node.input[2]
-                quant_output_min = quantize_node_name + ":1"
-                quant_output_max = quantize_node_name + ":2"
-                if len(i[-1]) == 3:
-                    quantize_input_name = i[1]
-                else:
-                    quantize_input_name = i[2]
-
-                quantized_node_name = self.graph_info[quantize_node_name].outputs[0]
-                # _QuantizedBatchMatMul requires T1 and T2 with qint8 type
-                # _QuantizedFusedBatchNorm requires T with qint8 type
-                if (
-                    self.graph_info[quantized_node_name].node.op == "_QuantizedBatchMatMul"
-                    or self.graph_info[quantized_node_name].node.op == "_QuantizedFusedBatchNorm"
-                ) and self.graph_info[dequantize_node_name].node.attr["T"].type != dtypes.qint8.as_datatype_enum:
-                    continue
-
-                for index, value in enumerate(self.graph_info[quantized_node_name].node.input):
-                    if value == quant_output_min:
-                        self.graph_info[quantized_node_name].node.input[index] = deq_min_range
-
-                    if value == quant_output_max:
-                        self.graph_info[quantized_node_name].node.input[index] = deq_max_range
-
-                    if index == 0:
-                        self.graph_info[quantized_node_name].node.input[index] = quantize_input_name
-
-                new_dtype = self.graph_info[dequantize_node_name].node.attr["T"].type
-                for node_name in i[1:-1]:
-                    self.graph_info[node_name].node.attr["T"].type = new_dtype
-
-                if "T1" in self.graph_info[quantized_node_name].node.attr:
-                    self.graph_info[quantized_node_name].node.attr["T1"].type = new_dtype
-
-                if "Tinput" in self.graph_info[quantized_node_name].node.attr:
-                    self.graph_info[quantized_node_name].node.attr["Tinput"].type = new_dtype
-
-                if "Thost_inputs" in self.graph_info[quantized_node_name].node.attr:
-                    self.graph_info[quantized_node_name].node.attr["Thost_inputs"].list.type[0] = new_dtype
-
-                if "T" in self.graph_info[quantized_node_name].node.attr:
-                    self.graph_info[quantized_node_name].node.attr["T"].type = new_dtype
-
-                self.graph_info[i[1]].node.input[0] = self.graph_info[dequantize_node_name].node.input[0]
-                self.graph_analyzer.remove_node(dequantize_node_name)
-                self.graph_analyzer.remove_node(self.graph_info[quantize_node_name].node.input[1])
-                self.graph_analyzer.remove_node(self.graph_info[quantize_node_name].node.input[2])
-                self.graph_analyzer.remove_node(quantize_node_name)
-        return GraphAnalyzer().dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/post_hostconst_converter.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/post_hostconst_converter.py
deleted file mode 100644
index 64ff5ca44ee..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/post_hostconst_converter.py
+++ /dev/null
@@ -1,53 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Post HostConst Graph Rewriter."""
-
-import os
-
-from tensorflow.core.framework import graph_pb2, node_def_pb2
-
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class PostHostConstConverter(GraphRewriterBase):
-    """Support HostConst as default for all devices, not just for GPU."""
-
-    @dump_elapsed_time("Pass PostHostConstConverter")
-    def do_transformation(self):
-        """Convert Const to HostConst as default."""
-        if os.environ.get("DISABLE_HOSTCONST") == "1":
-            return self.model
-        output_graph_def = graph_pb2.GraphDef()
-        for node in self.model.node:
-            new_node = node_def_pb2.NodeDef()
-            new_node.CopyFrom(node)
-            new_node.device = ""
-            if (
-                node.op == "Const"
-                and node.attr["dtype"].type in [1, 3]
-                and (
-                    node.name.endswith("_min")
-                    or node.name.endswith("_max")
-                    or node.name.endswith("_max_only")
-                    or node.name.endswith("_min_only")
-                )
-            ):
-                new_node.op = "HostConst"
-            output_graph_def.node.extend([new_node])
-        return output_graph_def
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/post_quantized_op_cse.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/post_quantized_op_cse.py
deleted file mode 100644
index 1a3d920f119..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/post_quantized_op_cse.py
+++ /dev/null
@@ -1,135 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Post CSE Graph Rewriter."""
-
-import hashlib
-
-from tensorflow.core.framework import graph_pb2
-from tensorflow.python.framework import tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class PostCseOptimizer(GraphRewriterBase):
-    """Remove duplicated nodes like shared quantizev2 and const to decrease the output model size."""
-
-    control_op_types = ("Switch", "Enter", "Merge", "NextIteration", "Exit")
-
-    def _gen_node_hash(self, graph_info, node):
-        """Generate nodes hash md5 data."""
-        hash_str = node.op
-        hash_str += str(len(node.input))
-        for i in node.input:
-            input_node = graph_info[Helper.node_name_from_input(i)].node
-            if input_node.op == "Const":
-                float_tensor = tensor_util.MakeNdarray(input_node.attr["value"].tensor)
-                hash_str += str(float_tensor.flatten())
-            else:
-                hash_str += i
-
-        attr_keys = sorted(node.attr)
-        for i in attr_keys:
-            hash_str += str(node.attr[i])
-
-        return hashlib.md5(hash_str.encode("utf-8")).hexdigest()  # nosec
-
-    @dump_elapsed_time("Pass PostCseOptimizer")
-    def do_transformation(self):
-        """Apply post CSE optimization."""
-        GraphAnalyzer().graph = self.model
-        graph_info = GraphAnalyzer().parse_graph()
-        node_hash_info = {}
-        loc_attr_node = []
-        need_to_keep_const_node_name = []
-
-        for _, v in graph_info.items():
-            if "_class" in v.node.attr:
-                loc_attr_node.append(v.node.attr["_class"].list.s[0].decode().split(":@")[-1])
-        for node_name, i in graph_info.items():
-            if node_name in loc_attr_node or i.node.op not in ("QuantizeV2", "Const"):
-                continue
-
-            hash_value = self._gen_node_hash(graph_info, i.node)
-
-            if hash_value not in node_hash_info:
-                node_hash_info[hash_value] = [node_name]
-
-            if node_name not in node_hash_info[hash_value]:
-                node_hash_info[hash_value].append(node_name)
-
-        for _, v in node_hash_info.items():
-            if len(v) == 1 or v[0] not in graph_info:
-                continue
-
-            node_type = graph_info[v[0]].node.op
-
-            for j in v[1:]:
-                if node_type == "Const" and j in graph_info:
-                    output_op_types = [
-                        graph_info[out_name].node.op in self.control_op_types for out_name in graph_info[j].outputs
-                    ]
-                    if any(output_op_types):
-                        continue
-
-                    for next_node in list(graph_info[j].outputs):
-                        matched_index = 0
-                        for index, origin_input in enumerate(graph_info[next_node].node.input):
-                            if origin_input == j:
-                                matched_index = index
-                                break
-
-                        graph_info[next_node].node.input[matched_index] = v[0]
-                        if v[0] not in need_to_keep_const_node_name:
-                            need_to_keep_const_node_name.append(v[0])
-                        graph_info[v[0]].outputs.append(next_node)
-
-                        if j in graph_info:
-                            graph_info.pop(j)
-
-                elif node_type == "QuantizeV2":  # pragma: no cover
-                    next_node = graph_info[j].outputs[0]
-                    quantize_v2_output_names = (j, j + ":1", j + ":2")
-
-                    replace_index = [list(graph_info[next_node].node.input).index(i) for i in quantize_v2_output_names]
-
-                    graph_info[next_node].node.input[replace_index[0]] = v[0]
-
-                    graph_info[next_node].node.input[replace_index[1]] = v[0] + ":1"
-                    graph_info[next_node].node.input[replace_index[2]] = v[0] + ":2"
-
-                    graph_info[v[0]].outputs.append(next_node)
-
-                    if graph_info[j].node.input[1] not in need_to_keep_const_node_name:
-                        graph_info.pop(graph_info[j].node.input[1])
-
-                    if graph_info[j].node.input[2] not in need_to_keep_const_node_name:
-                        graph_info.pop(graph_info[j].node.input[2])
-
-                    graph_info.pop(j)
-
-                else:
-                    self.logger.warning("Unknown Op type {}.".format(node_type))
-
-        output_graph_def = graph_pb2.GraphDef()
-
-        for _, node_info in graph_info.items():
-            output_graph_def.node.extend([node_info.node])
-        return output_graph_def
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/scale_propagation.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/scale_propagation.py
deleted file mode 100644
index f0170c47c86..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/int8/scale_propagation.py
+++ /dev/null
@@ -1,118 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Scale propagation Graph Rewriter."""
-
-from tensorflow.core.framework import attr_value_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-
-from ..graph_base import GraphRewriterBase
-
-
-class ScaleProPagationTransformer(GraphRewriterBase):
-    """Scale propagation converter."""
-
-    cac_pattern = [
-        ["QuantizeV2", "Requantize", "RequantizePerChannel"],
-        ["QuantizedAvgPool"],
-        [
-            "QuantizedConv2DWithBias",
-            "QuantizedConv2DWithBiasAndRelu",
-            "QuantizedConv2DPerChannel",
-            "QuantizedConv2D",
-            "QuantizedConv2DWithBiasSumAndRelu",
-        ],
-        ["Requantize", "RequantizePerChannel"],
-    ]
-
-    def __init__(self, model, direction="Up"):
-        """Initialization."""
-        super().__init__(model)
-        self.direction = direction if direction not in ("Up", "Down") else "Up"
-        self.cur_graph = GraphAnalyzer()
-        self.cur_graph.graph = self.model
-
-        self.graph_info = self.cur_graph.parse_graph()
-
-    def _create_new_const_node(self, new_const_node_name, value, old_const_node_name):
-        """Create new Const node."""
-        new_node = node_def_pb2.NodeDef()
-        new_node.op = "Const"
-        new_node.name = new_const_node_name
-        new_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-        new_node.attr["value"].CopyFrom(
-            attr_value_pb2.AttrValue(tensor=tensor_util.make_tensor_proto(float(value), dtypes.float32, []))
-        )
-        output_node_name = self.graph_info[old_const_node_name].outputs[0]
-        self.cur_graph.replace_const_node(
-            new_node, [Helper.node_name_from_input(output_node_name)], old_const_node_name
-        )
-        self.cur_graph.remove_node(old_const_node_name)
-
-    def _cac_transformation(self):
-        """Scale propagation pattern match and create new const nodes."""
-        target_nodes = self.cur_graph.query_fusion_pattern_nodes(self.cac_pattern)
-        quantize_v2_min_index = 1
-        requntize_min_index = 3
-        quantize_v2_max_index = 2
-        requntize_max_index = 4
-
-        for match in target_nodes:
-            pre_node_name = match[0]
-
-            pre_node = self.graph_info[pre_node_name].node
-
-            output_nodes_count = len(set(self.graph_info[pre_node_name].outputs))
-
-            if output_nodes_count > 1:
-                continue
-            # Skip transformation if avgpool has multi output nodes.
-            pooling_nodes_count = len(set(self.graph_info[match[1]].outputs))
-            if pooling_nodes_count > 1:
-                continue
-
-            if pre_node.op == "QuantizeV2":
-                pre_min_index, pre_max_index = quantize_v2_min_index, quantize_v2_max_index
-            else:
-                pre_min_index, pre_max_index = requntize_min_index, requntize_max_index
-
-            requantize_node_name = match[3]
-            requantize_node = self.graph_info[requantize_node_name].node
-
-            requantize_min = self.graph_info[
-                Helper.node_name_from_input(requantize_node.input[requntize_min_index])
-            ].node
-            requantize_max = self.graph_info[
-                Helper.node_name_from_input(requantize_node.input[requntize_max_index])
-            ].node
-
-            requantize_min_value = (requantize_min.attr["value"].tensor.float_val)[0]
-            requantize_max_value = (requantize_max.attr["value"].tensor.float_val)[0]
-            self._create_new_const_node(
-                pre_node_name + "_cac_requantize_min_value", requantize_min_value, pre_node.input[pre_min_index]
-            )
-            self._create_new_const_node(
-                pre_node_name + "_cac_requantize_max_value", requantize_max_value, pre_node.input[pre_max_index]
-            )
-
-    def do_transformation(self):
-        """Apply the scale propagation algrothim."""
-        self._cac_transformation()
-
-        return self.cur_graph.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/qdq/__init__.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/qdq/__init__.py
deleted file mode 100644
index 1663974f579..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/qdq/__init__.py
+++ /dev/null
@@ -1,17 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Tensorflow QDQ Graph Rewriters."""
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/qdq/insert_qdq_pattern.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/qdq/insert_qdq_pattern.py
deleted file mode 100644
index 64fc4a69dac..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/qdq/insert_qdq_pattern.py
+++ /dev/null
@@ -1,750 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Insert QDQ pattern Graph Rewriter."""
-
-import copy
-import re
-from collections import namedtuple
-
-import numpy as np
-from tensorflow.core.framework import attr_value_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class GenerateGraphWithQDQPattern(GraphRewriterBase):
-    """Insert Q/DQ pairs before quantizable ops."""
-
-    def __init__(
-        self,
-        model,
-        calibration_data,
-        op_wise_config,
-        fake_quant,
-        fp32_ops,
-        bf16_ops,
-        quantized_nodes,
-        device,
-        performance_only,
-        itex_mode,
-        llm_weight_minmax,
-    ):
-        """Initialization."""
-        super().__init__(model)
-        self.data = calibration_data
-        self.op_wise_config = op_wise_config
-        self.fake_quant = fake_quant
-        self.fp32_ops = fp32_ops
-        self.bf16_ops = bf16_ops
-        self.quantized_nodes = quantized_nodes
-        self.device = device
-        self.performance_only = performance_only
-        self.itex_mode = itex_mode
-        self.llm_weight_minmax = llm_weight_minmax
-        self.node_details = namedtuple("node_details", ["node", "output"])
-        self.node_name_mapping = {}
-        self.check_op_list = {
-            "ConcatV2",
-            "Conv2D",
-            "Conv3D",
-            "DepthwiseConv2D",
-            "QuantizeV2",
-            "DepthwiseConv2dNative",
-            "MaxPool",
-            "MaxPool3D",
-            "FusedBatchNormV3",
-            "Requantize",
-            "RequantizePerChannel",
-            "AvgPool",
-            "Pad",
-            "CropAndResize",
-            "Dequantize",
-            "Mean",
-            "MatMul",
-            "BatchMatMul",
-            "BatchMatMulV2",
-            "FakeQuantWithMinMaxVars",
-            "_MklFusedInstanceNorm",
-            "Conv2DBackpropInput",
-            "Conv3DBackpropInputV2",
-            "Sigmoid",
-        }
-
-        for node in self.model.node:
-            if node.name in self.node_name_mapping:
-                raise ValueError("Duplicate Node Found when _parse_graph, the node name is {}".format(node.name))
-            self.node_name_mapping[node.name] = self.node_details(node=node, output=[])
-        for node_name in self.node_name_mapping:
-            for each_input in self.node_name_mapping[node_name].node.input:
-                self.node_name_mapping[Helper.node_name_from_input(each_input)].output.append(node_name)
-
-    @dump_elapsed_time("Pass GenerateGraphWithQDQPattern")
-    def do_transformation(self):
-        """Generate the graph with QDQ patterns, this is the first step to do new api quantizaiton."""
-        min_max_values = {}
-        for i in self.data:
-            if i.find("_requant") == -1:
-                key, value = i.rsplit(":", 1)[0], i.rsplit(":", 1)[1]
-                key = key.split("_eightbit_")[0][1:] + key[-5:]
-                if key not in min_max_values:
-                    min_max_values[key] = [float(value[1:-1])]
-                else:
-                    min_max_values[key].append(float(value[1:-1]))
-        quantizable_op_names = []
-        for i in min_max_values:
-            if i.split("__")[0] not in quantizable_op_names:
-                quantizable_op_names.append(i.split("__")[0])
-
-        self.g = GraphAnalyzer()
-        self.g.graph = copy.deepcopy(self.model)
-        self.graph_info = self.g.parse_graph()
-
-        self.g.get_frame_info()
-
-        # insert QDQ pattern for op's input
-        for op_name in quantizable_op_names:
-            if self._ignore_insert_qdq_pattern(op_name):
-                continue
-
-            if op_name not in self.op_wise_config.keys():
-                is_asymmetric = False
-            else:
-                op_wise_cfg = self.op_wise_config[op_name]
-                is_asymmetric = op_wise_cfg[2]
-            if self.graph_info[op_name].node.op == "ConcatV2":
-                if not self.itex_mode:
-                    self._insert_qdq_pattern_for_concatv2(self.graph_info[op_name].node, is_asymmetric)
-            else:
-                self._insert_qdq_pattern_for_common_ops(self.graph_info[op_name].node, is_asymmetric)
-
-        # insert QDQ pattern for op's weight
-        self.g_weight = GraphAnalyzer()
-        self.g_weight.graph = self.g.dump_graph()
-        self.graph_info = self.g_weight.parse_graph()
-        target_nodes = self.g_weight.query_fusion_pattern_nodes(
-            [
-                [
-                    "Conv2D",
-                    "Conv3D",
-                    "DepthwiseConv2dNative",
-                    "MatMul",
-                    "BatchMatMul",
-                    "BatchMatMulV2",
-                    "Conv2DBackpropInput",
-                    "Conv3DBackpropInputV2",
-                ]
-            ]
-        )
-        for i in target_nodes:
-            if i[0] not in quantizable_op_names:
-                continue
-            computational_node_name = i[0]
-            if self._ignore_insert_qdq_pattern(computational_node_name):
-                continue
-
-            computational_node = self.graph_info[computational_node_name].node
-            weight_name = computational_node.input[1]
-            if re.search(r"\w+:\d+", weight_name):
-                weight_node = self.graph_info[weight_name.rsplit(":", 1)[0]].node
-            else:
-                weight_node = self.graph_info[weight_name].node
-            if weight_node.op == "Enter":  # pragma: no cover
-                if self.itex_mode:
-                    parent_node = self.graph_info[Helper.node_name_from_input(weight_node.input[0])].node
-                    if not parent_node.op == "Const":
-                        continue
-                    weight_node = parent_node
-                else:
-                    continue
-            if computational_node_name in self.op_wise_config.keys():
-                op_wise_cfg = self.op_wise_config[computational_node_name]
-                per_channel = op_wise_cfg[0]
-                weight_bit = op_wise_cfg[3]
-            else:
-                per_channel = False
-                weight_bit = 7
-
-            self._insert_qdq_pattern_for_weight_node(
-                computational_node, weight_node, weight_name, min_max_values, per_channel, weight_bit, self.device
-            )
-        # Adaption for strip equivalent nodes feature
-        # Replicate shared Dequantize for next step fusion
-        self.g_qdq = GraphAnalyzer()
-        self.g_qdq.graph = self.g_weight.dump_graph()
-        self.graph_info = self.g_qdq.parse_graph()
-        patterns = [["QuantizeV2"], ["Dequantize"]]
-        matched_nodes = self.g_qdq.query_fusion_pattern_nodes(patterns)
-        for i in matched_nodes:
-            quantize_node_name = self.graph_info[i[0]].node.name
-            deq_node_name = self.graph_info[i[1]].node.name
-            deq_node = self.graph_info[i[1]].node
-            len_deq_outputs = len(self.g_qdq.node_name_details[deq_node_name].outputs)
-            if len_deq_outputs == 1:
-                continue
-
-            for index in range(len_deq_outputs - 1):
-                rep_dequantize_node = Helper.create_node(
-                    "Dequantize",
-                    deq_node_name + "_" + str(index + 1),
-                    [quantize_node_name, quantize_node_name + ":1", quantize_node_name + ":2"],
-                )
-                rep_dequantize_node.attr["T"].CopyFrom(deq_node.attr["T"])
-                rep_dequantize_node.attr["mode"].CopyFrom(deq_node.attr["mode"])
-                if "axis" in deq_node.attr:
-                    rep_dequantize_node.attr["axis"].CopyFrom(deq_node.attr["axis"])
-                next_node_name = self.g_qdq.node_name_details[deq_node_name].outputs[index + 1]
-                self.g_qdq.add_node(rep_dequantize_node, quantize_node_name, [next_node_name])
-                for input_index, each_input in enumerate(self.g_qdq.node_name_details[next_node_name].node.input):
-                    if each_input == deq_node_name:
-                        self.g_qdq.node_name_details[next_node_name].node.input[input_index] = rep_dequantize_node.name
-
-        return self.g_qdq.dump_graph()
-
-    def _check_op_list(self, node_type):
-        """Check if the node_type in the allowed op list."""
-        return any([node_type.find(i) != -1 for i in self.check_op_list])
-
-    def _find_relu_node(self, node):
-        """Find Relu node algorithm to identify the positive input."""
-        if node.op == "MaxPool":
-            self.check_op_list.add("BiasAdd")
-
-        if (
-            node.op in ("Relu", "Relu6", "Elu")
-            or (
-                node.op.find("AndRelu") != -1
-                and ("alpha" not in node.attr or ("alpha" in node.attr and node.attr["alpha"].f == 0))
-            )
-        ) and (
-            node.op != "Relu"
-            or not self.performance_only
-            or self.node_name_mapping[Helper.node_name_from_input(node.input[0])].node.op.find("FusedBatchNorm") == -1
-            or self.node_name_mapping[Helper.node_name_from_input(node.input[0])].node.attr["is_training"].b
-            or len(self.node_name_mapping[Helper.node_name_from_input(node.input[0])].output) > 1
-        ):
-            return True
-        elif "T" in node.attr and dtypes.DType(node.attr["T"].type) in (dtypes.quint8, dtypes.uint8):
-            return True
-        elif (
-            node.op.find("QuantizedConv") != -1
-            or node.op.find("QuantizedDepthwiseConv") != -1
-            or node.op.find("QuantizedMatMul") != -1
-        ) and (
-            (node.op.find("Relu") == -1 and node.op.find("Elu") == -1)
-            or ("alpha" in node.attr and node.attr["alpha"].f > 0)
-        ):
-            return False
-        elif self.itex_mode and node.op in ("Add", "AddV2", "AddN"):
-            if re.search(r"\w+:\d+", node.input[0]):
-                input0_node = self.node_name_mapping[node.input[0].rsplit(":", 1)[0]].node
-            else:
-                input0_node = self.node_name_mapping[node.input[0]].node
-            if re.search(r"\w+:\d+", node.input[1]):
-                input1_node = self.node_name_mapping[node.input[1].rsplit(":", 1)[0]].node
-            else:
-                input1_node = self.node_name_mapping[node.input[1]].node
-            if input0_node.op in ("BiasAdd", "Add", "AddV2", "AddN") or input1_node.op in (
-                "BiasAdd",
-                "Add",
-                "AddV2",
-                "AddN",
-            ):
-                return False
-            return self._find_relu_node(input0_node) and self._find_relu_node(input1_node)
-        elif self._check_op_list(node.op) or (self.itex_mode and node.op in ("Add", "AddV2")):
-            if node.op == "ConcatV2":
-                find_relu = False
-                for i in range(0, node.attr["N"].i):
-                    if re.search(r"\w+:\d+", node.input[i]):
-                        input_node = self.node_name_mapping[node.input[i].rsplit(":", 1)[0]].node
-                    else:
-                        input_node = self.node_name_mapping[node.input[i]].node
-                    find_relu |= self._find_relu_node(input_node)
-                return find_relu
-            if re.search(r"\w+:\d+", node.input[0]):
-                input_node = self.node_name_mapping[node.input[0].rsplit(":", 1)[0]].node
-            else:
-                input_node = self.node_name_mapping[node.input[0]].node
-            return self._find_relu_node(input_node)
-        else:
-            return False
-
-    def _insert_qdq_pattern_for_common_ops(self, original_node, is_asymmetric):
-        """Insert QDQ patterns for common OPs."""
-        namespace_prefix = original_node.name + "_eightbit"
-        if original_node.op in ("Conv2DBackpropInput", "Conv3DBackpropInputV2"):
-            all_inputs = self.node_name_mapping[original_node.name].node.input[-1:]
-        else:
-            all_inputs = self.node_name_mapping[original_node.name].node.input[:1]
-        for each_input_name in all_inputs:
-            if each_input_name[0] == "^":
-                continue
-
-            # if dq+maxpool is detected as input of this node
-            # the qdq in pattern dq+maxpool+q should be with the same dtype in the itex mode
-            if (
-                self.itex_mode
-                and each_input_name in self.node_name_mapping
-                and self.node_name_mapping[each_input_name].node.op == "MaxPool"
-                and self.graph_info[self.graph_info[each_input_name].node.input[0]].node.op == "Dequantize"
-            ):
-                maxpool_node = self.graph_info[each_input_name].node
-                dtype = dtypes.DType(self.graph_info[maxpool_node.input[0]].node.attr["T"].type)
-            elif self.node_name_mapping[original_node.name].node.op == "MatMul":
-                dtype = dtypes.quint8
-            elif (
-                self.node_name_mapping[original_node.name].node.op == "BatchMatMulV2"
-                or self.node_name_mapping[original_node.name].node.op == "BatchMatMul"
-            ):
-                dtype = dtypes.qint8
-            # the qdq in pattern dq+bn+relu+q and dq+bn+q should be s8 in itex mode
-            elif self.node_name_mapping[original_node.name].node.op == "FusedBatchNormV3":
-                dtype = dtypes.qint8
-            else:
-                input_node_name = Helper.node_name_from_input(each_input_name)
-                if input_node_name in self.graph_info:
-                    if self.graph_info[input_node_name].node.op == "Dequantize":
-                        dtype = dtypes.DType(self.graph_info[input_node_name].node.attr["T"].type)
-                    elif self.graph_info[input_node_name].node.op == "FusedBatchNormV3":
-                        dtype = dtypes.qint8
-                    elif self._find_relu_node(self.node_name_mapping[original_node.name].node):
-                        dtype = dtypes.quint8
-                    else:
-                        dtype = dtypes.qint8
-                else:
-                    dtype = (
-                        dtypes.quint8
-                        if self._find_relu_node(self.node_name_mapping[original_node.name].node)
-                        else dtypes.qint8
-                    )
-            self._insert_qdq_pattern_for_each_input(
-                original_node.name, namespace_prefix, each_input_name, is_asymmetric, dtype, device=self.device
-            )
-
-    def _insert_qdq_pattern_for_concatv2(self, original_node, is_asymmetric):
-        """Insert QDQ patterns for each input of ConcatV2."""
-        namespace_prefix = original_node.name + "_eightbit"
-        normal_inputs = [i for i in original_node.input if i[0] != "^"]
-        num_input = len(normal_inputs)
-        original_inputs = normal_inputs[0 : num_input - 1]
-        input_idx = 0
-        for original_input_name in original_inputs:
-            self._insert_qdq_pattern_for_each_input(
-                original_node.name,
-                namespace_prefix,
-                original_input_name,
-                is_asymmetric,
-                dtypes.quint8,
-                input_idx,
-                device=self.device,
-            )
-            input_idx += 1
-
-    def _insert_qdq_pattern_for_each_input(
-        self, op_name, namespace_prefix, input_name, is_asymmetric, dtype=dtypes.quint8, input_index=0, device="cpu"
-    ):
-        """Takes one float input to an op, and converts it to quantized form."""
-        unique_input_name = input_name.replace(":", "__port__").replace("^", "__hat__")
-        min_input_name = namespace_prefix + "_min_" + unique_input_name
-        max_input_name = namespace_prefix + "_max_" + unique_input_name
-        quantize_input_name = namespace_prefix + "_quantize_" + unique_input_name
-
-        reshape_dims_name = namespace_prefix + "_reshape_dims" + unique_input_name
-        reduction_dims_name = namespace_prefix + "_reduction_dims" + unique_input_name
-
-        if self.fake_quant:  # pragma: no cover
-            min_node = Helper.create_constant_node(min_input_name, -1.0, dtypes.float32, device="cpu")
-            max_node = Helper.create_constant_node(max_input_name, 1.0, dtypes.float32, device="cpu")
-            quant_v2_node = Helper.create_node(
-                "QuantizeV2", quantize_input_name, [input_name, min_input_name, max_input_name]
-            )
-            Helper.set_attr_dtype(quant_v2_node, "T", dtype)
-            if not is_asymmetric:
-                Helper.set_attr_string(quant_v2_node, "round_mode", b"HALF_TO_EVEN")
-            # Helper.set_attr_bool(quant_v2_node, "narrow_range", False if is_asymmetric else True)
-            if "BatchMatMul" in self.graph_info[op_name].node.op:
-                Helper.set_attr_string(quant_v2_node, "mode", b"SCALED")
-            else:
-                Helper.set_attr_string(quant_v2_node, "mode", b"MIN_FIRST" if is_asymmetric else b"SCALED")
-
-            if "Concat" in self.graph_info[op_name].node.op:
-                dequantize_node = Helper.create_node(
-                    "Dequantize",
-                    op_name + "_dequantize_" + str(input_index),
-                    [quant_v2_node.name, quant_v2_node.name + ":1", quant_v2_node.name + ":2"],
-                )
-            else:
-                dequantize_node = Helper.create_node(
-                    "Dequantize",
-                    op_name + "_dequantize",
-                    [quant_v2_node.name, quant_v2_node.name + ":1", quant_v2_node.name + ":2"],
-                )
-            Helper.set_attr_dtype(dequantize_node, "T", dtype)
-            if "BatchMatMul" in self.graph_info[op_name].node.op:
-                Helper.set_attr_string(dequantize_node, "mode", b"SCALED")
-            else:
-                Helper.set_attr_string(dequantize_node, "mode", b"MIN_FIRST" if is_asymmetric else b"SCALED")
-
-            self.g.add_node(quant_v2_node, self.graph_info[op_name].node.input[0], [dequantize_node.name])
-            self.g.add_node(dequantize_node, quant_v2_node.name, [op_name])
-            self.g.add_node(min_node, None, [quant_v2_node.name])
-            self.g.add_node(max_node, None, [quant_v2_node.name])
-            self.graph_info[op_name].node.input[input_index] = dequantize_node.name
-        else:
-            reshape_dims_node = Helper.create_constant_node(reshape_dims_name, -1, dtypes.int32, [1])
-            reduction_dims_node = Helper.create_constant_node(reduction_dims_name, 0, dtypes.int32, [1])
-            reshape_input_name = namespace_prefix + "_reshape_" + unique_input_name
-            if self.itex_mode and self.graph_info[op_name].node.op == "FusedBatchNormV3":
-                min_input_name = namespace_prefix + "_input7_output_min"
-                max_input_name = namespace_prefix + "_input8_output_max"
-                quantize_input_name = namespace_prefix + "_quantize_bn"
-            else:
-                min_input_name = namespace_prefix + "_min_" + unique_input_name
-                max_input_name = namespace_prefix + "_max_" + unique_input_name
-                quantize_input_name = namespace_prefix + "_quantize_" + unique_input_name
-
-            reshape_input_node = Helper.create_node("Reshape", reshape_input_name, [input_name, reshape_dims_name])
-            Helper.set_attr_dtype(reshape_input_node, "T", dtypes.float32)
-
-            min_input_node = Helper.create_node("Min", min_input_name, [reshape_input_name, reduction_dims_name])
-            Helper.set_attr_dtype(min_input_node, "T", dtypes.float32)
-            Helper.set_attr_dtype(min_input_node, "Tidx", dtypes.int32)
-            Helper.set_attr_bool(min_input_node, "keep_dims", False)
-
-            max_input_node = Helper.create_node("Max", max_input_name, [reshape_input_name, reduction_dims_name])
-            Helper.set_attr_dtype(max_input_node, "T", dtypes.float32)
-            Helper.set_attr_dtype(max_input_node, "Tidx", dtypes.int32)
-            Helper.set_attr_bool(max_input_node, "keep_dims", False)
-
-            if "BatchMatMul" in self.graph_info[op_name].node.op:
-                min_input_node.input.append("^" + input_name)
-                max_input_node.input.append("^" + input_name)
-
-            if self.itex_mode:
-                min_input_node.input.append("^" + input_name)
-                max_input_node.input.append("^" + input_name)
-            quant_v2_node = Helper.create_node(
-                "QuantizeV2", quantize_input_name, [input_name, min_input_name, max_input_name]
-            )
-            Helper.set_attr_dtype(quant_v2_node, "T", dtype)
-            if not is_asymmetric:
-                Helper.set_attr_string(quant_v2_node, "round_mode", b"HALF_TO_EVEN")
-            # Helper.set_attr_bool(quant_v2_node, "narrow_range", False if is_asymmetric else True)
-            if self.performance_only or "BatchMatMul" in self.graph_info[op_name].node.op:
-                Helper.set_attr_string(quant_v2_node, "mode", b"SCALED")
-            else:
-                Helper.set_attr_string(quant_v2_node, "mode", b"MIN_FIRST" if is_asymmetric else b"SCALED")
-
-            if "Concat" in self.graph_info[op_name].node.op:
-                dequantize_node = Helper.create_node(
-                    "Dequantize",
-                    op_name + "_dequantize_" + str(input_index),
-                    [quant_v2_node.name, quant_v2_node.name + ":1", quant_v2_node.name + ":2"],
-                )
-            else:
-                dequantize_node = Helper.create_node(
-                    "Dequantize",
-                    op_name + "_dequantize",
-                    [quant_v2_node.name, quant_v2_node.name + ":1", quant_v2_node.name + ":2"],
-                )
-            Helper.set_attr_dtype(dequantize_node, "T", dtype)
-            if self.performance_only or "BatchMatMul" in self.graph_info[op_name].node.op:
-                Helper.set_attr_string(dequantize_node, "mode", b"SCALED")
-            else:
-                Helper.set_attr_string(dequantize_node, "mode", b"MIN_FIRST" if is_asymmetric else b"SCALED")
-            if self.graph_info[op_name].node.op in ("Conv2DBackpropInput", "Conv3DBackpropInputV2"):
-                input_index = 2
-
-            self.g.add_node(quant_v2_node, self.graph_info[op_name].node.input[input_index], [dequantize_node.name])
-            self.g.add_node(dequantize_node, quant_v2_node.name, [op_name])
-            self.g.add_node(reshape_dims_node, None, [reshape_input_name])
-            self.g.add_node(reduction_dims_node, None, [min_input_name, max_input_name])
-            self.g.add_node(reshape_input_node, reshape_dims_name, [min_input_name, max_input_name])
-            self.g.add_node(min_input_node, reshape_input_name, [quant_v2_node.name])
-            self.g.add_node(max_input_node, reshape_input_name, [quant_v2_node.name])
-            self.graph_info[op_name].node.input[input_index] = dequantize_node.name
-
-    def _insert_qdq_pattern_for_weight_node(
-        self, computational_node, weight_node, weight_name, min_max_values, per_channel, weight_bit=7.0, device="cpu"
-    ):
-        """Insert QDQ pattern for weight node."""
-        host_op_type = computational_node.op
-        base_name = weight_node.name + "_"
-        qint8_const_name = base_name + "qint8_const"
-        min_name = base_name + "min"
-        max_name = base_name + "max"
-        epsilon = 1e-4  # Needs to be set empirically if accuracy is not satisfactory
-        range_coefficent = 127 / (2**weight_bit - 1)
-        min_value = 0
-        max_value = 0
-        insert_reshape = False
-        shape_convert = None
-        shape_revert = None
-        # The weight node of BatchMatMul may have no value
-        if "value" in weight_node.attr and host_op_type in (
-            "Conv2D",
-            "MatMul",
-            "BatchMatMul",
-            "BatchMatMulV2",
-            "Conv3D",
-            "Conv2DBackpropInput",
-            "Conv3DBackpropInputV2",
-        ):
-            float_tensor = tensor_util.MakeNdarray(weight_node.attr["value"].tensor)
-            if per_channel:
-                if host_op_type in ("Conv3D", "Conv3DBackpropInputV2"):
-                    ranges = np.abs(float_tensor).max(axis=(0, 1, 2, 3))
-                elif host_op_type in ("Conv2D", "Conv2DBackpropInput"):
-                    ranges = np.abs(float_tensor).max(axis=(0, 1, 2))
-                elif host_op_type in ("MatMul"):  # pragma: no cover
-                    if "transpose_b" in weight_node.attr and weight_node.attr["transpose_b"].b:  # pragma: no cover
-                        ranges = np.abs(float_tensor).max(axis=(1))
-                    else:
-                        # itex qdq needs to transpose this range
-                        ranges = np.abs(float_tensor).max(axis=(0))
-                else:
-                    ranges = np.abs(float_tensor).max(axis=(0, 1))
-
-                ranges *= range_coefficent
-                min_value = -ranges
-                max_value = ranges
-                # nudging min-max values outside epsilon radius around zero
-                ranges[ranges < epsilon] = epsilon
-                min_value[np.abs(min_value) < epsilon] = -epsilon
-                max_value[np.abs(max_value) < epsilon] = epsilon
-                # qint8_tensor = (np.around(float_tensor *127.0/ranges)).astype(np.int8)
-            else:
-                min_value = np.min(float_tensor)
-                max_value = np.max(float_tensor)
-                min_value *= range_coefficent
-                max_value *= range_coefficent
-                min_value = min(min_value, 0.0)
-                if min_value == max_value:
-                    if abs(min_value) < 0.000001:
-                        max_value = min_value + 1.0
-                    elif min_value > 0:
-                        max_value = 2 * min_value
-                    else:
-                        max_value = min_value / 2.0
-                range_value = np.max(np.abs([min_value, max_value]))
-                # qint8_tensor = (np.around(float_tensor * 127.0 / range_value)).astype(np.int8)
-                # qint8_tensor = np.clip(qint8_tensor, -127, 127).astype(np.int8)
-                min_value = -range_value
-                max_value = range_value
-        elif weight_node.op == "ReadVariableOp":
-            min_value = self.llm_weight_minmax[weight_node.name][0]
-            max_value = self.llm_weight_minmax[weight_node.name][1]
-            min_value *= range_coefficent
-            max_value *= range_coefficent
-            min_value = min(min_value, 0.0)
-            if min_value == max_value:
-                if abs(min_value) < 0.000001:
-                    max_value = min_value + 1.0
-                elif min_value > 0:
-                    max_value = 2 * min_value
-                else:
-                    max_value = min_value / 2.0
-            range_value = np.max(np.abs([min_value, max_value]))
-            # qint8_tensor = (np.around(float_tensor * 127.0 / range_value)).astype(np.int8)
-            # qint8_tensor = np.clip(qint8_tensor, -127, 127).astype(np.int8)
-            min_value = -range_value
-            max_value = range_value
-        elif host_op_type == "DepthwiseConv2dNative":
-            float_tensor = tensor_util.MakeNdarray(weight_node.attr["value"].tensor)
-            # get the max values based on dim 0 and 1 for depthwise conv
-            # since, the output channel will be dim 2 * dim 3
-            ranges = np.abs(float_tensor).max(axis=(0, 1))
-            ranges = ranges.flatten()
-            min_value = -ranges
-            max_value = ranges
-            # nudging min-max values outside epsilon radius around zero
-            ranges[ranges < epsilon] = epsilon
-            min_value[np.abs(min_value) < epsilon] = -epsilon
-            max_value[np.abs(max_value) < epsilon] = epsilon
-            # Since output channel will be 1 dim which is dim 2 * dim 3
-            # When divide by range, qint8_tensor needs to be 3 dim
-            # where, 3rd dim should be same dim of ranges
-            a, b, c, d = float_tensor.shape
-            # qint8_tensor = (np.around(float_tensor.reshape(a, b, c * d) * 127.0 /
-            #                ranges)).astype(np.int8)
-            # get the shape back to 4 dim
-            # qint8_tensor = qint8_tensor.reshape(a, b, c, d)
-            if self.itex_mode and d != 1:
-                insert_reshape = True
-                shape_convert = [a, b, c * d]
-                shape_revert = [a, b, c, d]
-        else:
-            min_value = np.min(min_max_values[computational_node.name + "__min"])
-            max_value = np.max(min_max_values[computational_node.name + "__max"])
-
-        min_node = Helper.create_constant_node(min_name, min_value, dtypes.float32, device="cpu")
-        max_node = Helper.create_constant_node(max_name, max_value, dtypes.float32, device="cpu")
-        if "BatchMatMul" in host_op_type and "BatchMatMul" not in weight_node.op:
-            min_node.input.append("^" + weight_name)
-            max_node.input.append("^" + weight_name)
-
-        min_enter_node = None
-        max_enter_node = None
-        if insert_reshape:
-            reshape_dims_4to3_name = qint8_const_name + "_reshape_dims_4to3_"
-            reshape_dims_4to3_node = Helper.create_constant_node(reshape_dims_4to3_name, shape_convert, dtypes.int32)
-            reshape_4to3_name = qint8_const_name + "_reshape_4to3_"
-            reshape_4to3_node = Helper.create_node(
-                "Reshape", reshape_4to3_name, [weight_node.name, reshape_dims_4to3_name]
-            )
-            reshape_4to3_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-            quant_node = Helper.create_node(
-                "QuantizeV2", qint8_const_name + "_quant", [reshape_4to3_name, min_name, max_name]
-            )
-        else:
-            quant_node = Helper.create_node(
-                "QuantizeV2", qint8_const_name + "_quant", [weight_node.name, min_name, max_name]
-            )
-
-        dequant_node = Helper.create_node(
-            "Dequantize", base_name + "_dequant", [quant_node.name, quant_node.name + ":1", quant_node.name + ":2"]
-        )
-        Helper.set_attr_dtype(quant_node, "T", dtypes.qint8)
-        Helper.set_attr_string(quant_node, "mode", b"SCALED")
-        Helper.set_attr_string(quant_node, "round_mode", b"HALF_TO_EVEN")
-        Helper.set_attr_dtype(dequant_node, "T", dtypes.qint8)
-        Helper.set_attr_string(dequant_node, "mode", b"SCALED")
-        if per_channel:
-            if host_op_type in ("Conv2D", "Conv2DBackpropInput"):
-                Helper.set_attr_int(quant_node, "axis", 3)
-                Helper.set_attr_int(dequant_node, "axis", 3)
-            elif host_op_type in ("Conv3D", "Conv3DBackpropInputV2"):
-                Helper.set_attr_int(quant_node, "axis", 4)
-                Helper.set_attr_int(dequant_node, "axis", 4)
-            elif host_op_type == "MatMul":
-                Helper.set_attr_int(quant_node, "axis", 1)
-                Helper.set_attr_int(dequant_node, "axis", 1)
-            else:
-                Helper.set_attr_int(quant_node, "axis", -1)
-                Helper.set_attr_int(dequant_node, "axis", -1)
-        if host_op_type == "DepthwiseConv2dNative":
-            Helper.set_attr_int(quant_node, "axis", 2)
-            Helper.set_attr_int(dequant_node, "axis", 2)
-
-        if insert_reshape:
-            reshape_dims_3to4_name = qint8_const_name + "_reshape_dims_3to4_"
-            reshape_dims_3to4_node = Helper.create_constant_node(reshape_dims_3to4_name, shape_revert, dtypes.int32)
-            reshape_3to4_name = qint8_const_name + "_reshape_3to4_"
-            reshape_3to4_node = Helper.create_node(
-                "Reshape", reshape_3to4_name, [dequant_node.name, reshape_dims_3to4_name]
-            )
-            reshape_3to4_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-            self.g_weight.add_node(reshape_dims_4to3_node, None, [reshape_4to3_name])
-            self.g_weight.add_node(reshape_dims_3to4_node, None, [reshape_3to4_name])
-            self.g_weight.add_node(reshape_4to3_node, weight_node.name, [quant_node.name])
-            self.g_weight.add_node(quant_node, reshape_4to3_name, [])
-            self.g_weight.add_node(min_node, None, [quant_node.name])
-            self.g_weight.add_node(max_node, None, [quant_node.name])
-            self.g_weight.add_node(dequant_node, quant_node.name, [reshape_3to4_name])
-            self.g_weight.add_node(reshape_3to4_node, dequant_node.name, [computational_node.name])
-            computational_node.input[1] = reshape_3to4_node.name
-        else:
-            if (
-                computational_node.name in self.g.parent_frame_details
-                and self.g.parent_frame_details[computational_node.name]
-            ):  # pragma: no cover
-                weight_enter_node = Helper.create_node("Enter", weight_node.name + "_enter", [weight_node.name])
-                Helper.set_attr_string(
-                    weight_enter_node,
-                    "frame_name",
-                    self.g.parent_frame_details[computational_node.name].attr["frame_name"].s,
-                )
-                Helper.set_attr_dtype(weight_enter_node, "T", dtypes.float32)
-                Helper.set_attr_bool(weight_enter_node, "is_constant", True)
-                Helper.set_attr_int(
-                    weight_enter_node,
-                    "parallel_iterations",
-                    self.g.parent_frame_details[computational_node.name].attr["parallel_iterations"].i,
-                )
-
-                min_enter_node = Helper.create_node("Enter", min_name + "_enter", [min_name])
-                Helper.set_attr_string(
-                    min_enter_node,
-                    "frame_name",
-                    self.g.parent_frame_details[computational_node.name].attr["frame_name"].s,
-                )
-                Helper.set_attr_dtype(min_enter_node, "T", dtypes.float32)
-                Helper.set_attr_bool(min_enter_node, "is_constant", True)
-                Helper.set_attr_int(
-                    min_enter_node,
-                    "parallel_iterations",
-                    self.g.parent_frame_details[computational_node.name].attr["parallel_iterations"].i,
-                )
-
-                max_enter_node = Helper.create_node("Enter", max_name + "_enter", [max_name])
-                Helper.set_attr_string(
-                    max_enter_node,
-                    "frame_name",
-                    self.g.parent_frame_details[computational_node.name].attr["frame_name"].s,
-                )
-                Helper.set_attr_dtype(max_enter_node, "T", dtypes.float32)
-                Helper.set_attr_bool(max_enter_node, "is_constant", True)
-                Helper.set_attr_int(
-                    max_enter_node,
-                    "parallel_iterations",
-                    self.g.parent_frame_details[computational_node.name].attr["parallel_iterations"].i,
-                )
-
-                self.g_weight.add_node(quant_node, weight_name, [])
-                self.g_weight.add_node(min_node, None, [min_enter_node.name])
-                self.g_weight.add_node(max_node, None, [max_enter_node.name])
-                self.g_weight.add_node(min_enter_node, min_node.name, [quant_node.name])
-                self.g_weight.add_node(max_enter_node, max_node.name, [quant_node.name])
-                self.g_weight.add_node(weight_enter_node, weight_node.name, [quant_node.name])
-                quant_node.input[0] = weight_enter_node.name
-                quant_node.input[1] = min_enter_node.name
-                quant_node.input[2] = max_enter_node.name
-                self.g_weight.add_node(quant_node, weight_enter_node.name, [])
-                self.g_weight.add_node(dequant_node, quant_node.name, [computational_node.name])
-                computational_node.input[1] = dequant_node.name
-            else:
-                self.g_weight.add_node(quant_node, weight_name, [])
-                self.g_weight.add_node(min_node, None, [quant_node.name])
-                self.g_weight.add_node(max_node, None, [quant_node.name])
-                self.g_weight.add_node(dequant_node, quant_node.name, [computational_node.name])
-                computational_node.input[1] = dequant_node.name
-
-    def _ignore_insert_qdq_pattern(self, matched_node_name):
-        """For some cases we don't need to insert QDQ patterns."""
-        if (matched_node_name in self.fp32_ops or matched_node_name in self.bf16_ops) and (
-            (matched_node_name,) not in self.quantized_nodes
-        ):
-            return True
-
-        if matched_node_name not in self.op_wise_config and (matched_node_name,) not in self.quantized_nodes:
-            return True
-
-        # TODO Remove below two lines once the TF enabled the QuantizedMatMul while
-        # transpose_a could be set to True.
-        if not self.itex_mode and self.graph_info[matched_node_name].node.op == "MatMul":
-            if self.graph_info[matched_node_name].node.attr["transpose_a"].b is True:
-                return True
-        if "FusedBatchNorm" in self.graph_info[matched_node_name].node.op and not self.itex_mode:
-            return True
-        if "_MklFusedInstanceNorm" == self.graph_info[matched_node_name].node.op and not self.itex_mode:
-            return True
-        return False
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/qdq/merge_duplicated_qdq.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/qdq/merge_duplicated_qdq.py
deleted file mode 100644
index 17a608135cd..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/qdq/merge_duplicated_qdq.py
+++ /dev/null
@@ -1,94 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Merge duplicated QDQ patterns Graph Rewriter."""
-
-from tensorflow.core.framework import node_def_pb2
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class MergeDuplicatedQDQOptimizer(GraphRewriterBase):
-    """Merge duplicated QDQ patterns."""
-
-    @dump_elapsed_time("Pass MergeDuplicatedQDQOptimizer")
-    def do_transformation(self):
-        """Execute the merge."""
-        cur_graph = GraphAnalyzer()
-        cur_graph.graph = self.model
-        graph_info = cur_graph.parse_graph()
-
-        patterns = [["QuantizeV2"], ["Dequantize"]]
-        matched_nodes = cur_graph.query_fusion_pattern_nodes(patterns)
-
-        quantizev2_input_map = {}
-        dequantize_map = {}
-        for i in matched_nodes:
-            quantizev2_input_node_name = graph_info[i[0]].node.input[0]
-            if quantizev2_input_node_name in quantizev2_input_map:
-                quantizev2_input_map[quantizev2_input_node_name].append(graph_info[i[0]].node)
-                dequantize_map[quantizev2_input_node_name].append(graph_info[i[1]].node)
-            else:
-                quantizev2_input_map[quantizev2_input_node_name] = [graph_info[i[0]].node]
-                dequantize_map[quantizev2_input_node_name] = [graph_info[i[1]].node]
-
-        for input_map_node_name, quantizev2_nodes in quantizev2_input_map.items():
-            if input_map_node_name not in cur_graph.node_name_details:
-                continue
-
-            # the nodes share the the same input and have the same QuantizeV2 op type
-            if len(quantizev2_nodes) > 1:
-                # merge the duplicated QuantizeV2 op.
-                new_quantize_node = quantizev2_nodes[0]
-                new_dequantize_node = dequantize_map[input_map_node_name][0]
-
-                do_merge = True
-                for i in quantizev2_nodes:
-                    if i.name != new_quantize_node.name and i.attr["T"].type != new_quantize_node.attr["T"].type:
-                        do_merge = False
-                        break
-
-                if not do_merge:
-                    continue
-
-                # set the new QuantizeV2 node as the only output of the parent node
-                for i in quantizev2_nodes:
-                    if i.name != new_quantize_node.name:
-                        cur_graph.node_name_details[input_map_node_name].outputs.remove(i.name)
-
-                # set the new QuantizeV2 node as all the other input of the Dequantize nodes
-                for i in dequantize_map[input_map_node_name]:
-                    if i.name != new_dequantize_node.name:
-                        cur_graph.node_name_details[i.name].node.ClearField("input")
-                        cur_graph.node_name_details[i.name].node.input.extend(
-                            [new_quantize_node.name, new_quantize_node.name + ":1", new_quantize_node.name + ":2"]
-                        )
-
-                # remove the duplicated quantized nodes
-                for i in quantizev2_nodes:
-                    if i.name != new_quantize_node.name:
-                        # remove quantize min node
-                        cur_graph.remove_node(cur_graph.node_name_details[i.name].node.input[1])
-                        # remove quantize max node
-                        cur_graph.remove_node(cur_graph.node_name_details[i.name].node.input[2])
-                        # remove quantize node
-                        cur_graph.remove_node(i.name)
-
-        return cur_graph.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/qdq/share_qdq_y_pattern.py b/neural_compressor/tensorflow/quantization/utils/graph_rewriter/qdq/share_qdq_y_pattern.py
deleted file mode 100644
index 363e45d8fa3..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_rewriter/qdq/share_qdq_y_pattern.py
+++ /dev/null
@@ -1,60 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Share QDQ for ITEX Y pattern Graph Rewriter."""
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..graph_base import GraphRewriterBase
-
-
-class ShareQDQForItexYPatternOptimizer(GraphRewriterBase):
-    """Insert Q/DQ op before one input of Add to enable Conv/MatMul + BiasAdd + Add + Relu fusion for ITEX.
-
-    Only 1 Q/DQ before Add op need to be inserted. Insert 2 Q/DQ breaks the ITEX fusion pattern.
-    """
-
-    @dump_elapsed_time("Pass ShareQDQForItexYPatternOptimizer")
-    def do_transformation(self):
-        """Share the QDQ of one output of Relu node with the another output which is Add node."""
-        g = GraphAnalyzer()
-        g.graph = self.model
-        graph_info = g.parse_graph()
-
-        patterns = [["Relu", "MaxPool"], ["QuantizeV2"], ["Dequantize"]]
-        matched_nodes = g.query_fusion_pattern_nodes(patterns)
-
-        for i in matched_nodes:
-            relu_node_name = graph_info[i[0]].node.name
-            if len(g.node_name_details[relu_node_name].outputs) != 2:
-                continue
-
-            add_node_name = g.node_name_details[relu_node_name].outputs[0]
-            quantize_node_name = g.node_name_details[relu_node_name].outputs[1]
-            if (
-                "Add" not in g.node_name_details[add_node_name].node.op
-                or g.node_name_details[quantize_node_name].node.op != "QuantizeV2"
-            ):
-                continue
-            dequantize_node_name = graph_info[i[2]].node.name
-
-            g.node_name_details[relu_node_name].outputs.remove(add_node_name)
-            g.node_name_details[dequantize_node_name].outputs.append(add_node_name)
-            g.node_name_details[add_node_name].node.input.remove(relu_node_name)
-            g.node_name_details[add_node_name].node.input.append(dequantize_node_name)
-
-        return g.dump_graph()
diff --git a/neural_compressor/tensorflow/quantization/utils/graph_util.py b/neural_compressor/tensorflow/quantization/utils/graph_util.py
deleted file mode 100644
index 167ae6eb25c..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/graph_util.py
+++ /dev/null
@@ -1,1118 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Tensorflow Graph Utils Helper Classes."""
-
-import copy
-import logging
-import re
-from collections import namedtuple
-
-import numpy as np
-from tensorflow.core.framework import attr_value_pb2, graph_pb2, node_def_pb2
-from tensorflow.python.framework import tensor_util
-
-from neural_compressor.tensorflow.utils import singleton
-
-logger = logging.getLogger("neural_compressor")
-
-
-@singleton
-class GraphAnalyzer:
-    """Tensorflow Graph Analyzer class which implemented under singleton mode.
-
-    This class provides the following API:
-    * Analyze the graph
-    * Analyze the input/output node names of the specified graph
-    """
-
-    # TODO add the positive input flag
-    node_details = namedtuple("node_details", ["node", "outputs"])
-
-    def __init__(self, extend_engine=None):
-        """Initialization.
-
-        Args:
-            extend_engine: extended engine, for future extension API。
-        """
-        self._graph = None
-        self.extend_engine = extend_engine
-
-    @property
-    def graph(self):
-        """Getter of the _graph object.
-
-        Returns:
-            graph: current graphdef object
-        """
-        return self._graph
-
-    @graph.setter
-    def graph(self, new_graph):
-        """Update the internal graph value.
-
-        Args:
-            new_graph (graphdef object): new model object
-        """
-        self._graph = new_graph
-
-    def _has_positive_input(self, start_node):
-        """Check the start_node if has positive input."""
-        op_type = start_node.op
-        if op_type in ("Relu", "Relu6") or op_type.find("AndRelu") != -1:
-            return True
-        elif op_type.startswith("Quantized") and not op_type.endswith("AndRelu"):
-            return False
-        elif op_type in ("Concat", "Add", "AddV2", "AddN"):
-            for each_input in start_node.input:
-                has_relu = self._has_positive_input(
-                    self.node_name_details[GraphRewriterHelper.node_name_from_input(each_input)].node
-                )
-                if not has_relu:
-                    return False
-            return True
-        elif op_type in (
-            "Conv3D",
-            "Conv2D",
-            "DepthwiseConv2D",
-            "QuantizeV2",
-            "DepthwiseConv2dNative",
-            "MaxPool",
-            "MaxPool3D",
-            "Requantize",
-            "AvgPool",
-            "Pad",
-            "CropAndResize",
-            "Dequantize",
-            "Mean",
-            "MatMul",
-            "FusedBatchNormV3",
-            "_MklFusedInstanceNorm",
-        ):
-            return self._has_positive_input(
-                self.node_name_details[GraphRewriterHelper.node_name_from_input(start_node.input[0])].node
-            )
-        else:
-            return False
-
-    def has_positive_input(self, node_name):
-        """Check the specified node has positive input data or not.
-
-        Args:
-            node_name (string): node name
-
-        Returns:
-            bool: return True if the node has the positive input data,
-                return False if the node has the negative input data.
-        """
-        return self._has_positive_input(self.node_name_details[node_name].node)
-
-    def get_graph_input_output(self):
-        """Get the graphdef input/output node names.
-
-        Sometimes, the configuration doesn't specifies the input/output names of the graph,
-        but tensorflow need to know them clearly to run the graph.We implement this function has the similar
-        feature like summarize_graph.py which writtern by Google.
-
-        Returns:
-            tuple: (inputs' name list, outputs'name list)
-        """
-        input_node_names = []
-        output_node_names = []
-        unlikely_output_types = [
-            "Const",
-            "HostConst",
-            "Assign",
-            "NoOp",
-            "Parameter",
-            "Assert",
-            "save",
-            "global_step",
-            "read",
-            "switch",
-            "cond",
-            "train",
-            "init_ops",
-            "[A-Za-z]+Dataset",
-        ]
-        unlikely_input_types = [
-            "FIFOQueueV2",
-            "QueueDequeueV2",
-            "QueueDequeueUpToV2",
-            "OneShotIterator",
-            "IteratorGetNext",
-            "IteratorV2",
-        ]
-        exclude_input_names = []
-        extra_input_names = []
-
-        for _, i in self.node_name_details.items():
-            for exclude_input_name in exclude_input_names:
-                if exclude_input_name == i.node.name:
-                    if i.node.op in unlikely_input_types:
-                        exclude_input_names += i.outputs
-                    else:
-                        extra_input_names.append(i.node.name)
-            if i.node.op in ["Const", "HostConst", "Variable", "VariableV2"]:
-                continue
-            if not i.node.input and not i.outputs:
-                logger.debug("Skip isolated node {}.".format(i.node.name))
-            elif i.node.op == "Placeholder":
-                input_node_names.append(i.node.name)
-            elif not i.node.input:
-                if i.node.op not in unlikely_input_types:
-                    input_node_names.append(i.node.name)
-                else:
-                    exclude_input_names += i.outputs
-            elif (
-                not i.outputs
-                and i.node.op not in unlikely_output_types
-                and not re.match(unlikely_output_types[-1], i.node.op)
-            ):
-                output_node_names.append(i.node.name)
-            else:
-                pass
-
-        if len(input_node_names) == 0 and len(extra_input_names) != 0:
-            for extra_input_name in extra_input_names:
-                input_node_names.append(extra_input_name)
-
-        logger.warning(
-            "Found possible input node names: {}, output node names: {}.".format(input_node_names, output_node_names)
-        )
-
-        return (input_node_names, output_node_names)
-
-    def query_fusion_pattern_nodes(self, patterns=None):
-        """Public interface for query the nodes aggregation status.
-
-        Args:
-            patterns (string list): Please check the _search_patterns definition.
-
-        Returns:
-            [string list]: The matched node names which saved as the string list.
-        """
-        if self.extend_engine:
-            # Todo keep this for future extension API
-            pass
-        else:
-            return self._search_patterns(patterns)
-
-    def _search_patterns(self, input_pattern):
-        """Search user specified patterns on internal graph structure.
-
-        Args:
-            input_pattern (list): The element of the pattern list could be string/list/tuple.
-            string or list means the specified types are mandatory while tuple stands for optional.
-            e.g:
-            ['Conv2D', ['BiasAdd'], ("Add", "AddN"), ["Relu","Relu6"]] it equals to below patterns:
-            Conv2D + BiasAdd + Add + Relu
-            Conv2D + BiasAdd + AddN + Relu
-            Conv2D + BiasAdd + Add + Relu6
-            Conv2D + BiasAdd + AddN + Relu6
-            Conv2D + BiasAdd + Relu
-            Conv2D + BiasAdd + Relu6
-
-        Return: [string list]. Each matched pattern composed of matched node name and we put the
-                    match node op as the last element of each pair.
-                    e.g
-                    [
-                        ['resnet_model/conv2d_4/Conv2D',
-                        'resnet_model/batch_normalization_4/FusedBatchNorm',
-                        'resnet_model/add',
-                        'resnet_model/Relu_3',
-                        ['Conv2D', 'BiasAdd', 'Add', 'Relu']],
-                        ['resnet_model/conv2d_7/Conv2D',
-                        'resnet_model/batch_normalization_7/FusedBatchNorm',
-                        'resnet_model/add_1',
-                        'resnet_model/Relu_6',
-                        ['Conv2D', 'BiasAdd', 'AddN', 'Relu6']]
-                    ]
-        """
-
-        def _validate_input(data, criteria):
-            """Check whether a node op matches the criteria."""
-            if isinstance(criteria, str) and data == criteria:
-                return True
-
-            if isinstance(criteria, (list, tuple)) and data in criteria:
-                return True
-
-            return False
-
-        def _compare_list(list_a, list_b):
-            """Check list a is a subset of list b.
-
-            e.g, list a is ['a', 'b', 'c'] while list b is ['a', 'b', 'c', 'd'],
-            then list a is subset of list b.
-
-            Args:
-                list_a ([Any]): list A
-                list_b ([Any]): list B
-
-            Returns:
-                [bool]: list a is a subset of list b or not.
-            """
-            assert isinstance(list_a, list)
-            assert isinstance(list_b, list)
-            is_subset = True
-
-            for index, value in enumerate(list_a):
-                is_subset &= value == list_b[index]
-
-            return is_subset
-
-        def _dfs(op_names, op_types, graph_info, node, pattern):
-            """Depth-first search to match graph patterns."""
-            if pattern == []:
-                return
-            start_index = 0
-            end_index = len(pattern) - 1
-            matched_flag = False
-            while start_index <= end_index:
-                matched_flag = _validate_input(node.op, pattern[end_index])
-
-                if not matched_flag and isinstance(pattern[end_index], tuple):
-                    end_index -= 1
-                    continue
-
-                if matched_flag:
-                    op_names.append(node.name)
-                    op_types.append(node.op)
-                    break
-
-                return
-
-            if start_index == end_index:
-                if matched_flag:
-                    matched_res = copy.deepcopy(op_names)
-                    matched_res.reverse()
-                    op_types_copy = copy.deepcopy(op_types)
-                    op_types_copy.reverse()
-                    matched_res.append(op_types_copy)
-                    if matched_res not in output_result:
-                        output_result.append(matched_res)
-
-                    op_names.pop()
-                    op_types.pop()
-                return
-
-            for index, value in enumerate(node.input):
-                cur_node = graph_info[GraphRewriterHelper.node_name_from_input(value)].node
-                _dfs(op_names, op_types, graph_info, cur_node, pattern[:end_index])
-                if index == len(node.input) - 1:
-                    op_names.pop()
-                    op_types.pop()
-
-        output_result = []
-
-        for _, v in self.node_name_details.items():
-            start_index = len(input_pattern) - 1
-            while start_index >= 0:
-                find_first_match = _validate_input(v.node.op, input_pattern[start_index])
-                if find_first_match:
-                    break
-
-                if isinstance(input_pattern[start_index], tuple):
-                    start_index -= 1
-                    continue
-
-                start_index = -2
-
-            if start_index < 0:
-                continue
-
-            visited_op_name = []
-            visited_op_types = []
-
-            _dfs(visited_op_name, visited_op_types, self.node_name_details, v.node, input_pattern)
-
-        sorted_output = sorted(output_result, key=lambda i: i[-1])
-
-        useless_match_list = []
-        for index, value in enumerate(sorted_output):
-            if index == len(sorted_output) - 1:
-                break
-
-            next_matched_op_names = sorted_output[index + 1][:-1]
-            if len(value[:-1]) < len(next_matched_op_names) and _compare_list(value[:-1], next_matched_op_names):
-                useless_match_list.append(value)
-
-        for i in useless_match_list:
-            sorted_output.remove(i)
-
-        longest_match = {}
-        final_output = []
-        for i in sorted_output:
-            key = i[0]
-            if key not in longest_match:
-                longest_match[key] = i[-1]
-                continue
-
-            if len(longest_match[key]) < len(i[-1]):
-                longest_match[key] = i[-1]
-
-        for i in sorted_output:
-            if i[0] in longest_match and i[-1] == longest_match[i[0]]:
-                final_output.append(i)
-
-        return final_output
-
-    def remove_node_with_single_input_output(self, node_name):
-        """Remove node with one input and rebuild internal graph data structure.
-
-        Args:
-            node_name (string): node name
-
-        Returns:
-            [bool]: True if remove the node without exception,
-                    False if failed to remove it.
-        """
-        if node_name not in self.node_name_details:
-            logger.debug("The {} is not a valid node name.".format(node_name))
-            return False
-
-        non_const_node_count = len(
-            [
-                GraphRewriterHelper.node_name_from_input(i)
-                for i in self.node_name_details[node_name].node.input
-                if self.node_name_details[GraphRewriterHelper.node_name_from_input(i)].node.op != "Const"
-            ]
-        )
-
-        if non_const_node_count > 1:
-            logger.debug("The target node {} has more than one input.".format(node_name))
-            return False
-
-        try:
-            top_node_name = GraphRewriterHelper.node_name_from_input(self.node_name_details[node_name].node.input[0])
-
-            for bottom_node_name in self.node_name_details[node_name].outputs:
-                update_output_name = [
-                    bottom_node_name if i == node_name else i for i in self.node_name_details[top_node_name].outputs
-                ]
-                self.node_name_details[top_node_name]._replace(outputs=update_output_name)
-
-                update_input_name = [
-                    self.node_name_details[node_name].node.input[0] if i == node_name else i
-                    for i in self.node_name_details[bottom_node_name].node.input
-                ]
-
-                if self.node_name_details[bottom_node_name].node.input:
-                    self.node_name_details[bottom_node_name].node.ClearField("input")
-                    self.node_name_details[bottom_node_name].node.input.extend(update_input_name)
-
-        except Exception as e:
-            logger.debug("Fail to remove node {} due to {}.".format(node_name, str(e)))
-            return False
-        else:
-            return self.remove_node(node_name)
-
-    def remove_node(self, node_name):
-        """Remove the user specified node by its name.
-
-        Args:
-            node_name (string): node name string.
-
-        Returns:
-            [bool]: True if remove the node without exception.
-                    False if failed to remove it.
-        """
-        if node_name not in self.node_name_details:
-            logger.debug("The {} is not a valid node name.".format(node_name))
-            return False
-        try:
-            self.node_name_details.pop(node_name)
-        except Exception as e:
-            logger.info("Fail to remove {} due to {}.".format(node_name, str(e)))
-            return False
-        else:
-            logger.debug("{} has been removed.".format(node_name))
-            return True
-
-    def replace_const_node(self, new_const_node, target_node, old_constant_node_name, replace_all=True):
-        """Replace the specified const node with another one.
-
-        Args:
-            new_const_node (NodeDef): node name string.
-            target_node (list): the string list that contains name of node that
-                                need to be replaced const node.
-            old_constant_node_name (string): the outdated const node name.
-            replace_all (bool): replace the specified node name once or not.
-        """
-        new_const_node_name = new_const_node.name
-
-        self.node_name_details[new_const_node_name] = self.node_details(node=new_const_node, outputs=target_node)
-
-        for sub_node in target_node:
-            if sub_node not in self.node_name_details:
-                continue
-            for index, each_node_name in enumerate(self.node_name_details[sub_node].node.input):
-                if each_node_name + ":0" == old_constant_node_name or each_node_name == old_constant_node_name:
-                    new_input_name = (
-                        self.node_name_details[sub_node].node.input[:index]
-                        + [new_const_node_name]
-                        + self.node_name_details[sub_node].node.input[index + 1 :]
-                    )
-                    self.node_name_details[sub_node].node.ClearField("input")
-                    self.node_name_details[sub_node].node.input.extend(new_input_name)
-                    if old_constant_node_name in self.node_name_details:
-                        self.node_name_details[old_constant_node_name].outputs.remove(sub_node)
-                        if len(self.node_name_details[old_constant_node_name].outputs) == 0:
-                            self.remove_node(old_constant_node_name)
-                    if not replace_all:
-                        break
-
-    def replace_constant_graph_with_constant_node(self, new_node, old_end_node_name):
-        """Remove sub-graph with a const node.
-
-        Args:
-            new_node (nodedef): the constant node
-            old_end_node_name (string):  the sub-graph end node which will be updated by new node
-
-        Returns:
-            [bool]: True if remove the node without exception.
-                    False if failed to remove it.
-        """
-        new_node_name = new_node.name
-
-        if new_node.op != "Const":
-            logger.warning("The input of replace_with_constant_node must be a constant node.")
-            return False
-        try:
-            inputs = self.node_name_details[old_end_node_name].node.input
-            inputs = [GraphRewriterHelper.node_name_from_input(i) for i in inputs]
-            for input_name in inputs:
-                if self.node_name_details[input_name].node.op != "Const":
-                    logger.warning("The subgraph replaces must be constant.")
-                    return False
-                elif len(self.node_name_details[input_name].outputs) == 1:
-                    self.node_name_details.pop(input_name)
-            output_node_name = self.node_name_details[old_end_node_name].outputs
-            self.replace_node(new_node, old_end_node_name, output_node_name)
-            self.node_name_details[new_node_name].node.ClearField("input")
-        except Exception as e:
-            logger.info("Fail to replace {} due to {}.".format(old_end_node_name, str(e)))
-            return False
-        else:
-            return True
-
-    def replace_single_node(
-        self, new_node, old_output_node_names, old_output_name, old_input_node_names, old_input_name
-    ):
-        """Insert one node into the graph.
-
-        Args:
-            new_node (nodedef): new nodedef object
-            old_output_node_names (string list):the node names that would be the top node of new
-                                                node.
-            old_output_name (string list): the names that need to be updated with new node name
-            old_input_node_names (string list): the node names that would be the bottom node of new
-                                                node.
-            old_input_name (string list): the names that need to be updated with new node name
-        """
-        new_node_name = new_node.name
-        for i in old_output_node_names:
-            while old_output_name in self.node_name_details[i].outputs:
-                self.node_name_details[i].outputs.remove(old_output_name)
-            self.node_name_details[i].outputs.append(new_node_name)
-
-        self.node_name_details[new_node_name] = self.node_details(node=new_node, outputs=old_input_node_names)
-
-        for each_input_node_name in old_input_node_names:
-            for index, each_node_name in enumerate(self.node_name_details[each_input_node_name].node.input):
-                if self.node_name_details[each_input_node_name].node.input and (each_node_name) == old_input_name:
-                    new_input_name = (
-                        self.node_name_details[each_input_node_name].node.input[:index]
-                        + [new_node_name]
-                        + self.node_name_details[each_input_node_name].node.input[index + 1 :]
-                    )
-                    self.node_name_details[each_input_node_name].node.ClearField("input")
-                    self.node_name_details[each_input_node_name].node.input.extend(new_input_name)
-
-    def replace_node(self, new_node, old_node_name, output_nodes_name):
-        """Replace the node into the internal data structure node_name_details.
-
-        Args:
-            new_node (nodedef): the nodedef object.
-            old_node_name (string): the parent node of input node.
-            output_nodes_name (string list): output node names list
-        """
-        new_node_name = new_node.name
-        self.node_name_details[new_node_name] = self.node_details(node=new_node, outputs=output_nodes_name)
-        old_node = self.node_name_details[old_node_name].node
-        for input_node_name in old_node.input:
-            if input_node_name in self.node_name_details:
-                self.node_name_details[input_node_name].outputs.remove(old_node_name)
-                self.node_name_details[input_node_name].outputs.append(new_node_name)
-
-        for node_name in output_nodes_name:
-            for index, each_node_name in enumerate(self.node_name_details[node_name].node.input):
-                if (
-                    self.node_name_details[node_name].node.input
-                    and GraphRewriterHelper.node_name_from_input(each_node_name) == old_node_name
-                ):
-                    new_input_name = (
-                        self.node_name_details[node_name].node.input[:index]
-                        + [new_node_name]
-                        + self.node_name_details[node_name].node.input[index + 1 :]
-                    )
-                    self.node_name_details[node_name].node.ClearField("input")
-                    self.node_name_details[node_name].node.input.extend(new_input_name)
-        self.remove_node(old_node_name)
-
-    def add_node(self, new_node, start_node_name, end_node_names):
-        """Add the node into the internal data structure node_name_details.
-
-        Args:
-            new_node (nodedef): the nodedef object.
-            start_node_name (string): the parent node of input node.
-            end_node_names (string list): output node names list
-        """
-        new_node_name = new_node.name
-
-        if new_node_name in self.node_name_details:
-            logger.debug("Remove the existed node {} from internal data structure.".format((new_node_name)))
-            self.node_name_details.pop(new_node_name)
-
-        self.node_name_details[new_node_name] = self.node_details(node=new_node, outputs=end_node_names)
-
-        for end_node_name in end_node_names:
-            # Update start node's output info
-            if end_node_name not in self.node_name_details:
-                continue
-            if (
-                start_node_name
-                and end_node_name
-                in self.node_name_details[GraphRewriterHelper.node_name_from_input(start_node_name)].outputs
-            ):
-                self.node_name_details[GraphRewriterHelper.node_name_from_input(start_node_name)].outputs.remove(
-                    end_node_name
-                )
-
-            # reset output node's input
-            for index, each_node_name in enumerate(self.node_name_details[end_node_name].node.input):
-                if each_node_name == start_node_name:
-                    new_input_name = (
-                        self.node_name_details[end_node_name].node.input[:index]
-                        + [new_node_name]
-                        + self.node_name_details[end_node_name].node.input[index + 1 :]
-                    )
-                    self.node_name_details[end_node_name].node.ClearField("input")
-                    self.node_name_details[end_node_name].node.input.extend(new_input_name)
-
-        # add the inserted node into the start node's output.
-        if start_node_name:
-            self.node_name_details[GraphRewriterHelper.node_name_from_input(start_node_name)].outputs.append(
-                new_node_name
-            )
-
-    def dump_graph(self):
-        """Dump the current model's graphdef.
-
-        Returns:
-            [graphdef]: A graphdef object
-        """
-        output_graph_def = graph_pb2.GraphDef()
-        for _, v in self.node_name_details.items():
-            output_graph_def.node.extend([v.node])
-
-        return output_graph_def
-
-    def get_frame_info(self):
-        """Get the frame info of the model.
-
-        Returns:
-            [parent_frame_details]: OrderedDict frame info of the graph nodes.
-        """
-        from collections import OrderedDict
-
-        self.parent_frame_details = OrderedDict()
-        input_node_names, _ = self.get_graph_input_output()
-
-        traverse_list = copy.deepcopy(input_node_names)
-        visited = []
-
-        while traverse_list:
-            node_name = traverse_list.pop(0)
-            node_details = self.node_name_details[node_name]
-
-            if node_details.node.name in visited:
-                continue
-
-            for output in node_details.outputs:
-                traverse_list.append(output)
-
-                inputs = node_details.node.input
-                if not inputs:
-                    self.parent_frame_details[node_details.node.name] = None
-                if self.node_name_details[output].node.op == "Enter":
-                    self.parent_frame_details[output] = self.node_name_details[output].node
-                elif self.node_name_details[output].node.op == "Exit":
-                    self.parent_frame_details[output] = None
-                else:
-                    if output in self.parent_frame_details and self.parent_frame_details[output]:
-                        if (
-                            node_details.node.name in self.parent_frame_details
-                            and self.parent_frame_details[node_details.node.name]
-                        ):
-                            assert (
-                                self.parent_frame_details[output].attr["frame_name"]
-                                == self.parent_frame_details[node_details.node.name].attr["frame_name"]
-                            )
-                    else:
-                        if node_details.node.name in self.parent_frame_details:
-                            self.parent_frame_details[output] = self.parent_frame_details[node_details.node.name]
-
-            visited.append(node_details.node.name)
-        return self.parent_frame_details
-
-    def parse_graph(self, input_graph_def=None):
-        """Analyze the input graphdef and return the list contains each node's input/outputnode names.
-
-        Args:
-            input_graph_def ([graphdef]): graphdef object
-
-        Returns:
-            [list]: A list contains each node's inputs/outputs info.
-        """
-        if not input_graph_def:
-            input_graph_def = self._graph
-
-        self.node_name_details = {}
-
-        for node in input_graph_def.node:
-            node_name = GraphRewriterHelper.node_name_from_input(node.name)
-
-            each_node = self.node_details(node=node, outputs=[])
-
-            if node_name not in self.node_name_details:
-                self.node_name_details[node_name] = each_node
-
-        for node_name, node_details in self.node_name_details.items():
-            # update the upper node's output information.
-            for each_input in node_details.node.input:
-                self.node_name_details[GraphRewriterHelper.node_name_from_input(each_input)].outputs.append(node_name)
-
-        return self.node_name_details
-
-
-class GraphRewriterHelper:
-    """Encapsulates the graph operation into one class."""
-
-    node_name_cache = {}
-    node_name_port_cache = {}
-
-    @staticmethod
-    def compare_node_attr(node_a, node_b):
-        """Compare two node has identical attributes or not.
-
-        Args:
-            node_a (nodedef): Input node.
-            node_b (nodedef): Another node to be compared.
-
-        Returns:
-            [bool]: True if two node have the identical attributes.
-        """
-        if len(node_a.input) > 1:
-            return False
-
-        if node_a.input != node_b.input:
-            return False
-
-        if node_a.op != node_b.op:
-            return False
-
-        if len(node_a.attr) != len(node_b.attr):
-            return False
-
-        node_a_attr = sorted(list(node_a.attr))
-        node_b_attr = sorted(list(node_b.attr))
-
-        if node_a_attr != node_b_attr:
-            return False
-
-        for attr_name in node_a_attr:
-            if node_a.attr[attr_name] != node_b.attr[attr_name]:
-                return False
-
-        return True
-
-    @staticmethod
-    def create_node(op, name, inputs):
-        """Create a nodedef object.
-
-        Args:
-            op (string): op type
-            name (string): op name
-            inputs (string list): op's inputs name
-
-        Returns:
-            nodedef: the created nodedef object
-        """
-        new_node = node_def_pb2.NodeDef()
-        new_node.op = op
-        new_node.name = name
-        for input_name in inputs:
-            new_node.input.extend([input_name])
-        return new_node
-
-    @staticmethod
-    def create_constant_node(name, value, dtype, shape=None, device="cpu"):
-        """Create constant node.
-
-        Args:
-            name (string): op name
-            value (np.array): input data
-            dtype (datatype): data type of the input value
-            shape (int list, optional): the value's shape. Defaults to None.
-            device (str, optional): the device type, it may be the 'cpu' or 'gpu'.
-                                    Defaults to 'cpu'.
-
-        Returns:
-            [type]: [description]
-        """
-        node = GraphRewriterHelper.create_node("Const" if device == "cpu" else "HostConst", name, [])
-        GraphRewriterHelper.set_attr_dtype(node, "dtype", dtype)
-        GraphRewriterHelper.set_attr_tensor(node, "value", value, dtype, shape)
-        return node
-
-    @staticmethod
-    def set_attr_dtype(node, key, value):
-        """Set the attribute data type."""
-        node.attr[key].CopyFrom(attr_value_pb2.AttrValue(type=value.as_datatype_enum))
-
-    @staticmethod
-    def set_attr_tensor(node, key, value, dtype, shape=None):
-        """Set the tensor value to specified attribute field.
-
-        Args:
-            node (nodedef): the target nodedef object
-            key (string): attribute name
-            value (np.array): the content
-            dtype (dtypes): data type
-            shape (int list, optional): the input tensor's shape. Defaults to None.
-        """
-        node.attr[key].CopyFrom(
-            attr_value_pb2.AttrValue(tensor=tensor_util.make_tensor_proto(value, dtype=dtype, shape=shape))
-        )
-
-    @staticmethod
-    def set_attr_type_list(node, key, value):
-        """Set the node's attr which data type is int list."""
-        list_value = attr_value_pb2.AttrValue.ListValue(type=value)
-        node.attr[key].CopyFrom(attr_value_pb2.AttrValue(list=list_value))
-
-    @staticmethod
-    def set_attr_string_list(node, key, value):
-        """Set the node's attr which data type is int list."""
-        list_value = attr_value_pb2.AttrValue.ListValue(s=value)
-        node.attr[key].CopyFrom(attr_value_pb2.AttrValue(list=list_value))
-
-    @staticmethod
-    def set_attr_string(node, key, value):
-        """Set the node's attr which data type is string."""
-        node.attr[key].CopyFrom(attr_value_pb2.AttrValue(s=value))
-
-    @staticmethod
-    def set_attr_int_list(node, key, value):
-        """Set the node's attr which data type is int list."""
-        list_value = attr_value_pb2.AttrValue.ListValue(i=value)
-        node.attr[key].CopyFrom(attr_value_pb2.AttrValue(list=list_value))
-
-    @staticmethod
-    def set_attr_int(node, key, value):
-        """Set the node's attr which data type is int."""
-        node.attr[key].CopyFrom(attr_value_pb2.AttrValue(i=value))
-
-    @staticmethod
-    def set_attr_float(node, key, value):
-        """Set the node's attr which data type is float."""
-        node.attr[key].CopyFrom(attr_value_pb2.AttrValue(f=value))
-
-    @staticmethod
-    def set_attr_bool(node, key, value):
-        """Set the node's attr which data type is bool."""
-        node.attr[key].CopyFrom(attr_value_pb2.AttrValue(b=value))
-
-    @staticmethod
-    def node_name_from_input(node_name):
-        """Static method that get the valid node name from input name.
-
-        Args:
-            node_name (string): node name defined in the input field.
-
-        Returns:
-            string: node's name
-        """
-        if node_name not in GraphRewriterHelper.node_name_cache:
-            key = node_name
-            if node_name.startswith("^"):
-                node_name = node_name[1:]
-            m = re.search(r"(.*):\d+$", node_name)
-            if m:
-                node_name = m.group(1)
-            GraphRewriterHelper.node_name_cache[key] = node_name
-            return node_name
-
-        return GraphRewriterHelper.node_name_cache[node_name]
-
-    @staticmethod
-    def values_from_const(node_def):
-        """Extracts the values from a const NodeDef as a numpy ndarray.
-
-        Args:
-          node_def: Const NodeDef that has the values we want to access.
-
-        Returns:
-          Numpy ndarray containing the values.
-
-        Raises:
-          ValueError: If the node isn't a Const.
-        """
-        assert node_def.op == "Const", "Node named '%s' should be a Const op." % node_def.name
-
-        input_tensor = node_def.attr["value"].tensor
-        tensor_value = tensor_util.MakeNdarray(input_tensor)
-        return tensor_value
-
-    @staticmethod
-    def generate_int32_bias_for_conv(
-        bias_tensor,
-        channel_size,
-        max_input,
-        min_input,
-        max_filter_tensor,
-        min_filter_tensor,
-        activation_range,
-        weights_range=127.0,
-    ):
-        """Static method that generate int32 bias for conv op.
-
-        Args:
-            bias_tensor: bias node tensor.
-            channel_size: channel size.
-            max_input: max activation input value.
-            min_input: min activation input value.
-            max_filter_tensor: max weight input tensor.
-            min_filter_tensor: min weight input tensor.
-            activation_range: activation range value.
-            weights_range: weight range value.
-
-        Returns:
-            int32_bias: int32 bias
-        """
-        bias_length = bias_tensor.shape[0]
-        scales = []
-        if len(max_filter_tensor) > 1:
-            for i in range(channel_size):
-                scales.append(
-                    activation_range
-                    * weights_range
-                    / (max(abs(max_input), abs(min_input)) * max(abs(max_filter_tensor[i]), abs(min_filter_tensor[i])))
-                )
-        else:
-            for i in range(channel_size):
-                scales.append(
-                    activation_range
-                    * weights_range
-                    / (max(abs(max_input), abs(min_input)) * max(abs(max_filter_tensor[0]), abs(min_filter_tensor[0])))
-                )
-        int32_bias = []
-        if channel_size > 1:
-            for i in range(bias_length):
-                int32_bias.append((int)(np.around(bias_tensor[i] * scales[i])))
-        else:
-            for i in range(bias_length):
-                int32_bias.append((int)(np.around(bias_tensor[i] * scales[0])))
-
-        return int32_bias
-
-    @staticmethod
-    def generate_int32_bias_for_matmul(
-        bias_tensor,
-        weights_tensor,
-        input_range,
-        max_input,
-        min_input,
-        max_filter_value,
-        min_filter_value,
-    ):
-        """Static method that generate int32 bias for matmul op.
-
-        Args:
-            bias_tensor: bias node tensor.
-            weights_tensor: weights tensor.
-            input_range: activation range value.
-            max_input: max activation input value.
-            min_input: min activation input value.
-            max_filter_tensor: max weight input tensor.
-            min_filter_tensor: min weight input tensor.
-
-        Returns:
-            int32_bias: int32 bias
-        """
-        bias_scale = 255.0 * 127.0 / (input_range * max(abs(max_filter_value), abs(min_filter_value)))
-        relative_scale = 255 * min_input / (max_input - min_input)
-        int32_bias = []
-        for bias_index, value in enumerate(np.sum(np.array(weights_tensor, dtype=np.int32), axis=0, dtype=np.int32)):
-            if bias_index >= bias_tensor.size:
-                continue
-            int32_bias.append(int(np.around(bias_tensor[bias_index] * bias_scale + value * relative_scale)))
-
-        return int32_bias
-
-    @staticmethod
-    def generate_int32_bias_for_matmul_per_channel(
-        bias_tensor,
-        weights_tensor,
-        max_input,
-        min_input,
-        max_filter_tensor,
-        min_filter_tensor,
-    ):  # pragma: no cover
-        """Static method that generate per-channel int32 bias for matmul op.
-
-        Args:
-            bias_tensor: bias node tensor.
-            weights_tensor: weights tensor.
-            max_input: max activation input value.
-            min_input: min activation input value.
-            max_filter_tensor: max weight input tensor.
-            min_filter_tensor: min weight input tensor.
-
-        Returns:
-            int32_bias: int32 bias
-        """
-        channel_size = bias_tensor.shape[0]
-        activation_range = 255.0
-        weights_range = 127.0
-        scales = []
-        relative_scale = 255 * min_input / (max_input - min_input)
-        for i in range(channel_size):
-            scales.append(
-                activation_range
-                * weights_range
-                / ((max_input - min_input) * max(abs(max_filter_tensor[i]), abs(min_filter_tensor[i])))
-            )
-        int32_bias = []
-        for i in range(channel_size):
-            value = np.sum(np.array(weights_tensor), axis=0, dtype=np.int32)[i]
-            int32_bias.append((int)(np.around(value * relative_scale + bias_tensor[i] * scales[i])))
-
-        return int32_bias
-
-    @staticmethod
-    def gen_valid_sampling_log(log_path):
-        """Generate the valid sampling log.
-
-        Args:
-          log_path: the valid sampling log file path.
-
-        Returns:
-          the sampling min max value.
-        """
-
-        def gen_per_iter(data):
-            """Normalize per-iteration log entries for min/max values."""
-            res = []
-            requant_tmp = []
-            for i in data:
-                if i.find("__print__;__requant_") == -1:
-                    res.append(i)
-                else:
-                    requant_tmp.append(i)
-            sorted_requant = sorted(requant_tmp)
-            odd_list = sorted_requant[::2]
-            even_list = sorted_requant[1::2]
-            for index, value in enumerate(even_list):
-                min_value = min(0, float(value.split(":")[1][1:-1]))
-                max_value = float(odd_list[index].split(":")[1][1:-1])
-                max_value = max_value if max_value > min_value else min_value + 1e-05
-                mixed_str = value.split(":")[0] + "_max:[" + str(min_value) + "][" + str(max_value) + "]"
-
-                res.append(mixed_str)
-            return res
-
-        def separate(line):
-            """This function is to separate the strings.
-
-            Example:
-                ';slice__print__;__max:[1];slice__print__;__min:[-1]' -->
-                [';slice__print__;__max:[1]', ';slice__print__;__min:[-1]']
-            """
-            separated_lines = []
-            for subline in line.split("];"):
-                if not subline.startswith(";"):
-                    subline = ";" + subline
-                if not subline.endswith("]"):
-                    subline += "]"
-                separated_lines.append(subline)
-            return separated_lines
-
-        with open(log_path) as f:
-            valid_data = []
-            for i in f.readlines():
-                if not i.startswith(";"):
-                    continue
-                line = i.strip()
-                if line.find("];") != 0:
-                    separated_lines = separate(line)
-                    valid_data += separated_lines
-                else:
-                    valid_data.append(line)
-
-        first_line = valid_data[0].rsplit(":")[0]
-
-        iterations = 0
-        for i in valid_data:
-            if i.startswith(first_line):
-                iterations += 1
-
-        step = int(len(valid_data) / iterations)
-        if step % 2 == 1:
-            step -= 1
-            iterations = int(len(valid_data) / step) + int(len(valid_data) % step > 0)
-
-        final_res = []
-
-        for i in range(iterations):
-            final_res.extend(gen_per_iter(valid_data[int(i * step) : int(step * (i + 1))]))
-            if i + 1 == iterations and int(step * (i + 1)) < len(valid_data):
-                final_res.extend(gen_per_iter(valid_data[int(step * (i + 1)) : len(valid_data)]))
-
-        return final_res
-
-    @staticmethod
-    def analysis_rnn_model(graph_def, bf16_ops=[], fp32_ops=[]):
-        """Match the RNN and dynamic RNN patterns."""
-        g = GraphAnalyzer()
-        g.graph = graph_def
-        graph_info = g.parse_graph()
-        rnn_pattern = [["TensorArrayV3"], ["Enter"], ["TensorArrayReadV3"], ["MatMul"], ["BiasAdd"]]
-        target_nodes = g.query_fusion_pattern_nodes(rnn_pattern)
-        res = {}
-        for i in target_nodes:
-            if i[-3] not in bf16_ops and i[-3] not in fp32_ops:
-                res[(i[-3], i[-2])] = graph_info[i[1]].node.attr["frame_name"].s.decode()
-
-        dynamic_rnn_pattern = [["Enter"], ["MatMul"], ["BiasAdd"]]
-        target_nodes = g.query_fusion_pattern_nodes(dynamic_rnn_pattern)
-        for i in target_nodes:
-            if i[-3] not in bf16_ops and i[-3] not in fp32_ops:
-                res[(i[1], i[2])] = graph_info[i[0]].node.attr["frame_name"].s.decode()
-
-        return res
diff --git a/neural_compressor/tensorflow/quantization/utils/quantize_graph/__init__.py b/neural_compressor/tensorflow/quantization/utils/quantize_graph/__init__.py
deleted file mode 100644
index 6c2cd4525f0..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/quantize_graph/__init__.py
+++ /dev/null
@@ -1,17 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Tensorflow Graph Quantizers."""
diff --git a/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/__init__.py b/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/__init__.py
deleted file mode 100644
index 88afa0711e7..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/__init__.py
+++ /dev/null
@@ -1,17 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Tensorflow QDQ Graph Quantizers."""
diff --git a/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_bn.py b/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_bn.py
deleted file mode 100644
index b48ac2fab17..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_bn.py
+++ /dev/null
@@ -1,303 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Quantize FusedBatchNormV3 to int8 op."""
-
-from tensorflow.core.framework import graph_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper as helper
-
-from ..quantize_graph_base import QuantizeNodeBase
-
-
-class FuseNodeStartWithFusedBatchNormV3(QuantizeNodeBase):
-    """Quantize FusedBatchNormV3 to int8 op _QuantizedFusedBatchNorm."""
-
-    def __init__(self, **kwargs):
-        """Initialization."""
-        super().__init__(**kwargs)
-        self.sorted_patterns = sorted(self.patterns, key=lambda i: len(i), reverse=True)
-        if self.new_api:
-            self.fusion_mapping = {
-                "FusedBatchNormV3": self.apply_newly_bn_relu_fusion,
-                "FusedBatchNormV3Relu": self.apply_newly_bn_relu_fusion,
-                "FusedBatchNormV3LeakyRelu": self.apply_newly_bn_leakyrelu_fusion,
-            }
-        else:
-            self.fusion_mapping = {}
-        self.exclude_bn_nodes = []
-
-    def apply_newly_bn_relu_fusion(self, match_node_name):
-        """Apply the BN + Relu fusion."""
-        matched_node = self.node_name_mapping[match_node_name[0]]
-        skip_node_name = match_node_name[1:]
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        scale_name = normal_inputs[1]
-        offset_name = normal_inputs[2]
-        mean_name = normal_inputs[3]
-        variance_name = normal_inputs[4]
-
-        all_input_names = self._add_eightbit_prologue_nodes(matched_node.node.name)
-        all_input_names = [
-            all_input_names[0],
-            scale_name,
-            offset_name,
-            mean_name,
-            variance_name,
-            all_input_names[1],
-            all_input_names[2],
-        ]
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[0]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-
-                relu_node_name = match_node_name[1] if len(match_node_name) == 2 else None
-
-                node_op = "_QuantizedFusedBatchNorm"
-                quantized_node_name = node.name + "_eightbit_quantized_bn"
-                output_min_node_name = quantized_node_name + "_input7_output_min"
-                output_max_node_name = quantized_node_name + "_input8_output_max"
-                quantized_node_input_names = (
-                    all_input_names + [output_min_node_name] + [output_max_node_name] + control_inputs
-                )
-                output_min_node = helper.create_constant_node(output_min_node_name, -1.0, dtypes.float32)
-                output_max_node = helper.create_constant_node(output_max_node_name, 1.0, dtypes.float32)
-                quantized_bn_node = helper.create_node(node_op, quantized_node_name, quantized_node_input_names)
-                if relu_node_name is not None:
-                    helper.set_attr_string(quantized_bn_node, "activation_mode", b"Relu")
-                if self.node_name_mapping[offset_name].node.op == "Const":
-                    helper.set_attr_bool(quantized_bn_node, "is_offset_const", True)
-                else:
-                    helper.set_attr_bool(quantized_bn_node, "is_offset_const", False)
-                if self.node_name_mapping[mean_name].node.op == "Const":
-                    helper.set_attr_bool(quantized_bn_node, "is_mean_const", True)
-                else:
-                    helper.set_attr_bool(quantized_bn_node, "is_mean_const", False)
-                helper.set_attr_dtype(quantized_bn_node, "T", dtypes.qint8)
-                helper.set_attr_dtype(quantized_bn_node, "U", dtypes.float32)
-                helper.set_attr_dtype(quantized_bn_node, "Tout", dtypes.qint8)
-                """# 0.
-
-                x
-                # 1. scale
-                # 2. offset
-                # 3. mean
-                # 4. variance
-                # 5. x_min
-                # 6. x_max
-                # 7. {output_min}
-                # 8. {output_max}
-                """
-                helper.set_attr_type_list(
-                    quantized_bn_node,
-                    "input_types",
-                    [
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                """# 0.
-
-                output
-                # 1. output_min
-                # 2. output_max
-                """
-                helper.set_attr_type_list(
-                    quantized_bn_node,
-                    "out_types",
-                    [
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                self.add_output_graph_node(output_min_node)
-                self.add_output_graph_node(output_max_node)
-                self.add_output_graph_node(quantized_bn_node)
-                self._intel_cpu_add_dequantize_result_node(
-                    quantized_output_name=quantized_node_name,
-                    original_node_name=match_node_name[-1],
-                    dtype=dtypes.qint8,
-                    min_tensor_index=1,
-                    performance_only=self.performance_only,
-                )
-
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def apply_newly_bn_leakyrelu_fusion(self, match_node_name):
-        """Apply BN + LeakyRelu fusion."""
-        matched_node = self.node_name_mapping[match_node_name[0]]
-        skip_node_name = match_node_name[1:]
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        scale_name = normal_inputs[1]
-        offset_name = normal_inputs[2]
-        mean_name = normal_inputs[3]
-        variance_name = normal_inputs[4]
-
-        all_input_names = self._add_eightbit_prologue_nodes(matched_node.node.name)
-        all_input_names = [
-            all_input_names[0],
-            scale_name,
-            offset_name,
-            mean_name,
-            variance_name,
-            all_input_names[1],
-            all_input_names[2],
-        ]
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[0]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-                leakyrelu_node_name = match_node_name[1]
-                node_op = "_QuantizedFusedBatchNorm"
-                quantized_node_name = node.name + "_eightbit_quantized_bn"
-                output_min_node_name = quantized_node_name + "_input7_output_min"
-                output_max_node_name = quantized_node_name + "_input8_output_max"
-                quantized_node_input_names = (
-                    all_input_names + [output_min_node_name] + [output_max_node_name] + control_inputs
-                )
-                output_min_node = helper.create_constant_node(output_min_node_name, -1.0, dtypes.float32)
-                output_max_node = helper.create_constant_node(output_max_node_name, 1.0, dtypes.float32)
-                quantized_bn_node = helper.create_node(node_op, quantized_node_name, quantized_node_input_names)
-
-                helper.set_attr_string(quantized_bn_node, "activation_mode", b"LeakyRelu")
-                helper.copy_attr(
-                    quantized_bn_node, "alpha", self.node_name_mapping[leakyrelu_node_name].node.attr["alpha"]
-                )
-                if self.node_name_mapping[offset_name].node.op == "Const":
-                    helper.set_attr_bool(quantized_bn_node, "is_offset_const", True)
-                else:
-                    helper.set_attr_bool(quantized_bn_node, "is_offset_const", False)
-                if self.node_name_mapping[mean_name].node.op == "Const":
-                    helper.set_attr_bool(quantized_bn_node, "is_mean_const", True)
-                else:
-                    helper.set_attr_bool(quantized_bn_node, "is_mean_const", False)
-                helper.set_attr_dtype(quantized_bn_node, "T", dtypes.qint8)
-                helper.set_attr_dtype(quantized_bn_node, "U", dtypes.float32)
-                helper.set_attr_dtype(quantized_bn_node, "Tout", dtypes.qint8)
-                """# 0.
-
-                x
-                # 1. scale
-                # 2. offset
-                # 3. mean
-                # 4. variance
-                # 5. x_min
-                # 6. x_max
-                # 7. {output_min}
-                # 8. {output_max}
-                """
-                helper.set_attr_type_list(
-                    quantized_bn_node,
-                    "input_types",
-                    [
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                """# 0.
-
-                output
-                # 1. output_min
-                # 2. output_max
-                """
-                helper.set_attr_type_list(
-                    quantized_bn_node,
-                    "out_types",
-                    [
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                self.add_output_graph_node(output_min_node)
-                self.add_output_graph_node(output_max_node)
-                self.add_output_graph_node(quantized_bn_node)
-                self._intel_cpu_add_dequantize_result_node(
-                    quantized_output_name=quantized_node_name,
-                    original_node_name=match_node_name[-1],
-                    dtype=dtypes.qint8,
-                    min_tensor_index=1,
-                    performance_only=self.performance_only,
-                )
-
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def get_longest_fuse(self):
-        """Get the longest fusion pattern."""
-        self._get_op_list()
-        real_patterns = [pattern[1:-1] for pattern in self.sorted_patterns]
-        # Cannot match if: self._is_match([['Q','BN','Relu','DQ']],['Q','BN','DQ']])
-        matched_rule, matched_node_name = self._is_match(real_patterns)
-        return matched_rule, matched_node_name
-
-    def apply_the_transform(self):
-        """Apply the BN int8 fusion."""
-        self._get_op_list()
-        real_patterns = [pattern[1:-1] for pattern in self.sorted_patterns]
-        # Cannot match if: self._is_match([['Q','BN','Relu','DQ']],['Q','BN','DQ']])
-        matched_rule, matched_node_name = self._is_match(real_patterns)
-        if matched_node_name:
-            self.output_graph = graph_pb2.GraphDef()
-            fusion_name = "".join(matched_rule)
-            bn_node = self.node_name_mapping[matched_node_name[0]].node
-            is_training = bn_node.attr["is_training"].b
-            if fusion_name in self.fusion_mapping and is_training is False:
-                self.fusion_mapping[fusion_name](matched_node_name)
-            else:
-                if is_training is True:
-                    self.logger.info(
-                        "Skip quantizing the BN node '{}' due to the attr 'is_training == true'.".format(bn_node.name)
-                    )
-                    self.exclude_bn_nodes.append(bn_node.name)
-                elif self.new_api:
-                    self.logger.info("Unknown fusion pattern {} .".format(fusion_name))
-                if self.remove_redundant_quant_flag:
-                    self.input_graph = self.remove_redundant_quantization(self.input_graph)
-                return self.input_graph, self.exclude_bn_nodes
-
-            self.input_graph = self.output_graph
-            self._reset_output_node_maps()
-            if self.remove_redundant_quant_flag:
-                self.output_graph = self.remove_redundant_quantization(self.output_graph)
-            return self.output_graph, []
-        return self.input_graph, []
diff --git a/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_concatv2.py b/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_concatv2.py
deleted file mode 100644
index d732d8bebb1..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_concatv2.py
+++ /dev/null
@@ -1,261 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Quantize ConcatV2 to int8 op."""
-
-import os
-import re
-
-from tensorflow.core.framework import node_def_pb2
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper as helper
-
-from ..quantize_graph_base import QuantizeNodeBase
-
-
-class FuseNodeStartWithConcatV2(QuantizeNodeBase):
-    """Quantize ConcatV2 to int8 op QuantizedConcatV2."""
-
-    def __init__(self, **kwargs):
-        """Initilizaiton."""
-        super().__init__(**kwargs)
-        self.sorted_patterns = sorted(self.patterns, key=lambda i: len(i), reverse=True)
-        self.dtype = dtypes.quint8
-        self.exclude_concat_nodes = []
-
-    def _get_node_from_name(self, name):
-        """Get node struct from node name."""
-        if name.startswith("^"):
-            name = name[1:]
-        if re.search(r"\w+:\d+", name):
-            node = self.node_name_mapping[name.rsplit(":", 1)[0]].node
-        else:
-            node = self.node_name_mapping[name].node
-        return node
-
-    def _get_first_input_from_name(self, name):
-        """Get the first input of the node."""
-        if len(name) == 0:
-            return name
-        node = self._get_node_from_name(name)
-        if len(node.input) == 0:
-            return ""
-        return node.input[0]
-
-    def _quantizable_concat(self, node):
-        """Check if the ConcatV2 is quantizable."""
-        deq_type = []
-        is_quantizable = True
-        if self.performance_only or os.getenv("TF_FORCE_CONCAT_OPTS") == "1":
-            _, normal_inputs = self._get_node_input(node.name)
-            original_inputs = normal_inputs[: node.attr["N"].i]
-
-            # the input chain of concatv2 is QuantizedOp -> (req) -> q -> dq -> concat
-            for each_input in original_inputs:
-                dq_input = self._get_first_input_from_name(each_input)
-                q_input = self._get_first_input_from_name(dq_input)
-                pre_input = self._get_first_input_from_name(q_input)
-                if pre_input == "":
-                    continue
-                req_input = self._get_node_from_name(pre_input)
-
-                # the concatv2 with these Ops as inputs can't be reranged
-                if req_input.op in ["_QuantizedFusedBatchNorm", "_QuantizedFusedInstanceNorm"]:
-                    is_quantizable = False
-                    break
-                if (
-                    req_input.op == "Requantize"
-                    or req_input.op == "RequantizePerChannel"
-                    or req_input.op.startswith("Quantized")
-                ):
-                    is_quantizable = True
-                    if str(self.node_name_mapping[pre_input].node.attr["out_type"]) != "":
-                        deq_type.append(self.node_name_mapping[pre_input].node.attr["out_type"].type)
-                    else:
-                        deq_type.append(self.node_name_mapping[pre_input].node.attr["T"].type)
-        else:
-            for input_node_name in node.input[: node.attr["N"].i]:
-                node_name = helper.node_name_from_input(input_node_name)
-                if self.node_name_mapping[node_name].node.op != "Dequantize":
-                    self.exclude_concat_nodes.append(node.name)
-                    return False
-
-                deq_type.append(self.node_name_mapping[node_name].node.attr["T"].type)
-
-        if len(set(deq_type)) != 1:
-            is_quantizable = False
-        else:
-            if self.performance_only or os.getenv("TF_FORCE_CONCAT_OPTS") == "1":
-                self.dtype = dtypes.DType(deq_type[0])
-
-        if not is_quantizable:
-            self.exclude_concat_nodes.append(node.name)
-
-        return is_quantizable
-
-    def _apply_concatv2_quantization(self, match_node_name):
-        """Quantize ConcatV2."""
-        # Dequantize + ConcatV2 + QuantizeV2
-        skip_node_names = match_node_name[2:]
-        matched_node = self.node_name_mapping[match_node_name[1]]
-        _, normal_inputs = self._get_node_input(matched_node.node.name)
-        num_input = len(normal_inputs)
-        shape_input_name = normal_inputs[num_input - 1]
-        original_inputs = normal_inputs[0 : num_input - 1]
-
-        input_names = []
-        min_names = []
-        max_names = []
-        for each_input in original_inputs:
-            _, q_each_input = self._get_node_input(each_input)
-            input_names.append(q_each_input[0])
-            min_names.append(q_each_input[1])
-            max_names.append(q_each_input[2])
-            skip_node_names.append(each_input)
-
-        if self.dtype == dtypes.qint8:
-            for each_name in input_names:
-                input_node = self._get_node_from_name(each_name)
-                if input_node.op == "QuantizeV2":
-                    helper.set_attr_dtype(input_node, "T", self.dtype)
-                pre_input = self._get_first_input_from_name(each_name)
-                pre_input_node = self._get_node_from_name(pre_input)
-                if pre_input_node.op == "Dequantize":
-                    helper.set_attr_dtype(pre_input_node, "T", self.dtype)
-
-        all_input_names = input_names
-        all_input_names.append(shape_input_name)
-        all_input_names.extend(min_names)
-        all_input_names.extend(max_names)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_names:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[1]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-                quantized_op_name = node.name + "_eightbit_quantized_concatv2"
-                quantized_op_type = "Quantized" + node.op
-                quantized_concat_node = helper.create_node(quantized_op_type, quantized_op_name, all_input_names)
-
-                helper.set_attr_int(quantized_concat_node, "N", len(original_inputs))
-                helper.set_attr_dtype(quantized_concat_node, "T", self.dtype)
-                self.add_output_graph_node(quantized_concat_node)
-                self._intel_cpu_add_dequantize_result_node(quantized_op_name, node.name, dtype=self.dtype)
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def get_longest_fuse(self, do_transform=False):
-        """Get longest fusion pattern."""
-        self._get_op_list()
-        matched_node_name = []
-
-        for k, v in enumerate(self.op_list):
-            if v in set(fusion[1] for fusion in self.sorted_patterns):
-                cur_node = self.node_name_mapping[list(self.node_name_mapping.keys())[k]].node
-
-                if cur_node.name != self.start_node_name:
-                    continue
-
-                # possible attributes that decide output data type
-                output_attr_list = ["out_type", "T", "dtype", "Taxis", "Tindices", "Tparams"]
-                if not do_transform:
-                    _, normal_inputs = self._get_node_input(cur_node.name)
-                    original_inputs = normal_inputs[: cur_node.attr["N"].i]
-                    unsupported_input_type = False
-                    for each_input in original_inputs:
-                        each_input_name = helper.node_name_from_input(each_input)
-                        input_dtype = None
-                        for output_attr in output_attr_list:
-                            input_dtype_attr = self.node_name_mapping[each_input_name].node.attr[output_attr]
-                            if str(input_dtype_attr) != "":
-                                input_dtype = dtypes.DType(input_dtype_attr.type)
-                                break
-                        if input_dtype != dtypes.bfloat16 and input_dtype != dtypes.float32:
-                            unsupported_input_type = True
-                            break
-                    if unsupported_input_type:
-                        continue
-
-                for sub_rule in self.sorted_patterns:
-                    if sub_rule[0] != "Dequantize" or sub_rule[-1] != "QuantizeV2":
-                        continue
-                    if v != sub_rule[1]:
-                        continue
-
-                if (self.performance_only or os.getenv("TF_FORCE_CONCAT_OPTS") == "1") and not do_transform:
-                    matched_node_name.clear()
-                    matched_node_name.append(cur_node.name)
-                    return sub_rule, matched_node_name
-
-                if self._quantizable_concat(cur_node):
-                    if dtypes.as_dtype(cur_node.attr["T"].type) == dtypes.float32 and not re.search(
-                        r"map(_\d+)?/while", cur_node.name
-                    ):
-                        matched_node_name.clear()
-                        matched_node_name.append(sub_rule[0])
-                        matched_node_name.append(cur_node.name)
-                        matched_node_name.append(sub_rule[-1])
-                        return sub_rule, matched_node_name
-                else:
-                    if self.performance_only or os.getenv("TF_FORCE_CONCAT_OPTS") == "1":
-                        new_inputs = []
-                        control_inputs, normal_inputs = self._get_node_input(cur_node.name)
-                        original_inputs = normal_inputs[: cur_node.attr["N"].i]
-                        for each_input in original_inputs:
-                            each_node = self._get_node_from_name(each_input)
-                            if each_node.op == "Dequantize":
-                                q_input = self._get_first_input_from_name(each_input)
-                                if q_input == "":
-                                    continue
-                                if self._get_node_from_name(q_input).op == "QuantizeV2":
-                                    pre_input = self._get_first_input_from_name(q_input)
-                                    new_inputs.append(pre_input)
-                                elif self._get_node_from_name(q_input).op == "Requantize":
-                                    new_inputs.append(each_input)
-                            else:
-                                new_inputs.append(each_input)
-                        new_inputs.append(normal_inputs[-1])
-                        cur_node.ClearField("input")
-                        cur_node.input.extend(new_inputs + control_inputs)
-
-        return None, None
-
-    def apply_the_transform(self):
-        """Apply the quantization of ConcatV2."""
-        self._get_op_list()
-        matched_rule, matched_node_name = self.get_longest_fuse(do_transform=True)
-        if matched_node_name:
-            fusion_name = "".join(matched_rule)
-            if fusion_name == "DequantizeConcatV2QuantizeV2":
-                self._apply_concatv2_quantization(matched_node_name)
-            else:  # pragma: no cover
-                self.logger.info("Unknown fusion pattern {}.".format(fusion_name))
-                if self.remove_redundant_quant_flag:
-                    self.input_graph = self.remove_redundant_quantization(self.input_graph)
-                return self.input_graph, self.exclude_concat_nodes
-
-            self.input_graph = self.output_graph
-            self._reset_output_node_maps()
-            if self.remove_redundant_quant_flag:
-                self.output_graph = self.remove_redundant_quantization(self.output_graph)
-            return self.output_graph, self.exclude_concat_nodes
-
-        if self.remove_redundant_quant_flag:
-            self.input_graph = self.remove_redundant_quantization(self.input_graph)
-        return self.input_graph, self.exclude_concat_nodes
diff --git a/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_conv.py b/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_conv.py
deleted file mode 100644
index f6c704402f0..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_conv.py
+++ /dev/null
@@ -1,2022 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Quantize Conv2D/Conv3D/DepthwiseConv2dNative."""
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.core.framework import graph_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper as helper
-
-from ..quantize_graph_base import QuantizeNodeBase
-
-
-class FuseNodeStartWithConv2d(QuantizeNodeBase):
-    """Quantize Conv2D/Conv3D/DepthwiseConv2dNative to int8 op."""
-
-    exclude_conv_nodes = []
-
-    def __init__(self, **kwargs):
-        """Initialization."""
-        super().__init__(**kwargs)
-        self.sorted_patterns = sorted(self.patterns, key=lambda i: len(i), reverse=True)
-        if self.new_api:
-            # fmt: off
-            self.fusion_mapping = {
-                'DequantizeConv2DBiasAddQuantizeV2': self.apply_newly_conv_biasadd_fusion,
-                'DequantizeConv2DBiasAddAddNReluQuantizeV2': self.apply_newly_conv_biasadd_addn_relu_fusion,
-                'DequantizeConv2DAddNReluQuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeConv2DBiasAddAddNRelu6QuantizeV2': self.apply_newly_conv_biasadd_addn_relu_fusion,
-                'DequantizeConv2DAddNRelu6QuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeConv2DBiasAddAddV2ReluQuantizeV2': self.apply_newly_conv_biasadd_addn_relu_fusion,
-                'DequantizeConv2DAddV2ReluQuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeConv2DBiasAddAddV2Relu6QuantizeV2': self.apply_newly_conv_biasadd_addn_relu_fusion,
-                'DequantizeConv2DAddV2Relu6QuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeConv2DBiasAddAddReluQuantizeV2': self.apply_newly_conv_biasadd_addn_relu_fusion,
-                'DequantizeConv2DBiasAddRelu6QuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeConv2DRelu6QuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeConv2DBiasAddReluQuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeConv2DReluQuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeConv2DBiasAddEluQuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeConv2DEluQuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeConv2DBiasAddLeakyReluQuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeConv2DLeakyReluQuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeConv2DBiasAddSigmoidQuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeConv2DSigmoidQuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeConv2DBiasAddLeakyReluAddV2QuantizeV2': self.apply_newly_conv_biasadd_addn_relu_fusion,
-                'DequantizeConv2DBiasAddLeakyReluAddQuantizeV2': self.apply_newly_conv_biasadd_addn_relu_fusion,
-                'DequantizeConv2DBiasAddReluAddV2QuantizeV2': self.apply_newly_conv_biasadd_addn_relu_fusion,
-                'DequantizeConv2DBiasAddReluAddQuantizeV2': self.apply_newly_conv_biasadd_addn_relu_fusion,
-                'DequantizeConv2DBiasAddAddLeakyReluQuantizeV2': self.apply_newly_conv_biasadd_addn_relu_fusion,
-                'DequantizeConv2DBiasAddAddV2LeakyReluQuantizeV2': self.apply_newly_conv_biasadd_addn_relu_fusion,
-                'DequantizeConv2DAddLeakyReluQuantizeV2': self.apply_newly_conv_biasadd_addn_relu_fusion,
-                'DequantizeConv2DAddV2LeakyReluQuantizeV2': self.apply_newly_conv_biasadd_addn_relu_fusion,
-                'DequantizeConv2DLeakyReluAddV2QuantizeV2': self.apply_newly_conv_biasadd_addn_relu_fusion,
-                'DequantizeConv2DLeakyReluAddQuantizeV2': self.apply_newly_conv_biasadd_addn_relu_fusion,
-                'DequantizeConv2DReluAddV2QuantizeV2': self.apply_newly_conv_biasadd_addn_relu_fusion,
-                'DequantizeConv2DReluAddQuantizeV2': self.apply_newly_conv_biasadd_addn_relu_fusion,
-                'DequantizeConv2DAddRelu6QuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeConv2DAddReluQuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeConv2DBiasAddAddRelu6MulMulQuantizeV2': self.apply_conv_biasadd_hardswish_fusion,
-                'DequantizeConv2DAddRelu6MulMulQuantizeV2': self.apply_conv_biasadd_hardswish_fusion,
-                'DequantizeConv2DBiasAddswish_f32QuantizeV2': self.apply_newly_conv_biasadd_swishf32_fusion,
-                'DequantizeConv2DAddswish_f32QuantizeV2': self.apply_newly_conv_biasadd_swishf32_fusion,
-                'DequantizeConv2DAddV2swish_f32QuantizeV2': self.apply_newly_conv_biasadd_swishf32_fusion,
-                'DequantizeConv2Dswish_f32QuantizeV2': self.apply_newly_conv_biasadd_swishf32_fusion,
-                'DequantizeDepthwiseConv2dNativeBiasAddAddRelu6MulMulQuantizeV2':
-                               self.apply_conv_biasadd_hardswish_fusion,
-                'DequantizeDepthwiseConv2dNativeAddRelu6MulMulQuantizeV2': self.apply_conv_biasadd_hardswish_fusion,
-                'DequantizeDepthwiseConv2dNativeBiasAddswish_f32QuantizeV2':
-                               self.apply_newly_conv_biasadd_swishf32_fusion,
-                'DequantizeDepthwiseConv2dNativeAddswish_f32QuantizeV2': self.apply_newly_conv_biasadd_swishf32_fusion,
-                'DequantizeDepthwiseConv2dNativeAddV2swish_f32QuantizeV2':
-                               self.apply_newly_conv_biasadd_swishf32_fusion,
-                'DequantizeDepthwiseConv2dNativeswish_f32QuantizeV2': self.apply_newly_conv_biasadd_swishf32_fusion,
-                'DequantizeDepthwiseConv2dNativeAddRelu6QuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeDepthwiseConv2dNativeBiasAddReluQuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeDepthwiseConv2dNativeReluQuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeDepthwiseConv2dNativeRelu6QuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeDepthwiseConv2dNativeBiasAddQuantizeV2': self.apply_newly_conv_biasadd_fusion,
-                'DequantizeDepthwiseConv2dNativeBiasAddLeakyReluQuantizeV2':
-                               self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeDepthwiseConv2dNativeLeakyReluQuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeDepthwiseConv2dNativeBiasAddRelu6QuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
-                'DequantizeConv2DQuantizeV2': self.apply_newly_conv_single_fusion,
-                'DequantizeConv2DAddQuantizeV2': self.apply_newly_conv_biasadd_fusion,
-                'DequantizeConv2DAddV2QuantizeV2': self.apply_newly_conv_biasadd_fusion,
-                'DequantizeConv2DAddAddQuantizeV2': self.apply_newly_conv_biasadd_addn_fusion,
-                'DequantizeConv2DAddV2AddQuantizeV2': self.apply_newly_conv_biasadd_addn_fusion,
-                'DequantizeConv2DBiasAddAddQuantizeV2': self.apply_newly_conv_biasadd_addn_fusion,
-                'DequantizeConv2DAddAddReluQuantizeV2': self.apply_newly_conv_biasadd_addn_relu_fusion,
-                'DequantizeConv3DQuantizeV2': self.apply_conv3d_single_fusion,
-                'DequantizeConv3DBiasAddQuantizeV2': self.apply_conv3d_add_fusion,
-                'DequantizeConv3DBiasAddAddQuantizeV2': self.apply_conv3d_add_addn_fusion,
-                'DequantizeConv3DBiasAddAddV2QuantizeV2': self.apply_conv3d_add_addn_fusion,
-                'DequantizeConv3DAddV2AddV2QuantizeV2': self.apply_conv3d_add_addn_fusion,
-                'DequantizeConv3DAddV2AddV2ReluQuantizeV2': self.apply_conv3d_add_addn_relu_fusion,
-                'DequantizeConv3DBiasAddAddV2ReluQuantizeV2': self.apply_conv3d_add_addn_relu_fusion,
-                'DequantizeConv3DAddQuantizeV2': self.apply_conv3d_add_fusion,
-                'DequantizeConv3DAddReluQuantizeV2': self.apply_conv3d_add_relu_fusion,
-                'DequantizeConv3DAddV2QuantizeV2': self.apply_conv3d_add_fusion,
-                'DequantizeConv3DAddV2ReluQuantizeV2': self.apply_conv3d_add_relu_fusion,
-                'DequantizeConv3DReluQuantizeV2': self.apply_conv3d_add_relu_fusion,
-                'DequantizeConv3DBiasAddReluQuantizeV2': self.apply_conv3d_add_relu_fusion,
-                'DequantizeConv3DRelu6QuantizeV2': self.apply_conv3d_add_relu_fusion,
-                'DequantizeConv3DBiasAddRelu6QuantizeV2': self.apply_conv3d_add_relu_fusion,
-                'DequantizeConv3DAddRelu6QuantizeV2': self.apply_conv3d_add_relu_fusion,
-                'DequantizeConv3DEluQuantizeV2': self.apply_conv3d_add_relu_fusion,
-                'DequantizeConv3DBiasAddEluQuantizeV2': self.apply_conv3d_add_relu_fusion,
-                'DequantizeConv3DAddEluQuantizeV2': self.apply_conv3d_add_relu_fusion,
-                'DequantizeConv3DLeakyReluQuantizeV2': self.apply_conv3d_add_relu_fusion,
-                'DequantizeConv3DBiasAddLeakyReluQuantizeV2': self.apply_conv3d_add_relu_fusion,
-                'DequantizeConv3DAddLeakyReluQuantizeV2': self.apply_conv3d_add_relu_fusion,
-                'DequantizeDepthwiseConv2dNativeQuantizeV2': self.apply_newly_conv_single_fusion
-            }
-            # fmt: on
-
-    def _insert_dummy_biasadd(self, match_node_name, matched_node):
-        """Insert dummy biasadd for fusion."""
-        target_node_name = matched_node.node.name
-        op_a_node_name = helper.node_name_from_input(matched_node.node.input[0])
-        op_a_node = self.node_name_mapping[op_a_node_name].node
-
-        _, normal_inputs = self._get_node_input(matched_node.node.name)
-        _, q_weights_inputs = self._get_node_input(normal_inputs[1])
-
-        quantizev2_weights_name = q_weights_inputs[0]
-        _, weights_name = self._get_node_input(quantizev2_weights_name)
-        op_b_node_name = weights_name[0]
-        op_b_node = self.node_name_mapping[op_b_node_name].node
-
-        if op_a_node.op == "Const" and op_b_node.op != "Const":
-            pass
-        else:
-            from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-
-            g = GraphAnalyzer()
-            g.graph = self.input_graph
-            graph_info = g.parse_graph()
-            next_node_names = graph_info[matched_node.node.name].outputs
-            bias_node_name = target_node_name + "_dummy_biasadd"
-            bias_const_node_name = target_node_name + "_fake_const"
-
-            if (
-                matched_node.node.op in ("Conv2D" or "DepthwiseConv2dNative")
-                and matched_node.node.attr["data_format"].s == b"NHWC"
-            ):
-                t_b_index = 3
-            elif (
-                matched_node.node.op in ("Conv2D" or "DepthwiseConv2dNative")
-                and matched_node.node.op.attr["data_format"].s == b"NCHW"
-            ):
-                t_b_index = 1
-            elif matched_node.node.op == "Conv3D" and matched_node.node.attr["data_format"].s == b"NDHWC":
-                t_b_index = 4
-            elif matched_node.node.op == "Conv3D" and matched_node.node.attr["data_format"].s == b"NCDHW":
-                t_b_index = 1
-            bias_add_length = op_b_node.attr["value"].tensor.tensor_shape.dim[t_b_index].size
-
-            bias_add_content = [0.0] * bias_add_length
-
-            bias_const_node = helper.create_constant_node(
-                bias_const_node_name, bias_add_content, dtypes.float32, shape=[bias_add_length]
-            )
-            bias_node = helper.create_node("BiasAdd", bias_node_name, [target_node_name, bias_const_node_name])
-            helper.set_attr_dtype(bias_node, "T", dtypes.float32)
-
-            g.add_node(bias_node, target_node_name, next_node_names)
-            g.add_node(bias_const_node, None, [bias_node_name])
-            self.input_graph = g.dump_graph()
-            self._parse_graph(self.input_graph)
-            new_match_node_name = match_node_name[:2] + [bias_node_name] + match_node_name[2:]
-            new_match_node_name = match_node_name[:2] + [bias_node_name] + match_node_name[2:]
-
-        return new_match_node_name
-
-    def apply_conv3d_add_addn_relu_fusion(self, match_node_name):
-        """Apply Conv3D Add Addn Relu fusion.
-
-        Dequantize + Conv3D + AddV2+ AddV2 + Relu + QuantizeV2
-        """
-        skip_node_name = match_node_name[2:]
-        matched_node = self.node_name_mapping[match_node_name[1]]
-
-        second_node = self.node_name_mapping[match_node_name[2]].node
-        need_insert_dummy_biasadd = 1
-        add_a_node_name = helper.node_name_from_input(second_node.input[0])
-        add_a_node = self.node_name_mapping[add_a_node_name].node
-        add_b_node_name = helper.node_name_from_input(second_node.input[1])
-        add_b_node = self.node_name_mapping[add_b_node_name].node
-
-        if add_a_node.op != "Const" and add_b_node.op == "Const":
-            need_insert_dummy_biasadd = 0
-        if need_insert_dummy_biasadd:
-            new_match_node_name = self._insert_dummy_biasadd(match_node_name, matched_node)
-            # after insert dummy biasadd, that is Conv3D+dummybiasadd+add*+add*+relu*
-            return self.apply_conv3d_add_addn_fusion(new_match_node_name[:4] + [new_match_node_name[-1]])
-
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        _, q_inputs = self._get_node_input(normal_inputs[0])
-        _, q_weights_inputs = self._get_node_input(normal_inputs[1])
-        quantizev2_weights_name = q_weights_inputs[0]
-
-        _, weights_name = self._get_node_input(quantizev2_weights_name)
-        weights_min_name = weights_name[1]
-        weights_max_name = weights_name[2]
-
-        third_node = self.node_name_mapping[match_node_name[3]].node
-        sumadd_a_node_name = helper.node_name_from_input(third_node.input[0])
-        sumadd_a_node = self.node_name_mapping[sumadd_a_node_name].node
-        sumadd_b_node_name = helper.node_name_from_input(third_node.input[1])
-        sumadd_b_node = self.node_name_mapping[sumadd_b_node_name].node
-
-        if sumadd_a_node.op != "Const" and sumadd_b_node.op == "Const":
-            return self.apply_conv3d_add_fusion(match_node_name[:3] + [match_node_name[-1]])
-
-        forth_node = self.node_name_mapping[match_node_name[4]].node
-        if third_node.op != "LeakyRelu" and not self._find_relu_node(matched_node.node):
-            return self.apply_conv3d_add_fusion(match_node_name[:3] + [match_node_name[-1]])
-
-        is_leakyrelu_add_fusion = third_node.op == "LeakyRelu" and forth_node.op.find("Add") != -1
-        is_relu_add_fusion = third_node.op == "Relu" and forth_node.op.find("Add") != -1
-
-        relu_offset = 0
-        if is_leakyrelu_add_fusion or is_relu_add_fusion:
-            relu_offset = 1
-        if is_leakyrelu_add_fusion or is_relu_add_fusion:
-            relu_node_name = match_node_name[3]
-        else:
-            relu_node_name = match_node_name[4]
-        sum_index = (
-            1
-            if match_node_name[2 + relu_offset]
-            == self.node_name_mapping[match_node_name[3 + relu_offset]].node.input[0]
-            else 0
-        )
-
-        sum_node_name = self.node_name_mapping[match_node_name[3 + relu_offset]].node.input[sum_index]
-        deq_node = self.node_name_mapping[sum_node_name].node
-        if deq_node.op != "Dequantize" or deq_node.op.find("Quantize") != -1:
-            return self.apply_conv3d_add_fusion(match_node_name[:3] + [match_node_name[-1]])
-
-        add_node = self.node_name_mapping[match_node_name[2]].node
-        original_add_input = self.node_name_mapping[add_node.input[1]].node
-        if original_add_input.op == "Const":
-            shape = tensor_util.MakeNdarray(original_add_input.attr["value"].tensor)
-            if shape.ndim > 1 and shape.shape[:-1] == (1, 1, 1, 1):
-                squeezed_value = np.squeeze(shape)
-                squeezed_node = helper.create_constant_node(
-                    match_node_name[1] + "_squeezed", squeezed_value, dtypes.float32
-                )
-                skip_node_name.append(add_node.input[1])
-                add_node.input[1] = squeezed_node.name
-                self.add_output_graph_node(squeezed_node)
-
-        q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-            matched_node.node.op, self.node_name_mapping[weights_name[0]].node, self.per_channel
-        )
-
-        all_input_names = q_inputs[:1] + [q_weights_name] + q_inputs[1:]
-        all_input_names.append(q_weights_min_name)
-        all_input_names.append(q_weights_max_name)
-        skip_node_name.append(normal_inputs[0])
-        skip_node_name.append(normal_inputs[1])
-        skip_node_name.append(weights_name[0])
-        skip_node_name.append(weights_min_name)
-        skip_node_name.append(weights_max_name)
-        skip_node_name.append(quantizev2_weights_name)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[1]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-                quantized_node_name = node.name + "_eightbit_quantized_conv"
-                bias_node_name = self.node_name_mapping[match_node_name[2]].node.input[1]
-
-                is_relu6 = self.node_name_mapping[relu_node_name].node.op == "Relu6"
-                quantized_node_input_names = (
-                    all_input_names[:2] + [bias_node_name] + all_input_names[2:] + [sum_node_name] + control_inputs
-                )
-
-                if sum_node_name.find("mul") != -1:
-                    quantized_node_input_names = (
-                        all_input_names[:2]
-                        + [bias_node_name]
-                        + [self.node_name_mapping[match_node_name[3 + relu_offset]].node.input[sum_index]]
-                        + all_input_names[2:]
-                        + control_inputs
-                    )
-
-                node_op = "_FusedQuantizedConv3D"
-
-                quantized_conv_node = helper.create_node(node_op, quantized_node_name, quantized_node_input_names)
-                helper.copy_attr(quantized_conv_node, "strides", node.attr["strides"])
-                helper.copy_attr(quantized_conv_node, "padding", node.attr["padding"])
-                helper.copy_attr(quantized_conv_node, "data_format", node.attr["data_format"])
-                if "explicit_paddings" in node.attr:
-                    helper.copy_attr(quantized_conv_node, "explicit_paddings", node.attr["explicit_paddings"])
-                helper.copy_attr(quantized_conv_node, "dilations", node.attr["dilations"])
-                input_data_type = dtypes.quint8 if self._find_relu_node(node) else dtypes.qint8
-                helper.set_attr_dtype(quantized_conv_node, "Tinput", input_data_type)
-                helper.set_attr_dtype(quantized_conv_node, "Tfilter", dtypes.qint8)
-                helper.set_attr_dtype(quantized_conv_node, "out_type", dtypes.qint32)
-                if "alpha" in self.node_name_mapping[relu_node_name].node.attr:
-                    helper.copy_attr(
-                        quantized_conv_node, "alpha", self.node_name_mapping[relu_node_name].node.attr["alpha"]
-                    )
-                helper.set_attr_string_list(quantized_conv_node, "fused_ops", [b"BiasAdd", b"Sum", b"Relu"])
-                helper.set_attr_dtype(quantized_conv_node, "Tbias", dtypes.float32)
-                # if self.device == 'gpu' else dtypes.qint32)
-                helper.set_attr_dtype(quantized_conv_node, "Tsummand", dtypes.qint32)
-                if is_leakyrelu_add_fusion:
-                    helper.set_attr_string_list(quantized_conv_node, "fused_ops", [b"BiasAdd", b"LeakyRelu", b"Sum"])
-                elif is_relu_add_fusion:
-                    helper.set_attr_string_list(quantized_conv_node, "fused_ops", [b"BiasAdd", b"Relu", b"Sum"])
-
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_inputs",
-                    [
-                        input_data_type.as_datatype_enum,
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,  # both cpu and gpu use float32 in New API
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_outputs",
-                    [
-                        dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-
-                self.add_output_graph_node(quantized_conv_node)
-
-                if is_leakyrelu_add_fusion:
-                    quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtypes.qint8, False)
-                    self._intel_cpu_add_dequantize_result_node(
-                        quantize_down_name,
-                        match_node_name[4],
-                        dtype=dtypes.qint8,
-                        performance_only=self.performance_only,
-                    )
-                else:
-                    dtype = dtypes.quint8
-                    if [
-                        i
-                        for i in self.node_name_mapping[relu_node_name].output
-                        if "FusedBatchNorm" in self.node_name_mapping[i].node.op and i in self.op_wise_config_name_list
-                    ]:
-                        dtype = dtypes.qint8
-                    quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtype, is_relu6)
-                    self._intel_cpu_add_dequantize_result_node(
-                        quantize_down_name, relu_node_name, dtype, performance_only=self.performance_only
-                    )
-
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def apply_conv3d_add_addn_fusion(self, match_node_name):
-        """Apply Conv3D Add Addn fusion.
-
-        Dequantize + Conv3D + BiasAdd + Add + QuantizeV2
-        Dequantize + Conv3D + BiasAdd + AddV2 + QuantizeV2
-        Dequantize + Conv3D + AddV2 + AddV2 + QuantizeV2
-        """
-        skip_node_name = match_node_name[2:]
-        matched_node = self.node_name_mapping[match_node_name[1]]
-
-        second_node = self.node_name_mapping[match_node_name[2]].node
-        need_insert_dummy_biasadd = 1
-        add_a_node_name = helper.node_name_from_input(second_node.input[0])
-        add_a_node = self.node_name_mapping[add_a_node_name].node
-        add_b_node_name = helper.node_name_from_input(second_node.input[1])
-        add_b_node = self.node_name_mapping[add_b_node_name].node
-
-        if add_a_node.op != "Const" and add_b_node.op == "Const":
-            need_insert_dummy_biasadd = 0
-        if need_insert_dummy_biasadd:
-            new_match_node_name = self._insert_dummy_biasadd(match_node_name, matched_node)
-            # after insert dummy biasadd, that is Conv+dummybiasadd+add*+add*
-            return self.apply_conv3d_add_addn_fusion(new_match_node_name[:4] + [new_match_node_name[-1]])
-
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        _, q_inputs = self._get_node_input(normal_inputs[0])
-        _, q_weights_inputs = self._get_node_input(normal_inputs[1])
-        quantizev2_weights_name = q_weights_inputs[0]
-
-        _, weights_name = self._get_node_input(quantizev2_weights_name)
-        weights_min_name = weights_name[1]
-        weights_max_name = weights_name[2]
-
-        third_node = self.node_name_mapping[match_node_name[3]].node
-        sumadd_a_node_name = helper.node_name_from_input(third_node.input[0])
-        sumadd_a_node = self.node_name_mapping[sumadd_a_node_name].node
-        sumadd_b_node_name = helper.node_name_from_input(third_node.input[1])
-        sumadd_b_node = self.node_name_mapping[sumadd_b_node_name].node
-        if sumadd_a_node.op != "Const" and sumadd_b_node.op == "Const":
-            return self.apply_conv3d_add_fusion(match_node_name[:3] + [match_node_name[-1]])
-
-        sum_index = 1 if match_node_name[2] == self.node_name_mapping[match_node_name[3]].node.input[0] else 0
-        sum_node_name = self.node_name_mapping[match_node_name[3]].node.input[sum_index]
-        deq_node = self.node_name_mapping[sum_node_name].node
-        if deq_node.op != "Dequantize" or deq_node.op.find("Quantize") != -1:
-            return self.apply_conv3d_add_fusion(match_node_name[:3] + [match_node_name[-1]])
-
-        add_node = self.node_name_mapping[match_node_name[2]].node
-        original_add_input = self.node_name_mapping[add_node.input[1]].node
-        if original_add_input.op == "Const":
-            shape = tensor_util.MakeNdarray(original_add_input.attr["value"].tensor)
-            if shape.ndim > 1 and shape.shape[:-1] == (1, 1, 1, 1):
-                squeezed_value = np.squeeze(shape)
-                squeezed_node = helper.create_constant_node(
-                    match_node_name[2] + "_squeezed", squeezed_value, dtypes.float32
-                )
-                skip_node_name.append(add_node.input[1])
-                add_node.input[1] = squeezed_node.name
-                self.add_output_graph_node(squeezed_node)
-
-        q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-            matched_node.node.op, self.node_name_mapping[weights_name[0]].node, self.per_channel
-        )
-
-        all_input_names = q_inputs[:1] + [q_weights_name] + q_inputs[1:]
-        all_input_names.append(q_weights_min_name)
-        all_input_names.append(q_weights_max_name)
-        skip_node_name.append(normal_inputs[0])
-        skip_node_name.append(normal_inputs[1])
-        skip_node_name.append(weights_name[0])
-        skip_node_name.append(weights_min_name)
-        skip_node_name.append(weights_max_name)
-        skip_node_name.append(quantizev2_weights_name)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[1]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-                quantized_node_name = node.name + "_eightbit_quantized_conv"
-                bias_node_name = self.node_name_mapping[match_node_name[2]].node.input[1]
-
-                quantized_node_input_names = (
-                    all_input_names[:2] + [bias_node_name] + all_input_names[2:] + [sum_node_name] + control_inputs
-                )
-                node_op = "_FusedQuantizedConv3D"
-
-                quantized_conv_node = helper.create_node(node_op, quantized_node_name, quantized_node_input_names)
-                helper.copy_attr(quantized_conv_node, "strides", node.attr["strides"])
-                helper.copy_attr(quantized_conv_node, "padding", node.attr["padding"])
-                helper.copy_attr(quantized_conv_node, "data_format", node.attr["data_format"])
-                if "explicit_paddings" in node.attr:
-                    helper.copy_attr(quantized_conv_node, "explicit_paddings", node.attr["explicit_paddings"])
-                helper.copy_attr(quantized_conv_node, "dilations", node.attr["dilations"])
-                input_data_type = dtypes.quint8 if self._find_relu_node(node) else dtypes.qint8
-                helper.set_attr_dtype(quantized_conv_node, "Tinput", input_data_type)
-                helper.set_attr_dtype(quantized_conv_node, "Tfilter", dtypes.qint8)
-                helper.set_attr_dtype(quantized_conv_node, "out_type", dtypes.qint32)
-                helper.set_attr_string_list(quantized_conv_node, "fused_ops", [b"BiasAdd", b"Sum"])
-                helper.set_attr_dtype(quantized_conv_node, "Tbias", dtypes.float32)
-                # if self.device == 'gpu' else dtypes.qint32)
-                helper.set_attr_dtype(quantized_conv_node, "Tsummand", dtypes.qint32)
-
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_inputs",
-                    [
-                        input_data_type.as_datatype_enum,
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,  # if self.device == 'gpu' else dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_outputs",
-                    [
-                        dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-
-                self.add_output_graph_node(quantized_conv_node)
-                quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtypes.qint8, False)
-                self._intel_cpu_add_dequantize_result_node(
-                    quantize_down_name, match_node_name[3], dtype=dtypes.qint8, performance_only=self.performance_only
-                )
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def apply_conv3d_add_relu_fusion(self, match_node_name):
-        """Apply Conv3D Add Relu fusion.
-
-        Dequantize + Conv3D + Add + Relu + QuantizeV2
-        Dequantize + Conv3D + AddV2 + Relu + QuantizeV2
-        """
-        skip_node_name = match_node_name[2:]
-        matched_node = self.node_name_mapping[match_node_name[1]]
-
-        second_node = self.node_name_mapping[match_node_name[2]].node
-        if second_node.op in ("Relu", "Relu6", "LeakyRelu", "Elu"):
-            new_match_node_name = self._insert_dummy_biasadd(match_node_name, matched_node)
-            return self.apply_conv3d_add_relu_fusion(new_match_node_name)
-
-        need_insert_dummy_biasadd = 1
-        add_a_node_name = helper.node_name_from_input(second_node.input[0])
-        add_a_node = self.node_name_mapping[add_a_node_name].node
-        add_b_node_name = helper.node_name_from_input(second_node.input[1])
-        add_b_node = self.node_name_mapping[add_b_node_name].node
-
-        if add_a_node.op != "Const" and add_b_node.op == "Const":
-            need_insert_dummy_biasadd = 0
-        if need_insert_dummy_biasadd:
-            new_match_node_name = self._insert_dummy_biasadd(match_node_name, matched_node)
-            # after insert dummy biasadd, that is Conv+dummybiasadd+add*+relu*
-            return self.apply_conv3d_add_addn_relu_fusion(new_match_node_name)
-
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        _, q_inputs = self._get_node_input(normal_inputs[0])
-        _, q_weights_inputs = self._get_node_input(normal_inputs[1])
-        quantizev2_weights_name = q_weights_inputs[0]
-
-        _, weights_name = self._get_node_input(quantizev2_weights_name)
-        weights_min_name = weights_name[1]
-        weights_max_name = weights_name[2]
-
-        # third_node = self.node_name_mapping[match_node_name[3]].node
-        # if third_node.op != 'LeakyRelu' and not self._find_relu_node(matched_node.node):
-        #     return self.apply_conv3d_add_fusion(match_node_name[:3] + [match_node_name[-1]])
-
-        add_node = self.node_name_mapping[match_node_name[2]].node
-        original_add_input = self.node_name_mapping[add_node.input[1]].node
-        if original_add_input.op == "Const":
-            shape = tensor_util.MakeNdarray(original_add_input.attr["value"].tensor)
-            if shape.ndim > 1 and shape.shape[:-1] == (1, 1, 1, 1):
-                squeezed_value = np.squeeze(shape)
-                squeezed_node = helper.create_constant_node(
-                    match_node_name[1] + "_squeezed", squeezed_value, dtypes.float32
-                )
-                skip_node_name.append(add_node.input[1])
-                add_node.input[1] = squeezed_node.name
-                self.add_output_graph_node(squeezed_node)
-
-        q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-            matched_node.node.op, self.node_name_mapping[weights_name[0]].node, self.per_channel
-        )
-
-        all_input_names = q_inputs[:1] + [q_weights_name] + q_inputs[1:]
-        all_input_names.append(q_weights_min_name)
-        all_input_names.append(q_weights_max_name)
-        skip_node_name.append(normal_inputs[0])
-        skip_node_name.append(normal_inputs[1])
-        skip_node_name.append(weights_name[0])
-        skip_node_name.append(weights_min_name)
-        skip_node_name.append(weights_max_name)
-        skip_node_name.append(quantizev2_weights_name)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[1]:
-                # actually DepthwiseConv3dNative is not supported in intel-tf 2.8 yet
-                postfix = "_eightbit_quantized_depthwise_conv3d"
-                if node.op == "Conv3D":
-                    postfix = "_eightbit_quantized_conv3d"
-                quantized_node_name = node.name + postfix
-
-                bias_node_name = self.node_name_mapping[match_node_name[2]].node.input[1]
-                relu_node_name = match_node_name[3]
-                is_relu6 = self.node_name_mapping[relu_node_name].node.op == "Relu6"
-                quantized_node_input_names = (
-                    all_input_names[:2] + [bias_node_name] + all_input_names[2:] + control_inputs
-                )
-
-                is_leakyrelu = self.node_name_mapping[relu_node_name].node.op == "LeakyRelu"
-
-                quantized_conv_node = helper.create_node(
-                    "_FusedQuantizedConv3D", quantized_node_name, quantized_node_input_names
-                )
-
-                helper.copy_attr(quantized_conv_node, "strides", node.attr["strides"])
-                helper.copy_attr(quantized_conv_node, "padding", node.attr["padding"])
-                helper.copy_attr(quantized_conv_node, "data_format", node.attr["data_format"])
-                if "alpha" in self.node_name_mapping[relu_node_name].node.attr:
-                    helper.copy_attr(
-                        quantized_conv_node, "alpha", self.node_name_mapping[relu_node_name].node.attr["alpha"]
-                    )
-                if node.op != "DepthwiseConv3dNative" and "explicit_paddings" in node.attr:
-                    helper.copy_attr(quantized_conv_node, "explicit_paddings", node.attr["explicit_paddings"])
-                helper.copy_attr(quantized_conv_node, "dilations", node.attr["dilations"])
-                input_data_type = dtypes.quint8 if self._find_relu_node(node) else dtypes.qint8
-                helper.set_attr_dtype(quantized_conv_node, "Tinput", input_data_type)
-                helper.set_attr_dtype(quantized_conv_node, "Tfilter", dtypes.qint8)
-                helper.set_attr_dtype(quantized_conv_node, "Tsummand", dtypes.qint32)
-                # helper.set_attr_string(quantized_conv_node, '_kernel', b'QuantizedMklOp')
-                helper.set_attr_dtype(quantized_conv_node, "out_type", dtypes.qint32)
-                # helper.set_attr_dtype(quantized_conv_node, "alpha", dtypes.quint8)
-                helper.set_attr_dtype(quantized_conv_node, "Tbias", dtypes.float32)
-                # if self.device == 'gpu' else dtypes.qint32)
-                if self.node_name_mapping[relu_node_name].node.op == "LeakyRelu":
-                    helper.set_attr_string_list(quantized_conv_node, "fused_ops", [b"BiasAdd", b"LeakyRelu"])
-                elif self.node_name_mapping[relu_node_name].node.op == "Elu":
-                    helper.set_attr_string_list(quantized_conv_node, "fused_ops", [b"BiasAdd", b"Elu"])
-                else:
-                    helper.set_attr_string_list(quantized_conv_node, "fused_ops", [b"BiasAdd", b"Relu"])
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_inputs",
-                    [
-                        input_data_type.as_datatype_enum,
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,  # if self.device == 'gpu' else dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_outputs",
-                    [
-                        dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-
-                self.add_output_graph_node(quantized_conv_node)
-                if not is_leakyrelu:
-                    dtype = dtypes.quint8
-                    if [
-                        i
-                        for i in self.node_name_mapping[relu_node_name].output
-                        if "FusedBatchNorm" in self.node_name_mapping[i].node.op and i in self.op_wise_config_name_list
-                    ]:
-                        dtype = dtypes.qint8
-                    quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtype, is_relu6)
-                    self._intel_cpu_add_dequantize_result_node(
-                        quantize_down_name, relu_node_name, dtype, performance_only=self.performance_only
-                    )
-                else:
-                    quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtypes.qint8, False)
-                    self._intel_cpu_add_dequantize_result_node(
-                        quantize_down_name, relu_node_name, dtype=dtypes.qint8, performance_only=self.performance_only
-                    )
-
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def apply_conv3d_add_fusion(self, match_node_name):
-        """Apply Conv3D Add fusion.
-
-        Dequantize + Conv3D + BiasAdd + QuantizeV2
-        Dequantize + Conv3D + Add + QuantizeV2
-        Dequantize + Conv3D + AddV2 + QuantizeV2
-        """
-        skip_node_name = match_node_name[2:]
-        matched_node = self.node_name_mapping[match_node_name[1]]
-
-        second_node = self.node_name_mapping[match_node_name[2]].node
-        need_insert_dummy_biasadd = 1
-        add_a_node_name = helper.node_name_from_input(second_node.input[0])
-        add_a_node = self.node_name_mapping[add_a_node_name].node
-        add_b_node_name = helper.node_name_from_input(second_node.input[1])
-        add_b_node = self.node_name_mapping[add_b_node_name].node
-        if add_a_node.op != "Const" and add_b_node.op == "Const":
-            need_insert_dummy_biasadd = 0
-        if need_insert_dummy_biasadd:
-            new_match_node_name = self._insert_dummy_biasadd(match_node_name, matched_node)
-            return self.apply_conv3d_add_addn_fusion(new_match_node_name)
-
-        _, normal_inputs = self._get_node_input(matched_node.node.name)
-        _, q_inputs = self._get_node_input(normal_inputs[0])
-        _, q_weights_inputs = self._get_node_input(normal_inputs[1])
-        quantizev2_weights_name = q_weights_inputs[0]
-
-        _, weights_name = self._get_node_input(quantizev2_weights_name)
-        weights_min_name = weights_name[1]
-        weights_max_name = weights_name[2]
-
-        add_node = self.node_name_mapping[match_node_name[2]].node
-        original_add_input = self.node_name_mapping[add_node.input[1]].node
-        if original_add_input.op == "Const":
-            shape = tensor_util.MakeNdarray(original_add_input.attr["value"].tensor)
-            if shape.ndim > 1 and shape.shape[:-1] == (1, 1, 1, 1):
-                squeezed_value = np.squeeze(shape)
-                squeezed_node = helper.create_constant_node(
-                    match_node_name[2] + "_squeezed", squeezed_value, dtypes.float32
-                )
-                skip_node_name.append(add_node.input[1])
-                add_node.input[1] = squeezed_node.name
-                self.add_output_graph_node(squeezed_node)
-
-        q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-            matched_node.node.op, self.node_name_mapping[weights_name[0]].node, self.per_channel
-        )
-
-        all_input_names = q_inputs[:1] + [q_weights_name] + q_inputs[1:]
-        all_input_names.append(q_weights_min_name)
-        all_input_names.append(q_weights_max_name)
-        skip_node_name.append(normal_inputs[0])
-        skip_node_name.append(normal_inputs[1])
-        skip_node_name.append(weights_name[0])
-        skip_node_name.append(weights_min_name)
-        skip_node_name.append(weights_max_name)
-        skip_node_name.append(quantizev2_weights_name)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[1]:
-                # actually DepthwiseConv3dNative is not supported in intel-tf 2.8 yet
-                postfix = "_eightbit_quantized_depthwise_conv3d"
-                if node.op == "Conv3D":
-                    postfix = "_eightbit_quantized_conv3d"
-                quantized_node_name = node.name + postfix
-
-                bias_node_name = self.node_name_mapping[match_node_name[2]].node.input[1]
-                quantized_node_input_names = all_input_names[:2] + [bias_node_name] + all_input_names[2:]
-                if node.op == "Conv3D":
-                    quantized_conv_node = helper.create_node(
-                        "_FusedQuantizedConv3D", quantized_node_name, quantized_node_input_names
-                    )
-
-                helper.copy_attr(quantized_conv_node, "strides", node.attr["strides"])
-                helper.copy_attr(quantized_conv_node, "padding", node.attr["padding"])
-                helper.copy_attr(quantized_conv_node, "data_format", node.attr["data_format"])
-                if node.op != "DepthwiseConv3dNative" and "explicit_paddings" in node.attr:
-                    helper.copy_attr(quantized_conv_node, "explicit_paddings", node.attr["explicit_paddings"])
-                helper.copy_attr(quantized_conv_node, "dilations", node.attr["dilations"])
-                input_data_type = dtypes.quint8 if self._find_relu_node(node) else dtypes.qint8
-                helper.set_attr_dtype(quantized_conv_node, "Tinput", input_data_type)
-                helper.set_attr_dtype(quantized_conv_node, "Tfilter", dtypes.qint8)
-                helper.set_attr_dtype(quantized_conv_node, "Tbias", dtypes.float32)
-                # if self.device == 'gpu' else dtypes.qint32)
-                helper.set_attr_dtype(quantized_conv_node, "Tsummand", dtypes.qint32)
-                # helper.set_attr_string(quantized_conv_node, '_kernel', b'QuantizedMklOp')
-                helper.set_attr_dtype(quantized_conv_node, "out_type", dtypes.qint32)
-                helper.set_attr_string_list(quantized_conv_node, "fused_ops", [b"BiasAdd"])
-
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_inputs",
-                    [
-                        input_data_type.as_datatype_enum,
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,  # if self.device == 'gpu' else dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_outputs",
-                    [
-                        dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-
-                self.add_output_graph_node(quantized_conv_node)
-
-                quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtypes.qint8)
-
-                self._intel_cpu_add_dequantize_result_node(
-                    quantize_down_name, match_node_name[2], dtypes.qint8, performance_only=self.performance_only
-                )
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def apply_conv3d_single_fusion(self, match_node_name):
-        """Apply Conv3D single fusion.
-
-        Dequantize + Conv3D + QuantizeV2
-        """
-        skip_node_name = match_node_name[2:]
-        matched_node = self.node_name_mapping[match_node_name[1]]
-        _, normal_inputs = self._get_node_input(matched_node.node.name)
-        _, q_inputs = self._get_node_input(normal_inputs[0])
-        _, q_weights_inputs = self._get_node_input(normal_inputs[1])
-        quantizev2_weights_name = q_weights_inputs[0]
-
-        _, weights_name = self._get_node_input(quantizev2_weights_name)
-        weights_min_name = weights_name[1]
-        weights_max_name = weights_name[2]
-
-        q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-            matched_node.node.op, self.node_name_mapping[weights_name[0]].node, self.per_channel
-        )
-
-        all_input_names = q_inputs[:1] + [q_weights_name] + q_inputs[1:]
-        all_input_names.append(q_weights_min_name)
-        all_input_names.append(q_weights_max_name)
-        skip_node_name.append(normal_inputs[0])
-        skip_node_name.append(normal_inputs[1])
-        skip_node_name.append(weights_name[0])
-        skip_node_name.append(weights_min_name)
-        skip_node_name.append(weights_max_name)
-        skip_node_name.append(quantizev2_weights_name)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[1]:
-                # actually DepthwiseConv3dNative is not supported in intel-tf 2.8 yet
-                postfix = "_eightbit_quantized_depthwise_conv3d"
-                if node.op == "Conv3D":
-                    postfix = "_eightbit_quantized_conv3d"
-                quantized_node_name = node.name + postfix
-                quantized_conv_node = helper.create_node(
-                    "_FusedQuantizedConv3D",
-                    quantized_node_name,
-                    all_input_names,
-                )
-
-                helper.copy_attr(quantized_conv_node, "strides", node.attr["strides"])
-                helper.copy_attr(quantized_conv_node, "padding", node.attr["padding"])
-                helper.copy_attr(quantized_conv_node, "data_format", node.attr["data_format"])
-                if node.op != "DepthwiseConv3dNative" and "explicit_paddings" in node.attr:
-                    helper.copy_attr(quantized_conv_node, "explicit_paddings", node.attr["explicit_paddings"])
-                helper.copy_attr(quantized_conv_node, "dilations", node.attr["dilations"])
-                input_data_type = dtypes.quint8 if self._find_relu_node(node) else dtypes.qint8
-                helper.set_attr_dtype(quantized_conv_node, "Tinput", input_data_type)
-                helper.set_attr_dtype(quantized_conv_node, "Tfilter", dtypes.qint8)
-                helper.set_attr_dtype(quantized_conv_node, "out_type", dtypes.qint32)
-                helper.set_attr_dtype(quantized_conv_node, "Tsummand", dtypes.qint32)
-                helper.set_attr_dtype(quantized_conv_node, "Tbias", dtypes.float32)
-                # if self.device == 'gpu' else dtypes.qint32)
-                # helper.set_attr_string(quantized_conv_node, '_kernel', b'QuantizedMklOp')
-                helper.set_attr_string_list(quantized_conv_node, "fused_ops", [])
-
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_inputs",
-                    [
-                        input_data_type.as_datatype_enum,
-                        dtypes.qint8.as_datatype_enum,
-                        # dtypes.float32.as_datatype_enum if self.device == 'gpu' else dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_outputs",
-                    [
-                        dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                self.add_output_graph_node(quantized_conv_node)
-                quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtypes.qint8)
-                self._intel_cpu_add_dequantize_result_node(
-                    quantize_down_name, node.name, dtypes.qint8, performance_only=self.performance_only
-                )
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def apply_newly_conv_biasadd_relu_fusion(self, match_node_name):
-        """Apply Conv2D BiasAdd Relu fusion.
-
-        Dequantize + Conv2D + AddN + Relu + QuantizeV2
-        Dequantize + Conv2D + AddN + Relu6 + QuantizeV2
-        Dequantize + Conv2D + AddV2 + Relu + QuantizeV2
-        Dequantize + Conv2D + AddV2 + Relu6 + QuantizeV2
-        Dequantize + Conv2D + BiasAdd + Relu6 + QuantizeV2
-        Dequantize + Conv2D + Relu6 + QuantizeV2
-        Dequantize + Conv2D + BiasAdd + Relu + QuantizeV2
-        Dequantize + Conv2D + Relu + QuantizeV2
-        Dequantize + Conv2D + BiasAdd + Elu + QuantizeV2
-        Dequantize + Conv2D + Elu + QuantizeV2
-        Dequantize + Conv2D + BiasAdd + LeakyRelu + QuantizeV2
-        Dequantize + Conv2D + LeakyRelu + QuantizeV2
-        Dequantize + Conv2D + BiasAdd + Sigmoid + QuantizeV2
-        Dequantize + Conv2D + Sigmoid + QuantizeV2
-        Dequantize + Conv2D + Add + Relu6 + QuantizeV2
-        Dequantize + Conv2D + Add + Relu + QuantizeV2
-        Dequantize + DepthwiseConv2dNative + Add + Relu6 + QuantizeV2
-        Dequantize + DepthwiseConv2dNative + BiasAdd + Relu + QuantizeV2
-        Dequantize + DepthwiseConv2dNative + Relu + QuantizeV2
-        Dequantize + DepthwiseConv2dNative + Relu6 + QuantizeV2
-        Dequantize + DepthwiseConv2dNative + BiasAdd + LeakyRelu + QuantizeV2
-        Dequantize + DepthwiseConv2dNative + LeakyRelu + QuantizeV2
-        Dequantize + DepthwiseConv2dNative + BiasAdd + Relu6 + QuantizeV2
-        """
-        skip_node_name = match_node_name[2:]
-        matched_node = self.node_name_mapping[match_node_name[1]]
-
-        second_node = self.node_name_mapping[match_node_name[2]].node
-        if second_node.op in ("Relu", "Relu6", "LeakyRelu", "Elu", "Sigmoid"):
-            new_match_node_name = self._insert_dummy_biasadd(match_node_name, matched_node)
-            return self.apply_newly_conv_biasadd_relu_fusion(new_match_node_name)
-
-        need_insert_dummy_biasadd = 1
-        add_a_node_name = helper.node_name_from_input(second_node.input[0])
-        add_a_node = self.node_name_mapping[add_a_node_name].node
-        add_b_node_name = helper.node_name_from_input(second_node.input[1])
-        add_b_node = self.node_name_mapping[add_b_node_name].node
-
-        if add_a_node.op != "Const" and add_b_node.op == "Const":
-            need_insert_dummy_biasadd = 0
-        if need_insert_dummy_biasadd:
-            new_match_node_name = self._insert_dummy_biasadd(match_node_name, matched_node)
-            # after insert dummy biasadd, that is Conv+dummybiasadd+add*+relu*
-            return self.apply_newly_conv_biasadd_addn_relu_fusion(new_match_node_name)
-
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        _, q_inputs = self._get_node_input(normal_inputs[0])
-        _, q_weights_inputs = self._get_node_input(normal_inputs[1])
-
-        quantizev2_weights_name = q_weights_inputs[0]
-        _, weights_name = self._get_node_input(quantizev2_weights_name)
-        weights_min_name = weights_name[1]
-        weights_max_name = weights_name[2]
-
-        q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-            matched_node.node.op, self.node_name_mapping[weights_name[0]].node, self.per_channel
-        )
-
-        all_input_names = q_inputs[:1] + [q_weights_name] + q_inputs[1:]
-        all_input_names.append(q_weights_min_name)
-        all_input_names.append(q_weights_max_name)
-        skip_node_name.append(normal_inputs[0])
-        skip_node_name.append(normal_inputs[1])
-        skip_node_name.append(weights_name[0])
-        skip_node_name.append(weights_min_name)
-        skip_node_name.append(weights_max_name)
-        skip_node_name.append(quantizev2_weights_name)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[1]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-                quantized_node_name = node.name + "_eightbit_quantized_depthwise_conv"
-                if node.op == "Conv2D":
-                    quantized_node_name = node.name + "_eightbit_quantized_conv"
-
-                bias_node_name = self.node_name_mapping[match_node_name[2]].node.input[1]
-                relu_node_name = match_node_name[3]
-                is_relu6 = self.node_name_mapping[relu_node_name].node.op == "Relu6"
-                quantized_node_input_names = (
-                    all_input_names[:2] + [bias_node_name] + all_input_names[2:] + control_inputs
-                )
-                is_leakyrelu = self.node_name_mapping[relu_node_name].node.op == "LeakyRelu"
-                is_elu = self.node_name_mapping[relu_node_name].node.op == "Elu"
-                is_sigmoid = self.node_name_mapping[relu_node_name].node.op == "Sigmoid"
-
-                node_op = "_FusedQuantizedDepthwiseConv2D"
-                if node.op == "Conv2D":
-                    node_op = "_FusedQuantizedConv2D"
-                quantized_conv_node = helper.create_node(node_op, quantized_node_name, quantized_node_input_names)
-
-                helper.copy_attr(quantized_conv_node, "strides", node.attr["strides"])
-                helper.copy_attr(quantized_conv_node, "padding", node.attr["padding"])
-                helper.copy_attr(quantized_conv_node, "data_format", node.attr["data_format"])
-                if "alpha" in self.node_name_mapping[relu_node_name].node.attr:
-                    helper.copy_attr(
-                        quantized_conv_node, "alpha", self.node_name_mapping[relu_node_name].node.attr["alpha"]
-                    )
-                if "explicit_paddings" in node.attr:
-                    helper.copy_attr(quantized_conv_node, "explicit_paddings", node.attr["explicit_paddings"])
-                helper.copy_attr(quantized_conv_node, "dilations", node.attr["dilations"])
-                input_data_type = dtypes.quint8 if self._find_relu_node(node) else dtypes.qint8
-                helper.set_attr_dtype(quantized_conv_node, "Tinput", input_data_type)
-                helper.set_attr_dtype(quantized_conv_node, "Tfilter", dtypes.qint8)
-                helper.set_attr_dtype(quantized_conv_node, "Tsummand", dtypes.qint32)
-                # helper.set_attr_string(quantized_conv_node, '_kernel', b'QuantizedMklOp')
-                helper.set_attr_dtype(quantized_conv_node, "out_type", dtypes.qint32)
-                # helper.set_attr_dtype(quantized_conv_node, "alpha", dtypes.quint8)
-                helper.set_attr_dtype(quantized_conv_node, "Tbias", dtypes.float32)
-                # if self.device == 'gpu' else dtypes.qint32)
-                fused_ops = [b"BiasAdd", b"Relu"]
-                if is_leakyrelu:
-                    fused_ops = [b"BiasAdd", b"LeakyRelu"]
-                if is_elu:
-                    fused_ops = [b"BiasAdd", b"Elu"]
-                if is_sigmoid:
-                    fused_ops = [b"BiasAdd", b"Sigmoid"]
-                helper.set_attr_string_list(quantized_conv_node, "fused_ops", fused_ops)
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_inputs",
-                    [
-                        input_data_type.as_datatype_enum,
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,  # if self.device == 'gpu' else dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_outputs",
-                    [
-                        dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                self.add_output_graph_node(quantized_conv_node)
-
-                if not is_leakyrelu:
-                    dtype = dtypes.quint8
-                    if [
-                        i
-                        for i in self.node_name_mapping[relu_node_name].output
-                        if "FusedBatchNorm" in self.node_name_mapping[i].node.op and i in self.op_wise_config_name_list
-                    ]:
-                        dtype = dtypes.qint8
-                    quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtype, is_relu6)
-                    self._intel_cpu_add_dequantize_result_node(
-                        quantize_down_name, relu_node_name, dtype, performance_only=self.performance_only
-                    )
-                else:
-                    quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtypes.qint8, False)
-                    self._intel_cpu_add_dequantize_result_node(
-                        quantize_down_name, relu_node_name, dtype=dtypes.qint8, performance_only=self.performance_only
-                    )
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def apply_newly_conv_biasadd_fusion(self, match_node_name):
-        """Apply Conv2D BiasAdd fusion.
-
-        Dequantize + Conv2D + Biasadd + QuantizeV2
-        Dequantize + DepthwiseConv2dNative + BiasAdd + QuantizeV2
-        Dequantize + Conv2D + Add + QuantizeV2
-        Dequantize + Conv2D + AddV2 + QuantizeV2
-        """
-        skip_node_name = match_node_name[2:]
-        matched_node = self.node_name_mapping[match_node_name[1]]
-
-        second_node = self.node_name_mapping[match_node_name[2]].node
-        need_insert_dummy_biasadd = 1
-        add_a_node_name = helper.node_name_from_input(second_node.input[0])
-        add_a_node = self.node_name_mapping[add_a_node_name].node
-        add_b_node_name = helper.node_name_from_input(second_node.input[1])
-        add_b_node = self.node_name_mapping[add_b_node_name].node
-
-        if add_a_node.op != "Const" and add_b_node.op == "Const":
-            need_insert_dummy_biasadd = 0
-        if need_insert_dummy_biasadd:
-            new_match_node_name = self._insert_dummy_biasadd(match_node_name, matched_node)
-            # after insert dummy biasadd, that is Conv+dummybiasadd+add
-            return self.apply_newly_conv_biasadd_addn_fusion(new_match_node_name)
-
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        _, q_inputs = self._get_node_input(normal_inputs[0])
-        _, q_weights_inputs = self._get_node_input(normal_inputs[1])
-
-        quantizev2_weights_name = q_weights_inputs[0]
-        _, weights_name = self._get_node_input(quantizev2_weights_name)
-        weights_min_name = weights_name[1]
-        weights_max_name = weights_name[2]
-
-        q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-            matched_node.node.op, self.node_name_mapping[weights_name[0]].node, self.per_channel
-        )
-
-        all_input_names = q_inputs[:1] + [q_weights_name] + q_inputs[1:]
-        all_input_names.append(q_weights_min_name)
-        all_input_names.append(q_weights_max_name)
-        skip_node_name.append(normal_inputs[0])
-        skip_node_name.append(normal_inputs[1])
-        skip_node_name.append(weights_name[0])
-        skip_node_name.append(weights_min_name)
-        skip_node_name.append(weights_max_name)
-        skip_node_name.append(quantizev2_weights_name)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[1]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-                quantized_node_name = node.name + "_eightbit_quantized_depthwise_conv"
-                if node.op == "Conv2D":
-                    quantized_node_name = node.name + "_eightbit_quantized_conv"
-
-                bias_node_name = self.node_name_mapping[match_node_name[2]].node.input[1]
-                quantized_node_input_names = (
-                    all_input_names[:2] + [bias_node_name] + all_input_names[2:] + control_inputs
-                )
-
-                node_op = "_FusedQuantizedConv2D" if node.op == "Conv2D" else "_FusedQuantizedDepthwiseConv2D"
-                quantized_conv_node = helper.create_node(node_op, quantized_node_name, quantized_node_input_names)
-
-                helper.copy_attr(quantized_conv_node, "strides", node.attr["strides"])
-                helper.copy_attr(quantized_conv_node, "padding", node.attr["padding"])
-                helper.copy_attr(quantized_conv_node, "data_format", node.attr["data_format"])
-                if "explicit_paddings" in node.attr:
-                    helper.copy_attr(quantized_conv_node, "explicit_paddings", node.attr["explicit_paddings"])
-                helper.copy_attr(quantized_conv_node, "dilations", node.attr["dilations"])
-                input_data_type = dtypes.quint8 if self._find_relu_node(node) else dtypes.qint8
-                helper.set_attr_dtype(quantized_conv_node, "Tinput", input_data_type)
-                helper.set_attr_dtype(quantized_conv_node, "Tfilter", dtypes.qint8)
-                helper.set_attr_dtype(quantized_conv_node, "Tsummand", dtypes.qint32)
-                # helper.set_attr_string(quantized_conv_node, '_kernel', b'QuantizedMklOp')
-                helper.set_attr_dtype(quantized_conv_node, "out_type", dtypes.qint32)
-                # helper.set_attr_dtype(quantized_conv_node, "alpha", dtypes.quint8)
-                helper.set_attr_dtype(quantized_conv_node, "Tbias", dtypes.float32)
-                # if self.device == 'gpu' else dtypes.qint32)
-                helper.set_attr_string_list(quantized_conv_node, "fused_ops", [b"BiasAdd"])
-
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_inputs",
-                    [
-                        input_data_type.as_datatype_enum,
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,  # if self.device == 'gpu' else dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_outputs",
-                    [
-                        dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-
-                self.add_output_graph_node(quantized_conv_node)
-                quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtypes.qint8, False)
-                self._intel_cpu_add_dequantize_result_node(
-                    quantize_down_name, match_node_name[2], dtypes.qint8, performance_only=self.performance_only
-                )
-
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def apply_newly_conv_single_fusion(self, match_node_name):
-        """Apply Conv2D single fusion.
-
-        Dequantize + Conv2D + QuantizeV2
-        Dequantize + DepthwiseConv2dNative + QuantizeV2
-        """
-        skip_node_name = match_node_name[2:]
-        matched_node = self.node_name_mapping[match_node_name[1]]
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        _, q_inputs = self._get_node_input(normal_inputs[0])
-        _, q_weights_inputs = self._get_node_input(normal_inputs[1])
-
-        quantizev2_weights_name = q_weights_inputs[0]
-        _, weights_name = self._get_node_input(quantizev2_weights_name)
-        weights_min_name = weights_name[1]
-        weights_max_name = weights_name[2]
-
-        q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-            matched_node.node.op, self.node_name_mapping[weights_name[0]].node, self.per_channel
-        )
-
-        all_input_names = q_inputs[:1] + [q_weights_name] + q_inputs[1:]
-        all_input_names.append(q_weights_min_name)
-        all_input_names.append(q_weights_max_name)
-        skip_node_name.append(normal_inputs[0])
-        skip_node_name.append(normal_inputs[1])
-        skip_node_name.append(weights_name[0])
-        skip_node_name.append(weights_min_name)
-        skip_node_name.append(weights_max_name)
-        skip_node_name.append(quantizev2_weights_name)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[1]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-                quantized_node_name = node.name + "_eightbit_quantized_depthwise_conv"
-                if node.op == "Conv2D":
-                    quantized_node_name = node.name + "_eightbit_quantized_conv"
-
-                node_op = "_FusedQuantizedConv2D" if node.op == "Conv2D" else "_FusedQuantizedDepthwiseConv2D"
-                quantized_conv_node = helper.create_node(node_op, quantized_node_name, all_input_names)
-
-                helper.copy_attr(quantized_conv_node, "strides", node.attr["strides"])
-                helper.copy_attr(quantized_conv_node, "padding", node.attr["padding"])
-                helper.copy_attr(quantized_conv_node, "data_format", node.attr["data_format"])
-                if "explicit_paddings" in node.attr:
-                    helper.copy_attr(quantized_conv_node, "explicit_paddings", node.attr["explicit_paddings"])
-                helper.copy_attr(quantized_conv_node, "dilations", node.attr["dilations"])
-                input_data_type = dtypes.quint8 if self._find_relu_node(node) else dtypes.qint8
-                helper.set_attr_dtype(quantized_conv_node, "Tinput", input_data_type)
-                helper.set_attr_dtype(quantized_conv_node, "Tfilter", dtypes.qint8)
-                helper.set_attr_dtype(quantized_conv_node, "Tsummand", dtypes.qint32)
-                # helper.set_attr_string(quantized_conv_node, '_kernel', b'QuantizedMklOp')
-                helper.set_attr_dtype(quantized_conv_node, "out_type", dtypes.qint32)
-                # helper.set_attr_dtype(quantized_conv_node, "alpha", dtypes.quint8)
-                helper.set_attr_dtype(quantized_conv_node, "Tbias", dtypes.float32)
-                # if self.device == 'gpu' else dtypes.qint32)
-                #
-                helper.set_attr_string_list(quantized_conv_node, "fused_ops", [])
-
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_inputs",
-                    [
-                        input_data_type.as_datatype_enum,
-                        dtypes.qint8.as_datatype_enum,
-                        # dtypes.float32.as_datatype_enum if self.device == 'gpu' else dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_outputs",
-                    [
-                        dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-
-                self.add_output_graph_node(quantized_conv_node)
-                quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtypes.qint8, False)
-                self._intel_cpu_add_dequantize_result_node(
-                    quantize_down_name, match_node_name[1], dtypes.qint8, performance_only=self.performance_only
-                )
-
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def apply_newly_conv_biasadd_addn_relu_fusion(self, match_node_name):
-        """Apply Conv2D BiasAdd AddN Relu fusion.
-
-        Dequantize + Conv2D + BiasAdd + AddN + Relu + QuantizeV2
-        Dequantize + Conv2D + BiasAdd + AddN + Relu6 + QuantizeV2
-        Dequantize + Conv2D + BiasAdd + AddV2 + Relu + QuantizeV2
-        Dequantize + Conv2D + BiasAdd + AddV2 + Relu6 + QuantizeV2
-        Dequantize + Conv2D + BiasAdd + Add + Relu + QuantizeV2
-        Dequantize + Conv2D + BiasAdd + LeakyRelu + AddV2 + QuantizeV2
-        Dequantize + Conv2D + BiasAdd + Relu + AddV2(Add) + QuantizeV2
-        Dequantize + Conv2D + LeakyRelu + AddV2 + QuantizeV2
-        Dequantize + Conv2D + Relu + AddV2(Add) + QuantizeV2
-        Dequantize + Conv2D + Add + Add + Relu + QuantizeV2
-        Dequantize + Conv2D + BiasAdd + Add + Relu + QuantizeV2
-        """
-        skip_node_name = match_node_name[2:]
-        matched_node = self.node_name_mapping[match_node_name[1]]
-        second_node = self.node_name_mapping[match_node_name[2]].node
-        need_insert_dummy_biasadd = 1
-        add_a_node_name = helper.node_name_from_input(second_node.input[0])
-        add_a_node = self.node_name_mapping[add_a_node_name].node
-        add_b_node_name = helper.node_name_from_input(second_node.input[1])
-        add_b_node = self.node_name_mapping[add_b_node_name].node
-
-        if add_a_node.op != "Const" and add_b_node.op == "Const":
-            need_insert_dummy_biasadd = 0
-            if len(match_node_name) == 5 and "Relu" in match_node_name[3]:
-                return self.apply_newly_conv_biasadd_relu_fusion(match_node_name)
-
-        if need_insert_dummy_biasadd:
-            new_match_node_name = self._insert_dummy_biasadd(match_node_name, matched_node)
-            # after insert dummy biasadd, that is Conv+dummybiasadd+add*+add*+relu*
-            return self.apply_newly_conv_biasadd_addn_fusion(new_match_node_name[:4] + [new_match_node_name[-1]])
-
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        _, q_inputs = self._get_node_input(normal_inputs[0])
-        _, q_weights_inputs = self._get_node_input(normal_inputs[1])
-
-        quantizev2_weights_name = q_weights_inputs[0]
-        _, weights_name = self._get_node_input(quantizev2_weights_name)
-        weights_min_name = weights_name[1]
-        weights_max_name = weights_name[2]
-
-        third_node = self.node_name_mapping[match_node_name[3]].node
-        if third_node.op in ("BiasAdd", "Add", "AddV2", "AddN"):
-            sumadd_a_node_name = helper.node_name_from_input(third_node.input[0])
-            sumadd_a_node = self.node_name_mapping[sumadd_a_node_name].node
-            sumadd_b_node_name = helper.node_name_from_input(third_node.input[1])
-            sumadd_b_node = self.node_name_mapping[sumadd_b_node_name].node
-            if sumadd_a_node.op != "Const" and sumadd_b_node.op == "Const":
-                return self.apply_newly_conv_biasadd_fusion(match_node_name[:3] + [match_node_name[-1]])
-
-        forth_node = self.node_name_mapping[match_node_name[4]].node
-        if forth_node.op not in ("LeakyRelu", "Relu"):
-            if third_node.op not in ("LeakyRelu", "Relu") and not self._find_relu_node(matched_node.node):
-                return self.apply_newly_conv_biasadd_fusion(match_node_name[:3] + [match_node_name[-1]])
-
-        is_leakyrelu_add_fusion = third_node.op == "LeakyRelu" and forth_node.op.find("Add") != -1
-        is_relu_add_fusion = third_node.op == "Relu" and forth_node.op.find("Add") != -1
-
-        relu_offset = 0
-        if is_leakyrelu_add_fusion or is_relu_add_fusion:
-            relu_offset = 1
-        sum_index = (
-            1
-            if match_node_name[2 + relu_offset]
-            == self.node_name_mapping[match_node_name[3 + relu_offset]].node.input[0]
-            else 0
-        )
-
-        sum_node_name = self.node_name_mapping[match_node_name[3 + relu_offset]].node.input[sum_index]
-        deq_node = self.node_name_mapping[sum_node_name].node
-        if (
-            deq_node.op != "LeakyRelu" and deq_node.op != "Dequantize" and deq_node.op != "BiasAdd"
-        ) or deq_node.op.find("Quantize") != -1:
-            return self.apply_newly_conv_biasadd_fusion(match_node_name[:3] + [match_node_name[-1]])
-
-        q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-            matched_node.node.op, self.node_name_mapping[weights_name[0]].node, self.per_channel
-        )
-
-        all_input_names = q_inputs[:1] + [q_weights_name] + q_inputs[1:]
-        all_input_names.append(q_weights_min_name)
-        all_input_names.append(q_weights_max_name)
-        skip_node_name.append(normal_inputs[0])
-        skip_node_name.append(normal_inputs[1])
-        skip_node_name.append(weights_name[0])
-        skip_node_name.append(weights_min_name)
-        skip_node_name.append(weights_max_name)
-        skip_node_name.append(quantizev2_weights_name)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[1]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-                quantized_node_name = node.name + "_eightbit_quantized_depthwise_conv"
-                if node.op == "Conv2D":
-                    quantized_node_name = node.name + "_eightbit_quantized_conv"
-
-                bias_node_name = self.node_name_mapping[match_node_name[2]].node.input[1]
-
-                if is_leakyrelu_add_fusion or is_relu_add_fusion:
-                    relu_node_name = match_node_name[3]
-                else:
-                    relu_node_name = match_node_name[4]
-                is_relu6 = self.node_name_mapping[relu_node_name].node.op == "Relu6"
-                is_leakyrelu = self.node_name_mapping[relu_node_name].node.op == "LeakyRelu"
-
-                quantized_node_input_names = (
-                    all_input_names[:2] + [bias_node_name] + all_input_names[2:] + [sum_node_name] + control_inputs
-                )
-
-                if sum_node_name.find("mul") != -1:
-                    quantized_node_input_names = (
-                        all_input_names[:2]
-                        + [bias_node_name]
-                        + [self.node_name_mapping[match_node_name[3 + relu_offset]].node.input[sum_index]]
-                        + all_input_names[2:]
-                        + control_inputs
-                    )
-
-                node_op = "_FusedQuantizedConv2D" if node.op == "Conv2D" else "_FusedQuantizedDepthwiseConv2D"
-
-                quantized_conv_node = helper.create_node(node_op, quantized_node_name, quantized_node_input_names)
-                helper.copy_attr(quantized_conv_node, "strides", node.attr["strides"])
-                helper.copy_attr(quantized_conv_node, "padding", node.attr["padding"])
-                helper.copy_attr(quantized_conv_node, "data_format", node.attr["data_format"])
-                if "explicit_paddings" in node.attr:
-                    helper.copy_attr(quantized_conv_node, "explicit_paddings", node.attr["explicit_paddings"])
-                helper.copy_attr(quantized_conv_node, "dilations", node.attr["dilations"])
-                input_data_type = dtypes.quint8 if self._find_relu_node(node) else dtypes.qint8
-                helper.set_attr_dtype(quantized_conv_node, "Tinput", input_data_type)
-                helper.set_attr_dtype(quantized_conv_node, "Tfilter", dtypes.qint8)
-                helper.set_attr_dtype(quantized_conv_node, "out_type", dtypes.qint32)
-                if "alpha" in self.node_name_mapping[relu_node_name].node.attr:
-                    helper.copy_attr(
-                        quantized_conv_node, "alpha", self.node_name_mapping[relu_node_name].node.attr["alpha"]
-                    )
-                if is_leakyrelu:
-                    helper.set_attr_string_list(quantized_conv_node, "fused_ops", [b"BiasAdd", b"Sum", b"LeakyRelu"])
-                else:
-                    helper.set_attr_string_list(quantized_conv_node, "fused_ops", [b"BiasAdd", b"Sum", b"Relu"])
-                helper.set_attr_dtype(quantized_conv_node, "Tbias", dtypes.float32)
-                # if self.device == 'gpu' else dtypes.qint32)
-                helper.set_attr_dtype(quantized_conv_node, "Tsummand", dtypes.qint32)
-                if is_leakyrelu_add_fusion:
-                    helper.set_attr_string_list(quantized_conv_node, "fused_ops", [b"BiasAdd", b"LeakyRelu", b"Sum"])
-                elif is_relu_add_fusion:
-                    helper.set_attr_string_list(quantized_conv_node, "fused_ops", [b"BiasAdd", b"Relu", b"Sum"])
-
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_inputs",
-                    [
-                        input_data_type.as_datatype_enum,
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,  # if self.device == 'gpu' else dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_outputs",
-                    [
-                        dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-
-                self.add_output_graph_node(quantized_conv_node)
-
-                if is_leakyrelu_add_fusion or is_leakyrelu or is_relu_add_fusion:
-                    quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtypes.qint8, False)
-                    self._intel_cpu_add_dequantize_result_node(
-                        quantize_down_name,
-                        match_node_name[4],
-                        dtype=dtypes.qint8,
-                        performance_only=self.performance_only,
-                    )
-                else:
-                    dtype = dtypes.quint8
-                    if [
-                        i
-                        for i in self.node_name_mapping[relu_node_name].output
-                        if "FusedBatchNorm" in self.node_name_mapping[i].node.op and i in self.op_wise_config_name_list
-                    ]:
-                        dtype = dtypes.qint8
-                    quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtype, is_relu6)
-                    self._intel_cpu_add_dequantize_result_node(
-                        quantize_down_name, relu_node_name, dtype, performance_only=self.performance_only
-                    )
-
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def apply_conv_biasadd_hardswish_fusion(self, match_node_name):
-        """Apply Conv2D BiasAdd hardswish fusion.
-
-        Dequantize + Conv2D + BiasAdd + Add + Relu6 + Mul + Mul + QuantizeV2
-        Dequantize + Conv2D + Add + Relu6 + Mul + Mul + QuantizeV2
-        Dequantize + DepthwiseConv2dNative + BiasAdd + Add + Relu6 + Mul + Mul + QuantizeV2
-        Dequantize + DepthwiseConv2dNative + Add + Relu6 + Mul + Mul + QuantizeV2
-        """
-        skip_node_name = match_node_name[2:]
-        matched_node = self.node_name_mapping[match_node_name[1]]
-        second_node = self.node_name_mapping[match_node_name[2]].node
-
-        if len(match_node_name) == 7:
-            new_match_node_name = self._insert_dummy_biasadd(match_node_name, matched_node)
-            return self.apply_conv_biasadd_hardswish_fusion(new_match_node_name)
-        need_insert_dummy_biasadd = 1
-        add_a_node_name = helper.node_name_from_input(second_node.input[0])
-        add_a_node = self.node_name_mapping[add_a_node_name].node
-        add_b_node_name = helper.node_name_from_input(second_node.input[1])
-        add_b_node = self.node_name_mapping[add_b_node_name].node
-
-        if add_a_node.op != "Const" and add_b_node.op == "Const":
-            need_insert_dummy_biasadd = 0
-        if need_insert_dummy_biasadd:
-            new_match_node_name = self._insert_dummy_biasadd(match_node_name, matched_node)
-            # after insert dummy biasadd, that is Conv+dummybiasadd+add+add+relu6+mul+mul
-            return self.apply_newly_conv_biasadd_addn_fusion(new_match_node_name[:4] + [new_match_node_name[-1]])
-
-        third_node = self.node_name_mapping[match_node_name[3]].node
-        sumadd_a_node_name = helper.node_name_from_input(third_node.input[0])
-        sumadd_a_node = self.node_name_mapping[sumadd_a_node_name].node
-        sumadd_b_node_name = helper.node_name_from_input(third_node.input[1])
-        sumadd_b_node = self.node_name_mapping[sumadd_b_node_name].node
-        if sumadd_a_node.op != "Const" and sumadd_b_node.op == "Const":
-            need_insert_dummy_biasadd = 0
-        else:
-            # third node is sumadd
-            return self.apply_newly_conv_biasadd_addn_fusion(match_node_name[:4] + [new_match_node_name[-1]])
-
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        _, q_inputs = self._get_node_input(normal_inputs[0])
-        _, q_weights_inputs = self._get_node_input(normal_inputs[1])
-        quantizev2_weights_name = q_weights_inputs[0]
-
-        _, weights_name = self._get_node_input(quantizev2_weights_name)
-        weights_min_name = weights_name[1]
-        weights_max_name = weights_name[2]
-
-        q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-            matched_node.node.op, self.node_name_mapping[weights_name[0]].node, self.per_channel
-        )
-
-        all_input_names = q_inputs[:1] + [q_weights_name] + q_inputs[1:]
-        all_input_names.append(q_weights_min_name)
-        all_input_names.append(q_weights_max_name)
-        skip_node_name.append(normal_inputs[0])
-        skip_node_name.append(normal_inputs[1])
-        skip_node_name.append(weights_name[0])
-        skip_node_name.append(weights_min_name)
-        skip_node_name.append(weights_max_name)
-        skip_node_name.append(quantizev2_weights_name)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[1]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-                quantized_node_name = node.name + "_eightbit_quantized_depthwise_conv"
-                if node.op == "Conv2D":
-                    quantized_node_name = node.name + "_eightbit_quantized_conv"
-
-                bias_node_name = self.node_name_mapping[match_node_name[2]].node.input[1]
-                relu_node_name = match_node_name[4]
-                is_relu6 = self.node_name_mapping[relu_node_name].node.op == "Relu6"
-                quantized_node_input_names = (
-                    all_input_names[:2] + [bias_node_name] + all_input_names[2:] + control_inputs
-                )
-
-                node_op = "_FusedQuantizedConv2D" if node.op == "Conv2D" else "_FusedQuantizedDepthwiseConv2D"
-                quantized_conv_node = helper.create_node(node_op, quantized_node_name, quantized_node_input_names)
-
-                helper.copy_attr(quantized_conv_node, "strides", node.attr["strides"])
-                helper.copy_attr(quantized_conv_node, "padding", node.attr["padding"])
-                helper.copy_attr(quantized_conv_node, "data_format", node.attr["data_format"])
-                if "alpha" in self.node_name_mapping[relu_node_name].node.attr:
-                    helper.copy_attr(
-                        quantized_conv_node, "alpha", self.node_name_mapping[relu_node_name].node.attr["alpha"]
-                    )
-                if "explicit_paddings" in node.attr:
-                    helper.copy_attr(quantized_conv_node, "explicit_paddings", node.attr["explicit_paddings"])
-                helper.copy_attr(quantized_conv_node, "dilations", node.attr["dilations"])
-                input_data_type = dtypes.quint8 if self._find_relu_node(node) else dtypes.qint8
-                helper.set_attr_dtype(quantized_conv_node, "Tinput", input_data_type)
-                helper.set_attr_dtype(quantized_conv_node, "Tfilter", dtypes.qint8)
-                helper.set_attr_dtype(quantized_conv_node, "Tsummand", dtypes.qint32)
-                # helper.set_attr_string(quantized_conv_node, '_kernel', b'QuantizedMklOp')
-                helper.set_attr_dtype(quantized_conv_node, "out_type", dtypes.qint32)
-                # helper.set_attr_dtype(quantized_conv_node, "alpha", dtypes.quint8)
-                helper.set_attr_dtype(quantized_conv_node, "Tbias", dtypes.float32)
-                # if self.device == 'gpu' else dtypes.qint32)
-                helper.set_attr_string_list(quantized_conv_node, "fused_ops", [b"BiasAdd", b"_FusedHardSwish"])
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_inputs",
-                    [
-                        input_data_type.as_datatype_enum,
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,  # if self.device == 'gpu' else dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_outputs",
-                    [
-                        dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-
-                self.add_output_graph_node(quantized_conv_node)
-                quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtypes.quint8, is_relu6)
-                self._intel_cpu_add_dequantize_result_node(
-                    quantize_down_name, match_node_name[6], dtypes.quint8, performance_only=self.performance_only
-                )
-
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def apply_newly_conv_biasadd_swishf32_fusion(self, match_node_name):
-        """Apply Conv2D BiasAdd swishf32 fusion.
-
-        Dequantize + Conv2D + BiasAdd + swish_f32 + QuantizeV2
-        Dequantize + Conv2D + Add + swish_f32 + QuantizeV2
-        Dequantize + Conv2D + AddV2 + swish_f32 + QuantizeV2
-        Dequantize + Conv2D + swish_f32 + QuantizeV2
-        Dequantize + DepthwiseConv2dNative + BiasAdd + swish_f32 + QuantizeV2
-        Dequantize + DepthwiseConv2dNative + Add + swish_f32 + QuantizeV2
-        Dequantize + DepthwiseConv2dNative + AddV2 + swish_f32 + QuantizeV2
-        Dequantize + DepthwiseConv2dNative + swish_f32 + QuantizeV2
-        """
-        skip_node_name = match_node_name[2:]
-        matched_node = self.node_name_mapping[match_node_name[1]]
-        second_node = self.node_name_mapping[match_node_name[2]].node
-
-        if second_node.op == "swish_f32":
-            new_match_node_name = self._insert_dummy_biasadd(match_node_name, matched_node)
-            return self.apply_newly_conv_biasadd_swishf32_fusion(new_match_node_name)
-
-        need_insert_dummy_biasadd = 1
-        add_a_node_name = helper.node_name_from_input(second_node.input[0])
-        add_a_node = self.node_name_mapping[add_a_node_name].node
-        add_b_node_name = helper.node_name_from_input(second_node.input[1])
-        add_b_node = self.node_name_mapping[add_b_node_name].node
-
-        if add_a_node.op != "Const" and add_b_node.op == "Const":
-            need_insert_dummy_biasadd = 0
-        if need_insert_dummy_biasadd:
-            new_match_node_name = self._insert_dummy_biasadd(match_node_name, matched_node)
-            # TF not support ['BiasAdd', 'Sum', '_FusedSwish'] pattern yet
-            return self.apply_newly_conv_biasadd_addn_fusion(new_match_node_name[:4] + [new_match_node_name[-1]])
-
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        _, q_inputs = self._get_node_input(normal_inputs[0])
-        _, q_weights_inputs = self._get_node_input(normal_inputs[1])
-        quantizev2_weights_name = q_weights_inputs[0]
-
-        _, weights_name = self._get_node_input(quantizev2_weights_name)
-        weights_min_name = weights_name[1]
-        weights_max_name = weights_name[2]
-
-        q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-            matched_node.node.op, self.node_name_mapping[weights_name[0]].node, self.per_channel
-        )
-
-        all_input_names = q_inputs[:1] + [q_weights_name] + q_inputs[1:]
-        all_input_names.append(q_weights_min_name)
-        all_input_names.append(q_weights_max_name)
-        skip_node_name.append(normal_inputs[0])
-        skip_node_name.append(normal_inputs[1])
-        skip_node_name.append(weights_name[0])
-        skip_node_name.append(weights_min_name)
-        skip_node_name.append(weights_max_name)
-        skip_node_name.append(quantizev2_weights_name)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[1]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-                quantized_node_name = node.name + "_eightbit_quantized_depthwise_conv"
-                if node.op == "Conv2D":
-                    quantized_node_name = node.name + "_eightbit_quantized_conv"
-
-                bias_node_name = self.node_name_mapping[match_node_name[2]].node.input[1]
-                swish_node_name = match_node_name[3]
-                quantized_node_input_names = (
-                    all_input_names[:2] + [bias_node_name] + all_input_names[2:] + control_inputs
-                )
-
-                node_op = "_FusedQuantizedDepthwiseConv2D"
-                if node.op == "Conv2D":
-                    node_op = "_FusedQuantizedConv2D"
-                quantized_conv_node = helper.create_node(node_op, quantized_node_name, quantized_node_input_names)
-
-                helper.copy_attr(quantized_conv_node, "strides", node.attr["strides"])
-                helper.copy_attr(quantized_conv_node, "padding", node.attr["padding"])
-                helper.copy_attr(quantized_conv_node, "data_format", node.attr["data_format"])
-                if "alpha" in self.node_name_mapping[swish_node_name].node.attr:
-                    helper.copy_attr(
-                        quantized_conv_node, "alpha", self.node_name_mapping[swish_node_name].node.attr["alpha"]
-                    )
-                if "explicit_paddings" in node.attr:
-                    helper.copy_attr(quantized_conv_node, "explicit_paddings", node.attr["explicit_paddings"])
-                helper.copy_attr(quantized_conv_node, "dilations", node.attr["dilations"])
-                input_data_type = dtypes.quint8 if self._find_relu_node(node) else dtypes.qint8
-                helper.set_attr_dtype(quantized_conv_node, "Tinput", input_data_type)
-                helper.set_attr_dtype(quantized_conv_node, "Tfilter", dtypes.qint8)
-                helper.set_attr_dtype(quantized_conv_node, "Tsummand", dtypes.qint32)
-                helper.set_attr_dtype(quantized_conv_node, "out_type", dtypes.qint32)
-                helper.set_attr_dtype(
-                    quantized_conv_node, "Tbias", dtypes.float32 if self.device == "gpu" else dtypes.qint32
-                )
-                fused_ops = [b"BiasAdd", b"_FusedSwish"]
-                helper.set_attr_string_list(quantized_conv_node, "fused_ops", fused_ops)
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_inputs",
-                    [
-                        input_data_type.as_datatype_enum,
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum if self.device == "gpu" else dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_outputs",
-                    [
-                        dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                self.add_output_graph_node(quantized_conv_node)
-                quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtypes.qint8, False)
-                self._intel_cpu_add_dequantize_result_node(
-                    quantize_down_name, swish_node_name, dtype=dtypes.qint8, performance_only=self.performance_only
-                )
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def apply_newly_conv_biasadd_addn_fusion(self, match_node_name):
-        """Apply Conv2D BiasAdd AddN fusion.
-
-        Dequantize + Conv2D + Add + Add + QuantizeV2
-        Dequantize + Conv2D + AddV2 + Add + QuantizeV2
-        Dequantize + Conv2D + BiasAdd + Add + QuantizeV2
-        """
-        skip_node_name = match_node_name[2:]
-        matched_node = self.node_name_mapping[match_node_name[1]]
-
-        second_node = self.node_name_mapping[match_node_name[2]].node
-        need_insert_dummy_biasadd = 1
-        add_a_node_name = helper.node_name_from_input(second_node.input[0])
-        add_a_node = self.node_name_mapping[add_a_node_name].node
-        add_b_node_name = helper.node_name_from_input(second_node.input[1])
-        add_b_node = self.node_name_mapping[add_b_node_name].node
-
-        if add_a_node.op != "Const" and add_b_node.op == "Const":
-            need_insert_dummy_biasadd = 0
-        if need_insert_dummy_biasadd:
-            new_match_node_name = self._insert_dummy_biasadd(match_node_name, matched_node)
-            # after insert dummy biasadd, that is Conv+dummybiasadd+add*+add*
-            return self.apply_newly_conv_biasadd_addn_fusion(new_match_node_name[:4] + [new_match_node_name[-1]])
-
-        third_node = self.node_name_mapping[match_node_name[3]].node
-        sumadd_a_node_name = helper.node_name_from_input(third_node.input[0])
-        sumadd_a_node = self.node_name_mapping[sumadd_a_node_name].node
-        sumadd_b_node_name = helper.node_name_from_input(third_node.input[1])
-        sumadd_b_node = self.node_name_mapping[sumadd_b_node_name].node
-        if sumadd_a_node.op != "Const" and sumadd_b_node.op == "Const":
-            return self.apply_newly_conv_biasadd_fusion(match_node_name[:3] + [new_match_node_name[-1]])
-
-        sum_index = 1 if match_node_name[2] == self.node_name_mapping[match_node_name[3]].node.input[0] else 0
-        sum_node_name = self.node_name_mapping[match_node_name[3]].node.input[sum_index]
-        deq_node = self.node_name_mapping[sum_node_name].node
-        if deq_node.op != "Dequantize" or deq_node.op.find("Quantize") != -1:
-            return self.apply_newly_conv_biasadd_fusion(match_node_name[:3] + [match_node_name[-1]])
-
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        _, q_inputs = self._get_node_input(normal_inputs[0])
-        _, q_weights_inputs = self._get_node_input(normal_inputs[1])
-        quantizev2_weights_name = q_weights_inputs[0]
-
-        _, weights_name = self._get_node_input(quantizev2_weights_name)
-        weights_min_name = weights_name[1]
-        weights_max_name = weights_name[2]
-
-        q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-            matched_node.node.op, self.node_name_mapping[weights_name[0]].node, self.per_channel
-        )
-
-        all_input_names = q_inputs[:1] + [q_weights_name] + q_inputs[1:]
-        all_input_names.append(q_weights_min_name)
-        all_input_names.append(q_weights_max_name)
-        skip_node_name.append(normal_inputs[0])
-        skip_node_name.append(normal_inputs[1])
-        skip_node_name.append(weights_name[0])
-        skip_node_name.append(weights_min_name)
-        skip_node_name.append(weights_max_name)
-        skip_node_name.append(quantizev2_weights_name)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[1]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-                quantized_node_name = node.name + "_eightbit_quantized_depthwise_conv"
-                if node.op == "Conv2D":
-                    quantized_node_name = node.name + "_eightbit_quantized_conv"
-                bias_node_name = self.node_name_mapping[match_node_name[2]].node.input[1]
-
-                quantized_node_input_names = (
-                    all_input_names[:2] + [bias_node_name] + all_input_names[2:] + [sum_node_name] + control_inputs
-                )
-                node_op = "_FusedQuantizedConv2D" if node.op == "Conv2D" else "_FusedQuantizedDepthwiseConv2D"
-
-                quantized_conv_node = helper.create_node(node_op, quantized_node_name, quantized_node_input_names)
-                helper.copy_attr(quantized_conv_node, "strides", node.attr["strides"])
-                helper.copy_attr(quantized_conv_node, "padding", node.attr["padding"])
-                helper.copy_attr(quantized_conv_node, "data_format", node.attr["data_format"])
-                if "explicit_paddings" in node.attr:
-                    helper.copy_attr(quantized_conv_node, "explicit_paddings", node.attr["explicit_paddings"])
-                helper.copy_attr(quantized_conv_node, "dilations", node.attr["dilations"])
-                input_data_type = dtypes.quint8 if self._find_relu_node(node) else dtypes.qint8
-                helper.set_attr_dtype(quantized_conv_node, "Tinput", input_data_type)
-                helper.set_attr_dtype(quantized_conv_node, "Tfilter", dtypes.qint8)
-                helper.set_attr_dtype(quantized_conv_node, "out_type", dtypes.qint32)
-                helper.set_attr_string_list(quantized_conv_node, "fused_ops", [b"BiasAdd", b"Sum"])
-                helper.set_attr_dtype(quantized_conv_node, "Tbias", dtypes.float32)
-                # if self.device == 'gpu' else dtypes.qint32)
-                helper.set_attr_dtype(quantized_conv_node, "Tsummand", dtypes.qint32)
-
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_inputs",
-                    [
-                        input_data_type.as_datatype_enum,
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,  # if self.device == 'gpu' else dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                helper.set_attr_type_list(
-                    quantized_conv_node,
-                    "Thost_outputs",
-                    [
-                        dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-
-                self.add_output_graph_node(quantized_conv_node)
-                quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtypes.qint8, False)
-                self._intel_cpu_add_dequantize_result_node(
-                    quantize_down_name, match_node_name[3], dtype=dtypes.qint8, performance_only=self.performance_only
-                )
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def get_longest_fuse(self):
-        """Get the longest fusion pattern."""
-        self._get_op_list()
-
-        matched_rule, matched_node_name = self._is_match_conv(self.sorted_patterns)
-        return matched_rule, matched_node_name
-
-    def apply_the_transform(self):
-        """Quantize Conv and apply the fusion."""
-        self._get_op_list()
-        matched_rule, matched_node_name = self._is_match_conv(self.sorted_patterns, True)
-        if matched_node_name:
-            self.output_graph = graph_pb2.GraphDef()
-            fusion_name = "".join(matched_rule)
-            if fusion_name in self.fusion_mapping:
-                if fusion_name.find("DequantizeConv2DAddReluQuantizeV2") != -1:
-                    for input_name in self.node_name_mapping[matched_node_name[2]].node.input:
-                        input_node_name = helper.node_name_from_input(input_name)
-                        if input_node_name != matched_node_name[1]:
-                            add_const_input_node = self.node_name_mapping[input_node_name].node
-                            add_node_content = tensor_util.MakeNdarray(add_const_input_node.attr["value"].tensor)
-                            if add_node_content.ndim != 1:
-                                fusion_name = "DequantizeConv2DQuantizeV2"
-                                matched_node_name = matched_node_name[:2] + [matched_node_name[-1]]
-                self.fusion_mapping[fusion_name](matched_node_name)
-            else:  # pragma: no cover
-                self.logger.info("Unknown fusion pattern {}.".format(fusion_name))
-                if self.remove_redundant_quant_flag:
-                    self.input_graph = self.remove_redundant_quantization(self.input_graph)
-                return self.input_graph, self.exclude_conv_nodes
-
-            self.input_graph = self.output_graph
-            self._reset_output_node_maps()
-            if self.remove_redundant_quant_flag:
-                self.output_graph = self.remove_redundant_quantization(self.output_graph)
-
-            return self.output_graph, self.exclude_conv_nodes
-
-        if self.remove_redundant_quant_flag:
-            self.input_graph = self.remove_redundant_quantization(self.input_graph)
-        return self.input_graph, self.exclude_conv_nodes
-
-    def _is_match_conv(self, patterns, qdq_inserted=False):
-        """Detect the rule matched nodes collections.
-
-        Returns:
-            [List] -- [the matched rule]
-            [String] -- [the list contains the matched node name]
-        """
-        matched_node_name = []
-
-        for k, v in enumerate(self.op_list):
-            if v in set(fusion[1] for fusion in patterns):
-                cur_node = self.node_name_mapping[list(self.node_name_mapping.keys())[k]].node
-                if cur_node.name != self.start_node_name:
-                    continue
-
-                if ((v in ("Conv2D", "DepthwiseConv2dNative") and not self.enable_s8)) and not self._find_relu_node(
-                    cur_node
-                ):
-                    self.exclude_conv_nodes.append(cur_node.name)
-                    continue
-
-                _, normal_inputs = self._get_node_input(cur_node.name)
-                if self.node_name_mapping[normal_inputs[1].rsplit(":")[0]].node.op == "Split":
-                    self.exclude_conv_nodes.append(cur_node.name)
-                    continue
-
-                for sub_rule in patterns:
-                    if sub_rule[0] != "Dequantize" or sub_rule[-1] != "QuantizeV2":
-                        self.exclude_conv_nodes.append(cur_node.name)
-                        continue
-                    if v != sub_rule[1]:
-                        self.exclude_conv_nodes.append(cur_node.name)
-                        continue
-
-                    if qdq_inserted:
-                        if (
-                            self.node_name_mapping[normal_inputs[0]].node.op != "Dequantize"
-                            or self.node_name_mapping[normal_inputs[1]].node.op != "Dequantize"
-                        ):
-                            continue
-
-                    sub_rule_len = len(sub_rule) - 2
-                    check_hardswish = True if sub_rule_len > 4 else False
-                    self.logger.debug("Try to apply rule: {}".format(sub_rule))
-
-                    cur_node_name = list(self.node_name_mapping.keys())[k]
-
-                    matched_node_name.clear()
-                    matched_node_name.append(sub_rule[0])
-                    matched_node_name.append(cur_node_name)
-
-                    count = 0
-                    while sub_rule_len > 1:
-                        if not self.node_name_mapping[cur_node_name].output:
-                            self.logger.debug("Fail to match {}".format(sub_rule))
-                            break
-
-                        next_node_name = self.node_name_mapping[cur_node_name].output[0]
-
-                        is_shared_output = True if len(self.node_name_mapping[cur_node_name].output) > 1 else False
-
-                        add_op_quantizable = True
-                        is_hardswish = False
-                        if is_shared_output:
-                            if next_node_name.find("hard_swish") != -1:
-                                self.logger.debug("Find Hard Swish pattern ......")
-                                is_hardswish = True
-                                count = count + 1
-                                if next_node_name.find("add") == -1:
-                                    next_node_name = self.node_name_mapping[cur_node_name].output[1]
-                            else:
-                                add_op_quantizable = False
-                        next_node_op = self.node_name_mapping[next_node_name].node.op
-                        if add_op_quantizable and next_node_op == sub_rule[-sub_rule_len]:
-                            if not is_shared_output:
-                                matched_node_name.append(next_node_name)
-                                sub_rule_len -= 1
-                                cur_node_name = next_node_name
-                            elif is_hardswish:
-                                matched_node_name.append(next_node_name)
-                                sub_rule_len -= 1
-                                cur_node_name = next_node_name
-                            else:
-                                matched_node_name.clear()
-                                self.logger.debug("Fail to match {}.".format(sub_rule))
-                                break
-                        else:
-                            matched_node_name.clear()
-                            self.logger.debug("Fail to match {}.".format(sub_rule))
-                            break
-
-                    if sub_rule_len == 1:
-                        matched_node_name.append(sub_rule[-1])
-                        if (
-                            check_hardswish
-                            and sub_rule[-2] == "Mul"
-                            and sub_rule[-3] == "Mul"
-                            and sub_rule[-4] == "Relu6"
-                            and sub_rule[-5] == "Add"
-                            and count != 1
-                        ):
-                            matched_node_name.clear()
-                            self.logger.debug("Fail to match {}.".format(sub_rule))
-                            break
-                        self.logger.debug("Match {} on nodes {}.".format(sub_rule, matched_node_name))
-                        return sub_rule, matched_node_name
-
-        return None, None
diff --git a/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_deconv.py b/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_deconv.py
deleted file mode 100644
index 74758596343..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_deconv.py
+++ /dev/null
@@ -1,541 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Quantize Conv2DBackpropInput and Conv3DBackpropInputV2."""
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.core.framework import graph_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper as helper
-
-from ..quantize_graph_base import QuantizeNodeBase
-
-
-class FuseNodeStartWithDeconv2d(QuantizeNodeBase):
-    """Quantize Conv2DBackpropInput and Conv3DBackpropInputV2 and apply the fusion."""
-
-    exclude_deconv_nodes = []
-
-    def __init__(self, **kwargs):
-        """Initialization."""
-        super().__init__(**kwargs)
-        self.sorted_patterns = sorted(self.patterns, key=lambda i: len(i), reverse=True)
-        if self.new_api:
-            self.fusion_mapping = {
-                "DequantizeConv2DBackpropInputQuantizeV2": self.apply_single_deconv2d_fusion,
-                "DequantizeConv2DBackpropInputBiasAddQuantizeV2": self.apply_deconv2d_biasadd_fusion,
-                "DequantizeConv3DBackpropInputV2QuantizeV2": self.apply_single_deconv3d_fusion,
-                "DequantizeConv3DBackpropInputV2BiasAddQuantizeV2": self.apply_deconv3d_biasadd_fusion,
-            }
-
-    def apply_single_deconv2d_fusion(self, match_node_name):
-        """Apply single Conv2DBackpropInput fusion.
-
-        Dequantize + Conv2DBackpropInput + QuantizeV2
-        """
-        skip_node_name = match_node_name[2:]
-        matched_node = self.node_name_mapping[match_node_name[1]]
-
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        _, q_inputs = self._get_node_input(normal_inputs[2])
-        _, q_weights_inputs = self._get_node_input(normal_inputs[1])
-
-        quantizev2_weights_name = q_weights_inputs[0]
-        _, weights_name = self._get_node_input(quantizev2_weights_name)
-        weights_min_name = weights_name[1]
-        weights_max_name = weights_name[2]
-
-        q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-            matched_node.node.op, self.node_name_mapping[weights_name[0]].node, self.per_channel
-        )
-
-        all_input_names = [normal_inputs[0]] + [q_weights_name] + q_inputs[:1]
-        all_input_names.append(q_weights_min_name)
-        all_input_names.append(q_weights_max_name)
-        all_input_names += q_inputs[1:]
-        skip_node_name.append(normal_inputs[2])
-        skip_node_name.append(normal_inputs[1])
-        skip_node_name.append(weights_name[0])
-        skip_node_name.append(weights_min_name)
-        skip_node_name.append(weights_max_name)
-        skip_node_name.append(quantizev2_weights_name)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[1]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-
-                quantized_node_name = node.name + "_eightbit_quantized_deconv"
-
-                quantized_node_input_names = all_input_names[:2] + all_input_names[2:] + control_inputs
-
-                node_op = "_FusedQuantizedDeconv2D"
-                quantized_deconv_node = helper.create_node(node_op, quantized_node_name, quantized_node_input_names)
-
-                helper.copy_attr(quantized_deconv_node, "strides", node.attr["strides"])
-                helper.copy_attr(quantized_deconv_node, "padding", node.attr["padding"])
-                helper.copy_attr(quantized_deconv_node, "data_format", node.attr["data_format"])
-                if "explicit_paddings" in node.attr:
-                    helper.copy_attr(quantized_deconv_node, "explicit_paddings", node.attr["explicit_paddings"])
-                helper.copy_attr(quantized_deconv_node, "dilations", node.attr["dilations"])
-                input_data_type = dtypes.quint8 if self._find_relu_node(node) else dtypes.qint8
-                helper.set_attr_dtype(quantized_deconv_node, "Tinput", input_data_type)
-                helper.set_attr_dtype(quantized_deconv_node, "Tfilter", dtypes.qint8)
-                # helper.set_attr_string(quantized_conv_node, '_kernel', b'QuantizedMklOp')
-                helper.set_attr_dtype(quantized_deconv_node, "out_type", dtypes.qint32)
-                # helper.set_attr_dtype(quantized_conv_node, "alpha", dtypes.quint8)
-
-                helper.set_attr_type_list(
-                    quantized_deconv_node,
-                    "Thost_inputs",
-                    [
-                        dtypes.int32.as_datatype_enum,
-                        dtypes.qint8.as_datatype_enum,
-                        input_data_type.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                helper.set_attr_type_list(
-                    quantized_deconv_node,
-                    "Thost_outputs",
-                    [
-                        dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-
-                self.add_output_graph_node(quantized_deconv_node)
-                quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtypes.qint8, False)
-                self._intel_cpu_add_dequantize_result_node(quantize_down_name, match_node_name[1], dtypes.qint8)
-
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def apply_deconv2d_biasadd_fusion(self, match_node_name):
-        """Apply Conv2DBackpropInput BiasAdd fusion.
-
-        Dequantize + Conv2DBackpropInput + Biasadd + QuantizeV2
-        """
-        skip_node_name = match_node_name[2:]
-        matched_node = self.node_name_mapping[match_node_name[1]]
-
-        second_node = self.node_name_mapping[match_node_name[2]].node
-        need_insert_dummy_biasadd = 1
-        add_a_node_name = helper.node_name_from_input(second_node.input[0])
-        add_a_node = self.node_name_mapping[add_a_node_name].node
-        add_b_node_name = helper.node_name_from_input(second_node.input[1])
-        add_b_node = self.node_name_mapping[add_b_node_name].node
-
-        # if add_a_node.op != 'Const' and add_b_node.op == 'Const':
-        #      need_insert_dummy_biasadd = 0
-        # if need_insert_dummy_biasadd:
-        #      new_match_node_name = self._insert_dummy_biasadd(match_node_name, matched_node)
-        #      # after insert dummy biasadd, that is Conv+dummybiasadd+add
-        #      return self.apply_deconv2d_biasadd_fusion(new_match_node_name)
-
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        _, q_inputs = self._get_node_input(normal_inputs[2])
-        _, q_weights_inputs = self._get_node_input(normal_inputs[1])
-
-        quantizev2_weights_name = q_weights_inputs[0]
-        _, weights_name = self._get_node_input(quantizev2_weights_name)
-        weights_min_name = weights_name[1]
-        weights_max_name = weights_name[2]
-
-        q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-            matched_node.node.op, self.node_name_mapping[weights_name[0]].node, self.per_channel
-        )
-
-        all_input_names = [normal_inputs[0]] + [q_weights_name] + q_inputs[:1]
-        all_input_names.append(q_weights_min_name)
-        all_input_names.append(q_weights_max_name)
-        all_input_names += q_inputs[1:]
-        skip_node_name.append(normal_inputs[2])
-        skip_node_name.append(normal_inputs[1])
-        skip_node_name.append(weights_name[0])
-        skip_node_name.append(weights_min_name)
-        skip_node_name.append(weights_max_name)
-        skip_node_name.append(quantizev2_weights_name)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[1]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-
-                quantized_node_name = node.name + "_eightbit_quantized_deconv"
-
-                bias_node_name = self.node_name_mapping[match_node_name[2]].node.input[1]
-                quantized_node_input_names = (
-                    all_input_names[:3] + [bias_node_name] + all_input_names[3:] + control_inputs
-                )
-
-                node_op = "_FusedQuantizedDeconv2D"
-                quantized_deconv_node = helper.create_node(node_op, quantized_node_name, quantized_node_input_names)
-
-                helper.copy_attr(quantized_deconv_node, "strides", node.attr["strides"])
-                helper.copy_attr(quantized_deconv_node, "padding", node.attr["padding"])
-                helper.copy_attr(quantized_deconv_node, "data_format", node.attr["data_format"])
-                if "explicit_paddings" in node.attr:
-                    helper.copy_attr(quantized_deconv_node, "explicit_paddings", node.attr["explicit_paddings"])
-                helper.copy_attr(quantized_deconv_node, "dilations", node.attr["dilations"])
-                input_data_type = dtypes.quint8 if self._find_relu_node(node) else dtypes.qint8
-                helper.set_attr_dtype(quantized_deconv_node, "Tinput", input_data_type)
-                helper.set_attr_dtype(quantized_deconv_node, "Tfilter", dtypes.qint8)
-                # helper.set_attr_string(quantized_conv_node, '_kernel', b'QuantizedMklOp')
-                helper.set_attr_dtype(quantized_deconv_node, "out_type", dtypes.qint32)
-                # helper.set_attr_dtype(quantized_conv_node, "alpha", dtypes.quint8)
-                helper.set_attr_dtype(quantized_deconv_node, "Tbias", dtypes.float32)
-                # if self.device == 'gpu' else dtypes.qint32)
-                helper.set_attr_string_list(quantized_deconv_node, "fused_ops", [b"BiasAdd"])
-
-                helper.set_attr_type_list(
-                    quantized_deconv_node,
-                    "Thost_inputs",
-                    [
-                        dtypes.int32.as_datatype_enum,
-                        dtypes.qint8.as_datatype_enum,
-                        input_data_type.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,  # if self.device == 'gpu' else dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                helper.set_attr_type_list(
-                    quantized_deconv_node,
-                    "Thost_outputs",
-                    [
-                        dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-
-                self.add_output_graph_node(quantized_deconv_node)
-                quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtypes.qint8, False)
-                self._intel_cpu_add_dequantize_result_node(quantize_down_name, match_node_name[2], dtypes.qint8)
-
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def apply_single_deconv3d_fusion(self, match_node_name):
-        """Apply single Conv3DBackpropInputV2 fusion.
-
-        Dequantize + Conv3DBackpropInputV2 + QuantizeV2
-        """
-        skip_node_name = match_node_name[2:]
-        matched_node = self.node_name_mapping[match_node_name[1]]
-
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        _, q_inputs = self._get_node_input(normal_inputs[2])
-        _, q_weights_inputs = self._get_node_input(normal_inputs[1])
-
-        quantizev2_weights_name = q_weights_inputs[0]
-        _, weights_name = self._get_node_input(quantizev2_weights_name)
-        weights_min_name = weights_name[1]
-        weights_max_name = weights_name[2]
-
-        q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-            matched_node.node.op, self.node_name_mapping[weights_name[0]].node, self.per_channel
-        )
-
-        all_input_names = [normal_inputs[0]] + [q_weights_name] + q_inputs[:1]
-        all_input_names.append(q_weights_min_name)
-        all_input_names.append(q_weights_max_name)
-        all_input_names += q_inputs[1:]
-        skip_node_name.append(normal_inputs[2])
-        skip_node_name.append(normal_inputs[1])
-        skip_node_name.append(weights_name[0])
-        skip_node_name.append(weights_min_name)
-        skip_node_name.append(weights_max_name)
-        skip_node_name.append(quantizev2_weights_name)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[1]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-
-                quantized_node_name = node.name + "_eightbit_quantized_deconv"
-
-                quantized_node_input_names = all_input_names[:2] + all_input_names[2:] + control_inputs
-
-                node_op = "_FusedQuantizedDeconv3D"
-                quantized_deconv_node = helper.create_node(node_op, quantized_node_name, quantized_node_input_names)
-
-                helper.copy_attr(quantized_deconv_node, "strides", node.attr["strides"])
-                helper.copy_attr(quantized_deconv_node, "padding", node.attr["padding"])
-                helper.copy_attr(quantized_deconv_node, "data_format", node.attr["data_format"])
-                if "explicit_paddings" in node.attr:
-                    helper.copy_attr(quantized_deconv_node, "explicit_paddings", node.attr["explicit_paddings"])
-                helper.copy_attr(quantized_deconv_node, "dilations", node.attr["dilations"])
-                input_data_type = dtypes.quint8 if self._find_relu_node(node) else dtypes.qint8
-                helper.set_attr_dtype(quantized_deconv_node, "Tinput", input_data_type)
-                helper.set_attr_dtype(quantized_deconv_node, "Tfilter", dtypes.qint8)
-                # helper.set_attr_string(quantized_conv_node, '_kernel', b'QuantizedMklOp')
-                helper.set_attr_dtype(quantized_deconv_node, "out_type", dtypes.qint32)
-                # helper.set_attr_dtype(quantized_conv_node, "alpha", dtypes.quint8)
-
-                helper.set_attr_type_list(
-                    quantized_deconv_node,
-                    "Thost_inputs",
-                    [
-                        dtypes.int32.as_datatype_enum,
-                        dtypes.qint8.as_datatype_enum,
-                        input_data_type.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                helper.set_attr_type_list(
-                    quantized_deconv_node,
-                    "Thost_outputs",
-                    [
-                        dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-
-                self.add_output_graph_node(quantized_deconv_node)
-                quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtypes.qint8, False)
-                self._intel_cpu_add_dequantize_result_node(quantize_down_name, match_node_name[1], dtypes.qint8)
-
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def apply_deconv3d_biasadd_fusion(self, match_node_name):
-        """Apply the Conv3DBackpropInputV2 BiasAdd fusion.
-
-        Dequantize + Conv3DBackpropInputV2 + Biasadd + QuantizeV2
-        """
-        skip_node_name = match_node_name[2:]
-        matched_node = self.node_name_mapping[match_node_name[1]]
-
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        _, q_inputs = self._get_node_input(normal_inputs[2])
-        _, q_weights_inputs = self._get_node_input(normal_inputs[1])
-
-        quantizev2_weights_name = q_weights_inputs[0]
-        _, weights_name = self._get_node_input(quantizev2_weights_name)
-        weights_min_name = weights_name[1]
-        weights_max_name = weights_name[2]
-
-        q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-            matched_node.node.op, self.node_name_mapping[weights_name[0]].node, self.per_channel
-        )
-
-        all_input_names = [normal_inputs[0]] + [q_weights_name] + q_inputs[:1]
-        all_input_names.append(q_weights_min_name)
-        all_input_names.append(q_weights_max_name)
-        all_input_names += q_inputs[1:]
-        skip_node_name.append(normal_inputs[2])
-        skip_node_name.append(normal_inputs[1])
-        skip_node_name.append(weights_name[0])
-        skip_node_name.append(weights_min_name)
-        skip_node_name.append(weights_max_name)
-        skip_node_name.append(quantizev2_weights_name)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[1]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-
-                quantized_node_name = node.name + "_eightbit_quantized_deconv"
-
-                bias_node_name = self.node_name_mapping[match_node_name[2]].node.input[1]
-                quantized_node_input_names = (
-                    all_input_names[:3] + [bias_node_name] + all_input_names[3:] + control_inputs
-                )
-
-                node_op = "_FusedQuantizedDeconv3D"
-                quantized_deconv_node = helper.create_node(node_op, quantized_node_name, quantized_node_input_names)
-
-                helper.copy_attr(quantized_deconv_node, "strides", node.attr["strides"])
-                helper.copy_attr(quantized_deconv_node, "padding", node.attr["padding"])
-                helper.copy_attr(quantized_deconv_node, "data_format", node.attr["data_format"])
-                if "explicit_paddings" in node.attr:
-                    helper.copy_attr(quantized_deconv_node, "explicit_paddings", node.attr["explicit_paddings"])
-                helper.copy_attr(quantized_deconv_node, "dilations", node.attr["dilations"])
-                input_data_type = dtypes.quint8 if self._find_relu_node(node) else dtypes.qint8
-                helper.set_attr_dtype(quantized_deconv_node, "Tinput", input_data_type)
-                helper.set_attr_dtype(quantized_deconv_node, "Tfilter", dtypes.qint8)
-                # helper.set_attr_string(quantized_conv_node, '_kernel', b'QuantizedMklOp')
-                helper.set_attr_dtype(quantized_deconv_node, "out_type", dtypes.qint32)
-                # helper.set_attr_dtype(quantized_conv_node, "alpha", dtypes.quint8)
-                helper.set_attr_dtype(quantized_deconv_node, "Tbias", dtypes.float32)
-                # if self.device == 'gpu' else dtypes.qint32)
-                helper.set_attr_string_list(quantized_deconv_node, "fused_ops", [b"BiasAdd"])
-
-                helper.set_attr_type_list(
-                    quantized_deconv_node,
-                    "Thost_inputs",
-                    [
-                        dtypes.int32.as_datatype_enum,
-                        dtypes.qint8.as_datatype_enum,
-                        input_data_type.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,  # if self.device == 'gpu' else dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                helper.set_attr_type_list(
-                    quantized_deconv_node,
-                    "Thost_outputs",
-                    [
-                        dtypes.qint32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-
-                self.add_output_graph_node(quantized_deconv_node)
-                quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtypes.qint8, False)
-                self._intel_cpu_add_dequantize_result_node(quantize_down_name, match_node_name[2], dtypes.qint8)
-
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def get_longest_fuse(self):
-        """Get the longest fusion pattern."""
-        self._get_op_list()
-
-        matched_rule, matched_node_name = self._is_match_deconv(self.sorted_patterns)
-        return matched_rule, matched_node_name
-
-    def apply_the_transform(self):
-        """Quantize Conv2DBackpropInput and Conv3DBackpropInputV2 and apply the fusion."""
-        self._get_op_list()
-        matched_rule, matched_node_name = self._is_match_deconv(self.sorted_patterns, True)
-        if matched_node_name:
-            self.output_graph = graph_pb2.GraphDef()
-            fusion_name = "".join(matched_rule)
-            if fusion_name in self.fusion_mapping:
-                self.fusion_mapping[fusion_name](matched_node_name)
-            else:  # pragma: no cover
-                self.logger.info("Unknown fusion pattern {}.".format(fusion_name))
-                if self.remove_redundant_quant_flag:
-                    self.input_graph = self.remove_redundant_quantization(self.input_graph)
-                return self.input_graph, self.exclude_deconv_nodes
-
-            self.input_graph = self.output_graph
-            self._reset_output_node_maps()
-            if self.remove_redundant_quant_flag:
-                self.output_graph = self.remove_redundant_quantization(self.output_graph)
-
-            return self.output_graph, self.exclude_deconv_nodes
-
-        if self.remove_redundant_quant_flag:
-            self.input_graph = self.remove_redundant_quantization(self.input_graph)
-        return self.input_graph, self.exclude_deconv_nodes
-
-    def _is_match_deconv(self, patterns, qdq_inserted=False):
-        """Detect the rule matched nodes collections.
-
-        Returns:
-            [List] -- [the matched rule]
-            [String] -- [the list contains the matched node name]
-        """
-        matched_node_name = []
-
-        for k, v in enumerate(self.op_list):
-            if v in set(fusion[1] for fusion in patterns):
-                cur_node = self.node_name_mapping[list(self.node_name_mapping.keys())[k]].node
-                if cur_node.name != self.start_node_name:
-                    continue
-
-                if qdq_inserted:
-                    _, normal_inputs = self._get_node_input(cur_node.name)
-
-                for sub_rule in patterns:
-                    if sub_rule[0] != "Dequantize" or sub_rule[-1] != "QuantizeV2":
-                        self.exclude_deconv_nodes.append(cur_node.name)
-                        continue
-                    if v != sub_rule[1]:
-                        self.exclude_deconv_nodes.append(cur_node.name)
-                        continue
-
-                    if qdq_inserted:
-                        input_index = 0
-                        if sub_rule[1] in ("Conv2DBackpropInput", "Conv3DBackpropInputV2"):
-                            input_index = 2
-                        if (
-                            self.node_name_mapping[normal_inputs[input_index]].node.op != "Dequantize"
-                            or self.node_name_mapping[normal_inputs[1]].node.op != "Dequantize"
-                        ):
-                            continue
-
-                    sub_rule_len = len(sub_rule) - 2
-                    self.logger.debug("Try to apply rule: {}".format(sub_rule))
-
-                    cur_node_name = list(self.node_name_mapping.keys())[k]
-
-                    matched_node_name.clear()
-                    matched_node_name.append(sub_rule[0])
-                    matched_node_name.append(cur_node_name)
-
-                    while sub_rule_len > 1:
-                        if not self.node_name_mapping[cur_node_name].output:
-                            self.logger.debug("Fail to match {}".format(sub_rule))
-                            break
-
-                        next_node_name = self.node_name_mapping[cur_node_name].output[0]
-
-                        is_shared_output = True if len(self.node_name_mapping[cur_node_name].output) > 1 else False
-
-                        next_node_op = self.node_name_mapping[next_node_name].node.op
-                        if next_node_op == sub_rule[-sub_rule_len]:
-                            if not is_shared_output:
-                                matched_node_name.append(next_node_name)
-                                sub_rule_len -= 1
-                                cur_node_name = next_node_name
-                            else:
-                                matched_node_name.clear()
-                                self.logger.debug("Fail to match {}.".format(sub_rule))
-                                break
-                        else:
-                            matched_node_name.clear()
-                            self.logger.debug("Fail to match {}.".format(sub_rule))
-                            break
-
-                    if sub_rule_len == 1:
-                        matched_node_name.append(sub_rule[-1])
-                        self.logger.debug("Match {} on nodes {}.".format(sub_rule, matched_node_name))
-                        return sub_rule, matched_node_name
-
-        return None, None
diff --git a/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_in.py b/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_in.py
deleted file mode 100644
index 90f29fa3fa3..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_in.py
+++ /dev/null
@@ -1,183 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Quantize FusedInstanceNorm."""
-
-from tensorflow.core.framework import graph_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper as helper
-
-from ..quantize_graph_base import QuantizeNodeBase
-
-
-class FuseNodeStartWithFusedInstanceNorm(QuantizeNodeBase):  # pragma: no cover
-    """Quantize FusedInstanceNorm and apply the fusion."""
-
-    def __init__(self, **kwargs):
-        """Initialization."""
-        super().__init__(**kwargs)
-        self.sorted_patterns = sorted(self.patterns, key=lambda i: len(i), reverse=True)
-        if self.new_api:
-            self.fusion_mapping = {
-                "_MklFusedInstanceNormLeakyRelu": self.apply_newly_in_relu_fusion,
-                "_MklFusedInstanceNormRelu": self.apply_newly_in_relu_fusion,
-                "_MklFusedInstanceNorm": self.apply_newly_in_relu_fusion,
-            }
-        else:
-            self.fusion_mapping = {}
-
-    def apply_newly_in_relu_fusion(self, match_node_name):
-        """Apply FusedInstanceNorm Relu/LeakyRelu fusion."""
-        matched_node = self.node_name_mapping[match_node_name[0]]
-        skip_node_name = match_node_name[1:]
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        scale_name = normal_inputs[1]
-        offset_name = normal_inputs[2]
-        mean_name = normal_inputs[3]
-        variance_name = normal_inputs[4]
-
-        all_input_names = self._add_eightbit_prologue_nodes(matched_node.node.name)
-        all_input_names = [
-            all_input_names[0],
-            scale_name,
-            offset_name,
-            mean_name,
-            variance_name,
-            all_input_names[1],
-            all_input_names[2],
-        ]
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[0]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-
-                relu_node_name = match_node_name[1] if len(match_node_name) == 2 else None
-
-                node_op = "_QuantizedFusedInstanceNorm"
-                quantized_node_name = node.name + "_eightbit_quantized_in"
-                output_min_node_name = quantized_node_name + "_input7_output_min"
-                output_max_node_name = quantized_node_name + "_input8_output_max"
-                quantized_node_input_names = (
-                    all_input_names + [output_min_node_name] + [output_max_node_name] + control_inputs
-                )
-                output_min_node = helper.create_constant_node(output_min_node_name, -1.0, dtypes.float32)
-                output_max_node = helper.create_constant_node(output_max_node_name, 1.0, dtypes.float32)
-                quantized_in_node = helper.create_node(node_op, quantized_node_name, quantized_node_input_names)
-
-                if relu_node_name is not None:
-                    relu_node = self.node_name_mapping[relu_node_name].node
-                    if relu_node.op == "Relu":
-                        helper.set_attr_string(quantized_in_node, "activation_mode", b"Relu")
-                    elif relu_node.op == "LeakyRelu":
-                        helper.set_attr_string(quantized_in_node, "activation_mode", b"LeakyRelu")
-                        helper.set_attr_float(quantized_in_node, "leakyrelu_alpha", relu_node.attr["alpha"].f)
-
-                helper.set_attr_dtype(quantized_in_node, "T", dtypes.qint8)
-                helper.set_attr_dtype(quantized_in_node, "U", dtypes.float32)
-                helper.set_attr_dtype(quantized_in_node, "Tout", dtypes.qint8)
-                helper.copy_attr(quantized_in_node, "reduction_axes", node.attr["reduction_axes"])
-                """# 0.
-
-                x
-                # 1. scale
-                # 2. offset
-                # 3. mean
-                # 4. variance
-                # 5. x_min
-                # 6. x_max
-                # 7. {output_min}
-                # 8. {output_max}
-                """
-                helper.set_attr_type_list(
-                    quantized_in_node,
-                    "input_types",
-                    [
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                """# 0.
-
-                output
-                # 1. output_min
-                # 2. output_max
-                """
-                helper.set_attr_type_list(
-                    quantized_in_node,
-                    "out_types",
-                    [
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                self.add_output_graph_node(output_min_node)
-                self.add_output_graph_node(output_max_node)
-                self.add_output_graph_node(quantized_in_node)
-                self._intel_cpu_add_dequantize_result_node(
-                    quantized_output_name=quantized_node_name,
-                    original_node_name=match_node_name[-1],
-                    dtype=dtypes.qint8,
-                    min_tensor_index=1,
-                )
-
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def get_longest_fuse(self):
-        """Get the longest fusion pattern."""
-        self._get_op_list()
-        real_patterns = [pattern[1:-1] for pattern in self.sorted_patterns]
-        # Cannot match if: self._is_match([['Q','IN','LeakyRelu','DQ'],['Q','IN','Relu','DQ'],['Q','IN','DQ']])
-        matched_rule, matched_node_name = self._is_match(real_patterns)
-        return matched_rule, matched_node_name
-
-    def apply_the_transform(self):
-        """Quantize FusedInstanceNorm and apply the fusion pattern."""
-        self._get_op_list()
-        real_patterns = [pattern[1:-1] for pattern in self.sorted_patterns]
-        # Cannot match if: self._is_match([['Q','IN','LeakyRelu','DQ'],['Q','IN','Relu','DQ'],['Q','IN','DQ']])
-        matched_rule, matched_node_name = self._is_match(real_patterns)
-        if matched_node_name:
-            self.output_graph = graph_pb2.GraphDef()
-            fusion_name = "".join(matched_rule)
-            if fusion_name in self.fusion_mapping:
-                self.fusion_mapping[fusion_name](matched_node_name)
-            else:
-                if self.new_api:
-                    self.logger.info("Unknown fusion pattern {} .".format(fusion_name))
-                if self.remove_redundant_quant_flag:
-                    self.input_graph = self.remove_redundant_quantization(self.input_graph)
-                return self.input_graph, []
-
-            self.input_graph = self.output_graph
-            self._reset_output_node_maps()
-            if self.remove_redundant_quant_flag:
-                self.output_graph = self.remove_redundant_quantization(self.output_graph)
-            return self.output_graph, []
-        return self.input_graph, []
diff --git a/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_matmul.py b/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_matmul.py
deleted file mode 100644
index 2658bb02f8e..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_matmul.py
+++ /dev/null
@@ -1,1039 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Quantize MatMul/BatchMatMul/BatchMatMulV2."""
-
-import numpy as np
-from tensorflow.core.framework import graph_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper as helper
-
-from ..quantize_graph_base import QuantizeNodeBase
-
-
-class FuseNodeStartWithMatmul(QuantizeNodeBase):
-    """Quantize MatMul/BatchMatMul/BatchMatMulV2 and apply the fusion."""
-
-    exclude_matmul_nodes = []
-
-    def __init__(self, **kwargs):
-        """Initialization."""
-        super().__init__(**kwargs)
-
-        self.sorted_patterns = sorted(self.patterns, key=lambda i: len(i), reverse=True)
-        self.fusion_op_type = set(fusion[1] for fusion in self.patterns)
-
-        self.fusion_mapping = {
-            "DequantizeMatMulBiasAddQuantizeV2": self.apply_matmul_biasadd_fusion,
-            "DequantizeMatMulQuantizeV2": self.apply_matmul_biasadd_fusion,
-            "DequantizeMatMulBiasAddAddQuantizeV2": self.apply_matmul_biasadd_fusion,
-            "DequantizeMatMulAddQuantizeV2": self.apply_matmul_biasadd_fusion,
-            "DequantizeMatMulBiasAddAddV2QuantizeV2": self.apply_matmul_biasadd_fusion,
-            "DequantizeMatMulAddV2QuantizeV2": self.apply_matmul_biasadd_fusion,
-            "DequantizeMatMulBiasAddReluQuantizeV2": self.apply_matmul_biasadd_relu_fusion,
-            "DequantizeMatMulBiasAddRelu6QuantizeV2": self.apply_matmul_biasadd_relu_fusion,
-            "DequantizeMatMulBiasAddLeakyReluQuantizeV2": self.apply_matmul_biasadd_relu_fusion,
-            "DequantizeMatMulBiasAddGeluQuantizeV2": self.apply_matmul_biasadd_relu_fusion,
-            "DequantizeMatMulBiasAddEluQuantizeV2": self.apply_matmul_biasadd_relu_fusion,
-            "DequantizeMatMulBiasAddTanhQuantizeV2": self.apply_matmul_biasadd_relu_fusion,
-            "DequantizeMatMulBiasAddSigmoidQuantizeV2": self.apply_matmul_biasadd_relu_fusion,
-            "DequantizeMatMulReluQuantizeV2": self.apply_matmul_biasadd_relu_fusion,
-            "DequantizeMatMulRelu6QuantizeV2": self.apply_matmul_biasadd_relu_fusion,
-            "DequantizeMatMulLeakyReluQuantizeV2": self.apply_matmul_biasadd_relu_fusion,
-            "DequantizeMatMulGeluQuantizeV2": self.apply_matmul_biasadd_relu_fusion,
-            "DequantizeMatMulEluQuantizeV2": self.apply_matmul_biasadd_relu_fusion,
-            "DequantizeMatMulTanhQuantizeV2": self.apply_matmul_biasadd_relu_fusion,
-            "DequantizeMatMulSigmoidQuantizeV2": self.apply_matmul_biasadd_relu_fusion,
-            "DequantizeBatchMatMulQuantizeV2": self.apply_batchmatmulv2_fusion,
-            "DequantizeBatchMatMulV2QuantizeV2": self.apply_batchmatmulv2_fusion,
-            "DequantizeBatchMatMulMulQuantizeV2": self.apply_batchmatmulv2_mul_add_fusion,
-            "DequantizeBatchMatMulV2MulQuantizeV2": self.apply_batchmatmulv2_mul_add_fusion,
-            "DequantizeBatchMatMulAddQuantizeV2": self.apply_batchmatmulv2_mul_add_fusion,
-            "DequantizeBatchMatMulV2AddQuantizeV2": self.apply_batchmatmulv2_mul_add_fusion,
-            "DequantizeBatchMatMulAddV2QuantizeV2": self.apply_batchmatmulv2_mul_add_fusion,
-            "DequantizeBatchMatMulV2AddV2QuantizeV2": self.apply_batchmatmulv2_mul_add_fusion,
-            "DequantizeBatchMatMulMulAddV2QuantizeV2": self.apply_batchmatmulv2_mul_add_fusion,
-            "DequantizeBatchMatMulV2MulAddV2QuantizeV2": self.apply_batchmatmulv2_mul_add_fusion,
-            "DequantizeBatchMatMulMulAddQuantizeV2": self.apply_batchmatmulv2_mul_add_fusion,
-            "DequantizeBatchMatMulV2MulAddQuantizeV2": self.apply_batchmatmulv2_mul_add_fusion,
-        }
-
-    def apply_matmul_biasadd_relu_fusion(self, match_node_name):
-        """Apply dequantize + matmul + biasadd + activation + quantizev2 fusion.
-
-        Dequantize + MatMul + BiasAdd + Relu + QuantizeV2
-        Dequantize + MatMul + Relu + QuantizeV2
-        Dequantize + MatMul + BiasAdd + Relu6 + QuantizeV2
-        Dequantize + MatMul + Relu6 + QuantizeV2
-        Dequantize + MatMul + BiasAdd + LeakyRelu + QuantizeV2
-        Dequantize + MatMul + LeakyRelu + QuantizeV2
-        Dequantize + MatMul + BiasAdd + Gelu + QuantizeV2
-        Dequantize + MatMul + Gelu + QuantizeV2
-        Dequantize + MatMul + BiasAdd + Elu + QuantizeV2
-        Dequantize + MatMul + Elu + QuantizeV2
-        Dequantize + MatMul + BiasAdd + Tanh + QuantizeV2
-        Dequantize + MatMul + Tanh + QuantizeV2
-        Dequantize + MatMul + BiasAdd + Sigmoid + QuantizeV2
-        Dequantize + MatMul + Sigmoid + QuantizeV2
-        """
-        matched_node = self.node_name_mapping[match_node_name[1]]
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-
-        # QDQ inserted for input0 in phase 1
-        _, q_inputs = self._get_node_input(normal_inputs[0])
-
-        # Three scenarios to quantize input1:
-        #   a. weight node is const, insert QDQ directly in phase 1
-        #   b. weight node is non-const, insert QDQ directly in phase 1
-        #   c. weight node is 'Enter' and its parent node is const,
-        #      not insert QDQ in phase 1 for easy handling
-        weight_name = normal_inputs[1]
-        weight_node = self.node_name_mapping[helper.node_name_from_input(weight_name)].node
-        enter_node = None
-        quantizev2_weights_name = None
-        weights_min_name = None
-        weights_max_name = None
-        # no QDQ inserted for 'Enter' node in phase 1
-        if weight_node.op == "Enter":  # pragma: no cover
-            parent_node = self.node_name_mapping[helper.node_name_from_input(weight_node.input[0])].node
-            # FIXME We only quantize the MatMul op which second input node type is const. This is a
-            # workaround for RNN model like LTSM.
-            if parent_node.op != "Const":
-                self.logger.debug("The weight node of matched_node {} is not Const or Const + Enter, skipped")
-                self.exclude_matmul_nodes.append(matched_node.node.name)
-                self.output_graph = self.input_graph
-                return []
-            enter_node = weight_node
-            weight_node = parent_node
-            weight_name = weight_node.name
-        # QDQ inserted for other weight nodes in phase 1
-        else:
-            _, q_weights_inputs = self._get_node_input(weight_name)
-            quantizev2_weights_name = q_weights_inputs[0]
-
-            _, weights_name = self._get_node_input(quantizev2_weights_name)
-            weights_min_name = weights_name[1]
-            weights_max_name = weights_name[2]
-            weight_node = self.node_name_mapping[helper.node_name_from_input(weights_name[0])].node
-            weight_name = weight_node.name
-
-        if weight_node.op == "Const":
-            weights_content = tensor_util.MakeNdarray(weight_node.attr["value"].tensor)
-
-            if np.any(np.isnan(weights_content)):  # pragma: no cover
-                self.exclude_matmul_nodes.append(matched_node.node.name)
-                self.output_graph = self.input_graph
-                return []
-
-        # If weight node non const, can't insert dummy biasadd to do matmul fusion.
-        if weight_node.op != "Const" and len(match_node_name) == 3:
-            self.exclude_matmul_nodes.append(matched_node.node.name)
-            self.output_graph = self.input_graph
-            return []
-
-        second_node = self.node_name_mapping[match_node_name[2]].node
-        skip_node_name = match_node_name[2:]
-
-        need_insert_dummy_biasadd = 1
-        offset = 1
-        if len(match_node_name) == 5:
-            add_a_node_name = helper.node_name_from_input(second_node.input[0])
-            add_a_node = self.node_name_mapping[add_a_node_name].node
-            add_b_node_name = helper.node_name_from_input(second_node.input[1])
-            add_b_node = self.node_name_mapping[add_b_node_name].node
-            if (add_a_node.op != "Const" and add_b_node.op == "Const") or (
-                add_a_node.op != "Const" and add_b_node.op == "Enter"
-            ):
-                need_insert_dummy_biasadd = 0
-                offset = 0
-            if need_insert_dummy_biasadd:
-                self.apply_matmul_biasadd_fusion(match_node_name[:2] + [match_node_name[-1]])
-                return match_node_name[1:2]
-
-        if weight_node.op == "Const":
-            q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-                matched_node.node.op, self.node_name_mapping[weight_name].node, self.per_channel, enter_node
-            )
-            if weights_min_name:
-                skip_node_name.append(weights_min_name)
-            if weights_max_name:
-                skip_node_name.append(weights_max_name)
-            if quantizev2_weights_name:
-                skip_node_name.append(quantizev2_weights_name)
-            skip_node_name.append(weight_name)
-        else:
-            q_weights_name = q_weights_inputs[0]
-            q_weights_min_name = q_weights_inputs[1]
-            q_weights_max_name = q_weights_inputs[2]
-
-        skip_node_name.append(normal_inputs[0])
-        if enter_node:  # pragma: no cover
-            skip_node_name.append(enter_node.name)
-        else:
-            skip_node_name.append(normal_inputs[1])
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                pass
-            elif node.name == match_node_name[1]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-
-                quantized_node_name = node.name + "_eightbit_quantized_mat_mul"
-                if need_insert_dummy_biasadd and weight_node.op == "Const":
-                    t_b_index = 0 if matched_node.node.attr["transpose_b"].b else 1
-                    weights_content = tensor_util.MakeNdarray(weight_node.attr["value"].tensor)
-                    bias_size = weights_content.shape[t_b_index]
-                    bias_node_name = node.name + "_fake_bias"
-                    bias_node = helper.create_constant_node(
-                        bias_node_name, [0] * bias_size, dtypes.float32, shape=[bias_size]
-                    )
-
-                    if enter_node:  # pragma: no cover
-                        bias_enter_node = helper.create_node("Enter", bias_node_name + "_enter", [bias_node_name])
-                        helper.set_attr_string(bias_enter_node, "frame_name", enter_node.attr["frame_name"].s)
-                        helper.set_attr_dtype(bias_enter_node, "T", dtypes.float32)
-                        helper.set_attr_bool(bias_enter_node, "is_constant", True)
-                        helper.set_attr_int(
-                            bias_enter_node, "parallel_iterations", enter_node.attr["parallel_iterations"].i
-                        )
-
-                        self.add_output_graph_node(bias_enter_node)
-                        bias_node_name = bias_enter_node.name
-
-                    self.add_output_graph_node(bias_node)
-                else:
-                    bias_node_name = self.node_name_mapping[match_node_name[2]].node.input[1]
-                relu_node_name = match_node_name[3 - offset]
-
-                all_input_names = q_inputs[:1] + [q_weights_name] + q_inputs[1:]
-                all_input_names.append(q_weights_min_name)
-                all_input_names.append(q_weights_max_name)
-                quantized_node_input_names = (
-                    all_input_names[:2] + [bias_node_name] + all_input_names[2:] + control_inputs
-                )
-
-                quantized_matmul_node = helper.create_node(
-                    "_QuantizedMatMul", quantized_node_name, quantized_node_input_names
-                )
-                helper.copy_attr(quantized_matmul_node, "transpose_a", node.attr["transpose_a"])
-                helper.copy_attr(quantized_matmul_node, "transpose_b", node.attr["transpose_b"])
-                helper.set_attr_dtype(quantized_matmul_node, "T1", dtypes.quint8)
-                helper.set_attr_dtype(quantized_matmul_node, "T2", dtypes.qint8)
-                helper.set_attr_dtype(quantized_matmul_node, "Tout", dtypes.qint32)
-                helper.set_attr_string(
-                    quantized_matmul_node, "input_quant_mode", b"MIN_FIRST" if self.is_asymmetric else b"SCALED"
-                )
-                helper.set_attr_string(
-                    quantized_matmul_node, "output_quant_mode", b"MIN_FIRST" if self.is_asymmetric else b"SCALED"
-                )
-                if self.node_name_mapping[relu_node_name].node.op == "Relu":
-                    helper.set_attr_string_list(quantized_matmul_node, "fused_ops", [b"BiasAdd", b"Relu"])
-                elif self.node_name_mapping[relu_node_name].node.op == "Relu6":
-                    helper.set_attr_string_list(quantized_matmul_node, "fused_ops", [b"BiasAdd", b"Relu6"])
-                elif self.node_name_mapping[relu_node_name].node.op == "LeakyRelu":
-                    helper.set_attr_string_list(quantized_matmul_node, "fused_ops", [b"BiasAdd", b"LeakyRelu"])
-                elif self.node_name_mapping[relu_node_name].node.op == "Gelu":
-                    if self.node_name_mapping[relu_node_name].node.attr["approximate"].b:
-                        helper.set_attr_string_list(
-                            quantized_matmul_node, "fused_ops", [b"BiasAdd", b"GeluApproximate"]
-                        )
-                    else:
-                        helper.set_attr_string_list(quantized_matmul_node, "fused_ops", [b"BiasAdd", b"GeluExact"])
-                elif self.node_name_mapping[relu_node_name].node.op == "Elu":
-                    helper.set_attr_string_list(quantized_matmul_node, "fused_ops", [b"BiasAdd", b"Elu"])
-                elif self.node_name_mapping[relu_node_name].node.op == "Tanh":
-                    helper.set_attr_string_list(quantized_matmul_node, "fused_ops", [b"BiasAdd", b"Tanh"])
-                elif self.node_name_mapping[relu_node_name].node.op == "Sigmoid":
-                    helper.set_attr_string_list(quantized_matmul_node, "fused_ops", [b"BiasAdd", b"Sigmoid"])
-                helper.set_attr_dtype(quantized_matmul_node, "Tbias", dtypes.float32)
-                helper.set_attr_dtype(quantized_matmul_node, "U", dtypes.float32)
-
-                helper.set_attr_type_list(
-                    quantized_matmul_node,
-                    "Thost_inputs",
-                    [
-                        dtypes.quint8.as_datatype_enum,
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                helper.set_attr_type_list(
-                    quantized_matmul_node,
-                    "Thost_outputs",
-                    [dtypes.qint32.as_datatype_enum, dtypes.float32.as_datatype_enum, dtypes.float32.as_datatype_enum],
-                )
-
-                self.add_output_graph_node(quantized_matmul_node)
-
-                quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtypes.quint8, False)
-                self._intel_cpu_add_dequantize_result_node(
-                    quantize_down_name, relu_node_name, performance_only=self.performance_only
-                )
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                matmul_node = self.node_name_mapping[match_node_name[1]].node
-                matmul_node_output = self.node_name_mapping[match_node_name[1]].output
-                if new_node.name in matmul_node_output:
-                    for idx, node_input in enumerate(new_node.input):
-                        if helper.node_name_from_input(node_input) == matmul_node.name:
-                            new_node.input[idx] = node_input.replace(matmul_node.name, quantized_node_name)
-                self.add_output_graph_node(new_node)
-        return match_node_name
-
-    def apply_matmul_biasadd_fusion(self, match_node_name):
-        """Apply dequantize + matmul + biasadd + quantizev2 fusion.
-
-        Dequantize + MatMul + QuantizeV2
-        Dequantize + MatMul + BiasAdd + QuantizeV2
-        Dequantize + MatMul + Add + QuantizeV2
-        Dequantize + MatMul + BiasAdd + Add + QuantizeV2
-        Dequantize + MatMul + AddV2 + QuantizeV2
-        Dequantize + MatMul + BiasAdd + AddV2 + QuantizeV2
-        """
-        skip_node_name = match_node_name[2:]
-        matched_node = self.node_name_mapping[match_node_name[1]]
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-
-        # QDQ inserted for input0 in phase 1
-        _, q_inputs = self._get_node_input(normal_inputs[0])
-
-        weight_name = normal_inputs[1]
-        weight_node = self.node_name_mapping[helper.node_name_from_input(weight_name)].node
-        enter_node = None
-        weights_min_name = None
-        weights_max_name = None
-        quantizev2_weights_name = None
-
-        # no QDQ inserted for 'Enter' node in phase 1
-        if weight_node.op == "Enter":  # pragma: no cover
-            parent_node = self.node_name_mapping[helper.node_name_from_input(weight_node.input[0])].node
-            # FIXME We only quantize the MatMul op which second input node type is const. This is a
-            # workaround for RNN model like LTSM.
-            if parent_node.op != "Const":
-                self.logger.debug("The weight node of matched_node {} is not Const or Const + Enter, skipped")
-                self.exclude_matmul_nodes.append(matched_node.node.name)
-                self.output_graph = self.input_graph
-                return []
-            enter_node = weight_node
-            weight_node = parent_node
-            weight_name = weight_node.name
-        # QDQ inserted for other weight nodes in phase 1
-        else:
-            _, q_weights_inputs = self._get_node_input(weight_name)
-            quantizev2_weights_name = q_weights_inputs[0]
-
-            _, weights_name = self._get_node_input(quantizev2_weights_name)
-            weights_min_name = weights_name[1]
-            weights_max_name = weights_name[2]
-            weight_node = self.node_name_mapping[helper.node_name_from_input(weights_name[0])].node
-            weight_name = weight_node.name
-
-        # TODO Remove below two lines once the TF enabled the QuantizedMatMul while
-        # transpose_a could be set to True.
-        if matched_node.node.attr["transpose_a"].b is True:  # pragma: no cover
-            self.exclude_matmul_nodes.append(matched_node.node.name)
-            self.output_graph = self.input_graph
-            return []
-
-        if weight_node.op == "Const":
-            weights_content = tensor_util.MakeNdarray(weight_node.attr["value"].tensor)
-
-            if np.any(np.isnan(weights_content)):  # pragma: no cover
-                self.exclude_matmul_nodes.append(matched_node.node.name)
-                self.output_graph = self.input_graph
-                return []
-
-        len_output = len(matched_node.output)
-        is_shared_output = False
-        if len_output == 2:
-            if (
-                self.node_name_mapping[matched_node.output[0]].node.op == "Reshape"
-                or self.node_name_mapping[matched_node.output[1]].node.op == "Reshape"
-            ):
-                is_shared_output = False
-            else:
-                is_shared_output = True
-        elif len_output > 1:
-            is_shared_output = True
-
-        single_matmul_fusion = True
-        if len(match_node_name) == 3:
-            if is_shared_output:
-                self.output_graph = self.input_graph
-                self.exclude_matmul_nodes.append(matched_node.node.name)
-                return []
-        else:
-            second_node = self.node_name_mapping[match_node_name[2]].node
-            add_a_node_name = helper.node_name_from_input(second_node.input[0])
-            add_a_node = self.node_name_mapping[add_a_node_name].node
-            add_b_node_name = helper.node_name_from_input(second_node.input[1])
-            add_b_node = self.node_name_mapping[add_b_node_name].node
-            if (add_a_node.op != "Const" and add_b_node.op == "Const") or (
-                add_a_node.op != "Const" and add_b_node.op == "Enter"
-            ):
-                single_matmul_fusion = False
-            else:
-                return self.apply_matmul_biasadd_fusion(match_node_name[:2] + [match_node_name[-1]])
-
-        sum_node_name = ""
-        if len(match_node_name) == 4:
-            if self.node_name_mapping[match_node_name[2]].node.op in ("Add", "AddV2"):
-                sum_index = 1 if match_node_name[1] == self.node_name_mapping[match_node_name[2]].node.input[0] else 0
-                sum_node_name = self.node_name_mapping[match_node_name[2]].node.input[sum_index]
-                deq_node = self.node_name_mapping[sum_node_name].node
-                if deq_node.op != "Dequantize" or deq_node.op.find("Quantize") != -1:
-                    return self.apply_matmul_biasadd_fusion(match_node_name[:2] + [match_node_name[-1]])
-        if len(match_node_name) == 5:
-            if self.node_name_mapping[match_node_name[3]].node.op in ("Add", "AddV2"):
-                sum_index = 1 if match_node_name[2] == self.node_name_mapping[match_node_name[3]].node.input[0] else 0
-                sum_node_name = self.node_name_mapping[match_node_name[3]].node.input[sum_index]
-                deq_node = self.node_name_mapping[sum_node_name].node
-                if deq_node.op != "Dequantize" or deq_node.op.find("Quantize") != -1:
-                    return self.apply_matmul_biasadd_fusion(match_node_name[:3] + [match_node_name[-1]])
-
-        if weight_node.op == "Const":
-            q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-                matched_node.node.op, self.node_name_mapping[weight_name].node, self.per_channel, enter_node
-            )
-            if weights_min_name:
-                skip_node_name.append(weights_min_name)
-            if weights_max_name:
-                skip_node_name.append(weights_max_name)
-            if quantizev2_weights_name:
-                skip_node_name.append(quantizev2_weights_name)
-            skip_node_name.append(weight_name)
-        else:
-            q_weights_name = q_weights_inputs[0]
-            q_weights_min_name = q_weights_inputs[1]
-            q_weights_max_name = q_weights_inputs[2]
-
-        skip_node_name.append(normal_inputs[0])
-        if enter_node:
-            if len(self.node_name_mapping[helper.node_name_from_input(enter_node.name)].output) == 1:
-                skip_node_name.append(enter_node.name)
-        else:
-            skip_node_name.append(normal_inputs[1])
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                pass
-            elif node.name == match_node_name[1]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-
-                quantized_node_name = node.name + "_eightbit_quantized_mat_mul"
-                all_input_names = q_inputs[:1] + [q_weights_name] + q_inputs[1:]
-                all_input_names.append(q_weights_min_name)
-                all_input_names.append(q_weights_max_name)
-
-                if single_matmul_fusion:
-                    if sum_node_name:
-                        quantized_node_input_names = (
-                            all_input_names[:2] + [sum_node_name] + all_input_names[2:] + control_inputs
-                        )
-                    else:
-                        quantized_node_input_names = all_input_names[:2] + all_input_names[2:] + control_inputs
-                else:
-                    bias_node_name = self.node_name_mapping[match_node_name[2]].node.input[1]
-                    if sum_node_name:
-                        quantized_node_input_names = (
-                            all_input_names[:2]
-                            + [bias_node_name]
-                            + [sum_node_name]
-                            + all_input_names[2:]
-                            + control_inputs
-                        )
-                    else:
-                        quantized_node_input_names = (
-                            all_input_names[:2] + [bias_node_name] + all_input_names[2:] + control_inputs
-                        )
-
-                quantized_matmul_node = helper.create_node(
-                    "_QuantizedMatMul", quantized_node_name, quantized_node_input_names
-                )
-                helper.copy_attr(quantized_matmul_node, "transpose_a", node.attr["transpose_a"])
-                helper.copy_attr(quantized_matmul_node, "transpose_b", node.attr["transpose_b"])
-                helper.set_attr_dtype(quantized_matmul_node, "T1", dtypes.quint8)
-                helper.set_attr_dtype(quantized_matmul_node, "T2", dtypes.qint8)
-                helper.set_attr_dtype(quantized_matmul_node, "Tout", dtypes.qint32)
-                helper.set_attr_dtype(quantized_matmul_node, "U", dtypes.float32)
-                helper.set_attr_string(
-                    quantized_matmul_node, "input_quant_mode", b"MIN_FIRST" if self.is_asymmetric else b"SCALED"
-                )
-                helper.set_attr_string(
-                    quantized_matmul_node, "output_quant_mode", b"MIN_FIRST" if self.is_asymmetric else b"SCALED"
-                )
-                helper.set_attr_dtype(quantized_matmul_node, "Tbias", dtypes.float32)
-                if sum_node_name:
-                    helper.set_attr_string_list(quantized_matmul_node, "fused_ops", [b"BiasAdd", b"Add"])
-                    helper.set_attr_type_list(
-                        quantized_matmul_node,
-                        "Thost_inputs",
-                        [
-                            dtypes.quint8.as_datatype_enum,
-                            dtypes.qint8.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                        ],
-                    )
-                else:
-                    if not single_matmul_fusion:
-                        helper.set_attr_string_list(quantized_matmul_node, "fused_ops", [b"BiasAdd"])
-                        helper.set_attr_type_list(
-                            quantized_matmul_node,
-                            "Thost_inputs",
-                            [
-                                dtypes.quint8.as_datatype_enum,
-                                dtypes.qint8.as_datatype_enum,
-                                dtypes.float32.as_datatype_enum,
-                                dtypes.float32.as_datatype_enum,
-                                dtypes.float32.as_datatype_enum,
-                                dtypes.float32.as_datatype_enum,
-                                dtypes.float32.as_datatype_enum,
-                            ],
-                        )
-                    else:
-                        helper.set_attr_type_list(
-                            quantized_matmul_node,
-                            "Thost_inputs",
-                            [
-                                dtypes.quint8.as_datatype_enum,
-                                dtypes.qint8.as_datatype_enum,
-                                dtypes.float32.as_datatype_enum,
-                                dtypes.float32.as_datatype_enum,
-                                dtypes.float32.as_datatype_enum,
-                                dtypes.float32.as_datatype_enum,
-                            ],
-                        )
-                helper.set_attr_type_list(
-                    quantized_matmul_node,
-                    "Thost_outputs",
-                    [dtypes.qint32.as_datatype_enum, dtypes.float32.as_datatype_enum, dtypes.float32.as_datatype_enum],
-                )
-
-                self.add_output_graph_node(quantized_matmul_node)
-                requantize_type = dtypes.qint8
-
-                quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, requantize_type, False)
-                if sum_node_name:
-                    self._intel_cpu_add_dequantize_result_node(
-                        quantize_down_name,
-                        match_node_name[2] if single_matmul_fusion else match_node_name[3],
-                        requantize_type,
-                        performance_only=self.performance_only,
-                    )
-                else:
-                    self._intel_cpu_add_dequantize_result_node(
-                        quantize_down_name,
-                        match_node_name[1] if single_matmul_fusion else match_node_name[2],
-                        requantize_type,
-                        performance_only=self.performance_only,
-                    )
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-        return match_node_name
-
-    def apply_batchmatmulv2_fusion(self, match_node_name):  # pragma: no cover
-        """Apply dequantize + batchmatmul/batchmatmulv2 + quantizev2 fusion.
-
-        Dequantize + BatchMatMulV2 + QuantizeV2
-        """
-        skip_node_name = match_node_name[2:]
-        matched_node = self.node_name_mapping[match_node_name[1]]
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-
-        _, q_x_inputs = self._get_node_input(normal_inputs[0])
-        quantizev2_input_name = q_x_inputs[0]
-        weight_name = normal_inputs[1]
-        weight_node = self.node_name_mapping[helper.node_name_from_input(weight_name)].node
-        enter_node = None
-        weights_min_name = None
-        weights_max_name = None
-        quantizev2_y_name = None
-
-        if weight_node.op == "Enter":
-            parent_node = self.node_name_mapping[helper.node_name_from_input(weight_node.input[0])].node
-            # FIXME We only quantize the MatMul op which second input node type is const. This is a
-            # workaround for RNN model like LTSM.
-            if parent_node.op != "Const":
-                self.logger.debug("The weight node of matched_node {} is not Const or Const + Enter, skipped")
-                self.exclude_matmul_nodes.append(matched_node.node.name)
-                self.output_graph = self.input_graph
-                return []
-            enter_node = weight_node
-            weight_node = parent_node
-            weight_name = weight_node.name
-        else:
-            _, q_y_inputs = self._get_node_input(normal_inputs[1])
-            quantizev2_y_name = q_y_inputs[0]
-            _, weights_name = self._get_node_input(quantizev2_y_name)
-            weights_min_name = weights_name[1]
-            weights_max_name = weights_name[2]
-            weight_node = self.node_name_mapping[helper.node_name_from_input(weights_name[0])].node
-            weight_name = weight_node.name
-
-        if weight_node.op == "Const":
-            weights_content = tensor_util.MakeNdarray(weight_node.attr["value"].tensor)
-
-            if np.any(np.isnan(weights_content)):
-                self.output_graph = self.input_graph
-                self.exclude_matmul_nodes.append(matched_node.node.name)
-                return []
-
-            for i in self.node_name_mapping:
-                if (
-                    weight_node.input
-                    and not weight_node.input[0].startswith("^")
-                    and weight_node.name in self.node_name_mapping[i].output
-                ):
-                    self.output_graph = self.input_graph
-                    self.exclude_matmul_nodes.append(matched_node.node.name)
-                    return []
-
-            q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-                matched_node.node.op, self.node_name_mapping[weight_name].node, self.per_channel, enter_node
-            )
-
-            if weights_min_name:
-                skip_node_name.append(weights_min_name)
-            if weights_max_name:
-                skip_node_name.append(weights_max_name)
-            if quantizev2_y_name:
-                skip_node_name.append(quantizev2_y_name)
-            skip_node_name.append(weight_name)
-        else:
-            q_weights_name = q_y_inputs[0]
-            q_weights_min_name = q_y_inputs[1]
-            q_weights_max_name = q_y_inputs[2]
-
-        skip_node_name.append(normal_inputs[0])
-        if enter_node:
-            skip_node_name.append(enter_node.name)
-        else:
-            skip_node_name.append(normal_inputs[1])
-
-        batchmatmul_next_node = {}
-        for _, node in enumerate(self.input_graph.node):
-            quantized_node_name = ""
-            if node.name in skip_node_name:
-                pass
-            elif node.name == match_node_name[1]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-
-                quantized_node_name = node.name + "_eightbit_quantized_batch_matmul_v2"
-                all_input_names = [quantizev2_input_name] + [q_weights_name] + q_x_inputs[1:]
-                all_input_names.append(q_weights_min_name)
-                all_input_names.append(q_weights_max_name)
-
-                quantized_node_input_names = all_input_names + control_inputs
-
-                quantized_matmul_node = helper.create_node(
-                    "_QuantizedBatchMatMul", quantized_node_name, quantized_node_input_names
-                )
-
-                helper.copy_attr(quantized_matmul_node, "adj_x", node.attr["adj_x"])
-                helper.copy_attr(quantized_matmul_node, "adj_y", node.attr["adj_y"])
-                helper.set_attr_dtype(quantized_matmul_node, "T1", dtypes.qint8)
-                helper.set_attr_dtype(quantized_matmul_node, "T2", dtypes.qint8)
-                helper.set_attr_dtype(quantized_matmul_node, "U", dtypes.float32)
-                helper.set_attr_dtype(quantized_matmul_node, "Tout", dtypes.float32)
-                helper.set_attr_string(quantized_matmul_node, "input_quant_mode", b"SCALED")
-                helper.set_attr_string(quantized_matmul_node, "output_quant_mode", b"SCALED")
-                helper.set_attr_string_list(quantized_matmul_node, "fused_ops", [b"Dequantize"])
-                helper.set_attr_type_list(
-                    quantized_matmul_node,
-                    "Thost_inputs",
-                    [
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                helper.set_attr_type_list(quantized_matmul_node, "Thost_outputs", [dtypes.float32.as_datatype_enum])
-
-                self.add_output_graph_node(quantized_matmul_node)
-                for i in self.node_name_mapping[node.name].output:
-                    batchmatmul_next_node[i] = (quantized_node_name, node.name)
-            else:
-                new_node = node_def_pb2.NodeDef()
-                if batchmatmul_next_node.get(node.name):
-                    for index, name in enumerate(node.input):
-                        if name == batchmatmul_next_node[node.name][1]:
-                            node.input[index] = batchmatmul_next_node[node.name][0]
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-        return match_node_name
-
-    def apply_batchmatmulv2_mul_add_fusion(self, match_node_name):  # pragma: no cover
-        """Apply dequantize + batchmatmul/batchmatmulv2 + mul + add + quantizev2 fusion.
-
-        Dequantize + BatchMatMulV2 + Mul + QuantizeV2
-        Dequantize + BatchMatMulV2 + Add + QuantizeV2
-        Dequantize + BatchMatMulV2 + AddV2 + QuantizeV2
-        Dequantize + BatchMatMulV2 + Mul + Add + QuantizeV2
-        Dequantize + BatchMatMulV2 + Mul + AddV2 + QuantizeV2
-        """
-        skip_node_name = match_node_name[2:]
-        matched_node = self.node_name_mapping[match_node_name[1]]
-        # oneDNN limitation: add tensor ndim must be 4
-        if len(match_node_name) == 4 and self.node_name_mapping[match_node_name[2]].node.op in ("Add", "AddV2"):
-            add_node_input_name = self.node_name_mapping[match_node_name[2]].node.input[1]
-            if add_node_input_name == matched_node.node.name:
-                add_node_input_name = self.node_name_mapping[match_node_name[2]].node.input[0]
-            add_input_node = self.node_name_mapping[add_node_input_name].node
-            if add_input_node.op != "Const":
-                return self.apply_batchmatmulv2_fusion(match_node_name[:2] + [match_node_name[-1]])
-
-            shape = tensor_util.MakeNdarray(add_input_node.attr["value"].tensor)
-            if shape.ndim != 4:
-                return self.apply_batchmatmulv2_fusion(match_node_name[:2] + [match_node_name[-1]])
-
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-
-        weight_name = normal_inputs[1]
-        weight_node = self.node_name_mapping[helper.node_name_from_input(weight_name)].node
-        _, q_x_inputs = self._get_node_input(normal_inputs[0])
-        enter_node = None
-        weights_min_name = None
-        weights_max_name = None
-        quantizev2_weights_name = None
-        if weight_node.op == "Enter":
-            parent_node = self.node_name_mapping[helper.node_name_from_input(weight_node.input[0])].node
-            # FIXME We only quantize the MatMul op which second input node type is const. This is a
-            # workaround for RNN model like LTSM.
-            if parent_node.op != "Const":
-                self.logger.debug("The weight node of matched_node {} is not Const or Const + Enter, skipped")
-                self.exclude_matmul_nodes.append(matched_node.node.name)
-                self.output_graph = self.input_graph
-                return []
-            enter_node = weight_node
-            weight_node = parent_node
-            weight_name = weight_node.name
-        else:
-            _, q_weights_inputs = self._get_node_input(normal_inputs[1])
-            quantizev2_weights_name = q_weights_inputs[0]
-            _, weights_name = self._get_node_input(quantizev2_weights_name)
-            weights_min_name = weights_name[1]
-            weights_max_name = weights_name[2]
-            weight_node = self.node_name_mapping[helper.node_name_from_input(weights_name[0])].node
-            weight_name = weight_node.name
-
-        if weight_node.op == "Const":
-            weights_content = tensor_util.MakeNdarray(weight_node.attr["value"].tensor)
-
-            if np.any(np.isnan(weights_content)):
-                self.exclude_matmul_nodes.append(matched_node.node.name)
-                self.output_graph = self.input_graph
-                return []
-
-            for i in self.node_name_mapping:
-                if (
-                    weight_node.input
-                    and not weight_node.input[0].startswith("^")
-                    and weight_node.name in self.node_name_mapping[i].output
-                ):
-                    self.output_graph = self.input_graph
-                    self.exclude_matmul_nodes.append(matched_node.node.name)
-                    return []
-
-            q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-                matched_node.node.op, self.node_name_mapping[weight_name].node, self.per_channel, enter_node
-            )
-
-            if weights_min_name:
-                skip_node_name.append(weights_min_name)
-            if weights_max_name:
-                skip_node_name.append(weights_max_name)
-            if quantizev2_weights_name:
-                skip_node_name.append(quantizev2_weights_name)
-            skip_node_name.append(weight_name)
-        else:
-            q_weights_name = q_weights_inputs[0]
-            q_weights_min_name = q_weights_inputs[1]
-            q_weights_max_name = q_weights_inputs[2]
-
-        skip_node_name.append(normal_inputs[0])
-        if enter_node:
-            skip_node_name.append(enter_node.name)
-        else:
-            skip_node_name.append(normal_inputs[1])
-
-        batchmatmul_next_node = {}
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                pass
-            elif node.name == match_node_name[1]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-                quantized_node_name = node.name + "_eightbit_quantized_batch_matmul_v2"
-
-                if len(match_node_name) == 4:
-                    if self.node_name_mapping[match_node_name[2]].node.op == "Mul":
-                        mul_node_name = self.node_name_mapping[match_node_name[2]].node.input[1]
-                        all_input_names = q_x_inputs[:1] + [q_weights_name] + [mul_node_name] + q_x_inputs[1:]
-                        all_input_names.append(q_weights_min_name)
-                        all_input_names.append(q_weights_max_name)
-                    else:
-                        add_node_name = self.node_name_mapping[match_node_name[2]].node.input[1]
-                        all_input_names = q_x_inputs[:1] + [q_weights_name] + [add_node_name] + q_x_inputs[1:]
-                        all_input_names.append(q_weights_min_name)
-                        all_input_names.append(q_weights_max_name)
-                    skip_node_name.append(match_node_name[2])
-                else:
-                    mul_node_name = self.node_name_mapping[match_node_name[2]].node.input[1]
-                    add_node_name = self.node_name_mapping[match_node_name[3]].node.input[1]
-                    skip_node_name.append(match_node_name[2])
-                    skip_node_name.append(match_node_name[3])
-                    all_input_names = (
-                        q_x_inputs[:1] + [q_weights_name] + [mul_node_name] + [add_node_name] + q_x_inputs[1:]
-                    )
-                    all_input_names.append(q_weights_min_name)
-                    all_input_names.append(q_weights_max_name)
-
-                quantized_node_input_names = all_input_names + control_inputs
-
-                quantized_matmul_node = helper.create_node(
-                    "_QuantizedBatchMatMul", quantized_node_name, quantized_node_input_names
-                )
-
-                helper.copy_attr(quantized_matmul_node, "adj_x", node.attr["adj_x"])
-                helper.copy_attr(quantized_matmul_node, "adj_y", node.attr["adj_y"])
-                helper.set_attr_dtype(quantized_matmul_node, "T1", dtypes.qint8)
-                helper.set_attr_dtype(quantized_matmul_node, "T2", dtypes.qint8)
-                helper.set_attr_dtype(quantized_matmul_node, "U", dtypes.float32)
-                helper.set_attr_dtype(quantized_matmul_node, "Tout", dtypes.float32)
-                helper.set_attr_string(quantized_matmul_node, "input_quant_mode", b"SCALED")
-                helper.set_attr_string(quantized_matmul_node, "output_quant_mode", b"SCALED")
-                if len(match_node_name) == 4:
-                    if self.node_name_mapping[match_node_name[2]].node.op == "Mul":
-                        helper.set_attr_string_list(quantized_matmul_node, "fused_ops", [b"Mul", b"Dequantize"])
-                    else:
-                        helper.set_attr_string_list(quantized_matmul_node, "fused_ops", [b"Add", b"Dequantize"])
-                    helper.set_attr_type_list(
-                        quantized_matmul_node,
-                        "Thost_inputs",
-                        [
-                            dtypes.qint8.as_datatype_enum,
-                            dtypes.qint8.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                        ],
-                    )
-                else:
-                    helper.set_attr_string_list(quantized_matmul_node, "fused_ops", [b"Mul", b"Add", b"Dequantize"])
-                    helper.set_attr_type_list(
-                        quantized_matmul_node,
-                        "Thost_inputs",
-                        [
-                            dtypes.qint8.as_datatype_enum,
-                            dtypes.qint8.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                            dtypes.float32.as_datatype_enum,
-                        ],
-                    )
-                helper.set_attr_type_list(quantized_matmul_node, "Thost_outputs", [dtypes.float32.as_datatype_enum])
-
-                self.add_output_graph_node(quantized_matmul_node)
-                attr_fused_ops = "".join(
-                    x
-                    for x in quantized_matmul_node.attr["fused_ops"]
-                    .SerializeToString()
-                    .decode("UTF-8", "ignore")
-                    .strip()
-                    if x.isprintable()
-                )
-                if "MulAdd" in attr_fused_ops:
-                    for i in self.node_name_mapping[match_node_name[3]].output:
-                        batchmatmul_next_node[i] = (quantized_node_name, match_node_name[3])
-                else:
-                    for i in self.node_name_mapping[match_node_name[2]].output:
-                        batchmatmul_next_node[i] = (quantized_node_name, match_node_name[2])
-            else:
-                new_node = node_def_pb2.NodeDef()
-                if batchmatmul_next_node.get(node.name):
-                    for index, name in enumerate(node.input):
-                        if name == batchmatmul_next_node[node.name][1]:
-                            node.input[index] = batchmatmul_next_node[node.name][0]
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-        return match_node_name
-
-    def get_longest_fuse(self):
-        """Get the longest fusion pattern."""
-        self._get_op_list()
-        matched_rule, matched_node_name = self._is_match_matmul(self.sorted_patterns)
-        return matched_rule, matched_node_name
-
-    def apply_the_transform(self):
-        """Quantize MatMul/BatchMatMul/BatchMatMulV2 and apply the fusion pattern."""
-        self._get_op_list()
-        matched_rule, matched_node_name = self._is_match_matmul(self.sorted_patterns, True)
-        if matched_node_name:
-            _, normal_inputs = self._get_node_input(matched_node_name[1])
-        if matched_node_name and self.node_name_mapping[normal_inputs[0]].node.op == matched_node_name[0]:
-            self.output_graph = graph_pb2.GraphDef()
-            fusion_name = "".join(matched_rule)
-            if fusion_name in self.fusion_mapping:
-                _ = self.fusion_mapping[fusion_name](matched_node_name)
-            else:  # pragma: no cover
-                self.logger.debug("Unknown fusion pattern {}.".format(fusion_name))
-                if self.remove_redundant_quant_flag:
-                    self.input_graph = self.remove_redundant_quantization(self.input_graph)
-                return self.input_graph, self.exclude_matmul_nodes
-
-            self.input_graph = self.output_graph
-            self._reset_output_node_maps()
-            if self.remove_redundant_quant_flag:
-                self.output_graph = self.remove_redundant_quantization(self.output_graph)
-            return self.output_graph, self.exclude_matmul_nodes
-
-        if self.remove_redundant_quant_flag:
-            self.input_graph = self.remove_redundant_quantization(self.input_graph)
-        return self.input_graph, self.exclude_matmul_nodes
-
-    def _is_match_matmul(self, patterns, qdq_inserted=False):
-        """Detect the rule matched nodes collections.
-
-        Returns:
-            [List] -- [the matched rule]
-            [String] -- [the list contains the matched node name]
-        """
-        matched_node_name = []
-
-        for k, v in enumerate(self.op_list):
-            if v in set(fusion[1] for fusion in patterns):
-                cur_node = self.node_name_mapping[list(self.node_name_mapping.keys())[k]].node
-                if cur_node.name != self.start_node_name:
-                    continue
-
-                # Disable BatchMatMul quantization temporarily for its bad performance
-                # Enable it again when the performance issue is fixed.
-                if cur_node.op in ("BatchMatMulV2", "BatchMatMul"):
-                    self.exclude_matmul_nodes.append(cur_node.name)
-                    continue
-
-                control_inputs, normal_inputs = self._get_node_input(cur_node.name)
-                weight_name = normal_inputs[1]
-                weight_node = self.node_name_mapping[helper.node_name_from_input(weight_name)].node
-                if not qdq_inserted:
-                    # FIXME We only quantize the MatMul op which second input node type is const.
-                    # This is a workaround for RNN model like LTSM.
-                    parent_node = None
-                    if cur_node.op == "MatMul" and not self.itex_mode:
-                        if control_inputs:  # pragma: no cover
-                            self.exclude_matmul_nodes.append(cur_node.name)
-                            continue
-                        if weight_node.op != "Const":
-                            if weight_node.input:
-                                parent_node = self.node_name_mapping[
-                                    helper.node_name_from_input(weight_node.input[0])
-                                ].node
-                                if weight_node.op == "Enter":  # pragma: no cover
-                                    if len(self.node_name_mapping[helper.node_name_from_input(weight_name)].output) > 1:
-                                        self.exclude_matmul_nodes.append(cur_node.name)
-                                        continue
-                                    if parent_node.op == "Const":
-                                        weight_node = parent_node
-                                        weights_content = tensor_util.MakeNdarray(weight_node.attr["value"].tensor)
-                                        if np.any(np.isnan(weights_content)):
-                                            self.exclude_matmul_nodes.append(cur_node.name)
-                                            continue
-                                    else:
-                                        self.exclude_matmul_nodes.append(cur_node.name)
-                                        continue
-                        else:
-                            weights_content = tensor_util.MakeNdarray(weight_node.attr["value"].tensor)
-                            if np.any(np.isnan(weights_content)):  # pragma: no cover
-                                self.exclude_matmul_nodes.append(cur_node.name)
-                                continue
-
-                        # TODO Remove below two lines once the TF enabled the QuantizedMatMul while
-                        # transpose_a could be set to True.
-                        if cur_node.attr["transpose_a"].b is True:  # pragma: no cover
-                            self.exclude_matmul_nodes.append(cur_node.name)
-                            continue
-
-                for sub_rule in patterns:
-                    if sub_rule[0] != "Dequantize":
-                        self.exclude_matmul_nodes.append(cur_node.name)
-                        continue
-                    if v != sub_rule[1]:
-                        self.exclude_matmul_nodes.append(cur_node.name)
-                        continue
-
-                    if qdq_inserted:
-                        if control_inputs:  # pragma: no cover
-                            self.exclude_matmul_nodes.append(cur_node.name)
-                            continue
-                        if self.node_name_mapping[normal_inputs[0]].node.op != "Dequantize" or self.node_name_mapping[
-                            normal_inputs[1]
-                        ].node.op not in ("Dequantize", "Enter"):
-                            self.exclude_matmul_nodes.append(cur_node.name)
-                            continue
-
-                    sub_rule_len = len(sub_rule) - 2
-                    self.logger.debug("Try to apply rule: {}".format(sub_rule))
-
-                    cur_node_name = list(self.node_name_mapping.keys())[k]
-
-                    matched_node_name.clear()
-                    matched_node_name.append(sub_rule[0])
-                    matched_node_name.append(cur_node_name)
-
-                    while sub_rule_len > 1:
-                        if not self.node_name_mapping[cur_node_name].output:
-                            self.logger.debug("Fail to match {}".format(sub_rule))
-                            break
-
-                        next_node_name = self.node_name_mapping[cur_node_name].output[0]
-
-                        next_node_op = self.node_name_mapping[next_node_name].node.op
-
-                        if next_node_op == sub_rule[-sub_rule_len]:
-                            matched_node_name.append(next_node_name)
-                            sub_rule_len -= 1
-                            cur_node_name = next_node_name
-                        else:
-                            matched_node_name.clear()
-                            self.logger.debug("Fail to match {}.".format(sub_rule))
-                            break
-
-                    if sub_rule_len == 1:
-                        matched_node_name.append(sub_rule[-1])
-                        self.logger.debug("Match {} on nodes {}.".format(sub_rule, matched_node_name))
-                        return sub_rule, matched_node_name
-
-        return None, None
diff --git a/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_pooling.py b/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_pooling.py
deleted file mode 100644
index 591508712aa..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/fuse_qdq_pooling.py
+++ /dev/null
@@ -1,137 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Quantize the AvgPool/MaxPool."""
-
-import tensorflow as tf
-from tensorflow.core.framework import node_def_pb2
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper as helper
-from neural_compressor.tensorflow.utils import version1_eq_version2, version1_gt_version2, version1_lt_version2
-
-from ..quantize_graph_base import QuantizeNodeBase
-
-
-class FuseNodeStartWithPooling(QuantizeNodeBase):
-    """Quantize the AvgPool and MaxPool."""
-
-    def __init__(self, **kwargs):
-        """Initialization."""
-        super().__init__(**kwargs)
-        self.sorted_patterns = sorted(self.patterns, key=lambda i: len(i), reverse=True)
-
-    def _add_pool_function(self, original_node, quantized_op_node):
-        """Set quantized pooling node attributes."""
-        pooling_type = (
-            dtypes.quint8
-            if version1_lt_version2(tf.version.VERSION, "2.6.0") or self._find_relu_node(original_node)
-            else dtypes.qint8
-        )
-        helper.set_attr_dtype(quantized_op_node, "T", pooling_type)
-        helper.copy_attr(quantized_op_node, "ksize", original_node.attr["ksize"])
-        helper.copy_attr(quantized_op_node, "strides", original_node.attr["strides"])
-        helper.copy_attr(quantized_op_node, "padding", original_node.attr["padding"])
-
-    def _apply_pool_quantization(self, match_node_name):
-        """Quantize AvgPool/MaxPool.
-
-        Dequantize + MaxPool + QuantizeV2
-        Dequantize + MaxPool3D + QuantizeV2
-        Dequantize + AvgPool + QuantizeV2
-        """
-        skip_node_name = match_node_name[2:]
-        matched_node = self.node_name_mapping[match_node_name[1]]
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        _, q_inputs = self._get_node_input(normal_inputs[0])
-
-        all_input_names = q_inputs
-        skip_node_name.append(normal_inputs[0])
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[1]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-                quantized_op_name = node.name + "_eightbit_quantized"
-                quantized_op_type = "Quantized" + node.op
-                if node.op == "MaxPool3D":
-                    quantized_op_type = "_Quantized" + node.op
-
-                quantized_pool_node = helper.create_node(quantized_op_type, quantized_op_name, all_input_names)
-
-                self._add_pool_function(node, quantized_pool_node)
-                self.add_output_graph_node(quantized_pool_node)
-                deq_type = dtypes.quint8 if self._find_relu_node(node) else dtypes.qint8
-                self._intel_cpu_add_dequantize_result_node(
-                    quantized_op_name, node.name, dtype=deq_type, performance_only=self.performance_only
-                )
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def get_longest_fuse(self):
-        """Get the longest fusion pattern."""
-        self._get_op_list()
-        matched_node_name = []
-
-        for k, v in enumerate(self.op_list):
-            if v in set(fusion[1] for fusion in self.sorted_patterns):
-                cur_node = self.node_name_mapping[list(self.node_name_mapping.keys())[k]].node
-
-                if cur_node.name != self.start_node_name:
-                    continue
-
-                for sub_rule in self.sorted_patterns:
-                    if sub_rule[0] != "Dequantize" or sub_rule[-1] != "QuantizeV2":
-                        continue
-                    if v != sub_rule[1]:
-                        continue
-                    matched_node_name.clear()
-                    matched_node_name.append(sub_rule[0])
-                    matched_node_name.append(cur_node.name)
-                    matched_node_name.append(sub_rule[-1])
-                    return sub_rule, matched_node_name
-        return None, None
-
-    def apply_the_transform(self):
-        """Quantize AvgPool/MaxPool."""
-        self._get_op_list()
-        matched_rule, matched_node_name = self.get_longest_fuse()
-        if matched_node_name:
-            fusion_name = "".join(matched_rule)
-            if (
-                fusion_name == "DequantizeMaxPoolQuantizeV2"
-                or fusion_name == "DequantizeMaxPool3DQuantizeV2"
-                or fusion_name == "DequantizeAvgPoolQuantizeV2"
-            ):
-                self._apply_pool_quantization(matched_node_name)
-            else:  # pragma: no cover
-                self.logger.info("Unknown fusion pattern {}.".format(fusion_name))
-                if self.remove_redundant_quant_flag:
-                    self.input_graph = self.remove_redundant_quantization(self.input_graph)
-                return self.input_graph, []
-
-            self.input_graph = self.output_graph
-            self._reset_output_node_maps()
-            if self.remove_redundant_quant_flag:
-                self.output_graph = self.remove_redundant_quantization(self.output_graph)
-            return self.output_graph, []
-
-        if self.remove_redundant_quant_flag:
-            self.input_graph = self.remove_redundant_quantization(self.input_graph)
-        return self.input_graph, []
diff --git a/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/optimize_qdq.py b/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/optimize_qdq.py
deleted file mode 100644
index c361a46ced6..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/quantize_graph/qdq/optimize_qdq.py
+++ /dev/null
@@ -1,158 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Fuse the DQ + OP + Q fusion pattern, convert fp32 op to int8."""
-
-from tensorflow.core.framework import graph_pb2
-from tensorflow.python.platform import gfile
-
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from ..quantize_graph_base import QuantizeGraphBase
-from .fuse_qdq_bn import FuseNodeStartWithFusedBatchNormV3
-from .fuse_qdq_concatv2 import FuseNodeStartWithConcatV2
-from .fuse_qdq_conv import FuseNodeStartWithConv2d
-from .fuse_qdq_deconv import FuseNodeStartWithDeconv2d
-from .fuse_qdq_in import FuseNodeStartWithFusedInstanceNorm
-from .fuse_qdq_matmul import FuseNodeStartWithMatmul
-from .fuse_qdq_pooling import FuseNodeStartWithPooling
-
-
-class OptimizeQDQGraph(QuantizeGraphBase):
-    """Apply the fusion DQ + OP + Q pattern."""
-
-    def __init__(
-        self,
-        input_graph,
-        input_node_names,
-        output_node_names,
-        op_wise_config,
-        op_wise_sequences,
-        device,
-        fake_quant=False,
-        new_api=False,
-        performance_only=False,
-        itex_mode=False,
-    ):
-        """Optimize QDQ Graph."""
-        super().__init__(output_node_names)
-        self.op_wise_config = op_wise_config
-        # self.perchannel = perchannel
-        if isinstance(input_graph, graph_pb2.GraphDef):
-            self.input_graph = input_graph
-        else:
-            self.input_graph = graph_pb2.GraphDef()
-            with gfile.Open(input_graph, "rb") as f:
-                self.input_graph.ParseFromString(f.read())
-
-        input_output_names = input_node_names + output_node_names
-        self.input_graph = QuantizeGraphHelper().remove_training_nodes(
-            self.input_graph, protected_nodes=input_output_names
-        )
-
-        self.op_wise_seq = op_wise_sequences
-
-        self.device = device
-        self.fake_quant = fake_quant
-        self.new_api = new_api
-        self.performance_only = performance_only
-        self.itex_mode = itex_mode
-        self.exclude_node_list = []
-
-        self.all_quantizable_node = []
-        self.register_transformer("MaxPool", FuseNodeStartWithPooling)
-        self.register_transformer("MaxPool3D", FuseNodeStartWithPooling)
-        self.register_transformer("Conv2D", FuseNodeStartWithConv2d)
-        self.register_transformer("Conv3D", FuseNodeStartWithConv2d)
-        self.register_transformer("DepthwiseConv2dNative", FuseNodeStartWithConv2d)
-        self.register_transformer("FusedBatchNormV3", FuseNodeStartWithFusedBatchNormV3)
-        self.register_transformer("_MklFusedInstanceNorm", FuseNodeStartWithFusedInstanceNorm)
-        self.register_transformer("AvgPool", FuseNodeStartWithPooling)
-        self.register_transformer("ConcatV2", FuseNodeStartWithConcatV2)
-        self.register_transformer("MatMul", FuseNodeStartWithMatmul)
-        self.register_transformer("BatchMatMul", FuseNodeStartWithMatmul)
-        self.register_transformer("BatchMatMulV2", FuseNodeStartWithMatmul)
-        self.register_transformer("Conv2DBackpropInput", FuseNodeStartWithDeconv2d)
-        self.register_transformer("Conv3DBackpropInputV2", FuseNodeStartWithDeconv2d)
-
-    def get_quantized_nodes(self):
-        """Get the quantized Ops."""
-        count = 0
-        remove_redundant_quant_flag = False
-        op_wise_config_name_list = list(self.op_wise_config.keys())
-        all_node_length = len(self.op_wise_config)
-        for _, node in enumerate(self.input_graph.node):
-            if node in self.input_graph.node and node.op in self.transformers and node.name in self.op_wise_config:
-                count += 1
-                if count == all_node_length:
-                    remove_redundant_quant_flag = True
-                _, quantizable_nodes = self.transformers[node.op](
-                    input_graph=self.input_graph,
-                    patterns=self.op_wise_seq[node.op],
-                    remove_redundant_quant_flag=remove_redundant_quant_flag,
-                    op_wise_config_name_list=op_wise_config_name_list,
-                    op_wise_cfg=self.op_wise_config[node.name],
-                    start_node_name=node.name,
-                    device=self.device,
-                    fake_quant=self.fake_quant,
-                    new_api=self.new_api,
-                    performance_only=self.performance_only,
-                    itex_mode=self.itex_mode,
-                ).get_longest_fuse()
-
-                if quantizable_nodes:
-                    if quantizable_nodes[-1] == "QuantizeV2":
-                        quantizable_nodes.pop()
-                    if quantizable_nodes[0] == "Dequantize":
-                        quantizable_nodes.pop(0)
-                    if node.op in ("ConcatV2", "MaxPool", "MaxPool3D", "AvgPool"):
-                        self.all_quantizable_node.extend([[i] for i in quantizable_nodes])
-                    else:
-                        self.all_quantizable_node.append(quantizable_nodes)
-        return self.all_quantizable_node
-
-    @dump_elapsed_time("Pass OptimizeQDQGraph")
-    def do_transform(self):
-        """Apply all the transformers to fuse into int8 op."""
-        count = 0
-        remove_redundant_quant_flag = False
-        op_wise_config_name_list = list(self.op_wise_config.keys())
-        all_node_length = len(self.op_wise_config)
-        for _, node in enumerate(self.input_graph.node):
-            if node in self.input_graph.node and node.op in self.transformers and node.name in self.op_wise_config:
-                count += 1
-                if count == all_node_length:
-                    remove_redundant_quant_flag = True
-
-                self.input_graph, exclude_nodes = self.transformers[node.op](
-                    input_graph=self.input_graph,
-                    patterns=self.op_wise_seq[node.op],
-                    remove_redundant_quant_flag=remove_redundant_quant_flag,
-                    op_wise_cfg=self.op_wise_config[node.name],
-                    op_wise_config_name_list=op_wise_config_name_list,
-                    start_node_name=node.name,
-                    device=self.device,
-                    fake_quant=self.fake_quant,
-                    new_api=self.new_api,
-                    performance_only=self.performance_only,
-                    itex_mode=self.itex_mode,
-                ).apply_the_transform()
-
-                if exclude_nodes:
-                    self.exclude_node_list.extend(exclude_nodes)
-
-        return self.remove_dead_nodes(self.input_graph, self.output_node_names), self.exclude_node_list
diff --git a/neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_base.py b/neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_base.py
deleted file mode 100644
index 83cac55f9f2..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_base.py
+++ /dev/null
@@ -1,751 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""QuantizeGraph Base Class."""
-
-import logging
-from collections import namedtuple
-
-import tensorflow as tf
-from tensorflow.core.framework import graph_pb2
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper as helper
-from neural_compressor.tensorflow.utils import version1_eq_version2, version1_gt_version2, version1_lt_version2
-
-
-class QuantizeGraphBase:
-    """This is the base class for quantize graph."""
-
-    def __init__(self, output_node_names):
-        """Initilizaiton."""
-        self.output_node_names = output_node_names
-        self.transformers = {}
-
-    def register_transformer(self, node_name, entry):
-        """Register transformers API."""
-        if node_name not in self.transformers:
-            self.transformers[node_name] = {}
-
-        self.transformers[node_name] = entry
-
-    def do_transform(self):
-        """This is the virtual interface need to be implemented by derived class.
-
-        :return:
-        """
-        pass
-
-    def remove_dead_nodes(self, input_graph, output_names):
-        """Removes nodes that are no longer needed for inference from the graph."""
-        return tf.compat.v1.graph_util.extract_sub_graph(input_graph, output_names)
-
-
-class QuantizeNodeBase:
-    """This is the base class for nodes fusion.
-
-    Arguments:
-        object {[type]} -- [description]
-    """
-
-    node_details = namedtuple("node_details", ["node", "output"])
-
-    def __init__(self, **kwargs):
-        """Initilizaiton."""
-        self.logger = logging.getLogger("neural_compressor")
-        input_graph = kwargs["input_graph"]
-
-        assert isinstance(input_graph, graph_pb2.GraphDef)
-
-        self.input_graph = input_graph
-
-        self._parse_graph()
-        self.output_node_maps = {}
-        self.output_graph = graph_pb2.GraphDef()
-        self.quantized_node_dict = {}
-        self.patterns = kwargs["patterns"]
-        self.remove_redundant_quant_flag = kwargs["remove_redundant_quant_flag"]
-        self.fake_quant = kwargs["fake_quant"] if "fake_quant" in kwargs else False
-        self.frame_info = kwargs["frame_info"] if "frame_info" in kwargs else None
-        self.per_channel, self.is_asymmetric = kwargs["op_wise_cfg"][0], kwargs["op_wise_cfg"][2]
-        self.op_wise_config_name_list = kwargs["op_wise_config_name_list"]
-        self.weight_bit = kwargs["op_wise_cfg"][3]
-        self.start_node_name = kwargs["start_node_name"]
-        self.device = kwargs["device"]
-        self.new_api = kwargs["new_api"]
-        self.performance_only = kwargs["performance_only"]
-        self.itex_mode = kwargs["itex_mode"]
-        self.enable_s8 = bool(
-            version1_gt_version2(tf.version.VERSION, "2.1.0")
-            or version1_eq_version2(tf.version.VERSION, "2.1.0")
-            or tf.version.VERSION.find("1.15.0-up") != -1
-        )
-
-    def apply_the_transform(self):
-        """This is the virtual interface to be implemented by derived class.
-
-        :return: transformed graphdef
-        """
-        pass
-
-    def get_longest_fuse(self):
-        """This is the virtual interface to be implemented by derived class."""
-        pass
-
-    def _insert_dummy_biasadd(self, match_node_name, matched_node):  # pragma: no cover
-        """Insert dummy BiasAdd op."""
-        target_node_name = matched_node.node.name
-        matmul_a_node_name = helper.node_name_from_input(matched_node.node.input[0])
-        matmul_a_node = self.node_name_mapping[matmul_a_node_name].node
-        matmul_b_node_name = helper.node_name_from_input(matched_node.node.input[1])
-        matmul_b_node = self.node_name_mapping[matmul_b_node_name].node
-
-        if matmul_a_node.op == "Const" and matmul_b_node.op != "Const":
-            pass
-        else:
-            from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-
-            g = GraphAnalyzer()
-            g.graph = self.input_graph
-            graph_info = g.parse_graph()
-            next_node_names = graph_info[matched_node.node.name].outputs
-            bias_node_name = target_node_name + "_dummy_biasadd"
-            bias_const_node_name = target_node_name + "_fake_const"
-
-            if matched_node.node.op == "MatMul":
-                t_b_index = 0 if matched_node.node.attr["transpose_b"].b else 1
-            if (
-                matched_node.node.op in ("Conv2D" or "DepthwiseConv2dNative")
-                and matched_node.node.attr["data_format"].s == b"NHWC"
-            ):
-                t_b_index = 3
-            elif (
-                matched_node.node.op in ("Conv2D" or "DepthwiseConv2dNative")
-                and matched_node.node.op.attr["data_format"].s == b"NCHW"
-            ):
-                t_b_index = 1
-            elif matched_node.node.op == "Conv3D" and matched_node.node.attr["data_format"].s == b"NDHWC":
-                t_b_index = 4
-            elif matched_node.node.op == "Conv3D" and matched_node.node.attr["data_format"].s == b"NCDHW":
-                t_b_index = 1
-            bias_add_length = matmul_b_node.attr["value"].tensor.tensor_shape.dim[t_b_index].size
-
-            bias_add_content = [0.0] * bias_add_length
-
-            bias_const_node = helper.create_constant_node(
-                bias_const_node_name, bias_add_content, dtypes.float32, shape=[bias_add_length]
-            )
-            bias_node = helper.create_node("BiasAdd", bias_node_name, [target_node_name, bias_const_node_name])
-            helper.set_attr_dtype(bias_node, "T", dtypes.float32)
-
-            g.add_node(bias_node, target_node_name, next_node_names)
-            g.add_node(bias_const_node, None, [bias_node_name])
-            self.input_graph = g.dump_graph()
-            self._parse_graph(self.input_graph)
-            new_match_node_name = match_node_name[:1] + [bias_node_name] + match_node_name[1:]
-            new_match_node_name = match_node_name[:1] + [bias_node_name] + match_node_name[1:]
-
-            return new_match_node_name
-
-    def _is_match(self, patterns):
-        """Detect the rule matched nodes collections.
-
-        Returns:
-            [List] -- [the matched rule]
-            [String] -- [the list contains the matched node name]
-        """
-        matched_node_name = []
-
-        for k, v in enumerate(self.op_list):
-            if v in set(fusion[0] for fusion in patterns):
-                cur_node = self.node_name_mapping[list(self.node_name_mapping.keys())[k]].node
-                if cur_node.name != self.start_node_name:
-                    continue
-
-                if ((v in ("Conv2D", "DepthwiseConv2dNative") and not self.enable_s8)) and not self._find_relu_node(
-                    cur_node
-                ):
-                    continue
-
-                for sub_rule in patterns:
-                    if v != sub_rule[0]:
-                        continue
-
-                    sub_rule_len = len(sub_rule)
-                    check_hardswish = True if sub_rule_len > 4 else False
-                    self.logger.debug("Try to apply rule: {}".format(sub_rule))
-
-                    cur_node_name = list(self.node_name_mapping.keys())[k]
-
-                    matched_node_name.clear()
-
-                    matched_node_name.append(cur_node_name)
-                    count = 0
-                    while sub_rule_len > 1:
-                        if not self.node_name_mapping[cur_node_name].output:
-                            self.logger.debug("Fail to match {}".format(sub_rule))
-                            break
-
-                        next_node_name = self.node_name_mapping[cur_node_name].output[0]
-
-                        is_shared_output = True if len(self.node_name_mapping[cur_node_name].output) > 1 else False
-
-                        add_op_quantizable = True
-                        is_hardswish = False
-                        if is_shared_output:  # pragma: no cover
-                            if next_node_name.find("hard_swish") != -1:
-                                self.logger.debug("Find Hard Swish pattern ......")
-                                is_hardswish = True
-                                count = count + 1
-                                if next_node_name.find("add") == -1:
-                                    next_node_name = self.node_name_mapping[cur_node_name].output[1]
-                            else:
-                                add_op_quantizable = False
-                        next_node_op = self.node_name_mapping[next_node_name].node.op
-
-                        if next_node_op in ("Add", "AddV2", "AddN"):
-                            next_node = self.node_name_mapping[next_node_name].node
-                            next_node_inputs = list(next_node.input)
-                            cur_node_index = next_node_inputs.index(cur_node_name)
-
-                            for index, input_name in enumerate(next_node_inputs):
-                                node_type = self.node_name_mapping[helper.node_name_from_input(input_name)].node.op
-                                if input_name != cur_node_name and index < cur_node_index and node_type != "Dequantize":
-                                    add_op_quantizable = False
-                                    break
-
-                        if add_op_quantizable and next_node_op == sub_rule[1 - sub_rule_len]:
-                            if not is_shared_output:
-                                matched_node_name.append(next_node_name)
-                                sub_rule_len -= 1
-                                cur_node_name = next_node_name
-                            elif is_hardswish and self.new_api:  # pragma: no cover
-                                matched_node_name.append(next_node_name)
-                                sub_rule_len -= 1
-                                cur_node_name = next_node_name
-                            else:
-                                matched_node_name.clear()
-                                self.logger.debug("Fail to match {}.".format(sub_rule))
-                                break
-                        else:
-                            matched_node_name.clear()
-                            self.logger.debug("Fail to match {}.".format(sub_rule))
-                            break
-
-                    if sub_rule_len == 1:
-                        if (
-                            check_hardswish
-                            and sub_rule[-1] == "Mul"
-                            and sub_rule[-2] == "Mul"
-                            and sub_rule[-3] == "Relu6"
-                            and sub_rule[-4] == "Add"
-                            and count != 1
-                        ):
-                            matched_node_name.clear()
-                            self.logger.debug("Fail to match {}.".format(sub_rule))
-                            break
-                        self.logger.debug("Match {} on nodes {}.".format(sub_rule, matched_node_name))
-                        return sub_rule, matched_node_name
-
-        return None, None
-
-    def _need_to_check(self, node_type):
-        """Check op list."""
-        op_list = (
-            "ConcatV2",
-            "Conv2D",
-            "Conv3D",
-            "DepthwiseConv2D",
-            "QuantizeV2",
-            "DepthwiseConv2dNative",
-            "MaxPool",
-            "MaxPool3D",
-            "FusedBatchNormV3",
-            "Requantize",
-            "RequantizePerChannel",
-            "AvgPool",
-            "Pad",
-            "CropAndResize",
-            "Dequantize",
-            "Mean",
-            "MatMul",
-            "BatchMatMulV2",
-            "FakeQuantWithMinMaxVars",
-            "_MklFusedInstanceNorm",
-        )
-        return any([node_type.find(i) != -1 for i in op_list])
-
-    def _find_relu_node(self, node):
-        """Find relu node algorithm to identify the positive input."""
-        # if node.op.find("HardSwish") != -1:
-        #    return False
-        if (
-            node.op in ("Relu", "Relu6")
-            or (
-                node.op.find("AndRelu") != -1
-                and ("alpha" not in node.attr or ("alpha" in node.attr and node.attr["alpha"].f == 0))
-            )
-        ) and (
-            node.op != "Relu"
-            or not self.new_api
-            or not self.performance_only
-            or self.node_name_mapping[helper.node_name_from_input(node.input[0])].node.op.find("FusedBatchNorm") == -1
-            or self.node_name_mapping[helper.node_name_from_input(node.input[0])].node.attr["is_training"].b
-            or len(self.node_name_mapping[helper.node_name_from_input(node.input[0])].output) > 1
-        ):
-            return True
-        elif "T" in node.attr and node.attr["T"].type in (dtypes.quint8, dtypes.uint8):
-            return True
-        elif (
-            node.op.find("QuantizedConv") != -1
-            or node.op.find("QuantizedDepthwiseConv") != -1
-            or node.op.find("QuantizedMatMul") != -1
-        ) and (node.op.find("Relu") == -1 or ("alpha" in node.attr and node.attr["alpha"].f > 0)):
-            return False
-        elif self._need_to_check(node.op):
-            input_node = self.node_name_mapping[helper.node_name_from_input(node.input[0])]
-            return self._find_relu_node(input_node.node)
-        else:
-            return False
-
-    def _reset_output_node_maps(self):
-        """Reset output node maps."""
-        self.output_node_maps = {}
-
-    def _get_op_list(self):
-        """Get the op list."""
-        self.op_list = []
-        for _, v in enumerate(self.node_name_mapping):
-            self.op_list.append(self.node_name_mapping[v].node.op)
-
-    def _get_node_input(self, node_name):
-        """Return control_input name, non-control_input node name."""
-        return [i for i in self.node_name_mapping[node_name].node.input if i[0] == "^"], [
-            i for i in self.node_name_mapping[node_name].node.input if i[0] != "^"
-        ]
-
-    def _intel_cpu_add_dequantize_result_node(
-        self, quantized_output_name, original_node_name, dtype=dtypes.quint8, min_tensor_index=1, performance_only=False
-    ):
-        """Add Dequantize node after the quantized node."""
-        min_max_inputs = [
-            "%s:%s" % (quantized_output_name, min_tensor_index),
-            "%s:%s" % (quantized_output_name, min_tensor_index + 1),
-        ]
-        dequantize_name = original_node_name
-
-        dequantize_node = helper.create_node(
-            "Dequantize", dequantize_name, [quantized_output_name, min_max_inputs[0], min_max_inputs[1]]
-        )
-        helper.set_attr_dtype(dequantize_node, "T", dtype)
-        if performance_only:
-            helper.set_attr_string(dequantize_node, "mode", b"SCALED")
-        else:
-            helper.set_attr_string(dequantize_node, "mode", b"MIN_FIRST" if self.is_asymmetric else b"SCALED")
-        self.add_output_graph_node(dequantize_node)
-
-    def eightbitize_single_input_tensor_node(self, original_node, add_op_function):
-        """Quantize the single input tensor node."""
-        quantized_op_name = original_node.name + "_eightbit_quantized"
-        quantized_op_type = "Quantized" + original_node.op
-        if version1_gt_version2(tf.version.VERSION, "2.7.0") and original_node.op == "MaxPool3D":
-            quantized_op_type = "_Quantized" + original_node.op
-        all_input_names = self._add_eightbit_prologue_nodes(original_node.name)
-        quantized_op_node = helper.create_node(quantized_op_type, quantized_op_name, all_input_names)
-        add_op_function(original_node, quantized_op_node)
-        self.add_output_graph_node(quantized_op_node)
-        deq_type = dtypes.quint8 if self._find_relu_node(original_node) else dtypes.qint8
-        self._intel_cpu_add_dequantize_result_node(quantized_op_name, original_node.name, dtype=deq_type)
-
-    def _add_eightbit_prologue_nodes(self, original_node):
-        """Add quantized prologue nodes."""
-        namespace_prefix = original_node + "_eightbit"
-        reshape_dims_name, reduction_dims_name = self._add_common_quantization_nodes(
-            namespace_prefix, helper.node_name_from_input(self.node_name_mapping[original_node].node.input[0])
-        )
-        input_names = []
-        min_max_names = []
-        for each_input_name in self.node_name_mapping[original_node].node.input[:1]:
-            if each_input_name[0] == "^":
-                continue
-
-            if self.node_name_mapping[original_node].node.op == "MatMul":
-                # mkl ops _MklQuantizedMatMulWithBiasAndRelu|AndRequantize
-                # requires the T1 data type as quint8
-                dtype = dtypes.quint8
-            else:
-                input_node_name = helper.node_name_from_input(each_input_name)
-                if input_node_name in self.output_node_maps:
-                    if self.output_node_maps[input_node_name].op == "Dequantize":
-                        dtype = dtypes.DType(self.output_node_maps[input_node_name].attr["T"].type)
-                    elif self._find_relu_node(self.node_name_mapping[original_node].node):
-                        dtype = dtypes.quint8
-                    else:
-                        dtype = dtypes.qint8
-                else:
-                    dtype = (
-                        dtypes.quint8
-                        if self._find_relu_node(self.node_name_mapping[original_node].node)
-                        else dtypes.qint8
-                    )
-                    if "FusedBatchNorm" in self.node_name_mapping[original_node].node.op:
-                        dtype = dtypes.qint8
-            quantize_input_name, min_input_name, max_input_name = self._eightbitize_input_to_node(
-                namespace_prefix, each_input_name, reshape_dims_name, reduction_dims_name, dtype=dtype
-            )
-            input_names.append(quantize_input_name)
-            min_max_names.append(min_input_name)
-            min_max_names.append(max_input_name)
-        all_input_names = []
-        all_input_names.extend(input_names)
-        if min_max_names:
-            all_input_names.extend(min_max_names)
-
-        for original_input_name in self.node_name_mapping[original_node].node.input:
-            if original_input_name[0] == "^":
-                all_input_names.append(original_input_name)
-        return all_input_names
-
-    def _add_eightbit_prologue_nodes_for_enter(self, original_node, enter_node=None):
-        """Add quantized prologue nodes for control edge case."""
-        namespace_prefix = original_node + "_eightbit"
-        reshape_dims_name, reduction_dims_name = self._add_common_quantization_nodes(
-            namespace_prefix,
-            helper.node_name_from_input(self.node_name_mapping[original_node].node.input[0]),
-            enter_node=enter_node,
-        )
-        input_names = []
-        min_max_names = []
-        enter_input_name = self.node_name_mapping[original_node].node.input[1]
-        if enter_input_name[0] != "^":
-            if self.node_name_mapping[original_node].node.op == "MatMul":
-                # mkl ops _MklQuantizedMatMulWithBiasAndRelu|AndRequantize
-                # requires the T1 data type as quint8
-                dtype = dtypes.quint8
-            else:
-                input_node_name = helper.node_name_from_input(enter_input_name)
-                if input_node_name in self.output_node_maps:
-                    if self.output_node_maps[input_node_name].op == "Dequantize":
-                        dtype = dtypes.DType(self.output_node_maps[input_node_name].attr["T"].type)
-                    elif self._find_relu_node(self.node_name_mapping[original_node].node):
-                        dtype = dtypes.quint8
-                    else:
-                        dtype = dtypes.qint8
-                else:
-                    dtype = (
-                        dtypes.quint8
-                        if self._find_relu_node(self.node_name_mapping[original_node].node)
-                        else dtypes.qint8
-                    )
-                    if "FusedBatchNorm" in self.node_name_mapping[original_node].node.op:
-                        dtype = dtypes.qint8
-            quantize_input_name, min_input_name, max_input_name = self._eightbitize_input_to_node(
-                namespace_prefix, enter_input_name, reshape_dims_name, reduction_dims_name, dtype=dtype
-            )
-            input_names.append(quantize_input_name)
-            min_max_names.append(min_input_name)
-            min_max_names.append(max_input_name)
-
-        all_input_names = []
-        all_input_names.extend(input_names)
-        if min_max_names:
-            all_input_names.extend(min_max_names)
-
-        for original_input_name in self.node_name_mapping[original_node].node.input:
-            if original_input_name[0] == "^":
-                all_input_names.append(original_input_name)
-        return all_input_names
-
-    def _add_common_quantization_nodes(self, namespace_prefix, control_input_names=None, enter_node=None):
-        """Builds constant nodes needed for quantization of inputs."""
-        reshape_dims_name = namespace_prefix + "_reshape_dims"
-        reduction_dims_name = namespace_prefix + "_reduction_dims"
-
-        reshape_dims_node = helper.create_constant_node(reshape_dims_name, -1, dtypes.int32, [1])
-
-        if enter_node:  # pragma: no cover
-            reshape_dims_enter_node = helper.create_node("Enter", reshape_dims_name + "_enter", [reshape_dims_name])
-            helper.set_attr_string(reshape_dims_enter_node, "frame_name", enter_node.attr["frame_name"].s)
-            helper.set_attr_dtype(reshape_dims_enter_node, "T", dtypes.int32)
-            helper.set_attr_bool(reshape_dims_enter_node, "is_constant", True)
-            helper.set_attr_int(
-                reshape_dims_enter_node, "parallel_iterations", enter_node.attr["parallel_iterations"].i
-            )
-            self.add_output_graph_node(reshape_dims_enter_node)
-
-        self.add_output_graph_node(reshape_dims_node)
-        reduction_dims_node = helper.create_constant_node(reduction_dims_name, 0, dtypes.int32, [1])
-
-        if enter_node:  # pragma: no cover
-            reduction_dims_enter_node = helper.create_node(
-                "Enter", reduction_dims_name + "_enter", [reduction_dims_name]
-            )
-            helper.set_attr_string(reduction_dims_enter_node, "frame_name", enter_node.attr["frame_name"].s)
-            helper.set_attr_dtype(reduction_dims_enter_node, "T", dtypes.int32)
-            helper.set_attr_bool(reduction_dims_enter_node, "is_constant", True)
-            helper.set_attr_int(
-                reduction_dims_enter_node, "parallel_iterations", enter_node.attr["parallel_iterations"].i
-            )
-            self.add_output_graph_node(reduction_dims_enter_node)
-
-        self.add_output_graph_node(reduction_dims_node)
-        return (
-            reshape_dims_enter_node.name if enter_node else reshape_dims_name,
-            reduction_dims_enter_node.name if enter_node else reduction_dims_name,
-        )
-
-    def add_output_graph_node(self, output_node):
-        """Inserts one node into the new graph."""
-        assert output_node.name not in self.output_node_maps
-        self.output_node_maps[output_node.name] = output_node
-        self.output_graph.node.extend([output_node])
-
-    def _parse_graph(self, input_graph=None):
-        """Parse the graph and get the input node and output node name details."""
-        self.logger.debug("Start to parse graph.")
-
-        graph = self.input_graph if input_graph is None else input_graph
-        self.node_name_mapping = {}
-
-        for node in graph.node:
-            # each_node = self.node_details(node=node,  output=[])
-            if node.name in self.node_name_mapping:
-                raise ValueError("Duplicate Node Found when _parse_graph, the node name is {}".format(node.name))
-            self.node_name_mapping[node.name] = self.node_details(node=node, output=[])
-        for node_name in self.node_name_mapping:
-            for each_input in self.node_name_mapping[node_name].node.input:
-                self.node_name_mapping[helper.node_name_from_input(each_input)].output.append(node_name)
-
-    def remove_redundant_quantization(self, old_graph):
-        """Remove the redundant Quantize/QuantizeV2 nodes."""
-        old_nodes_map = self.create_nodes_map(old_graph)
-        self.output_graph = graph_pb2.GraphDef()
-        inputs_to_rename = {}
-        # We go through all the nodes, looking for any that match the patterns we
-        # know how to optimize away.
-        for node in old_graph.node:
-            # We always start with a Quantize node, and examine its inputs to see if
-            # they are in a form that can be removed.
-            if node.op not in ["Quantize", "QuantizeV2"]:
-                continue
-
-            dequantize_node_name = helper.node_name_from_input(node.input[0])
-
-            assert dequantize_node_name in old_nodes_map, (
-                "Input node name '" + dequantize_node_name + "' not found in node '" + node.name + "'"
-            )
-
-            dequantize_node = old_nodes_map[dequantize_node_name]
-            # Do we have a Dequantize feeding in, with the same type as the
-            # Quantize?
-            if dequantize_node.op != "Dequantize":
-                continue
-
-            if node.attr["T"] != dequantize_node.attr["T"]:
-                continue
-
-            # Now look at the other inputs, and ensure they're Min/Max nodes.
-            min_node_name = helper.node_name_from_input(node.input[1])
-            max_node_name = helper.node_name_from_input(node.input[2])
-            min_node = old_nodes_map[min_node_name]
-            max_node = old_nodes_map[max_node_name]
-            is_min_right_type = min_node.op in ["Min", "Dequantize"]
-            is_max_right_type = max_node.op in ["Max", "Dequantize"]
-            if not is_min_right_type or not is_max_right_type:
-                self.logger.info("Not find expected types on inputs {}, {}.".format(min_node.op, max_node.op))
-                continue
-            min_node_input_name = helper.node_name_from_input(min_node.input[0])
-            max_node_input_name = helper.node_name_from_input(max_node.input[0])
-            # There are two different patterns for Min nodes we can recognize, one
-            # where the input comes directly from the same one as the Max, and
-            # another where we run it through another Min first, so check for
-            # both.
-            is_same_input = False
-            if min_node_input_name == max_node_input_name:
-                is_same_input = True
-            else:
-                first_min_node_input = old_nodes_map[min_node_input_name]
-                if first_min_node_input.op == "Concat":
-                    second_min_node_name = helper.node_name_from_input(first_min_node_input.input[1])
-                    second_min_node = old_nodes_map[second_min_node_name]
-                    if second_min_node.op == "Min":
-                        second_min_node_input_name = helper.node_name_from_input(second_min_node.input[0])
-                        is_same_input = second_min_node_input_name == max_node_input_name
-            if not is_same_input:
-                self.logger.info("Different min/max inputs {}.".format(min_node_input_name))
-                continue
-            # We recognize this pattern, so mark the graph edges to be rewired to
-            # route around it entirely, since we know it's a no-op.
-            dequantize_source_name = helper.node_name_from_input(dequantize_node.input[0])
-            node_tensor_name = helper.ensure_tensor_name_has_port(node.name)
-            min_tensor_name = node.name + ":1"
-            max_tensor_name = node.name + ":2"
-
-            inputs_to_rename[node_tensor_name] = dequantize_source_name
-            inputs_to_rename[min_tensor_name] = dequantize_node.input[1]
-            inputs_to_rename[max_tensor_name] = dequantize_node.input[2]
-        # Finally we apply all the rewiring we've marked to the graph.
-        for node in old_graph.node:
-            for index, input_full_name in enumerate(node.input):
-                input_name = helper.ensure_tensor_name_has_port(input_full_name)
-                if input_name in inputs_to_rename:
-                    node.input[index] = inputs_to_rename[input_name]
-            self.add_output_graph_node(node)
-        return self.output_graph
-
-    def create_nodes_map(self, graph):
-        """Builds a mapping of node names to their defs from the graph."""
-        nodes_map = {}
-        for node in graph.node:
-            assert node.name not in nodes_map, "Duplicate node names detected."
-            nodes_map[node.name] = node
-
-        return nodes_map
-
-    def _add_quantize_down_nodes(
-        self, original_node, quantized_output_name, requantize_type=dtypes.quint8, is_relu6=False
-    ):
-        """Add quantize down nodes."""
-        quantized_outputs = [quantized_output_name, quantized_output_name + ":1", quantized_output_name + ":2"]
-        if not self.fake_quant:
-            # Add a RequantizationRange node for finding the min and max values.
-            requant_range_node = helper.create_node(
-                (
-                    "RequantizationRangePerChannel"
-                    if self.per_channel or original_node.op == "DepthwiseConv2dNative"
-                    else "RequantizationRange"
-                ),
-                original_node.name + "_eightbit_requant_range",
-                quantized_outputs,
-            )
-
-            if self.per_channel or original_node.op == "DepthwiseConv2dNative":
-                helper.set_attr_dtype(requant_range_node, "T", dtypes.qint32)
-                if is_relu6:
-                    helper.set_attr_float(requant_range_node, "clip_value_max", 6.0)
-                else:
-                    helper.set_attr_float(requant_range_node, "clip_value_max", 1e30)
-            else:
-                helper.set_attr_dtype(requant_range_node, "Tinput", dtypes.qint32)
-
-            self.add_output_graph_node(requant_range_node)
-            min_max_inputs = [requant_range_node.name + ":0", requant_range_node.name + ":1"]
-        else:
-            max_input_name = original_node.name + "_max"
-            max_node = helper.create_constant_node(max_input_name, 1.0, dtypes.float32)
-            self.add_output_graph_node(max_node)
-
-            min_input_name = original_node.name + "_min"
-            min_node = helper.create_constant_node(min_input_name, -1.0, dtypes.float32)
-            self.add_output_graph_node(min_node)
-
-            min_max_inputs = [min_input_name, max_input_name]
-
-        requantize_node = helper.create_node(
-            "RequantizePerChannel" if self.per_channel or original_node.op == "DepthwiseConv2dNative" else "Requantize",
-            original_node.name + "_eightbit_requantize",
-            quantized_outputs + min_max_inputs,
-        )
-        if self.per_channel or original_node.op == "DepthwiseConv2dNative":
-            helper.set_attr_dtype(requantize_node, "T", dtypes.qint32)
-        else:
-            helper.set_attr_dtype(requantize_node, "Tinput", dtypes.qint32)
-
-        helper.set_attr_dtype(requantize_node, "out_type", requantize_type)
-        self.add_output_graph_node(requantize_node)
-        return requantize_node.name
-
-    def _eightbitize_input_to_node(
-        self, namespace_prefix, original_input_name, reshape_dims_name, reduction_dims_name, dtype=dtypes.quint8
-    ):
-        """Takes one float input to an op, and converts it to quantized form."""
-        unique_input_name = helper.unique_node_name_from_input(original_input_name)
-        if unique_input_name in self.quantized_node_dict:
-            quantized_tuple = self.quantized_node_dict[unique_input_name]
-            return quantized_tuple[0], quantized_tuple[1], quantized_tuple[2]
-
-        if self.fake_quant:
-            min_input_name = namespace_prefix + "_min_" + unique_input_name
-            min_node = helper.create_constant_node(min_input_name, -1.0, dtypes.float32)
-            self.add_output_graph_node(min_node)
-            max_input_name = namespace_prefix + "_max_" + unique_input_name
-            max_node = helper.create_constant_node(max_input_name, 1.0, dtypes.float32)
-            self.add_output_graph_node(max_node)
-            quantize_input_name = namespace_prefix + "_quantize_" + unique_input_name
-            quantize_input_node = helper.create_node(
-                "QuantizeV2", quantize_input_name, [original_input_name, min_input_name, max_input_name]
-            )
-        else:
-            reshape_input_name = namespace_prefix + "_reshape_" + unique_input_name
-            min_input_name = namespace_prefix + "_min_" + unique_input_name
-            max_input_name = namespace_prefix + "_max_" + unique_input_name
-            quantize_input_name = namespace_prefix + "_quantize_" + unique_input_name
-            reshape_input_node = helper.create_node(
-                "Reshape", reshape_input_name, [original_input_name, reshape_dims_name]
-            )
-            helper.set_attr_dtype(reshape_input_node, "T", dtypes.float32)
-            self.add_output_graph_node(reshape_input_node)
-            min_input_node = helper.create_node("Min", min_input_name, [reshape_input_name, reduction_dims_name])
-            helper.set_attr_dtype(min_input_node, "T", dtypes.float32)
-            helper.set_attr_dtype(min_input_node, "Tidx", dtypes.int32)
-            helper.set_attr_bool(min_input_node, "keep_dims", False)
-            self.add_output_graph_node(min_input_node)
-            max_input_node = helper.create_node("Max", max_input_name, [reshape_input_name, reduction_dims_name])
-            helper.set_attr_dtype(max_input_node, "T", dtypes.float32)
-            helper.set_attr_dtype(max_input_node, "Tidx", dtypes.int32)
-            helper.set_attr_bool(max_input_node, "keep_dims", False)
-            self.add_output_graph_node(max_input_node)
-            quantize_input_node = helper.create_node(
-                "QuantizeV2", quantize_input_name, [original_input_name, min_input_name, max_input_name]
-            )
-
-        helper.set_attr_dtype(quantize_input_node, "T", dtype)
-        helper.set_attr_string(quantize_input_node, "mode", b"MIN_FIRST" if self.is_asymmetric else b"SCALED")
-        if not self.is_asymmetric:
-            helper.set_attr_string(quantize_input_node, "round_mode", b"HALF_TO_EVEN")
-        self.add_output_graph_node(quantize_input_node)
-        min_output_name = quantize_input_name + ":1"
-        max_output_name = quantize_input_name + ":2"
-        self.quantized_node_dict[unique_input_name] = (quantize_input_name, min_output_name, max_output_name)
-        return quantize_input_name, min_output_name, max_output_name
-
-    def _intel_cpu_quantize_weight_eightbit(self, parent, input_node, per_channel, enter_node=None):
-        """Quantize weight node."""
-        (
-            qint8_const_node,
-            min_node,
-            max_node,
-            qint8_const_enter_node,
-            min_enter_node,
-            max_enter_node,
-        ) = helper.generate_quantized_weight_node(
-            parent, input_node, per_channel, self.weight_bit, self.device, enter_node
-        )
-        if enter_node:  # pragma: no cover
-            self.add_output_graph_node(qint8_const_node)
-            self.add_output_graph_node(qint8_const_enter_node)
-            self.add_output_graph_node(min_node)
-            self.add_output_graph_node(min_enter_node)
-            self.add_output_graph_node(max_node)
-            self.add_output_graph_node(max_enter_node)
-
-            return qint8_const_enter_node.name, min_enter_node.name, max_enter_node.name
-        else:
-            self.add_output_graph_node(qint8_const_node)
-            self.add_output_graph_node(min_node)
-            self.add_output_graph_node(max_node)
-
-            return qint8_const_node.name, min_node.name, max_node.name
diff --git a/neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_bn.py b/neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_bn.py
deleted file mode 100644
index 6b3aa996410..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_bn.py
+++ /dev/null
@@ -1,298 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Quantize FusedBatchNormV3 to int8 op."""
-
-from tensorflow.core.framework import graph_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper as helper
-
-from .quantize_graph_base import QuantizeNodeBase
-
-
-class FuseNodeStartWithFusedBatchNormV3(QuantizeNodeBase):  # pragma: no cover
-    """Quantize FusedBatchNormV3 to int8 op and apply the fusion."""
-
-    def __init__(self, **kwargs):
-        """Initialization."""
-        super().__init__(**kwargs)
-        self.sorted_patterns = sorted(self.patterns, key=lambda i: len(i), reverse=True)
-        if self.new_api:
-            self.fusion_mapping = {
-                "FusedBatchNormV3": self.apply_newly_bn_relu_fusion,
-                "FusedBatchNormV3Relu": self.apply_newly_bn_relu_fusion,
-                "FusedBatchNormV3LeakyRelu": self.apply_newly_bn_leakyrelu_fusion,
-            }
-        else:
-            self.fusion_mapping = {}
-        self.exclude_bn_nodes = []
-
-    def apply_newly_bn_relu_fusion(self, match_node_name):
-        """Apply the FusedBatchNormV3 Relu fusion."""
-        matched_node = self.node_name_mapping[match_node_name[0]]
-        skip_node_name = match_node_name[1:]
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        scale_name = normal_inputs[1]
-        offset_name = normal_inputs[2]
-        mean_name = normal_inputs[3]
-        variance_name = normal_inputs[4]
-
-        all_input_names = self._add_eightbit_prologue_nodes(matched_node.node.name)
-        all_input_names = [
-            all_input_names[0],
-            scale_name,
-            offset_name,
-            mean_name,
-            variance_name,
-            all_input_names[1],
-            all_input_names[2],
-        ]
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[0]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-
-                relu_node_name = match_node_name[1] if len(match_node_name) == 2 else None
-
-                node_op = "_QuantizedFusedBatchNorm"
-                quantized_node_name = node.name + "_eightbit_quantized_bn"
-                output_min_node_name = quantized_node_name + "_input7_output_min"
-                output_max_node_name = quantized_node_name + "_input8_output_max"
-                quantized_node_input_names = (
-                    all_input_names + [output_min_node_name] + [output_max_node_name] + control_inputs
-                )
-                output_min_node = helper.create_constant_node(output_min_node_name, -1.0, dtypes.float32)
-                output_max_node = helper.create_constant_node(output_max_node_name, 1.0, dtypes.float32)
-                quantized_bn_node = helper.create_node(node_op, quantized_node_name, quantized_node_input_names)
-                if relu_node_name is not None:
-                    helper.set_attr_string(quantized_bn_node, "activation_mode", b"Relu")
-                if self.node_name_mapping[offset_name].node.op == "Const":
-                    helper.set_attr_bool(quantized_bn_node, "is_offset_const", True)
-                else:
-                    helper.set_attr_bool(quantized_bn_node, "is_offset_const", False)
-                if self.node_name_mapping[mean_name].node.op == "Const":
-                    helper.set_attr_bool(quantized_bn_node, "is_mean_const", True)
-                else:
-                    helper.set_attr_bool(quantized_bn_node, "is_mean_const", False)
-                helper.set_attr_dtype(quantized_bn_node, "T", dtypes.qint8)
-                helper.set_attr_dtype(quantized_bn_node, "U", dtypes.float32)
-                helper.set_attr_dtype(quantized_bn_node, "Tout", dtypes.qint8)
-                """# 0.
-
-                x
-                # 1. scale
-                # 2. offset
-                # 3. mean
-                # 4. variance
-                # 5. x_min
-                # 6. x_max
-                # 7. {output_min}
-                # 8. {output_max}
-                """
-                helper.set_attr_type_list(
-                    quantized_bn_node,
-                    "input_types",
-                    [
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                """# 0.
-
-                output
-                # 1. output_min
-                # 2. output_max
-                """
-                helper.set_attr_type_list(
-                    quantized_bn_node,
-                    "out_types",
-                    [
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                self.add_output_graph_node(output_min_node)
-                self.add_output_graph_node(output_max_node)
-                self.add_output_graph_node(quantized_bn_node)
-                self._intel_cpu_add_dequantize_result_node(
-                    quantized_output_name=quantized_node_name,
-                    original_node_name=match_node_name[-1],
-                    dtype=dtypes.qint8,
-                    min_tensor_index=1,
-                )
-
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def apply_newly_bn_leakyrelu_fusion(self, match_node_name):
-        """Apply the FusedBatchNormV3 LeakyRelu fusion."""
-        matched_node = self.node_name_mapping[match_node_name[0]]
-        skip_node_name = match_node_name[1:]
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        scale_name = normal_inputs[1]
-        offset_name = normal_inputs[2]
-        mean_name = normal_inputs[3]
-        variance_name = normal_inputs[4]
-
-        all_input_names = self._add_eightbit_prologue_nodes(matched_node.node.name)
-        all_input_names = [
-            all_input_names[0],
-            scale_name,
-            offset_name,
-            mean_name,
-            variance_name,
-            all_input_names[1],
-            all_input_names[2],
-        ]
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[0]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-                leakyrelu_node_name = match_node_name[1]
-                node_op = "_QuantizedFusedBatchNorm"
-                quantized_node_name = node.name + "_eightbit_quantized_bn"
-                output_min_node_name = quantized_node_name + "_input7_output_min"
-                output_max_node_name = quantized_node_name + "_input8_output_max"
-                quantized_node_input_names = (
-                    all_input_names + [output_min_node_name] + [output_max_node_name] + control_inputs
-                )
-                output_min_node = helper.create_constant_node(output_min_node_name, -1.0, dtypes.float32)
-                output_max_node = helper.create_constant_node(output_max_node_name, 1.0, dtypes.float32)
-                quantized_bn_node = helper.create_node(node_op, quantized_node_name, quantized_node_input_names)
-
-                helper.set_attr_string(quantized_bn_node, "activation_mode", b"LeakyRelu")
-                helper.copy_attr(
-                    quantized_bn_node, "alpha", self.node_name_mapping[leakyrelu_node_name].node.attr["alpha"]
-                )
-                if self.node_name_mapping[offset_name].node.op == "Const":
-                    helper.set_attr_bool(quantized_bn_node, "is_offset_const", True)
-                else:
-                    helper.set_attr_bool(quantized_bn_node, "is_offset_const", False)
-                if self.node_name_mapping[mean_name].node.op == "Const":
-                    helper.set_attr_bool(quantized_bn_node, "is_mean_const", True)
-                else:
-                    helper.set_attr_bool(quantized_bn_node, "is_mean_const", False)
-                helper.set_attr_dtype(quantized_bn_node, "T", dtypes.qint8)
-                helper.set_attr_dtype(quantized_bn_node, "U", dtypes.float32)
-                helper.set_attr_dtype(quantized_bn_node, "Tout", dtypes.qint8)
-                """# 0.
-
-                x
-                # 1. scale
-                # 2. offset
-                # 3. mean
-                # 4. variance
-                # 5. x_min
-                # 6. x_max
-                # 7. {output_min}
-                # 8. {output_max}
-                """
-                helper.set_attr_type_list(
-                    quantized_bn_node,
-                    "input_types",
-                    [
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                """# 0.
-
-                output
-                # 1. output_min
-                # 2. output_max
-                """
-                helper.set_attr_type_list(
-                    quantized_bn_node,
-                    "out_types",
-                    [
-                        dtypes.qint8.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                        dtypes.float32.as_datatype_enum,
-                    ],
-                )
-                self.add_output_graph_node(output_min_node)
-                self.add_output_graph_node(output_max_node)
-                self.add_output_graph_node(quantized_bn_node)
-                self._intel_cpu_add_dequantize_result_node(
-                    quantized_output_name=quantized_node_name,
-                    original_node_name=match_node_name[-1],
-                    dtype=dtypes.qint8,
-                    min_tensor_index=1,
-                    performance_only=self.performance_only,
-                )
-
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def get_longest_fuse(self):
-        """Get the longest fusion pattern."""
-        self._get_op_list()
-        matched_rule, matched_node_name = self._is_match(self.sorted_patterns)
-        return matched_rule, matched_node_name
-
-    def apply_the_transform(self):
-        """Quantize FusedBatchNormV3 and apply the fusion pattern."""
-        self._get_op_list()
-        matched_rule, matched_node_name = self._is_match(self.sorted_patterns)
-        if matched_node_name:
-            self.output_graph = graph_pb2.GraphDef()
-            fusion_name = "".join(matched_rule)
-            bn_node = self.node_name_mapping[matched_node_name[0]].node
-            is_training = bn_node.attr["is_training"].b
-            if fusion_name in self.fusion_mapping and is_training is False:
-                self.fusion_mapping[fusion_name](matched_node_name)
-            else:
-                if is_training is True:
-                    self.logger.info(
-                        "Skip quantizing the BN node '{}' due to the attr 'is_training == true'.".format(bn_node.name)
-                    )
-                    self.exclude_bn_nodes.append(bn_node.name)
-                elif self.new_api:
-                    self.logger.info("Unknown fusion pattern {} .".format(fusion_name))
-                if self.remove_redundant_quant_flag:
-                    self.input_graph = self.remove_redundant_quantization(self.input_graph)
-                return self.input_graph, self.exclude_bn_nodes
-
-            self.input_graph = self.output_graph
-            self._reset_output_node_maps()
-            if self.remove_redundant_quant_flag:
-                self.output_graph = self.remove_redundant_quantization(self.output_graph)
-            return self.output_graph, matched_node_name, []
-        return self.input_graph, [], []
diff --git a/neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_concatv2.py b/neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_concatv2.py
deleted file mode 100644
index 42a7ca5a1f5..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_concatv2.py
+++ /dev/null
@@ -1,106 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Quantize ConcatV2 to int8 op."""
-
-import re
-
-from tensorflow.core.framework import node_def_pb2
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper as helper
-
-from .quantize_graph_base import QuantizeNodeBase
-
-
-class FuseNodeStartWithConcatV2(QuantizeNodeBase):
-    """Quantize ConcatV2 to int8 op QuantizedConcatV2."""
-
-    def _apply_concatv2_transform(self, original_node):
-        """Quantize ConcatV2."""
-        namespace_prefix = original_node.name + "_eightbit"
-        quantized_concat_name = namespace_prefix + "_quantized_concatv2"
-        reshape_dims_name, reduction_dims_name = self._add_common_quantization_nodes(
-            namespace_prefix, helper.node_name_from_input(original_node.input[-1])
-        )
-        num_input = len(original_node.input)
-        shape_input_name = original_node.input[num_input - 1]
-        original_inputs = original_node.input[0 : num_input - 1]
-        input_names = []
-        min_names = []
-        max_names = []
-        for original_input_name in original_inputs:
-            original_input_node = self.node_name_mapping[original_input_name].node
-            input_data_type = dtypes.quint8 if self._find_relu_node(original_input_node) else dtypes.qint8
-            quantize_input_name, min_input_name, max_input_name = self._eightbitize_input_to_node(
-                namespace_prefix, original_input_name, reshape_dims_name, reduction_dims_name, dtype=input_data_type
-            )
-            input_names.append(quantize_input_name)
-            min_names.append(min_input_name)
-            max_names.append(max_input_name)
-        all_input_names = input_names
-        all_input_names.append(shape_input_name)
-        all_input_names.extend(min_names)
-        all_input_names.extend(max_names)
-        quantized_concat_node = helper.create_node("QuantizedConcatV2", quantized_concat_name, all_input_names)
-        helper.set_attr_int(quantized_concat_node, "N", len(original_inputs))
-        helper.set_attr_dtype(quantized_concat_node, "T", input_data_type)
-        self.add_output_graph_node(quantized_concat_node)
-        self._intel_cpu_add_dequantize_result_node(quantized_concat_name, original_node.name, input_data_type)
-
-    def _quantizable_concat(self, node):
-        """Check if the ConcatV2 is quantizable."""
-        deq_type = []
-        for input_node_name in node.input[: node.attr["N"].i]:
-            node_name = helper.node_name_from_input(input_node_name)
-            if self.node_name_mapping[node_name].node.op != "Dequantize":
-                return False
-
-            deq_type.append(self.node_name_mapping[node_name].node.attr["T"].type)
-
-        if len(set(deq_type)) != 1:
-            return False
-
-        return True
-
-    def _apply_concatv2_quantization(self):
-        """Quantize ConcatV2 if it's quantizable."""
-        for _, v in self.node_name_mapping.items():
-            if (
-                v.node.op in ("ConcatV2",)
-                and self._quantizable_concat(v.node)
-                and dtypes.as_dtype(v.node.attr["T"].type) == dtypes.float32
-                and not re.search(r"map(_\d+)?/while", v.node.name)
-            ):
-                self._apply_concatv2_transform(v.node)
-                self.quantizable_node_names.append(v.node.name)
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(v.node)
-                self.add_output_graph_node(new_node)
-
-    def get_longest_fuse(self):
-        """Only single ConcatV2, no fusion pattern."""
-        return 1
-
-    def apply_the_transform(self):
-        """Apply the quantization of ConcatV2."""
-        self.quantizable_node_names = []
-        self._apply_concatv2_quantization()
-        self._reset_output_node_maps()
-        if self.remove_redundant_quant_flag:
-            self.output_graph = self.remove_redundant_quantization(self.output_graph)
-        return self.output_graph, self.quantizable_node_names, []
diff --git a/neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_conv.py b/neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_conv.py
deleted file mode 100644
index 02de14e12d7..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_conv.py
+++ /dev/null
@@ -1,378 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Quantize Conv2D/DepthwiseConv2dNative."""
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.core.framework import graph_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper as helper
-from neural_compressor.tensorflow.utils import version1_gte_version2
-
-from .quantize_graph_base import QuantizeNodeBase
-
-
-class FuseNodeStartWithConv2d(QuantizeNodeBase):
-    """Quantize Conv2D/DepthwiseConv2dNative to int8 op."""
-
-    def __init__(self, **kwargs):
-        """Initialization."""
-        super().__init__(**kwargs)
-        self.sorted_patterns = sorted(self.patterns, key=lambda i: len(i), reverse=True)
-        self.exclude_conv_name = []
-
-        self.fusion_mapping = {
-            "Conv2DBiasAdd": self.apply_conv_biasadd_fusion,
-            "Conv2DBiasAddAddNRelu": self.apply_conv_biasadd_addn_relu_fusion,
-            "Conv2DBiasAddAddNRelu6": self.apply_conv_biasadd_addn_relu_fusion,
-            "Conv2DBiasAddAddV2Relu": self.apply_conv_biasadd_addn_relu_fusion,
-            "Conv2DBiasAddAddV2Relu6": self.apply_conv_biasadd_addn_relu_fusion,
-            "Conv2DBiasAddAddRelu": self.apply_conv_biasadd_addn_relu_fusion,
-            "Conv2DBiasAddRelu6": self.apply_conv_biasadd_relu_fusion,
-            "Conv2DBiasAddRelu": self.apply_conv_biasadd_relu_fusion,
-            "Conv2DBiasAddLeakyRelu": self.apply_conv_biasadd_relu_fusion,
-            "Conv2DBiasAddLeakyReluAddV2": self.apply_conv_biasadd_addn_relu_fusion,
-            "Conv2DAddRelu6": self.apply_conv_biasadd_relu_fusion,
-            "Conv2DAddRelu": self.apply_conv_biasadd_relu_fusion,
-            "DepthwiseConv2dNativeAddRelu6": self.apply_conv_biasadd_relu_fusion,
-            "DepthwiseConv2dNativeBiasAddRelu": self.apply_conv_biasadd_relu_fusion,
-            "DepthwiseConv2dNativeBiasAdd": self.apply_conv_biasadd_fusion,
-            "DepthwiseConv2dNativeBiasAddRelu6": self.apply_conv_biasadd_relu_fusion,
-            "Conv2D": self.apply_conv_single_fusion,
-            "DepthwiseConv2dNative": self.apply_conv_single_fusion,
-        }
-
-    def apply_conv_single_fusion(self, match_node_name):
-        """Apply Conv2D single fusion."""
-        skip_node_name = match_node_name[1:]
-        matched_node = self.node_name_mapping[match_node_name[0]]
-        _, normal_inputs = self._get_node_input(matched_node.node.name)
-        weight_name = normal_inputs[1]
-        # TODO this is workaround as the tf 2.1 doesn't support depthwise/conv s8
-        # feature.
-        if self.enable_s8 and not self._find_relu_node(matched_node.node):
-            self.exclude_conv_name.append(match_node_name[0])
-            self.output_graph = self.input_graph
-            return
-
-        q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-            matched_node.node.op, self.node_name_mapping[weight_name].node, self.per_channel
-        )
-
-        all_input_names = self._add_eightbit_prologue_nodes(matched_node.node.name)
-        all_input_names = all_input_names[:1] + [q_weights_name] + all_input_names[1:]
-        all_input_names.append(q_weights_min_name)
-        all_input_names.append(q_weights_max_name)
-        skip_node_name.append(weight_name)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("Skip node {}.".format(node.name))
-            elif node.name == match_node_name[0]:
-                postfix = "_eightbit_quantized_depthwise_conv"
-                if node.op == "Conv2D":
-                    postfix = "_eightbit_quantized_conv"
-                quantized_node_name = node.name + postfix
-                if node.op == "Conv2D":
-                    quantized_conv_node = helper.create_node(
-                        "QuantizedConv2DPerChannel" if self.per_channel else "QuantizedConv2D",
-                        quantized_node_name,
-                        all_input_names,
-                    )
-
-                elif node.op == "DepthwiseConv2dNative":
-                    quantized_conv_node = helper.create_node(
-                        "QuantizedDepthwiseConv2D", quantized_node_name, all_input_names
-                    )
-
-                helper.copy_attr(quantized_conv_node, "strides", node.attr["strides"])
-                helper.copy_attr(quantized_conv_node, "padding", node.attr["padding"])
-                if "padding_list" in node.attr:
-                    helper.copy_attr(quantized_conv_node, "padding_list", node.attr["padding_list"])
-                helper.copy_attr(quantized_conv_node, "dilations", node.attr["dilations"])
-                input_data_type = dtypes.quint8 if self._find_relu_node(node) else dtypes.qint8
-                helper.set_attr_dtype(quantized_conv_node, "Tinput", input_data_type)
-                helper.set_attr_dtype(quantized_conv_node, "Tfilter", dtypes.qint8)
-                helper.set_attr_dtype(quantized_conv_node, "out_type", dtypes.qint32)
-                self.add_output_graph_node(quantized_conv_node)
-                quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtypes.qint8)
-                self._intel_cpu_add_dequantize_result_node(quantize_down_name, node.name, dtypes.qint8)
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def apply_conv_biasadd_relu_fusion(self, match_node_name):
-        """Fuse the conv/biasadd/relu pattern."""
-        skip_node_name = match_node_name[1:]
-        matched_node = self.node_name_mapping[match_node_name[0]]
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        weight_name = normal_inputs[1]
-
-        q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-            matched_node.node.op, self.node_name_mapping[weight_name].node, self.per_channel
-        )
-
-        all_input_names = self._add_eightbit_prologue_nodes(matched_node.node.name)
-        all_input_names = all_input_names[:1] + [q_weights_name] + all_input_names[1:]
-        all_input_names.append(q_weights_min_name)
-        all_input_names.append(q_weights_max_name)
-        skip_node_name.append(weight_name)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("Skip node {}.".format(node.name))
-            elif node.name == match_node_name[0]:
-                postfix = "_eightbit_quantized_depthwise_conv"
-                if node.op == "Conv2D":
-                    postfix = "_eightbit_quantized_conv"
-                quantized_node_name = node.name + postfix
-                bias_node_name = self.node_name_mapping[match_node_name[1]].node.input[1]
-                relu_node_name = match_node_name[2]
-                is_relu6 = self.node_name_mapping[relu_node_name].node.op == "Relu6"
-                quantized_node_input_names = (
-                    all_input_names[:2] + [bias_node_name] + all_input_names[2:] + control_inputs
-                )
-                is_leakyrelu = self.node_name_mapping[relu_node_name].node.op == "LeakyRelu"
-                quantized_conv_node_op = "QuantizedDepthwiseConv2DWithBiasAndRelu"
-                if node.op == "Conv2D" or is_leakyrelu:
-                    quantized_conv_node_op = "QuantizedConv2DWithBiasAndRelu"
-                quantized_conv_node = helper.create_node(
-                    quantized_conv_node_op, quantized_node_name, quantized_node_input_names
-                )
-                helper.copy_attr(quantized_conv_node, "strides", node.attr["strides"])
-                helper.copy_attr(quantized_conv_node, "padding", node.attr["padding"])
-                if "alpha" in self.node_name_mapping[relu_node_name].node.attr:
-                    helper.copy_attr(
-                        quantized_conv_node, "alpha", self.node_name_mapping[relu_node_name].node.attr["alpha"]
-                    )
-                if "padding_list" in node.attr:
-                    helper.copy_attr(quantized_conv_node, "padding_list", node.attr["padding_list"])
-                helper.copy_attr(quantized_conv_node, "dilations", node.attr["dilations"])
-                input_data_type = dtypes.quint8 if self._find_relu_node(node) else dtypes.qint8
-                helper.set_attr_dtype(quantized_conv_node, "Tinput", input_data_type)
-                helper.set_attr_dtype(quantized_conv_node, "Tfilter", dtypes.qint8)
-                helper.set_attr_dtype(quantized_conv_node, "out_type", dtypes.qint32)
-                self.add_output_graph_node(quantized_conv_node)
-                if not is_leakyrelu:
-                    quantize_down_name = self._add_quantize_down_nodes(
-                        node, quantized_node_name, dtypes.quint8, is_relu6
-                    )
-                    self._intel_cpu_add_dequantize_result_node(quantize_down_name, relu_node_name)
-                else:
-                    quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtypes.qint8, False)
-                    self._intel_cpu_add_dequantize_result_node(quantize_down_name, relu_node_name, dtype=dtypes.qint8)
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def apply_conv_biasadd_fusion(self, match_node_name):
-        """Apply Conv BiasAdd fusion."""
-        skip_node_name = match_node_name[1:]
-        matched_node = self.node_name_mapping[match_node_name[0]]
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        weight_name = normal_inputs[1]
-
-        q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-            matched_node.node.op, self.node_name_mapping[weight_name].node, self.per_channel
-        )
-
-        all_input_names = self._add_eightbit_prologue_nodes(matched_node.node.name)
-        all_input_names = all_input_names[:1] + [q_weights_name] + all_input_names[1:]
-        all_input_names.append(q_weights_min_name)
-        all_input_names.append(q_weights_max_name)
-        skip_node_name.append(weight_name)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                pass
-            elif node.name == match_node_name[0]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-
-                quantized_node_name = node.name + "_eightbit_quantized_conv"
-                if node.op == "DepthwiseConv2dNative":
-                    quantized_node_name = node.name + "_eightbit_quantized_depthwise_conv"
-
-                bias_node_name = self.node_name_mapping[match_node_name[1]].node.input[1]
-                quantized_node_input_names = (
-                    all_input_names[:2] + [bias_node_name] + all_input_names[2:] + control_inputs
-                )
-
-                quantized_conv_node = helper.create_node(
-                    "QuantizedConv2DWithBias" if node.op == "Conv2D" else "QuantizedDepthwiseConv2DWithBias",
-                    quantized_node_name,
-                    quantized_node_input_names,
-                )
-
-                helper.copy_attr(quantized_conv_node, "strides", node.attr["strides"])
-                helper.copy_attr(quantized_conv_node, "padding", node.attr["padding"])
-                if "padding_list" in node.attr:
-                    helper.copy_attr(quantized_conv_node, "padding_list", node.attr["padding_list"])
-                helper.copy_attr(quantized_conv_node, "dilations", node.attr["dilations"])
-
-                input_data_type = dtypes.quint8 if self._find_relu_node(node) else dtypes.qint8
-
-                helper.set_attr_dtype(quantized_conv_node, "Tinput", input_data_type)
-                helper.set_attr_dtype(quantized_conv_node, "Tfilter", dtypes.qint8)
-                helper.set_attr_dtype(quantized_conv_node, "out_type", dtypes.qint32)
-                self.add_output_graph_node(quantized_conv_node)
-                requantize_type = dtypes.qint8
-
-                quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, requantize_type, False)
-                self._intel_cpu_add_dequantize_result_node(quantize_down_name, match_node_name[1], requantize_type)
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def apply_conv_biasadd_addn_relu_fusion(self, match_node_name):
-        """Apply Conv BiasAdd AddN Relu fusion."""
-        skip_node_name = match_node_name[1:]
-        matched_node = self.node_name_mapping[match_node_name[0]]
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        weight_name = normal_inputs[1]
-
-        third_node = self.node_name_mapping[match_node_name[2]].node
-        forth_node = self.node_name_mapping[match_node_name[3]].node
-        if third_node.op != "LeakyRelu" and not self._find_relu_node(matched_node.node):
-            return self.apply_conv_biasadd_fusion(match_node_name[:2])
-
-        is_leakyrelu_add_fusion = third_node.op == "LeakyRelu" and forth_node.op.find("Add") != -1
-
-        q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-            matched_node.node.op, self.node_name_mapping[weight_name].node, self.per_channel
-        )
-
-        all_input_names = self._add_eightbit_prologue_nodes(matched_node.node.name)
-        all_input_names = all_input_names[:1] + [q_weights_name] + all_input_names[1:]
-        all_input_names.append(q_weights_min_name)
-        all_input_names.append(q_weights_max_name)
-        skip_node_name.append(weight_name)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                self.logger.debug("skip node {}".format(node.name))
-            elif node.name == match_node_name[0]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-
-                quantized_node_name = node.name + "_eightbit_quantized_conv"
-
-                bias_node_name = self.node_name_mapping[match_node_name[1]].node.input[1]
-                leaky_offset = 1 if is_leakyrelu_add_fusion else 0
-                if is_leakyrelu_add_fusion:
-                    relu_node_name = match_node_name[2]
-                else:
-                    relu_node_name = match_node_name[3]
-                is_relu6 = self.node_name_mapping[relu_node_name].node.op == "Relu6"
-
-                sum_index = (
-                    1
-                    if match_node_name[1 + leaky_offset]
-                    == self.node_name_mapping[match_node_name[2 + leaky_offset]].node.input[0]
-                    else 0
-                )
-                quantized_node_input_names = (
-                    all_input_names[:2]
-                    + [bias_node_name]
-                    + all_input_names[2:]
-                    + [self.node_name_mapping[match_node_name[2 + leaky_offset]].node.input[sum_index]]
-                    + control_inputs
-                )
-
-                node_op = (
-                    "QuantizedConv2DWithBiasReluAndSum"
-                    if is_leakyrelu_add_fusion
-                    else "QuantizedConv2DWithBiasSumAndRelu"
-                )
-
-                quantized_conv_node = helper.create_node(node_op, quantized_node_name, quantized_node_input_names)
-                helper.copy_attr(quantized_conv_node, "strides", node.attr["strides"])
-                helper.copy_attr(quantized_conv_node, "padding", node.attr["padding"])
-                if "padding_list" in node.attr:
-                    helper.copy_attr(quantized_conv_node, "padding_list", node.attr["padding_list"])
-                helper.copy_attr(quantized_conv_node, "dilations", node.attr["dilations"])
-                input_data_type = dtypes.quint8 if self._find_relu_node(node) else dtypes.qint8
-                helper.set_attr_dtype(quantized_conv_node, "Tinput", input_data_type)
-                helper.set_attr_dtype(quantized_conv_node, "Tfilter", dtypes.qint8)
-                helper.set_attr_dtype(quantized_conv_node, "out_type", dtypes.qint32)
-                if "alpha" in self.node_name_mapping[relu_node_name].node.attr:
-                    helper.copy_attr(
-                        quantized_conv_node, "alpha", self.node_name_mapping[relu_node_name].node.attr["alpha"]
-                    )
-                self.add_output_graph_node(quantized_conv_node)
-
-                if is_leakyrelu_add_fusion:
-                    quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtypes.qint8, False)
-                    self._intel_cpu_add_dequantize_result_node(
-                        quantize_down_name, match_node_name[3], dtype=dtypes.qint8
-                    )
-                else:
-                    dtype = dtypes.quint8
-                    if [
-                        i
-                        for i in self.node_name_mapping[relu_node_name].output
-                        if "FusedBatchNorm" in self.node_name_mapping[i].node.op and i in self.op_wise_config_name_list
-                    ]:
-                        dtype = dtypes.qint8
-                    quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtype, is_relu6)
-                    self._intel_cpu_add_dequantize_result_node(quantize_down_name, relu_node_name, dtype)
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-
-    def get_longest_fuse(self):
-        """Get the longest fusion pattern."""
-        self._get_op_list()
-
-        matched_rule, matched_node_name = self._is_match(self.sorted_patterns)
-        return matched_rule, matched_node_name
-
-    def apply_the_transform(self):
-        """Quantize Conv2D/DepthwiseConv2dNative and apply the fusion pattern."""
-        self._get_op_list()
-        matched_rule, matched_node_name = self._is_match(self.sorted_patterns)
-        if matched_node_name:
-            self.output_graph = graph_pb2.GraphDef()
-            fusion_name = "".join(matched_rule)
-            if fusion_name in self.fusion_mapping:
-                if fusion_name.find("Conv2DAddRelu") != -1:
-                    for input_name in self.node_name_mapping[matched_node_name[1]].node.input:
-                        input_node_name = helper.node_name_from_input(input_name)
-                        if input_node_name != matched_node_name[0]:
-                            add_const_input_node = self.node_name_mapping[input_node_name].node
-                            add_node_content = tensor_util.MakeNdarray(add_const_input_node.attr["value"].tensor)
-                            if add_node_content.ndim != 1:
-                                fusion_name = "Conv2D"
-                                matched_node_name = matched_node_name[:1]
-                self.fusion_mapping[fusion_name](matched_node_name)
-            else:  # pragma: no cover
-                self.logger.info("Unknown fusion pattern {}.".format(fusion_name))
-                if self.remove_redundant_quant_flag:
-                    self.input_graph = self.remove_redundant_quantization(self.input_graph)
-                return self.input_graph, []
-
-            self.input_graph = self.output_graph
-            self._reset_output_node_maps()
-            if self.remove_redundant_quant_flag:
-                self.output_graph = self.remove_redundant_quantization(self.output_graph)
-
-            return self.output_graph, matched_node_name, self.exclude_conv_name
-
-        return self.input_graph, [], []
diff --git a/neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_for_intel_cpu.py b/neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_for_intel_cpu.py
deleted file mode 100644
index c9de7c04cfd..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_for_intel_cpu.py
+++ /dev/null
@@ -1,130 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Convert fp32 op to int8 and fuse the pattern."""
-
-from tensorflow.core.framework import graph_pb2
-from tensorflow.python.platform import gfile
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper
-from neural_compressor.tensorflow.utils import dump_elapsed_time
-
-from .quantize_graph_base import QuantizeGraphBase
-from .quantize_graph_bn import FuseNodeStartWithFusedBatchNormV3
-from .quantize_graph_concatv2 import FuseNodeStartWithConcatV2
-from .quantize_graph_conv import FuseNodeStartWithConv2d
-from .quantize_graph_matmul import FuseNodeStartWithMatmul
-from .quantize_graph_pooling import FuseNodeStartWithPooling
-
-
-class QuantizeGraphForIntel(QuantizeGraphBase):
-    """Quantize the graph."""
-
-    def __init__(
-        self,
-        input_graph,
-        input_node_names,
-        output_node_names,
-        op_wise_config,
-        op_wise_sequences,
-        device,
-        fake_quant=False,
-        new_api=False,
-        performance_only=False,
-        itex_mode=False,
-    ):
-        """Quantize Graph For Intel Cpu."""
-        super().__init__(output_node_names)
-        self.op_wise_config = op_wise_config
-        # self.perchannel = perchannel
-        if isinstance(input_graph, graph_pb2.GraphDef):
-            self.input_graph = input_graph
-        else:
-            self.input_graph = graph_pb2.GraphDef()
-            with gfile.Open(input_graph, "rb") as f:
-                self.input_graph.ParseFromString(f.read())
-
-        input_output_names = input_node_names + output_node_names
-        self.input_graph = QuantizeGraphHelper().remove_training_nodes(
-            self.input_graph, protected_nodes=input_output_names
-        )
-
-        self.graph_analyzer = GraphAnalyzer()
-        self.graph_analyzer.graph = self.input_graph
-
-        self.graph_info = self.graph_analyzer.parse_graph()
-        self.graph_analyzer.get_frame_info()
-
-        self.op_wise_seq = op_wise_sequences
-
-        self.device = device
-        self.fake_quant = fake_quant
-        self.new_api = new_api
-        self.performance_only = performance_only
-        self.itex_mode = itex_mode
-
-        self.all_quantizable_node = []
-        self.exclude_node_names = []
-        self.register_transformer("MaxPool", FuseNodeStartWithPooling)
-        self.register_transformer("MaxPool3D", FuseNodeStartWithPooling)
-        self.register_transformer("Conv2D", FuseNodeStartWithConv2d)
-        self.register_transformer("Conv3D", FuseNodeStartWithConv2d)
-        self.register_transformer("FusedBatchNormV3", FuseNodeStartWithFusedBatchNormV3)
-        self.register_transformer("DepthwiseConv2dNative", FuseNodeStartWithConv2d)
-        self.register_transformer("AvgPool", FuseNodeStartWithPooling)
-        self.register_transformer("ConcatV2", FuseNodeStartWithConcatV2)
-        self.register_transformer("MatMul", FuseNodeStartWithMatmul)
-
-    @dump_elapsed_time("Pass Quantization")
-    def do_transform(self):
-        """Apply all the transformers to fuse into int8 op."""
-        count = 0
-        remove_redundant_quant_flag = False
-        op_wise_config_name_list = list(self.op_wise_config.keys())
-        all_node_length = len(self.op_wise_config)
-        for _, node in enumerate(self.input_graph.node):
-            if node in self.input_graph.node and node.op in self.transformers and node.name in self.op_wise_config:
-                count += 1
-                if count == all_node_length:
-                    remove_redundant_quant_flag = True
-                self.input_graph, quantizable_node_names, exclude_node_names = self.transformers[node.op](
-                    input_graph=self.input_graph,
-                    patterns=self.op_wise_seq[node.op],
-                    remove_redundant_quant_flag=remove_redundant_quant_flag,
-                    op_wise_cfg=self.op_wise_config[node.name],
-                    op_wise_config_name_list=op_wise_config_name_list,
-                    start_node_name=node.name,
-                    device=self.device,
-                    fake_quant=self.fake_quant,
-                    new_api=self.new_api,
-                    performance_only=self.performance_only,
-                    itex_mode=self.itex_mode,
-                    frame_info=self.graph_analyzer.parent_frame_details,
-                ).apply_the_transform()
-                if quantizable_node_names:
-                    if node.op in ("ConcatV2", "MaxPool", "MaxPool3D", "AvgPool"):
-                        self.all_quantizable_node.extend([[i] for i in quantizable_node_names])
-                    else:
-                        self.all_quantizable_node.append(quantizable_node_names)
-                if exclude_node_names:
-                    self.exclude_node_names.extend(exclude_node_names)
-
-        return (
-            self.remove_dead_nodes(self.input_graph, self.output_node_names),
-            self.all_quantizable_node,
-            self.exclude_node_names,
-        )
diff --git a/neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_matmul.py b/neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_matmul.py
deleted file mode 100644
index b9f5b9b7ef4..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_matmul.py
+++ /dev/null
@@ -1,351 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Quantize MatMul."""
-
-import numpy as np
-from tensorflow.core.framework import graph_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper as helper
-
-from .quantize_graph_base import QuantizeNodeBase
-
-
-class FuseNodeStartWithMatmul(QuantizeNodeBase):
-    """Quantize MatMul and apply the fusion."""
-
-    def __init__(self, **kwargs):
-        """Initialization."""
-        super().__init__(**kwargs)
-
-        self.sorted_patterns = sorted(self.patterns, key=lambda i: len(i), reverse=True)
-        self.exclude_matmul_name = []
-        self.fusion_op_type = set(fusion[0] for fusion in self.patterns)
-        self.fusion_mapping = {
-            "MatMulBiasAdd": self.apply_matmul_biasadd_fusion,
-            "MatMul": self.apply_matmul_biasadd_fusion,
-            "MatMulBiasAddRelu": self.apply_matmul_biasadd_relu_fusion,
-            "MatMulRelu": self.apply_matmul_biasadd_relu_fusion,
-        }
-
-    def apply_matmul_biasadd_relu_fusion(self, match_node_name):
-        """Apply the MatMul BiasAdd Relu fusion."""
-        matched_node = self.node_name_mapping[match_node_name[0]]
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        weight_name = normal_inputs[1]
-        weight_node = self.node_name_mapping[helper.node_name_from_input(weight_name)].node
-
-        # FIXME We only quantize the MatMul op which second input node type is const. This is a
-        # workaround for RNN model like LTSM.
-        if weight_node.op != "Const":
-            self.output_graph = self.input_graph
-            return []
-
-        weights_content = tensor_util.MakeNdarray(weight_node.attr["value"].tensor)
-
-        if np.any(np.isnan(weights_content)):
-            self.output_graph = self.input_graph
-            return []
-
-        for i in self.node_name_mapping:
-            if weight_node.name in self.node_name_mapping[i].output:
-                self.output_graph = self.input_graph
-                return []
-        second_node = self.node_name_mapping[match_node_name[1]].node
-        skip_node_name = match_node_name[1:]
-
-        need_insert_dummy_biasadd = 1
-        offset = 1
-        if len(match_node_name) == 3:
-            add_a_node_name = helper.node_name_from_input(second_node.input[0])
-            add_a_node = self.node_name_mapping[add_a_node_name].node
-            add_b_node_name = helper.node_name_from_input(second_node.input[1])
-            add_b_node = self.node_name_mapping[add_b_node_name].node
-            if add_a_node.op != "Const" and add_b_node.op == "Const":
-                need_insert_dummy_biasadd = 0
-                offset = 0
-            if need_insert_dummy_biasadd:
-                self.apply_matmul_biasadd_fusion(match_node_name[:1])
-                return match_node_name[:1]
-
-        q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-            matched_node.node.op, self.node_name_mapping[weight_name].node, self.per_channel
-        )
-
-        skip_node_name.append(weight_name)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                pass
-            elif node.name == match_node_name[0]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-
-                quantized_node_name = node.name + "_eightbit_quantized_mat_mul"
-                if need_insert_dummy_biasadd:
-                    t_b_index = 0 if matched_node.node.attr["transpose_b"].b else 1
-                    bias_size = weights_content.shape[t_b_index]
-                    bias_node_name = node.name + "_fake_bias"
-                    bias_node = helper.create_constant_node(
-                        bias_node_name, [0] * bias_size, dtypes.float32, shape=[bias_size]
-                    )
-                    self.add_output_graph_node(bias_node)
-                else:
-                    bias_node_name = self.node_name_mapping[match_node_name[1]].node.input[1]
-
-                relu_node_name = match_node_name[2 - offset]
-                all_input_names = self._add_eightbit_prologue_nodes(matched_node.node.name)
-                all_input_names = all_input_names[:1] + [q_weights_name] + all_input_names[1:]
-                all_input_names.append(q_weights_min_name)
-                all_input_names.append(q_weights_max_name)
-                quantized_node_input_names = (
-                    all_input_names[:2] + [bias_node_name] + all_input_names[2:] + control_inputs
-                )
-
-                quantized_matmul_node = helper.create_node(
-                    "QuantizedMatMulWithBiasAndRelu", quantized_node_name, quantized_node_input_names
-                )
-
-                helper.copy_attr(quantized_matmul_node, "transpose_a", node.attr["transpose_a"])
-                helper.copy_attr(quantized_matmul_node, "transpose_b", node.attr["transpose_b"])
-                helper.set_attr_dtype(quantized_matmul_node, "T1", dtypes.quint8)
-                helper.set_attr_dtype(quantized_matmul_node, "T2", dtypes.qint8)
-                helper.set_attr_dtype(quantized_matmul_node, "Toutput", dtypes.qint32)
-                helper.set_attr_string(
-                    quantized_matmul_node, "input_quant_mode", b"MIN_FIRST" if self.is_asymmetric else b"SCALED"
-                )
-
-                self.add_output_graph_node(quantized_matmul_node)
-
-                quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, dtypes.quint8, False)
-                self._intel_cpu_add_dequantize_result_node(quantize_down_name, relu_node_name)
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-        return match_node_name
-
-    def apply_matmul_biasadd_fusion(self, match_node_name):
-        """Apply MatMul BiasAdd fusion."""
-        skip_node_name = match_node_name[1:]
-        matched_node = self.node_name_mapping[match_node_name[0]]
-        control_inputs, normal_inputs = self._get_node_input(matched_node.node.name)
-        weight_name = normal_inputs[1]
-        weight_node = self.node_name_mapping[helper.node_name_from_input(weight_name)].node
-
-        enter_node = None
-
-        if weight_node.op == "Enter":
-            parent_node = self.node_name_mapping[helper.node_name_from_input(weight_node.input[0])].node
-            # FIXME We only quantize the MatMul op which second input node type is const. This is a
-            # workaround for RNN model like LTSM.
-            if parent_node.op != "Const":
-                self.logger.debug("The weight node of matched_node {} is not Const or Const + Enter, skipped")
-                self.output_graph = self.input_graph
-                return []
-            enter_node = weight_node
-            weight_node = parent_node
-            weight_name = weight_node.name
-
-        if weight_node.op != "Const":
-            self.output_graph = self.input_graph
-            return []
-
-        # TODO Remove below two lines once the TF enabled the old QuantizedMatMul while
-        # transpose_a/transpose_b could be set to True.
-        if matched_node.node.attr["transpose_a"].b is True or matched_node.node.attr["transpose_b"].b is True:
-            self.exclude_matmul_name.append(match_node_name[0])
-            self.output_graph = self.input_graph
-            return []
-
-        if weight_node.op == "Const":
-            weights_content = tensor_util.MakeNdarray(weight_node.attr["value"].tensor)
-
-            if np.any(np.isnan(weights_content)):
-                self.output_graph = self.input_graph
-                return []
-
-        for i in self.node_name_mapping:
-            if (
-                weight_node.input
-                and not weight_node.input[0].startswith("^")
-                and weight_node.name in self.node_name_mapping[i].output
-            ):
-                self.output_graph = self.input_graph
-                return []
-
-        len_output = len(matched_node.output)
-        is_shared_output = False
-        if len_output == 2:
-            if (
-                self.node_name_mapping[matched_node.output[0]].node.op == "Reshape"
-                or self.node_name_mapping[matched_node.output[1]].node.op == "Reshape"
-            ):
-                is_shared_output = False
-            else:
-                is_shared_output = True
-        elif len_output > 1:
-            is_shared_output = True
-
-        need_insert_dummy_biasadd = 1
-        if len(match_node_name) == 1:
-            if is_shared_output:
-                self.output_graph = self.input_graph
-                return []
-        else:
-            second_node = self.node_name_mapping[match_node_name[1]].node
-            add_a_node_name = helper.node_name_from_input(second_node.input[0])
-            add_a_node = self.node_name_mapping[add_a_node_name].node
-            add_b_node_name = helper.node_name_from_input(second_node.input[1])
-            add_b_node = self.node_name_mapping[add_b_node_name].node
-            if add_a_node.op != "Const" and add_b_node.op in ("Const", "Enter"):
-                need_insert_dummy_biasadd = 0
-            if need_insert_dummy_biasadd:
-                self.apply_matmul_biasadd_fusion(match_node_name[:1])
-                return match_node_name[:1]
-
-        if self.frame_info and not enter_node:
-            from collections import OrderedDict
-
-            frame_info = OrderedDict(self.frame_info)
-            if match_node_name[0] in frame_info and frame_info[match_node_name[0]]:
-                enter_node = helper.create_node("Enter", weight_name + "_enter", [weight_name])
-                helper.set_attr_string(enter_node, "frame_name", frame_info[weight_name].attr["frame_name"].s)
-                helper.set_attr_dtype(enter_node, "T", dtypes.float32)
-                helper.set_attr_bool(enter_node, "is_constant", True)
-                helper.set_attr_int(
-                    enter_node, "parallel_iterations", frame_info[weight_name].attr["parallel_iterations"].i
-                )
-
-        q_weights_name, q_weights_min_name, q_weights_max_name = self._intel_cpu_quantize_weight_eightbit(
-            matched_node.node.op, self.node_name_mapping[weight_name].node, self.per_channel, enter_node
-        )
-
-        skip_node_name.append(weight_name)
-        if enter_node:
-            skip_node_name.append(enter_node.name)
-
-        for _, node in enumerate(self.input_graph.node):
-            if node.name in skip_node_name:
-                pass
-            elif node.name == match_node_name[0]:
-                self.logger.debug("Matched node {} with input {}.".format(node.name, node.input))
-
-                quantized_node_name = node.name + "_eightbit_quantized_mat_mul"
-
-                if need_insert_dummy_biasadd:
-                    t_b_index = 0 if matched_node.node.attr["transpose_b"].b else 1
-                    bias_size = weights_content.shape[t_b_index]
-                    bias_node_name = node.name + "_fake_bias"
-                    bias_node = helper.create_constant_node(
-                        bias_node_name, [0] * bias_size, dtypes.float32, shape=[bias_size]
-                    )
-                    if enter_node:
-                        bias_enter_node = helper.create_node("Enter", bias_node_name + "_enter", [bias_node_name])
-                        helper.set_attr_string(bias_enter_node, "frame_name", enter_node.attr["frame_name"].s)
-                        helper.set_attr_dtype(bias_enter_node, "T", dtypes.float32)
-                        helper.set_attr_bool(bias_enter_node, "is_constant", True)
-                        helper.set_attr_int(
-                            bias_enter_node, "parallel_iterations", enter_node.attr["parallel_iterations"].i
-                        )
-
-                        self.add_output_graph_node(bias_enter_node)
-                        bias_node_name = bias_enter_node.name
-
-                    self.add_output_graph_node(bias_node)
-                else:
-                    bias_node_name = self.node_name_mapping[match_node_name[1]].node.input[1]
-                    if self.node_name_mapping[bias_node_name].node.op == "Enter":
-                        bias_enter_node = helper.create_node("Enter", bias_node_name + "_enter", [bias_node_name])
-                        helper.set_attr_string(
-                            bias_enter_node,
-                            "frame_name",
-                            self.node_name_mapping[bias_node_name].node.attr["frame_name"].s,
-                        )
-                        helper.set_attr_dtype(bias_enter_node, "T", dtypes.float32)
-                        helper.set_attr_bool(bias_enter_node, "is_constant", True)
-                        helper.set_attr_int(
-                            bias_enter_node,
-                            "parallel_iterations",
-                            self.node_name_mapping[bias_node_name].node.attr["parallel_iterations"].i,
-                        )
-                        self.add_output_graph_node(bias_enter_node)
-
-                all_input_names = self._add_eightbit_prologue_nodes(matched_node.node.name)
-                all_input_names = all_input_names[:1] + [q_weights_name] + all_input_names[1:]
-                all_input_names.append(q_weights_min_name)
-                all_input_names.append(q_weights_max_name)
-                quantized_node_input_names = (
-                    all_input_names[:2] + [bias_node_name] + all_input_names[2:] + control_inputs
-                )
-
-                quantized_matmul_node = helper.create_node(
-                    "QuantizedMatMulWithBias", quantized_node_name, quantized_node_input_names
-                )
-
-                helper.copy_attr(quantized_matmul_node, "transpose_a", node.attr["transpose_a"])
-                helper.copy_attr(quantized_matmul_node, "transpose_b", node.attr["transpose_b"])
-                helper.set_attr_dtype(quantized_matmul_node, "T1", dtypes.quint8)
-                helper.set_attr_dtype(quantized_matmul_node, "T2", dtypes.qint8)
-                helper.set_attr_dtype(quantized_matmul_node, "Toutput", dtypes.qint32)
-                helper.set_attr_dtype(quantized_matmul_node, "Tbias", dtypes.float32)
-                helper.set_attr_string(
-                    quantized_matmul_node, "input_quant_mode", b"MIN_FIRST" if self.is_asymmetric else b"SCALED"
-                )
-
-                self.add_output_graph_node(quantized_matmul_node)
-                requantize_type = dtypes.qint8
-
-                quantize_down_name = self._add_quantize_down_nodes(node, quantized_node_name, requantize_type, False)
-                self._intel_cpu_add_dequantize_result_node(
-                    quantize_down_name,
-                    match_node_name[0] if need_insert_dummy_biasadd else match_node_name[1],
-                    requantize_type,
-                )
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(node)
-                self.add_output_graph_node(new_node)
-        return match_node_name
-
-    def get_longest_fuse(self):
-        """Get the longest fusion pattern."""
-        self._get_op_list()
-        matched_rule, _ = self._is_match(self.sorted_patterns)
-        return matched_rule
-
-    def apply_the_transform(self):
-        """Quantize MatMul and apply the fusion pattern."""
-        self._get_op_list()
-        matched_rule, matched_node_name = self._is_match(self.sorted_patterns)
-
-        if matched_node_name:
-            self.output_graph = graph_pb2.GraphDef()
-            fusion_name = "".join(matched_rule)
-            if fusion_name in self.fusion_mapping:
-                matched_nodes = self.fusion_mapping[fusion_name](matched_node_name)
-            else:  # pragma: no cover
-                self.logger.debug("Unknown fusion pattern {}.".format(fusion_name))
-                if self.remove_redundant_quant_flag:
-                    self.input_graph = self.remove_redundant_quantization(self.input_graph)
-                return self.input_graph, []
-            self.input_graph = self.output_graph
-            self._reset_output_node_maps()
-            if self.remove_redundant_quant_flag:
-                self.output_graph = self.remove_redundant_quantization(self.output_graph)
-            return self.output_graph, matched_nodes, self.exclude_matmul_name
-
-        return self.input_graph, [], []
diff --git a/neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_pooling.py b/neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_pooling.py
deleted file mode 100644
index fc854093396..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/quantize_graph/quantize_graph_pooling.py
+++ /dev/null
@@ -1,73 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Quantize the AvgPool/MaxPool."""
-
-import tensorflow as tf
-from tensorflow.core.framework import node_def_pb2
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper as helper
-from neural_compressor.tensorflow.utils import version1_eq_version2, version1_gt_version2, version1_lt_version2
-
-from .quantize_graph_base import QuantizeNodeBase
-
-
-class FuseNodeStartWithPooling(QuantizeNodeBase):
-    """Quantize the AvgPool and MaxPool."""
-
-    def _add_pool_function(self, original_node, quantized_op_node):
-        """Set quantized pooling node attributes."""
-        pooling_type = (
-            dtypes.quint8
-            if version1_lt_version2(tf.version.VERSION, "2.6.0") or self._find_relu_node(original_node)
-            else dtypes.qint8
-        )
-        helper.set_attr_dtype(quantized_op_node, "T", pooling_type)
-        helper.copy_attr(quantized_op_node, "ksize", original_node.attr["ksize"])
-        helper.copy_attr(quantized_op_node, "strides", original_node.attr["strides"])
-        helper.copy_attr(quantized_op_node, "padding", original_node.attr["padding"])
-
-    def _apply_pool_quantization(self):
-        """Quantize AvgPool/MaxPool."""
-        for _, v in self.node_name_mapping.items():
-            # Tensorflow 2.5.0 enabled the s8 input for pooling op.
-            # If the tf version is lower than 2.5.0, we need to confirm the input
-            # data type of pooling is unsigned.
-            if v.node.name == self.start_node_name and (
-                version1_gt_version2(tf.version.VERSION, "2.5.0")
-                or version1_lt_version2(tf.version.VERSION, "2.6.0")
-                and self._find_relu_node(v.node)
-            ):
-                self.eightbitize_single_input_tensor_node(v.node, self._add_pool_function)
-                self.quantizable_node_names.append(v.node.name)
-            else:
-                new_node = node_def_pb2.NodeDef()
-                new_node.CopyFrom(v.node)
-                self.add_output_graph_node(new_node)
-
-    def get_longest_fuse(self):
-        """Only pooling op itself, no fusion pattern."""
-        return 1
-
-    def apply_the_transform(self):
-        """Quantize AvgPool/MaxPool."""
-        self.quantizable_node_names = []
-        self._apply_pool_quantization()
-        self._reset_output_node_maps()
-        if self.remove_redundant_quant_flag:
-            self.output_graph = self.remove_redundant_quantization(self.output_graph)
-        return self.output_graph, self.quantizable_node_names, []
diff --git a/neural_compressor/tensorflow/quantization/utils/quantize_graph_common.py b/neural_compressor/tensorflow/quantization/utils/quantize_graph_common.py
deleted file mode 100644
index 9a210e695ff..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/quantize_graph_common.py
+++ /dev/null
@@ -1,448 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Quantize Graph Common Utils Herlper Class."""
-
-import re
-
-import numpy as np
-from tensorflow.core.framework import attr_value_pb2, graph_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-
-
-class QuantizeGraphHelper:
-    """This class contains several staticmethod functions."""
-
-    node_name_cache = {}
-    node_name_port_cache = {}
-
-    def __init__(self):
-        """Initialization."""
-        pass
-
-    def _recursive_graph_sorting(self, node_name):
-        """Recursive sort the graph."""
-        if node_name in self.op_list or not self.node_name_mapping[node_name].input:
-            return
-
-        for input_name in self.node_name_mapping[node_name].input:
-            if input_name not in self.node_name_mapping:
-                continue
-            else:
-                self._recursive_graph_sorting((input_name))
-
-        if node_name not in self.op_list:
-            self.op_list.append(node_name)
-
-        return
-
-    def _get_op_list(self, output_node_names):
-        """Get op list by recursive sorting the graph."""
-        for output_name in output_node_names:
-            self._recursive_graph_sorting(output_name)
-
-    def get_sorted_graph(self, input_graph, input_node_names, output_node_names):
-        """Return a sorted graphdef object.
-
-        Sometimes the input graphdef was composed of the random nodedef objects,
-        we reorder the graph to make the parsing easier.
-
-        Args:
-            input_graph (graphdef]): the input graphdef object
-            input_node_names (string list): the input node names
-            output_node_names (string list): the output node names
-
-        Returns:
-            [type]: [description]
-        """
-        self.node_name_mapping = {}
-        self.op_list = [input_node_name for input_node_name in input_node_names]
-        for node in input_graph.node:
-            self.node_name_mapping[node.name] = node
-        self._get_op_list(output_node_names)
-
-        all_ops = [i for i in list(self.node_name_mapping.keys()) if i not in self.op_list]
-        self.op_list.extend(sorted(set(all_ops), key=all_ops.index))
-
-        self.out_graph_def = graph_pb2.GraphDef()
-        for i in self.op_list:
-            new_node = node_def_pb2.NodeDef()
-            new_node.CopyFrom(self.node_name_mapping[i])
-            self.out_graph_def.node.extend([new_node])
-
-        return self.out_graph_def
-
-    @staticmethod
-    def split_shared_inputs(input_graph_def):
-        """Split shared inputs(like weights and bias) of the graph.
-
-        :param in_graph: input graph file.
-        :return: path to output graph file.
-        """
-        node_map = {}
-        for node in input_graph_def.node:
-            if node.name not in node_map:
-                node_map[node.name] = node
-
-        output_graph_def = graph_pb2.GraphDef()
-        is_shared_input = False
-        # map of: input_name - op_name
-        input_map = {}
-        for node_name in node_map.keys():
-            node = node_map[node_name]
-            for input_idx, input_node_name in enumerate(node.input):
-                if node_map[QuantizeGraphHelper.node_name_from_input(input_node_name)].op == "Const":
-                    # is shared and current node is not the first one
-                    # sharing the input
-                    if input_node_name in input_map.keys():
-                        is_shared_input = True
-                        input_map[input_node_name].append(node.name)
-                        new_input_node = node_def_pb2.NodeDef()
-                        new_input_node.CopyFrom(node_map[input_node_name])
-                        new_input_node.name = input_node_name + "_" + str(len(input_map[input_node_name]))
-                        node.input[input_idx] = new_input_node.name
-                        output_graph_def.node.extend([new_input_node])
-                    else:
-                        input_map[input_node_name] = [node.name]
-            output_graph_def.node.extend([node])
-
-        return output_graph_def if is_shared_input else input_graph_def
-
-    @staticmethod
-    def remove_training_nodes(input_graph, protected_nodes=[], types_to_splice=["Identity", "CheckNumerics"]):
-        """Prunes out nodes that aren't needed for inference.
-
-        Args:
-            input_graph: Model to analyze and prune.
-            types_to_splice: An optional list of types of nodes to be removed
-            unconditionally.
-
-        Returns:
-            A optimized graphdef object.
-        """
-        input_nodes = input_graph.node
-
-        control_input_names = set()
-        node_names_with_control_input = set()
-        for node in input_nodes:
-            for node_input in node.input:
-                if "^" in node_input:
-                    control_input_names.add(node_input.replace("^", ""))
-                    node_names_with_control_input.add(node.name)
-
-        names_to_splice = {}
-        for node in input_nodes:
-            if node.op in types_to_splice:
-                # We don't want to remove nodes that have control edge inputs, because
-                # they might be involved in subtle dependency issues that removing them
-                # will jeopardize.
-                if node.name not in node_names_with_control_input:
-                    names_to_splice[node.name] = node.input[0]
-
-        # We also don't want to remove nodes which are used as control edge inputs.
-        names_to_splice = {name: value for name, value in names_to_splice.items() if name not in control_input_names}
-
-        nodes_after_splicing = []
-
-        for node in input_nodes:
-            if node.name in names_to_splice and node.name not in protected_nodes:
-                continue
-
-            if node.name in protected_nodes and node.name in types_to_splice:
-                nodes_after_splicing.append(node)
-                continue
-
-            new_node = node_def_pb2.NodeDef()
-            new_node.CopyFrom(node)
-            input_before_removal = node.input
-            del new_node.input[:]
-            for full_input_name in input_before_removal:
-                input_name = re.sub(r"^\^", "", full_input_name)
-                while input_name in names_to_splice:
-                    full_input_name = names_to_splice[input_name]
-                    input_name = re.sub(r"^\^", "", full_input_name)
-                new_node.input.append(full_input_name)
-            nodes_after_splicing.append(new_node)
-
-        output_graph = graph_pb2.GraphDef()
-        output_graph.node.extend(nodes_after_splicing)
-        return output_graph
-
-    @staticmethod
-    def create_node(op, name, inputs):
-        """Create a nodedef object.
-
-        Args:
-            op (string): op type
-            name (string): op name
-            inputs (string list): op's inputs name
-
-        Returns:
-            nodedef: the created nodedef object
-        """
-        new_node = node_def_pb2.NodeDef()
-        new_node.op = op
-        new_node.name = name
-        for input_name in inputs:
-            new_node.input.extend([input_name])
-        return new_node
-
-    @staticmethod
-    def create_constant_node(name, value, dtype, shape=None, device="cpu"):
-        """Create constant node.
-
-        Args:
-            name (string): op name
-            value (np.array): input data
-            dtype (datatype): data type of the input value
-            shape (int list, optional): the value's shape. Defaults to None.
-            device (str, optional): the device type, it may be the 'cpu' or 'gpu'.
-                                    Defaults to 'cpu'.
-
-        Returns:
-            [type]: [description]
-        """
-        node = QuantizeGraphHelper.create_node("Const" if device == "cpu" else "HostConst", name, [])
-        QuantizeGraphHelper.set_attr_dtype(node, "dtype", dtype)
-        QuantizeGraphHelper.set_attr_tensor(node, "value", value, dtype, shape)
-        return node
-
-    @staticmethod
-    def copy_attr(node, key, attr_value):
-        """Copy the specified attr value to node.
-
-        Args:
-            node (nodedef): a nodedef object
-            key (string): string name
-            attr_value (any): the specified attribute value
-        """
-        node.attr[key].CopyFrom(attr_value)
-
-    @staticmethod
-    def set_attr_dtype(node, key, value):
-        """Set the attribute data type."""
-        node.attr[key].CopyFrom(attr_value_pb2.AttrValue(type=value.as_datatype_enum))
-
-    @staticmethod
-    def set_attr_tensor(node, key, value, dtype, shape=None):
-        """Set the tensor value to specified attribute field.
-
-        Args:
-            node (nodedef): the target nodedef object
-            key (string): attribute name
-            value (np.array): the content
-            dtype (dtypes): data type
-            shape (int list, optional): the input tensor's shape. Defaults to None.
-        """
-        node.attr[key].CopyFrom(
-            attr_value_pb2.AttrValue(tensor=tensor_util.make_tensor_proto(value, dtype=dtype, shape=shape))
-        )
-
-    @staticmethod
-    def set_attr_string_list(node, key, value):
-        """Set the node's attr which data type is int list."""
-        list_value = attr_value_pb2.AttrValue.ListValue(s=value)
-        node.attr[key].CopyFrom(attr_value_pb2.AttrValue(list=list_value))
-
-    @staticmethod
-    def set_attr_type_list(node, key, value):
-        """Set the node's attr which data type is int list."""
-        list_value = attr_value_pb2.AttrValue.ListValue(type=value)
-        node.attr[key].CopyFrom(attr_value_pb2.AttrValue(list=list_value))
-
-    @staticmethod
-    def set_attr_string(node, key, value):
-        """Set the node's attr which data type is string."""
-        node.attr[key].CopyFrom(attr_value_pb2.AttrValue(s=value))
-
-    @staticmethod
-    def set_attr_bool(node, key, value):
-        """Set the node's attr which data type is bool."""
-        node.attr[key].CopyFrom(attr_value_pb2.AttrValue(b=value))
-
-    @staticmethod
-    def set_attr_int(node, key, value):
-        """Set the node's attr which data type is int."""
-        node.attr[key].CopyFrom(attr_value_pb2.AttrValue(i=value))
-
-    @staticmethod
-    def set_attr_float(node, key, value):
-        """Set the node's attr which data type is float."""
-        node.attr[key].CopyFrom(attr_value_pb2.AttrValue(f=value))
-
-    @staticmethod
-    def node_name_from_input(node_name):
-        """Static method that get the valid node name from input name.
-
-        Args:
-            node_name (string): node name defined in the input field.
-
-        Returns:
-            string: node's name
-        """
-        if node_name not in QuantizeGraphHelper.node_name_cache:
-            key = node_name
-            if node_name.startswith("^"):
-                node_name = node_name[1:]
-            m = re.search(r"(.*):\d+$", node_name)
-            if m:
-                node_name = m.group(1)
-            QuantizeGraphHelper.node_name_cache[key] = node_name
-            return node_name
-
-        return QuantizeGraphHelper.node_name_cache[node_name]
-
-    @staticmethod
-    def unique_node_name_from_input(node_name):
-        """Get the node name from other node name's input field."""
-        return node_name.replace(":", "__port__").replace("^", "__hat__")
-
-    @staticmethod
-    def ensure_tensor_name_has_port(node_name):
-        """Makes sure that a tensor name has :0 if no explicit port exists."""
-        if node_name not in QuantizeGraphHelper.node_name_port_cache:
-            key = node_name
-            m = re.search(r"(.*):\d+$", node_name)
-            if not m:
-                node_name = node_name + ":0"
-            QuantizeGraphHelper.node_name_port_cache[key] = node_name
-            return node_name
-
-        return QuantizeGraphHelper.node_name_port_cache[node_name]
-
-    @staticmethod
-    def generate_quantized_weight_node(
-        host_op_type, input_node, per_channel, weight_bit=7.0, device="cpu", enter_node=None
-    ):
-        """Generated the quantized weight node."""
-        base_name = input_node.name + "_"
-        qint8_const_name = base_name + "qint8_const"
-        min_name = base_name + "min"
-        max_name = base_name + "max"
-        float_tensor = tensor_util.MakeNdarray(input_node.attr["value"].tensor)
-        epsilon = 1e-4  # Needs to be set empirically if accuracy is not satisfactory
-        range_coefficent = 127 / (2**weight_bit - 1)
-        if host_op_type in (
-            "Conv2D",
-            "MatMul",
-            "Conv3D",
-            "BatchMatMulV2",
-            "Conv2DBackpropInput",
-            "Conv3DBackpropInputV2",
-        ):
-            if per_channel:
-                if host_op_type in ("Conv3D", "Conv3DBackpropInputV2"):
-                    ranges = np.abs(float_tensor).max(axis=(0, 1, 2, 3))
-                elif host_op_type in ("Conv2D", "Conv2DBackpropInput"):
-                    ranges = np.abs(float_tensor).max(axis=(0, 1, 2))
-                elif host_op_type in ("MatMul"):
-                    if "transpose_b" in input_node.attr and input_node.attr["transpose_b"].b:  # pragma: no cover
-                        ranges = np.abs(float_tensor).max(axis=(1))
-                    else:
-                        ranges = np.abs(float_tensor).max(axis=(0))
-                else:
-                    ranges = np.abs(float_tensor).max(axis=(0, 1, 2))
-
-                ranges *= range_coefficent
-                min_value = -ranges
-                max_value = ranges
-                # nudging min-max values outside epsilon radius around zero
-                ranges[ranges < epsilon] = epsilon
-                min_value[np.abs(min_value) < epsilon] = -epsilon
-                max_value[np.abs(max_value) < epsilon] = epsilon
-                if "transpose_b" in input_node.attr and input_node.attr["transpose_b"].b:  # pragma: no cover
-                    # transpose for broadcasting
-                    float_tensor = np.transpose(float_tensor, [1, 0])
-                    qint8_tensor = (np.around(float_tensor * 127.0 / ranges)).astype(np.int8)
-                    qint8_tensor = np.transpose(qint8_tensor, [1, 0])
-                else:
-                    qint8_tensor = (np.around(float_tensor * 127.0 / ranges)).astype(np.int8)
-            else:
-                min_value = np.min(float_tensor)
-                max_value = np.max(float_tensor)
-                min_value *= range_coefficent
-                max_value *= range_coefficent
-                min_value = min(min_value, 0.0)
-                if min_value == max_value:
-                    if abs(min_value) < 0.000001:
-                        max_value = min_value + 1.0
-                    elif min_value > 0:
-                        max_value = 2 * min_value
-                    else:
-                        max_value = min_value / 2.0
-                range_value = np.max(np.abs([min_value, max_value]))
-                qint8_tensor = (np.around(float_tensor * 127.0 / range_value)).astype(np.int8)
-                qint8_tensor = np.clip(qint8_tensor, -127, 127).astype(np.int8)
-                min_value = -range_value
-                max_value = range_value
-        elif host_op_type == "DepthwiseConv2dNative":
-            # get the max values based on dim 0 and 1 for depthwise conv
-            # since, the output channel will be dim 2 * dim 3
-            ranges = np.abs(float_tensor).max(axis=(0, 1))
-            ranges = ranges.flatten()
-            min_value = -ranges
-            max_value = ranges
-            # nudging min-max values outside epsilon radius around zero
-            ranges[ranges < epsilon] = epsilon
-            min_value[np.abs(min_value) < epsilon] = -epsilon
-            max_value[np.abs(max_value) < epsilon] = epsilon
-            # Since output channel will be 1 dim which is dim 2 * dim 3
-            # When divide by range, qint8_tensor needs to be 3 dim
-            # where, 3rd dim should be same dim of ranges
-            a, b, c, d = float_tensor.shape
-            qint8_tensor = (np.around(float_tensor.reshape(a, b, c * d) * 127.0 / ranges)).astype(np.int8)
-            # get the shape back to 4 dim
-            qint8_tensor = qint8_tensor.reshape(a, b, c, d)
-        shape = tensor_util.TensorShapeProtoToList(input_node.attr["value"].tensor.tensor_shape)
-        qint8_const_node = QuantizeGraphHelper.create_constant_node(
-            qint8_const_name, qint8_tensor, dtypes.qint8, shape=shape
-        )
-        min_node = QuantizeGraphHelper.create_constant_node(min_name, min_value, dtypes.float32, device="cpu")
-
-        max_node = QuantizeGraphHelper.create_constant_node(max_name, max_value, dtypes.float32, device="cpu")
-
-        qint8_const_enter_node = None
-        min_enter_node = None
-        max_enter_node = None
-
-        if enter_node:
-            qint8_const_enter_node = QuantizeGraphHelper.create_node(
-                "Enter", qint8_const_name + "_enter", [qint8_const_name]
-            )
-            QuantizeGraphHelper.set_attr_string(qint8_const_enter_node, "frame_name", enter_node.attr["frame_name"].s)
-            QuantizeGraphHelper.set_attr_dtype(qint8_const_enter_node, "T", dtypes.qint8)
-            QuantizeGraphHelper.set_attr_bool(qint8_const_enter_node, "is_constant", True)
-            QuantizeGraphHelper.set_attr_int(
-                qint8_const_enter_node, "parallel_iterations", enter_node.attr["parallel_iterations"].i
-            )
-
-            min_enter_node = QuantizeGraphHelper.create_node("Enter", min_name + "_enter", [min_name])
-            QuantizeGraphHelper.set_attr_string(min_enter_node, "frame_name", enter_node.attr["frame_name"].s)
-            QuantizeGraphHelper.set_attr_dtype(min_enter_node, "T", dtypes.float32)
-            QuantizeGraphHelper.set_attr_bool(min_enter_node, "is_constant", True)
-            QuantizeGraphHelper.set_attr_int(
-                min_enter_node, "parallel_iterations", enter_node.attr["parallel_iterations"].i
-            )
-
-            max_enter_node = QuantizeGraphHelper.create_node("Enter", max_name + "_enter", [max_name])
-            QuantizeGraphHelper.set_attr_string(max_enter_node, "frame_name", enter_node.attr["frame_name"].s)
-            QuantizeGraphHelper.set_attr_dtype(max_enter_node, "T", dtypes.float32)
-            QuantizeGraphHelper.set_attr_bool(max_enter_node, "is_constant", True)
-            QuantizeGraphHelper.set_attr_int(
-                max_enter_node, "parallel_iterations", enter_node.attr["parallel_iterations"].i
-            )
-
-        return qint8_const_node, min_node, max_node, qint8_const_enter_node, min_enter_node, max_enter_node
diff --git a/neural_compressor/tensorflow/quantization/utils/transform_graph/__init__.py b/neural_compressor/tensorflow/quantization/utils/transform_graph/__init__.py
deleted file mode 100644
index a657ffcb4b1..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/transform_graph/__init__.py
+++ /dev/null
@@ -1,18 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-#  Copyright (c) 2021 Intel Corporation
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-#
-"""Tensorflow Graph Transformers."""
diff --git a/neural_compressor/tensorflow/quantization/utils/transform_graph/bias_correction.py b/neural_compressor/tensorflow/quantization/utils/transform_graph/bias_correction.py
deleted file mode 100644
index ae290b54d44..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/transform_graph/bias_correction.py
+++ /dev/null
@@ -1,137 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-#  Copyright (c) 2021 Intel Corporation
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-#
-"""Bias correction graph transform."""
-
-from __future__ import absolute_import, division, print_function
-
-import numpy as np
-from tensorflow.core.framework import attr_value_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-
-from .graph_transform_base import GraphTransformBase
-
-
-class BiasCorrection(GraphTransformBase):
-    """This class implements the bias correction graph transform.
-
-    Will correct the weight and scale for *Conv2D* op
-    weight_empirical:
-    our task is to correct int8 weight distribution close to fp32 weight
-    r*(W_int8 + u) -> W_fp32, r is variance ratio between fp32 and int8
-    u is the difference between fp32 and int8 channel wise, it's equal to minimize:
-    round(scale_c * (W_fp32 + shift))/scale - r*(round(scale * W_fp32) + scale*u)/scale
-    notice we can only change the first round: round(scale_c * (W_fp32 + shift))
-    an empirical solution is to make:
-    scale_c = r * scale and shift = u
-    with this we don't change the min/max value, and correct the weight
-    """
-
-    def __init__(self, input_graph, fp32_graph, method="weight_empirical", new_api=False):
-        """Initialization."""
-        # only support weight_empirical now
-        self.bias_correct_map = {"weight_empirical": self._weight_empirical}
-        assert method in self.bias_correct_map, "only support weight empirical correction method"
-
-        super(BiasCorrection, self).__init__(input_graph)
-        self.fp32_graph = fp32_graph
-        self.input_graph = input_graph
-        self.method = method
-        self.fp32_node_mapping = {}
-        self.parse_input_pb()
-        self.new_api = new_api
-
-    def _weight_empirical(self):
-        """Weight empirical correction method."""
-        for node in self.fp32_graph.node:
-            if node.name not in self.fp32_node_mapping:
-                self.fp32_node_mapping[node.name] = node
-
-        for node_name in self.node_mapping:
-            node = self.node_mapping[node_name]
-            node_op = node.op
-            if self.new_api:
-                if "_FusedQuantizedConv2D" not in node_op:
-                    continue
-            else:
-                if "QuantizedConv2D" not in node_op:
-                    continue
-
-            int8_filter = self.node_mapping[self.get_node_name_from_input(node.input[1])]
-
-            int8_value = tensor_util.MakeNdarray(int8_filter.attr["value"].tensor)
-            tr_int8_value = int8_value.transpose([3, 0, 1, 2])
-
-            fp32_filter_name = self.get_node_name_from_input(node.input[1]).split("_qint8_const")[0]
-            fp32_filter = self.fp32_node_mapping[fp32_filter_name]
-
-            fp32_value = tensor_util.MakeNdarray(fp32_filter.attr["value"].tensor)
-            tr_fp32_value = fp32_value.transpose([3, 0, 1, 2])
-
-            # if bias fused, then offset to min/max filter should be 5
-            if self.new_api:
-                offset = 5
-            else:
-                offset = 5 if "Bias" in node_op else 4
-            min_filter_node = self.node_mapping[node.input[offset]]
-            max_filter_node = self.node_mapping[node.input[offset + 1]]
-
-            channel_size = (
-                1
-                if not min_filter_node.attr["value"].tensor.tensor_shape.dim
-                else min_filter_node.attr["value"].tensor.tensor_shape.dim[0].size
-            )
-
-            if channel_size == 1:
-                max_filter_tensor = []
-                min_filter_tensor = []
-                max_filter_tensor.append((max_filter_node.attr["value"].tensor.float_val)[0])
-                min_filter_tensor.append((min_filter_node.attr["value"].tensor.float_val)[0])
-            else:
-                max_filter_tensor = tensor_util.MakeNdarray(max_filter_node.attr["value"].tensor)
-                min_filter_tensor = tensor_util.MakeNdarray(min_filter_node.attr["value"].tensor)
-
-            tr_quantized_fp32_value = np.zeros_like(tr_fp32_value)
-            tr_corrected_int8_value = np.zeros_like(tr_int8_value)
-
-            for i in range(channel_size):
-                scale = max(abs(max_filter_tensor[i]), abs(min_filter_tensor[i])) / 127
-                tr_quantized_fp32_value[i] = tr_int8_value[i].astype(np.float64) * scale
-                delta_mean = np.mean((tr_fp32_value[i] - tr_quantized_fp32_value[i]).flatten())
-                var_ratio = (
-                    np.std(tr_fp32_value[i].flatten()) / np.std(tr_quantized_fp32_value[i].flatten())
-                    if np.std(tr_quantized_fp32_value[i].flatten()) != 0
-                    else 1
-                )
-                tr_corrected_int8_value[i] = (var_ratio / scale) * (tr_fp32_value[i] + delta_mean)
-
-            correct_int8_value = tr_int8_value.transpose([1, 2, 3, 0])
-            assert (
-                int8_value.shape == correct_int8_value.shape
-            ), "correct filter shape should equal with origin filter shape"
-            bias = int8_value.astype(np.float32) - correct_int8_value.astype(np.float32)
-            if np.sum(bias) != 0:
-                int8_filter.attr["value"].CopyFrom(
-                    attr_value_pb2.AttrValue(
-                        tensor=tensor_util.make_tensor_proto(correct_int8_value, dtypes.qint8, int8_value.shape)
-                    )
-                )
-        return self.input_graph
-
-    def do_transformation(self):
-        """Apply bias correction graph transform."""
-        return self.bias_correct_map[self.method]()
diff --git a/neural_compressor/tensorflow/quantization/utils/transform_graph/graph_transform_base.py b/neural_compressor/tensorflow/quantization/utils/transform_graph/graph_transform_base.py
deleted file mode 100644
index 29c7a9d4352..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/transform_graph/graph_transform_base.py
+++ /dev/null
@@ -1,111 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-#  Copyright (c) 2021 Intel Corporation
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-#
-"""GraphTransform Base Class."""
-
-from __future__ import absolute_import, division, print_function
-
-import logging
-import re
-
-from tensorflow.core.framework import graph_pb2
-from tensorflow.python.platform import gfile
-
-logger = logging.getLogger("neural_compressor")
-
-
-class GraphTransformBase(object):
-    """GraphTransform Base Class."""
-
-    def __init__(self, input_pb):
-        """Basic class for graph transformation.
-
-        Args:
-             input_pb: the input graphdef or pb file.
-        """
-        if isinstance(input_pb, graph_pb2.GraphDef):
-            self.input_graph = input_pb
-        else:
-            try:
-                with gfile.Open(input_pb, "rb") as f:
-                    self.input_graph.ParseFromString(f.read())
-            except Exception as e:
-                logger.error("Fail to read input pb from {} due to {}.".format(input_pb, str(e)))
-
-        self.node_mapping = {}
-        self.node_name_list = []
-        self.output_node_map = {}
-        self.generate_input_map()
-
-    def parse_input_pb(self):
-        """Parse the input pbdef to get the node name and node mapping.
-
-        Returns:
-            the dict that key is node name while the value is nodeDef.
-        """
-        for node in self.input_graph.node:
-            self.node_name_list.append(node.name)
-
-            if node.name not in self.node_mapping:
-                self.node_mapping[node.name] = node
-            else:
-                logger.warning("Duplicated node name {}.".format(node.name))
-
-    def generate_input_map(self):
-        """Generate the input map."""
-        self.input_node_map = {}
-        for node in self.input_graph.node:
-            node_name = self.node_name_from_input(node.name)
-            if node_name not in self.input_node_map:
-                self.input_node_map[node_name] = node
-            else:
-                raise ValueError("Duplicate node names detected for ", node.name)
-
-    def node_name_from_input(self, node_name):
-        """Get the original node name from input string.
-
-        Args:
-            node_name: input node's name in string
-
-        Returns:
-            node's name
-        """
-        if node_name.startswith("^"):  # pragma: no cover
-            node_name = node_name[1:]
-        m = re.search(r"(.*):\d+$", node_name)
-        if m:
-            node_name = m.group(1)
-        return node_name
-
-    def get_node_name_from_input(self, node_name):
-        """Get the original node name from input string.
-
-        Args:
-            node_name: input node's name in string
-
-        Returns:
-            node's name
-        """
-        node_names = node_name.split(":")
-        return node_names[0]
-
-    def do_transformation(self):
-        """Virtual Interface.
-
-        Each transformation should implement it.
-        """
-        pass
diff --git a/neural_compressor/tensorflow/quantization/utils/transform_graph/insert_logging.py b/neural_compressor/tensorflow/quantization/utils/transform_graph/insert_logging.py
deleted file mode 100644
index 1dcf5333b73..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/transform_graph/insert_logging.py
+++ /dev/null
@@ -1,199 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-#  Copyright (c) 2021 Intel Corporation
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-#
-"""Insert logging graph transformation."""
-
-from __future__ import absolute_import, division, print_function
-
-from tensorflow.core.framework import attr_value_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes
-
-from .graph_transform_base import GraphTransformBase
-
-
-class InsertLogging(GraphTransformBase):
-    """Insert logging graph transformation."""
-
-    op_output_type_mapping = {
-        "RequantizationRange": [dtypes.float32.as_datatype_enum, dtypes.float32.as_datatype_enum],
-        "RequantizationRangePerChannel": [dtypes.float32.as_datatype_enum, dtypes.float32.as_datatype_enum],
-        "QuantizedConv2DWithBiasAndRelu": [dtypes.qint32.as_datatype_enum],
-        "QuantizedConv2DWithBiasAndReluAndRequantize": [dtypes.quint8.as_datatype_enum],
-        "QuantizedConv2DWithBiasAndRequantize": [dtypes.qint8.as_datatype_enum],
-        "QuantizedConv2DWithBiasSignedSumAndReluAndRequantize": [dtypes.qint8.as_datatype_enum],
-        "QuantizedConv2DWithBiasSumAndReluAndRequantize": [dtypes.quint8.as_datatype_enum],
-        "QuantizedDepthwiseConv2DWithBiasAndReluAndRequantize": [dtypes.quint8.as_datatype_enum],
-        "QuantizedConv2DWithBias": [dtypes.qint32.as_datatype_enum],
-        "Relu": [dtypes.float32.as_datatype_enum],
-        "Relu6": [dtypes.float32.as_datatype_enum],
-        "AvgPool": [dtypes.float32.as_datatype_enum],
-        "MaxPool": [dtypes.float32.as_datatype_enum],
-        "BiasAdd": [dtypes.float32.as_datatype_enum],
-        "Max": [dtypes.float32.as_datatype_enum],
-        "Min": [dtypes.float32.as_datatype_enum],
-    }
-
-    def __init__(
-        self,
-        input_pb,
-        ops=[],
-        node_name_list=[],
-        show_name=True,
-        show_op=False,
-        first_n=-1,
-        summarize=1024,
-        message="",
-        dump_fp32=False,
-    ):
-        """Initialization."""
-        super(InsertLogging, self).__init__(input_pb)
-
-        self.parse_input_pb()
-        self.ops = ops
-        self.node_name_list = node_name_list
-        self.show_name = show_name
-        self.show_op = show_op
-        self.message = message
-        self.first_n = first_n
-        self.summarize = summarize
-        self.output_name_index_mapping = {}
-        self.input_rename = {}
-        self.dump_fp32 = dump_fp32
-
-    def _get_suffix(self, input_str):
-        """Split the node name into two parts.
-
-        Returns:
-            Pure string name without suffix
-            Index of the node
-        """
-        splitted_str = input_str.split(":")
-        if len(splitted_str) < 2:
-            return input_str, 0
-
-        return splitted_str[0], int(splitted_str[-1])
-
-    def _get_output_index_mapping(self):
-        """Get the output_node_name and index mapping."""
-        for node_name in self.node_mapping:
-            for node_input in self.node_mapping[node_name].input:
-                node_stripped_name, suffix = self._get_suffix(node_input)
-
-                if node_stripped_name not in self.output_name_index_mapping:
-                    self.output_name_index_mapping[node_stripped_name] = set()
-
-                self.output_name_index_mapping[node_stripped_name].add(suffix)
-
-    def _insert_node(self):
-        """Insert the Print OP into the graph."""
-        for node_name in self.node_mapping:
-            if node_name not in self.output_name_index_mapping or (
-                not self.dump_fp32 and node_name.find("eightbit") == -1
-            ):
-                continue
-
-            if self.ops and self.node_mapping[node_name].op in self.ops or node_name in self.node_name_list:
-                name_suffix = "__print__"
-                print_node = node_def_pb2.NodeDef()
-                print_node.op = "Print"
-                print_node.name = node_name + name_suffix
-                node_message = ""
-                if self.show_op:
-                    node_message += ";" + self.node_mapping[node_name].op + ";"
-                if self.show_name:
-                    node_message += ";" + print_node.name + ";"
-                node_message += self.message
-
-                print_node.attr["message"].s = node_message.encode()
-                print_node.attr["first_n"].i = self.first_n
-                print_node.attr["summarize"].i = self.summarize
-
-                print_node.input.append(node_name + ":0")
-                print_node.attr["T"].CopyFrom(
-                    attr_value_pb2.AttrValue(type=self.op_output_type_mapping[self.node_mapping[node_name].op][0])
-                )
-
-                if self.node_mapping[node_name].op in ("QuantizedConv2DWithBias", "QuantizedConv2DWithBiasAndRelu"):
-                    for index in sorted(self.output_name_index_mapping[node_name])[:1]:
-                        print_node.input.append(node_name + ":" + str(index))
-
-                        print_node_1 = node_def_pb2.NodeDef()
-                        print_node_1.op = "Print"
-                        print_node_1.name = node_name + name_suffix + "_min_output"
-
-                        print_node_1.attr["message"].s = (node_message + "_min_output").encode()
-                        print_node_1.attr["first_n"].i = self.first_n
-                        print_node_1.attr["summarize"].i = self.summarize
-                        print_node_1.attr["U"].list.CopyFrom(
-                            attr_value_pb2.AttrValue.ListValue(type=[dtypes.float32.as_datatype_enum])
-                        )
-                        print_node_1.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-                        print_node_1.input.append(node_name + ":1")
-                        print_node_1.input.append(node_name + ":1")
-                        self.input_graph.node.extend([print_node_1])
-                        self.input_rename[node_name + ":1"] = print_node_1.name + ":0"
-
-                        print_node_2 = node_def_pb2.NodeDef()
-                        print_node_2.op = "Print"
-                        print_node_2.name = node_name + name_suffix + "_max_output"
-
-                        print_node_2.attr["message"].s = (node_message + "_max_output").encode()
-                        print_node_2.attr["first_n"].i = self.first_n
-                        print_node_2.attr["summarize"].i = self.summarize
-                        print_node_2.attr["U"].list.CopyFrom(
-                            attr_value_pb2.AttrValue.ListValue(type=[dtypes.float32.as_datatype_enum])
-                        )
-                        print_node_2.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-                        print_node_2.input.append(node_name + ":2")
-                        print_node_2.input.append(node_name + ":2")
-                        self.input_graph.node.extend([print_node_2])
-                        self.input_rename[node_name + ":2"] = print_node_2.name + ":0"
-                else:
-                    for index in range(len(self.op_output_type_mapping[self.node_mapping[node_name].op])):
-                        print_node.input.append(
-                            node_name + ":" + str(sorted(self.output_name_index_mapping[node_name])[index])
-                        )
-
-                print_node.attr["U"].list.CopyFrom(
-                    attr_value_pb2.AttrValue.ListValue(
-                        type=self.op_output_type_mapping[self.node_mapping[node_name].op]
-                    )
-                )
-
-                self.input_graph.node.extend([print_node])
-
-                self.input_rename[node_name + ":0"] = print_node.name + ":0"
-
-    def _rename_node(self):
-        """Rename the original input node and connect to new added print node."""
-        for node_name in self.node_mapping:
-            for index, input_name in enumerate(self.node_mapping[node_name].input):
-                if input_name in self.input_rename:
-                    self.node_mapping[node_name].input[index] = self.input_rename[input_name]
-                elif input_name + ":0" in self.input_rename:
-                    self.node_mapping[node_name].input[index] = self.input_rename[input_name + ":0"]
-
-    def do_transformation(self):
-        """Execute the insert logging transformation.
-
-        :return: Transformed graph
-        """
-        self._get_output_index_mapping()
-        self._insert_node()
-        self._rename_node()
-
-        return self.input_graph
diff --git a/neural_compressor/tensorflow/quantization/utils/transform_graph/rerange_quantized_concat.py b/neural_compressor/tensorflow/quantization/utils/transform_graph/rerange_quantized_concat.py
deleted file mode 100644
index f816cf5bf48..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/transform_graph/rerange_quantized_concat.py
+++ /dev/null
@@ -1,313 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-#  Copyright (c) 2021 Intel Corporation
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-#
-"""ConcatV2 rerange transform."""
-
-from __future__ import absolute_import, division, print_function
-
-import numpy as np
-from tensorflow.core.framework import attr_value_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-
-from .graph_transform_base import GraphTransformBase
-
-
-class RerangeQuantizedConcat(GraphTransformBase):
-    """This class implements the rerange_quantize concat graph transform."""
-
-    fused_requantized_bias_op = (
-        "QuantizedConv2DWithBiasAndRequantize",
-        "QuantizedConv2DWithBiasAndReluAndRequantize",
-        "QuantizedConv2DWithBiasSumAndReluAndRequantize",
-        "QuantizedConv2DWithBiasSignedSumAndReluAndRequantize",
-    )
-    fuse_requantized_bias_op_new_api = (
-        [b"BiasAdd", b"Requantize"],
-        [b"BiasAdd", b"Relu", b"Requantize"],
-        [b"BiasAdd", b"LeakyRelu", b"Requantize"],
-        [b"BiasAdd", b"Sum", b"Relu", b"Requantize"],
-        [b"BiasAdd", b"Sum", b"Requantize"],
-        [b"BiasAdd", b"Elu", b"Requantize"],
-    )
-    fuse_requantized_relu_op_new_api = (
-        [b"BiasAdd", b"Relu", b"Requantize"],
-        [b"BiasAdd", b"LeakyRelu", b"Requantize"],
-        # [b'BiasAdd', b'Sum',  b'Relu',  b'Requantize']
-        [b"BiasAdd", b"Elu", b"Requantize"],
-    )
-    offset_map = {
-        "QuantizedConv2DAndRequantize": 6,
-        "QuantizedConv2DAndReluAndRequantize": 6,
-        "QuantizedConv2DWithBiasAndRequantize": 7,
-        "QuantizedConv2DWithBiasAndReluAndRequantize": 7,
-        "QuantizedConv2DWithBiasSumAndReluAndRequantize": 7,
-        "QuantizedConv2DWithBiasSignedSumAndReluAndRequantize": 7,
-    }
-    offset_map_new_api = {
-        str([b"Requantize"]): 6,
-        str([b"Relu", b"Requantize"]): 6,
-        str([b"LeakyRelu", b"Requantize"]): 6,
-        str([b"BiasAdd", b"Requantize"]): 7,
-        str([b"BiasAdd", b"Relu", b"Requantize"]): 7,
-        str([b"BiasAdd", b"LeakyRelu", b"Requantize"]): 7,
-        str([b"BiasAdd", b"Elu", b"Requantize"]): 7,
-        str([b"BiasAdd", b"Sum", b"Relu", b"Requantize"]): 10,
-        str([b"BiasAdd", b"Sum", b"Requantize"]): 10,
-    }
-
-    def __init__(self, input_pb, device, performance_only=False):
-        """Initialization."""
-        super().__init__(input_pb)
-
-        self.parse_input_pb()
-        self.concat_node_input_mapping = {}
-        self.rerange_concat_node = []
-        self.device = device
-        self.performance_only = performance_only
-
-    def _analyze_concat_node_recursively(self, quantized_conv_nodes, input_node):
-        """Analyze all the ConcatV2 nodes recursively."""
-        op_type = input_node.op
-        if op_type == "QuantizedConcatV2":
-            can_rerange = True
-            concat_input_num = input_node.attr["N"].i
-            for index in range(concat_input_num):
-                concat_input_node = self.node_mapping[self.get_node_name_from_input(input_node.input[index])]
-                concat_input_node_op_type = concat_input_node.op
-                if concat_input_node_op_type in self.offset_map:
-                    quantized_conv_nodes.append(concat_input_node)
-                elif (
-                    concat_input_node.op == "_FusedQuantizedConv2D"
-                    and "fused_ops" in concat_input_node.attr
-                    and str(concat_input_node.attr["fused_ops"].list.s) in self.offset_map_new_api
-                ):
-                    quantized_conv_nodes.append(concat_input_node)
-                elif concat_input_node_op_type in ("QuantizedMaxPool", "QuantizedAvgPool"):
-                    another_concat_node = self.node_mapping[self.get_node_name_from_input(concat_input_node.input[0])]
-                    if self.performance_only:
-                        if (
-                            another_concat_node.op == "_FusedQuantizedConv2D"
-                            and "fused_ops" in another_concat_node.attr
-                            and str(another_concat_node.attr["fused_ops"].list.s) in self.offset_map_new_api
-                        ):
-                            quantized_conv_nodes.append(another_concat_node)
-                    else:
-                        if not self._analyze_concat_node_recursively(quantized_conv_nodes, another_concat_node):
-                            can_rerange = False
-                            break
-                elif concat_input_node_op_type == "QuantizedConcatV2":
-                    if not self._analyze_concat_node_recursively(quantized_conv_nodes, concat_input_node):
-                        can_rerange = False
-                        break
-                elif self.performance_only and concat_input_node_op_type == "QuantizeV2":
-                    quantized_conv_nodes.append(concat_input_node)
-                else:
-                    can_rerange = False
-                    break
-
-            return can_rerange
-        elif op_type == "QuantizedConv2DWithBiasAndReluAndRequantize" or (
-            input_node.op == "_FusedQuantizedConv2D"
-            and "fused_ops" in input_node.attr
-            and input_node.attr["fused_ops"].list.s in self.fuse_requantized_relu_op_new_api
-        ):
-            can_rerange = True
-            quantized_conv_nodes.append(input_node)
-            return can_rerange
-        else:
-            return False
-
-    def do_transformation(self):
-        """Apply the rerange quantized ConcatV2 transform."""
-        for _, node in enumerate(self.input_graph.node):
-            if node.op != "QuantizedConcatV2":
-                continue
-            quantized_conv_nodes = []
-            can_rerange = self._analyze_concat_node_recursively(quantized_conv_nodes, node)
-            if not can_rerange:
-                continue
-
-            self.rerange_concat_node.append(node.name)
-            combined_min = np.finfo(np.float64).max
-            combined_max = -combined_min
-
-            for node in quantized_conv_nodes:
-                offset_value = 6
-                if (
-                    node.op == "_FusedQuantizedConv2D"
-                    and "fused_ops" in node.attr
-                    and str(node.attr["fused_ops"].list.s) in self.offset_map_new_api
-                ):
-                    offset_value = self.offset_map_new_api[str(node.attr["fused_ops"].list.s)]
-                elif self.performance_only and node.op == "QuantizeV2":
-                    offset_value = 1
-                else:
-                    offset_value = self.offset_map[node.op]
-                min_value_node = self.node_mapping[node.input[offset_value]]
-                max_value_node = self.node_mapping[node.input[offset_value + 1]]
-                min_value = min_value_node.attr["value"].tensor.float_val[0]
-                max_value = max_value_node.attr["value"].tensor.float_val[0]
-                if min_value < combined_min:
-                    combined_min = min_value
-                if max_value > combined_max:
-                    combined_max = max_value
-
-            if self.performance_only:
-                combined_value = max(abs(combined_min), abs(combined_max))
-                combined_min = -combined_value
-                combined_max = combined_value
-
-            for node in quantized_conv_nodes:
-                offset_value = 6
-                if (
-                    node.op == "_FusedQuantizedConv2D"
-                    and "fused_ops" in node.attr
-                    and str(node.attr["fused_ops"].list.s) in self.offset_map_new_api
-                ):
-                    offset_value = self.offset_map_new_api[str(node.attr["fused_ops"].list.s)]
-                elif self.performance_only and node.op == "QuantizeV2":
-                    offset_value = 1
-                else:
-                    offset_value = self.offset_map[node.op]
-
-                min_value_node = self.node_mapping[node.input[offset_value]]
-                max_value_node = self.node_mapping[node.input[offset_value + 1]]
-                min_value_node.attr["value"].CopyFrom(
-                    attr_value_pb2.AttrValue(
-                        tensor=tensor_util.make_tensor_proto(float(combined_min), dtypes.float32, [])
-                    )
-                )
-
-                max_value_node.attr["value"].CopyFrom(
-                    attr_value_pb2.AttrValue(
-                        tensor=tensor_util.make_tensor_proto(float(combined_max), dtypes.float32, [])
-                    )
-                )
-        if self.device == "cpu":
-            self._update_bias()
-        return self.input_graph
-
-    def _update_bias(self):
-        """Convert the bias from float to int."""
-        for node_name in self.node_mapping:
-            current_node = self.node_mapping[node_name]
-            current_node_op = current_node.op
-            if (current_node_op in self.fused_requantized_bias_op) or (
-                current_node_op == "_FusedQuantizedConv2D"
-                and "fused_ops" in current_node.attr
-                and current_node.attr["fused_ops"].list.s in self.fuse_requantized_bias_op_new_api
-            ):
-                done = False
-                another_conv_node = None
-                original_conv_node = current_node
-                while not done:
-                    current_node = self.node_mapping[self.get_node_name_from_input(current_node.input[0])]
-                    if current_node.op in self.offset_map:
-                        another_conv_node = current_node
-                        done = True
-                    elif (
-                        current_node.op == "_FusedQuantizedConv2D"
-                        and "fused_ops" in current_node.attr
-                        and str(current_node.attr["fused_ops"].list.s) in self.offset_map_new_api
-                    ):
-                        another_conv_node = current_node
-                        done = True
-                    elif current_node.op == "QuantizedConcatV2":
-                        if current_node.name not in self.rerange_concat_node:
-                            done = True
-                    elif current_node.op not in ("QuantizedMaxPool", "QuantizedAvgPool"):
-                        done = True
-
-                if not another_conv_node:
-                    continue
-
-                bias_node = self.node_mapping[self.get_node_name_from_input(original_conv_node.input[2])]
-                bias_node_type = original_conv_node.attr["Tbias"]
-
-                if bias_node_type.type != dtypes.float32 or bias_node_type.type == dtypes.qint32:
-                    continue
-                sum_off_set = 0
-                if original_conv_node.op == "_FusedQuantizedConv2D":
-                    if str(original_conv_node.attr["fused_ops"].list.s) == str(
-                        [b"BiasAdd", b"Sum", b"Relu", b"Requantize"]
-                    ) or str(original_conv_node.attr["fused_ops"].list.s) == str([b"BiasAdd", b"Sum", b"Requantize"]):
-                        sum_off_set = 1
-                    # else:
-                    #    print(str(original_conv_node.attr['fused_ops'].list.s))
-                min_filter_node = self.node_mapping[original_conv_node.input[5 + sum_off_set]]
-                max_filter_node = self.node_mapping[original_conv_node.input[6 + sum_off_set]]
-
-                channel_size = (
-                    1
-                    if not min_filter_node.attr["value"].tensor.tensor_shape.dim
-                    else min_filter_node.attr["value"].tensor.tensor_shape.dim[0].size
-                )
-
-                if channel_size == 1:
-                    max_filter_tensor = []
-                    min_filter_tensor = []
-                    max_filter_tensor.append((max_filter_node.attr["value"].tensor.float_val)[0])
-                    min_filter_tensor.append((min_filter_node.attr["value"].tensor.float_val)[0])
-                else:
-                    max_filter_tensor = tensor_util.MakeNdarray(max_filter_node.attr["value"].tensor)
-                    min_filter_tensor = tensor_util.MakeNdarray(min_filter_node.attr["value"].tensor)
-
-                offset_value = 6
-                if (
-                    another_conv_node.op == "_FusedQuantizedConv2D"
-                    and "fused_ops" in another_conv_node.attr
-                    and str(another_conv_node.attr["fused_ops"].list.s) in self.offset_map_new_api
-                ):
-                    offset_value = self.offset_map_new_api[str(another_conv_node.attr["fused_ops"].list.s)]
-                else:
-                    offset_value = self.offset_map[another_conv_node.op]
-
-                min_freezed_output_node = self.node_mapping[another_conv_node.input[offset_value]]
-                max_freezed_output_node = self.node_mapping[another_conv_node.input[offset_value + 1]]
-                min_input = min_freezed_output_node.attr["value"].tensor.float_val[0]
-                max_input = max_freezed_output_node.attr["value"].tensor.float_val[0]
-                # To avoid generating int32 bias exception for corner case
-                if min_input == 0 and max_input == 0:
-                    continue
-
-                bias_tensor = tensor_util.MakeNdarray(bias_node.attr["value"].tensor)
-
-                activation_range = 127.0 if current_node.attr["out_type"].type == dtypes.qint8 else 255.0
-
-                int32_bias = Helper.generate_int32_bias_for_conv(
-                    bias_tensor,
-                    channel_size,
-                    max_input,
-                    min_input,
-                    max_filter_tensor,
-                    min_filter_tensor,
-                    activation_range,
-                )
-
-                original_conv_node.attr["Tbias"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.qint32.as_datatype_enum))
-                bias_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.qint32.as_datatype_enum))
-
-                bias_node.attr["value"].CopyFrom(
-                    attr_value_pb2.AttrValue(
-                        tensor=tensor_util.make_tensor_proto(int32_bias, dtypes.int32, bias_tensor.shape)
-                    )
-                )
-                bias_node.attr["value"].tensor.dtype = dtypes.qint32.as_datatype_enum
-                if "Thost_inputs" in original_conv_node.attr:
-                    original_conv_node.attr["Thost_inputs"].list.type[2] = original_conv_node.attr["Tbias"].type
diff --git a/neural_compressor/tensorflow/quantization/utils/utility.py b/neural_compressor/tensorflow/quantization/utils/utility.py
deleted file mode 100644
index e9a45e39a7b..00000000000
--- a/neural_compressor/tensorflow/quantization/utils/utility.py
+++ /dev/null
@@ -1,621 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-#  Copyright (c) 2021 Intel Corporation
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-#
-"""Tensorflow Utils Helper functions."""
-
-import os
-from collections import OrderedDict, UserDict
-
-import numpy as np
-import tensorflow as tf
-from google.protobuf import text_format
-from tensorflow.core.framework import attr_value_pb2, graph_pb2, node_def_pb2, variable_pb2
-from tensorflow.core.protobuf import config_pb2, meta_graph_pb2
-from tensorflow.python.eager import context, wrap_function
-from tensorflow.python.framework import convert_to_constants
-from tensorflow.python.grappler import tf_optimizer
-from tensorflow.python.platform import gfile
-from tensorflow.python.saved_model import load, save, signature_constants, tag_constants
-from tensorflow.python.training import saver
-from tensorflow.python.util import nest
-
-from neural_compressor.common import logger
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer, GraphRewriterHelper
-
-
-def read_graph(in_graph, in_graph_is_binary=True):
-    """Reads input graph file as GraphDef.
-
-    :param in_graph: input graph file.
-    :param in_graph_is_binary: whether input graph is binary, default True.
-    :return: input graphDef.
-    """
-    assert gfile.Exists(in_graph), "Input graph pb file %s does not exist." % in_graph
-
-    input_graph_def = graph_pb2.GraphDef()
-    mode = "rb" if in_graph_is_binary else "r"
-    with gfile.Open(in_graph, mode) as f:
-        data = f.read()
-        if in_graph_is_binary:
-            input_graph_def.ParseFromString(data)
-        else:
-            text_format.Merge(data, input_graph_def)
-
-    return input_graph_def
-
-
-def write_graph(out_graph_def, out_graph_file):
-    """Write output graphDef to file.
-
-    :param out_graph_def: output graphDef.
-    :param out_graph_file: path to output graph file.
-    :return: None.
-    """
-    assert isinstance(out_graph_def, tf.compat.v1.GraphDef), "out_graph_def is not instance of TensorFlow GraphDef."
-
-    assert out_graph_file and os.path.exists(
-        os.path.dirname(out_graph_file)
-    ), '"output_graph" directory does not exists.'
-
-    f = gfile.GFile(out_graph_file, "wb")
-    f.write(out_graph_def.SerializeToString())
-
-
-def is_ckpt_format(model_path):
-    """Check the model_path format is ckpt or not.
-
-    Args:
-        model_path (string): the model folder path
-
-    Returns:
-        string: return the ckpt prefix if the model_path contains ckpt format data else None.
-    """
-    file_list = [os.path.splitext(i)[-1] for i in os.listdir(model_path)]
-    if file_list.count(".meta") == 1 and file_list.count(".index") == 1:
-        return True
-    return False
-
-
-def _parse_ckpt_bn_input(graph_def):
-    """Parse ckpt batch norm inputs to match correct moving mean and variance.
-
-    Args:
-        graph_def (graph_def): original graph_def
-    Returns:
-        graph_def: well linked graph_def
-    """
-    for node in graph_def.node:
-        if node.op == "FusedBatchNorm":
-            moving_mean_op_name = node.input[3]
-            moving_var_op_name = node.input[4]
-            moving_mean_op = _get_nodes_from_name(moving_mean_op_name, graph_def)[0]
-            moving_var_op = _get_nodes_from_name(moving_var_op_name, graph_def)[0]
-
-            if moving_mean_op.op == "Const":
-                name_part = moving_mean_op_name.rsplit("/", 1)[0]
-                real_moving_mean_op_name = name_part + "/moving_mean"
-                if len(_get_nodes_from_name(real_moving_mean_op_name, graph_def)) > 0:
-                    # replace the real moving mean op name
-                    node.input[3] = real_moving_mean_op_name
-
-            if moving_var_op.op == "Const":
-                name_part = moving_var_op_name.rsplit("/", 1)[0]
-                real_moving_var_op_name = name_part + "/moving_variance"
-                if len(_get_nodes_from_name(real_moving_var_op_name, graph_def)) > 0:
-                    # replace the real moving mean op name
-                    node.input[4] = real_moving_var_op_name
-
-    return graph_def
-
-
-def _get_nodes_from_name(node_name, graph_def):
-    """Get nodes from graph_def using node name.
-
-    Args:
-        graph_def (graph_def): graph_def
-        node_name (str): node name
-
-    Returns:
-        node (NodeDef): graph node
-    """
-    return [node for node in graph_def.node if node.name == node_name]
-
-
-def is_saved_model_format(model_path):
-    """Check the model_path format is saved_model or not.
-
-    Args:
-        model_path (string): the model folder path
-
-    Returns:
-        bool: return True if the model_path contains saved_model format else False.
-    """
-    file_list = [os.path.splitext(i)[-1] for i in os.listdir(model_path)]
-    # TF 2.11.0 added a new fingerprint.pb to the SavedModel directory.
-    return bool(file_list.count(".pb") in [1, 2, 3] and ("variables") in os.listdir(model_path))
-
-
-def get_tensor_by_name(graph, name, try_cnt=3):
-    """Get the tensor by name.
-
-    Considering the 'import' scope when model may be imported more then once,
-    handle naming format like both name:0 and name.
-
-    Args:
-        graph (tf.compat.v1.GraphDef): the model to get name from
-        name (string): tensor of tensor_name:0 or tensor_name without suffixes
-        try_cnt: the times to add 'import/' to find  tensor
-
-    Returns:
-        tensor: tensor got by name.
-    """
-    if name.find(":") == -1:
-        name = name + ":0"
-    for _ in range(try_cnt):
-        try:
-            return graph.get_tensor_by_name(name)
-        except BaseException:
-            name = "import/" + name
-    raise ValueError("can not find tensor by name")
-
-
-def iterator_sess_run(sess, iter_op, feed_dict, output_tensor, iteration=-1, measurer=None):
-    """Run the graph that have iterator integrated in the graph.
-
-    Args:
-        sess (tf.compat.v1.Session): the model sess to run the graph
-        iter_op (Operator): the MakeIterator op
-        feed_dict(dict): the feeds to initialize a new iterator
-        output_tensor(list): the output tensors
-        iteration(int): iterations to run, when -1 set, run to end of iterator
-
-    Returns:
-        preds: the results of the predictions
-    """
-    sess.run(iter_op, feed_dict)
-    preds = []
-    idx = 0
-    while idx + 1 != iteration:
-        try:
-            if measurer:
-                measurer.start()
-                prediction = sess.run(output_tensor)
-                measurer.end()
-            else:
-                prediction = sess.run(output_tensor)
-            preds.append(prediction)
-            idx += 1
-        except tf.errors.OutOfRangeError:
-            break
-
-    preds = collate_tf_preds(preds)
-    return preds
-
-
-def collate_tf_preds(results):
-    """Collate the prediction results."""
-    batch = results[0]
-    if isinstance(batch, list):
-        results = zip(*results)
-        collate_results = []
-        for output in results:
-            if isinstance(output[0], np.ndarray):
-                collate_results.append(np.concatenate(output))
-            elif np.isscalar(output[0]):
-                collate_results.extend(output)
-    elif isinstance(batch, np.ndarray):
-        collate_results = np.concatenate(results)
-
-    return collate_results
-
-
-def get_input_output_node_names(graph_def):
-    """Get the input node name and output node name of the graph_def."""
-    g = GraphAnalyzer()
-    g.graph = graph_def
-    g.parse_graph()
-    return g.get_graph_input_output()
-
-
-def fix_ref_type_of_graph_def(graph_def):
-    """Fix ref type of the graph_def."""
-    # according to https://github.com/onnx/tensorflow-onnx/issues/77
-    for node in graph_def.node:
-        if node.op == "RefSwitch":
-            node.op = "Switch"
-            for index in range(len(node.input)):
-                if "moving_" in node.input[index]:
-                    node.input[index] = node.input[index] + "/read"
-        elif node.op == "AssignSub":
-            node.op = "Sub"
-            if "use_locking" in node.attr:
-                del node.attr["use_locking"]
-        elif node.op == "AssignAdd":
-            node.op = "Add"
-            if "use_locking" in node.attr:
-                del node.attr["use_locking"]
-        elif node.op == "Assign":
-            node.op = "Identity"
-            if "use_locking" in node.attr:
-                del node.attr["use_locking"]
-            if "validate_shape" in node.attr:
-                del node.attr["validate_shape"]
-            if len(node.input) == 2:
-                # input0: ref: Should be from a Variable node. May be uninitialized.
-                # input1: value: The value to be assigned to the variable.
-                node.input[0] = node.input[1]
-                del node.input[1]
-    return graph_def
-
-
-def strip_unused_nodes(graph_def, input_node_names, output_node_names):
-    """Strip unused nodes of the graph_def.
-
-    The strip_unused_nodes pass is from tensorflow/python/tools/strip_unused_lib.py
-    of official tensorflow r1.15 branch
-    """
-    cur_graph = GraphAnalyzer()
-    cur_graph.graph = graph_def
-    graph_info = cur_graph.parse_graph()
-    type_attr = {"Sub": "T", "RealDiv": "T", "Identity": "T"}
-    # this op should not be stripped for table initialization
-    if "init_all_tables" in graph_info.keys():
-        output_node_names.append("init_all_tables")
-    not_found = {name for name in input_node_names}
-    for node_name in list(graph_info.keys()):
-        if node_name in not_found:
-            not_found.remove(node_name)
-            node = graph_info[node_name].node
-            # skip the conversion to Placeholder that with type list
-            if "component_types" in node.attr:
-                continue
-            original_output = graph_info[node_name].outputs
-            placeholder_node = node_def_pb2.NodeDef()
-            placeholder_node.op = "Placeholder"
-            placeholder_node.name = node.name
-
-            if "dtype" in node.attr:
-                placeholder_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=node.attr["dtype"].type))
-            elif node.op in type_attr.keys():
-                placeholder_node.attr["dtype"].CopyFrom(
-                    attr_value_pb2.AttrValue(type=node.attr[type_attr[node.op]].type)
-                )
-            else:
-                raise KeyError("%s op's type attribute is not found," "you should add it to type_attr dict" % node.op)
-            if "_output_shapes" in node.attr:
-                placeholder_node.attr["_output_shapes"].CopyFrom(node.attr["_output_shapes"])
-            if "shape" in node.attr:
-                placeholder_node.attr["shape"].CopyFrom(node.attr["shape"])
-
-            cur_graph.remove_node(node_name)
-
-            cur_graph.replace_const_node(placeholder_node, [node_name], original_output)
-
-    return tf.compat.v1.graph_util.extract_sub_graph(cur_graph.dump_graph(), output_node_names)
-
-
-def strip_equivalent_nodes(graph_def, output_node_names):
-    """Strip nodes with the same input and attr."""
-    stripped_graph = GraphAnalyzer()
-    stripped_graph.graph = graph_def
-    stripped_graph_info = stripped_graph.parse_graph()
-
-    def is_equivalent_input(input_tensor_list_1, input_tensor_list_2):
-        """Check whether two input tensor lists are equivalent."""
-        if len(input_tensor_list_1) != len(input_tensor_list_2):
-            return False
-        const_num = 0
-        for input_tensor_1, input_tensor_2 in zip(input_tensor_list_1, input_tensor_list_2):
-            input_node_1 = stripped_graph_info[GraphRewriterHelper.node_name_from_input(input_tensor_1)].node
-            input_node_2 = stripped_graph_info[GraphRewriterHelper.node_name_from_input(input_tensor_2)].node
-            if input_node_1.op in ["Const", "HostConst"] and input_node_2.op in ["Const", "HostConst"]:
-                if input_node_1.attr != input_node_2.attr:
-                    return False
-                const_num += 1
-            elif input_tensor_1 != input_tensor_2:
-                return False
-        if const_num == len(input_tensor_list_1):
-            return False
-        return True
-
-    nodes_to_remove = []
-    replaced_nodes_type = {}
-    stripped_graph_node_names = list(stripped_graph_info.keys())
-    len_nodes = len(stripped_graph_node_names)
-    for idx_1 in range(len_nodes - 1):
-        node_name_1 = stripped_graph_node_names[idx_1]
-        node_1 = stripped_graph_info[node_name_1].node
-        if node_1.op in ["Const", "HostConst", "MatMul", "TensorArrayV3"] or node_name_1 in nodes_to_remove:
-            continue
-        for idx_2 in range(idx_1 + 1, len_nodes):
-            node_name_2 = stripped_graph_node_names[idx_2]
-            node_2 = stripped_graph_info[node_name_2].node
-            if (
-                node_1.op == node_2.op
-                and node_name_1 != node_name_2
-                and node_2 not in nodes_to_remove
-                and node_1.input
-                and is_equivalent_input(node_1.input, node_2.input)
-                and node_1.attr == node_2.attr
-            ):
-                for ouput_node_name in stripped_graph_info[node_name_2].outputs:
-                    output_node = stripped_graph_info[ouput_node_name].node
-                    for idx_output_node_input, output_node_input_name in enumerate(output_node.input):
-                        if GraphRewriterHelper.node_name_from_input(output_node_input_name) == node_name_2:
-                            new_input = output_node_input_name.replace(node_name_2, node_name_1)
-                            output_node.input[idx_output_node_input] = new_input
-                            logger.debug(
-                                "Replacing {} node '{}' with equivalent node '{}': "
-                                "set {} node '{}'.input[{}] = '{}'".format(
-                                    node_1.op,
-                                    node_name_2,
-                                    node_name_1,
-                                    output_node.op,
-                                    output_node.name,
-                                    idx_output_node_input,
-                                    new_input,
-                                )
-                            )
-                            replaced_nodes_type[node_1.op] = replaced_nodes_type.get(node_1.op, 0) + 1
-                            nodes_to_remove.append(node_name_2)
-    for node_to_remove in nodes_to_remove:
-        stripped_graph.remove_node(node_to_remove)
-    return (
-        tf.compat.v1.graph_util.extract_sub_graph(
-            stripped_graph.dump_graph(), list(set(stripped_graph_node_names).intersection(output_node_names))
-        ),
-        replaced_nodes_type,
-    )
-
-
-# THIS API IS TO BE DEPRECATED!
-def get_graph_def(model, outputs=[], auto_input_output=False):
-    """Get the model's graph_def."""
-    from neural_compressor.tensorflow.utils import BaseModel, Model
-
-    if not isinstance(model, BaseModel):
-        model = Model(model)
-        model.output_tensor_names = outputs
-    return model.graph_def
-
-
-def get_model_input_shape(model):
-    """Get the input shape of the input model."""
-    for node in model.graph_def.node:
-        if node.op == "Placeholder":
-            _shape = list(tf.compat.v1.TensorShape(node.attr["shape"].shape))
-            if tf.__version__ < "2.0.0":
-                _shape = [item.value for item in _shape]
-            if len(_shape) > 1 and isinstance(_shape[0], int):
-                return _shape[0]
-            elif isinstance(_shape, list) and hasattr(_shape[0], "value"):
-                return _shape[0].value
-    return 1
-
-
-def generate_feed_dict(input_tensor, inputs):
-    """Generate feed dict helper function."""
-    if len(input_tensor) == 1:
-        feed_dict = {}
-        if isinstance(inputs, dict) or isinstance(inputs, OrderedDict) or isinstance(inputs, UserDict):
-            for name in inputs:
-                for tensor in input_tensor:
-                    pos = tensor.name.rfind(":")
-                    t_name = tensor.name if pos < 0 else tensor.name[:pos]
-                    if name == t_name:
-                        feed_dict[tensor] = inputs[name]
-                        break
-        else:
-            feed_dict = {input_tensor[0]: inputs}  # get raw tensor using index [0]
-    else:
-        assert len(input_tensor) == len(inputs), "inputs len must equal with input_tensor"
-        feed_dict = {}
-        if isinstance(inputs, dict) or isinstance(inputs, OrderedDict) or isinstance(inputs, UserDict):
-            for name in inputs:
-                for tensor in input_tensor:
-                    pos = tensor.name.rfind(":")
-                    t_name = tensor.name if pos < 0 else tensor.name[:pos]
-                    if name in [tensor.name, t_name]:
-                        feed_dict[tensor] = inputs[name]
-                        break
-        else:
-            # sometimes the input_tensor is not the same order with inputs
-            # we should check and pair them
-            def check_shape(tensor, data):
-                """Validate that a tensor shape matches the sample data."""
-                # scalar or 1 dim default True
-                if tensor.shape is None or len(tensor.shape.dims) == 1 or not hasattr(data, "shape"):
-                    return True
-                tensor_shape = tuple(tensor.shape)
-                data_shape = tuple(data.shape)
-                for tensor_dim, data_dim in zip(tensor_shape, data_shape):
-                    if tensor_dim is not None and tensor_dim != data_dim:
-                        return False
-                return True
-
-            disorder_tensors = []
-            disorder_inputs = []
-            for idx, sort_tensor in enumerate(input_tensor):
-                sort_input = inputs[idx]
-                if check_shape(sort_tensor, sort_input):
-                    feed_dict.update({sort_tensor: sort_input})
-                else:
-                    disorder_tensors.append(sort_tensor)
-                    disorder_inputs.append(sort_input)
-            for i, dis_tensor in enumerate(disorder_tensors):
-                for j, dis_input in enumerate(disorder_inputs):
-                    if check_shape(dis_tensor, dis_input):
-                        feed_dict.update({dis_tensor: dis_input})
-                        break
-    return feed_dict
-
-
-def apply_inlining(func):
-    """Apply an inlining optimization to the function's graph definition.
-
-    Args:
-        func: A concrete function get from saved_model.
-
-    Returns:
-        new_graph_def: The optimized graph in graph_def format.
-    """
-    graph_def = func.graph.as_graph_def()
-
-    # In some cases, a secondary implementation of the function (e.g. for GPU) is
-    # written to the "api_implements" attribute. (e.g. `tf.keras.layers.LSTM` in
-    # TF2 produces a CuDNN-based RNN for GPU).
-    # This function suppose to inline all functions calls, but "api_implements"
-    # prevents this from happening. Removing the attribute solves the problem.
-    # To learn more about "api_implements", see:
-    #   tensorflow/core/grappler/optimizers/implementation_selector.h
-    for function in graph_def.library.function:
-        if "api_implements" in function.attr:
-            del function.attr["api_implements"]
-
-    meta_graph = saver.export_meta_graph(graph_def=graph_def, graph=func.graph)
-
-    # Clear the initializer_name for the variables collections, since they are not
-    # needed after saved to saved_model.
-    for name in ["variables", "model_variables", "trainable_variables", "local_variables"]:
-        raw_list = []
-        for raw in meta_graph.collection_def["variables"].bytes_list.value:
-            variable = variable_pb2.VariableDef()
-            variable.ParseFromString(raw)
-            variable.ClearField("initializer_name")
-            raw_list.append(variable.SerializeToString())
-        meta_graph.collection_def[name].bytes_list.value[:] = raw_list
-
-    # Add a collection 'train_op' so that Grappler knows the outputs.
-    fetch_collection = meta_graph_pb2.CollectionDef()
-    for array in func.inputs + func.outputs:
-        fetch_collection.node_list.value.append(array.name)
-    meta_graph.collection_def["train_op"].CopyFrom(fetch_collection)
-
-    # Initialize RewriterConfig with everything disabled except function inlining.
-    config = config_pb2.ConfigProto()
-    rewrite_options = config.graph_options.rewrite_options
-    rewrite_options.min_graph_nodes = -1  # do not skip small graphs
-    rewrite_options.optimizers.append("function")
-
-    new_graph_def = tf_optimizer.OptimizeGraph(config, meta_graph)
-
-    return new_graph_def
-
-
-def construct_function_from_graph_def(func, graph_def, frozen_func=None):
-    """Rebuild function from graph_def.
-
-    Args:
-        func: The original concrete function get from saved_model.
-        graph_def: The optimized graph after applying inlining optimization.
-
-    Returns:
-        new_func: The reconstructed function.
-    """
-    if frozen_func is None:
-        frozen_func = func
-
-    # If a function is converted, then the TF context contains the original
-    # function while the converted_graph_def contains the converted function.
-    # Remove the original function from the TF context in this case.
-    for f in graph_def.library.function:
-        while context.context().has_function(f.signature.name):
-            context.context().remove_function(f.signature.name)
-
-    captures = {c[1].name.split(":")[0]: c[0] for c in frozen_func.graph.captures}
-    new_func = wrap_function.function_from_graph_def(
-        graph_def,
-        [tensor.name for tensor in frozen_func.inputs],
-        [tensor.name for tensor in frozen_func.outputs],
-        captures,
-    )
-    new_func.graph.structured_outputs = nest.pack_sequence_as(
-        func.graph.structured_outputs, new_func.graph.structured_outputs
-    )
-    # new_func._function_type = func.function_type  # pylint: disable=protected-access
-
-    # Copy structured input signature from original function (used during
-    # serialization)
-    new_func.graph.structured_input_signature = func.structured_input_signature
-
-    return new_func
-
-
-def parse_saved_model(model, freeze=False, input_tensor_names=[], output_tensor_names=[]):
-    """Parse a input saved_model.
-
-    Args:
-        model(string or AutoTrackable object): The input saved_model.
-
-    Returns:
-        graph_def: The graph_def parsed from saved_model.
-        _saved_model: TF AutoTrackable object loaded from saved_model.
-        func: The concrete function get from saved_model.
-        frozen_func: The reconstructed function from inlining optimized graph.
-    """
-    config = tf.compat.v1.ConfigProto()
-    config.use_per_session_threads = 1
-    config.inter_op_parallelism_threads = 1
-
-    if isinstance(model, str):
-        _saved_model = load.load(model, [tag_constants.SERVING])
-    else:
-        _saved_model = model
-
-    func = _saved_model.signatures[signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY]
-
-    if freeze:
-        frozen_func = convert_to_constants.convert_variables_to_constants_v2(func)
-    else:
-        inlined_graph_def = apply_inlining(func)
-        frozen_func = construct_function_from_graph_def(func, inlined_graph_def)
-
-    if len(input_tensor_names) == 0:
-        # skip all inputs for ReadVariableOp
-        input_tensor_names = [i.name.split(":")[0] for i in frozen_func.inputs if "unknown" not in i.name]
-    if len(output_tensor_names) == 0:
-        output_tensor_names = [i.name.split(":")[0] for i in frozen_func.outputs]
-
-    frozen_graph_def = frozen_func.graph.as_graph_def()
-    grappler_meta_graph_def = saver.export_meta_graph(graph_def=frozen_graph_def, graph=frozen_func.graph)
-
-    # Add a collection 'train_op' so that Grappler knows the outputs.
-    fetch_collection = meta_graph_pb2.CollectionDef()
-    for array in frozen_func.inputs + frozen_func.outputs:
-        fetch_collection.node_list.value.append(array.name)
-        grappler_meta_graph_def.collection_def["train_op"].CopyFrom(fetch_collection)
-
-    grappler_session_config = config_pb2.ConfigProto()
-    rewrite_options = grappler_session_config.graph_options.rewrite_options
-    rewrite_options.min_graph_nodes = -1
-    graph_def = tf_optimizer.OptimizeGraph(grappler_session_config, grappler_meta_graph_def, graph_id=b"tf_graph")
-    return graph_def, _saved_model, func, frozen_func, input_tensor_names, output_tensor_names
-
-
-def reconstruct_saved_model(graph_def, func, frozen_func, trackable, path):
-    """Reconstruct a saved_model.
-
-    Args:
-        graph_def: The input graph_def.
-        func: The concrete function get from the original saved_model.
-        frozen_func: The reconstructed function from inlining optimized graph.
-        trackable: TF AutoTrackable object loaded from the original saved_model.
-        path: The destination path to save the reconstructed saved_model.
-    """
-    converted_func = construct_function_from_graph_def(func, graph_def, frozen_func)
-    signatures = {signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY: converted_func}
-    save.save(trackable, path, signatures, options=None)
diff --git a/neural_compressor/tensorflow/utils/__init__.py b/neural_compressor/tensorflow/utils/__init__.py
deleted file mode 100644
index 89d5eb8f006..00000000000
--- a/neural_compressor/tensorflow/utils/__init__.py
+++ /dev/null
@@ -1,56 +0,0 @@
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""The utils for Tensorflow."""
-
-from neural_compressor.tensorflow.utils.data import BaseDataLoader, DummyDataset, DummyDatasetV2
-from neural_compressor.tensorflow.utils.model import (
-    Model,
-    TFConfig,
-)
-from neural_compressor.tensorflow.utils.constants import (
-    SPR_BASE_VERSIONS,
-    TENSORFLOW_DEFAULT_CONFIG,
-    DEFAULT_SQ_ALPHA_ARGS,
-    UNIFY_OP_TYPE_MAPPING,
-)
-from neural_compressor.tensorflow.utils.model_wrappers import (
-    get_tf_model_type,
-    BaseModel,
-    KerasModel,
-    TensorflowLLMModel,
-    TensorflowBaseModel,
-    TensorflowSavedModelModel,
-)
-from neural_compressor.tensorflow.utils.utility import (
-    disable_random,
-    algos_mapping,
-    version1_lt_version2,
-    version1_gt_version2,
-    version1_eq_version2,
-    version1_gte_version2,
-    version1_lte_version2,
-    register_algo,
-    deep_get,
-    itex_installed,
-    dump_elapsed_time,
-    combine_histogram,
-    get_all_fp32_data,
-    get_tensor_histogram,
-    singleton,
-    CpuInfo,
-    Statistics,
-    CaptureOutputToFile,
-    valid_keras_format,
-    TFSlimNetsFactory,
-)
diff --git a/neural_compressor/tensorflow/utils/constants.py b/neural_compressor/tensorflow/utils/constants.py
deleted file mode 100644
index fc79b116e17..00000000000
--- a/neural_compressor/tensorflow/utils/constants.py
+++ /dev/null
@@ -1,60 +0,0 @@
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""The constants utils for Tensorflow."""
-
-SPR_BASE_VERSIONS = (
-    "2.11.0202242",
-    "2.11.0202250",
-    "2.11.0202317",
-    "2.11.0202323",
-    "2.14.0202335",
-    "2.14.dev202335",
-    "2.15.0202341",
-)
-
-TENSORFLOW_DEFAULT_CONFIG = {
-    "device": "cpu",
-    "backend": "default",
-    "approach": "post_training_static_quant",
-    "random_seed": 1978,
-    "format": "default",
-    "use_bf16": True,
-}
-
-DEFAULT_SQ_ALPHA_ARGS = {
-    "alpha_min": 0.0,
-    "alpha_max": 1.0,
-    "alpha_step": 0.1,
-    "shared_criterion": "mean",
-    "do_blockwise": False,
-}
-
-UNIFY_OP_TYPE_MAPPING = {
-    "Conv2D": "conv2d",
-    "Conv3D": "conv3d",
-    "DepthwiseConv2dNative": "conv2d",
-    "FusedBatchNormV3": "batchnorm",
-    "FusedBatchNorm": "batchnorm",
-    "_MklFusedInstanceNorm": "instancenorm",
-    "MaxPool": "pooling",
-    "MaxPool3D": "pooling",
-    "AvgPool": "pooling",
-    "ConcatV2": "concat",
-    "MatMul": "matmul",
-    "BatchMatMul": "matmul",
-    "BatchMatMulV2": "matmul",
-    "Pad": "pad",
-    "Conv2DBackpropInput": "deconv2d",
-    "Conv3DBackpropInputV2": "deconv3d",
-}
diff --git a/neural_compressor/tensorflow/utils/data.py b/neural_compressor/tensorflow/utils/data.py
deleted file mode 100644
index 008b7c29bd9..00000000000
--- a/neural_compressor/tensorflow/utils/data.py
+++ /dev/null
@@ -1,628 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-"""BaseDataloder of all dataloaders."""
-
-import collections
-import math
-import sys
-from abc import abstractmethod
-
-import numpy as np
-import tensorflow as tf
-
-from neural_compressor.common import logger
-
-
-def default_collate(batch):
-    """Merge data with outer dimension batch size."""
-    elem = batch[0]
-    if isinstance(elem, collections.abc.Mapping):
-        return {key: default_collate([d[key] for d in batch]) for key in elem}
-    elif isinstance(elem, collections.abc.Sequence):
-        batch = zip(*batch)
-        return [default_collate(samples) for samples in batch]
-    elif isinstance(elem, np.ndarray):
-        try:
-            return np.stack(batch)
-        except:
-            return batch
-    else:
-        return batch
-
-
-class IterableFetcher:
-    """Iterate to get next batch-size samples as a batch."""
-
-    def __init__(self, dataset, collate_fn, drop_last, distributed):
-        """Initialize IterableFetcher.
-
-        Args:
-            dataset (object): dataset object from which to get data
-            collate_fn (callable): merge data with outer dimension batch size
-            drop_last (bool): whether to drop the last batch if it is incomplete
-            distributed (bool): whether the dataloader is distributed
-        """
-        self.dataset = dataset
-        self.collate_fn = collate_fn
-        self.drop_last = drop_last
-        self.dataset_iter = iter(dataset)
-        self.index_whole = 0
-        self.process_rank = 0  # The default rank is 0, which represents the main process
-        self.process_size = 1  # By default, process_size=1, only the main process is running
-        if distributed:
-            import horovod.tensorflow as hvd
-
-            hvd.init()
-            self.process_rank = hvd.rank()
-            self.process_size = hvd.size()
-            if self.process_size < 2:
-                raise EnvironmentError(
-                    "The program is now trying to traverse"
-                    " the distributed TensorFlow DefaultDataLoader in only one process."
-                    " If you do not want to use distributed DataLoader, please set"
-                    " 'distributed: False'. Or If you want to use distributed DataLoader,"
-                    " please set 'distributed: True' and launch multiple processes."
-                )
-
-    def __call__(self, batched_indices):
-        """Fetch data.
-
-        Args:
-            batched_indices (list): fetch data according to batched_indices
-        """
-        batch_data = []
-        batch_size = len(batched_indices)
-        while True:
-            try:
-                iter_data = next(self.dataset_iter)
-                if (self.index_whole - self.process_rank) % self.process_size == 0:
-                    batch_data.append(iter_data)
-                self.index_whole += 1
-                if len(batch_data) == batch_size:
-                    break
-            except StopIteration:
-                break
-        if len(batch_data) == 0 or (self.drop_last and len(batch_data) < len(batched_indices)):
-            raise StopIteration
-        return self.collate_fn(batch_data)
-
-
-class IndexFetcher:
-    """Take single index or a batch of indices to fetch samples as a batch."""
-
-    def __init__(self, dataset, collate_fn, drop_last, distributed):
-        """Initialize IndexFetcher.
-
-        Args:
-            dataset (object): dataset object from which to get data
-            collate_fn (callable): merge data with outer dimension batch size
-            drop_last (bool): whether to drop the last batch if it is incomplete
-            distributed (bool): whether the dataloader is distributed
-        """
-        self.dataset = dataset
-        self.collate_fn = collate_fn
-        self.drop_last = drop_last
-
-    def __call__(self, batched_indices):
-        """Fetch data.
-
-        Args:
-            batched_indices (list): fetch data according to batched_indices
-        """
-        data = [self.dataset[idx] for idx in batched_indices]
-        return self.collate_fn(data)
-
-
-class IterableSampler:
-    """Internally samples elements.
-
-    Used for datasets retrieved element by iterator. Yield None to act as a placeholder for each iteration.
-    """
-
-    def __init__(self, dataset):
-        """Initialize IterableSampler.
-
-        Args:
-            dataset (object): dataset object from which to get data
-        """
-        self.whole_dataset = dataset
-
-    def __iter__(self):
-        """Yield data in iterative order."""
-        while True:
-            yield None
-
-    def __len__(self):
-        """Return the length of dataset."""
-        return len(self.whole_dataset)
-
-
-class SequentialSampler:
-    """Sequentially samples elements, used for datasets retrieved element by index."""
-
-    def __init__(self, dataset, distributed):
-        """Initialize SequentialSampler.
-
-        Args:
-            dataset (object): dataset object from which to get data
-            distributed (bool): whether the dataloader is distributed
-        """
-        self.whole_dataset = dataset
-        self.distributed = distributed
-
-    def __iter__(self):
-        """Yield data in iterative order."""
-        self.process_rank = 0  # The default rank is 0, which represents the main process
-        self.process_size = 1  # By default, process_size=1, only the main process is running
-        if self.distributed:
-            import horovod.tensorflow as hvd
-
-            hvd.init()
-            self.process_rank = hvd.rank()
-            self.process_size = hvd.size()
-            if self.process_size < 2:
-                raise EnvironmentError(
-                    "The program is now trying to traverse"
-                    " the distributed TensorFlow DefaultDataLoader in only one process."
-                    " If you do not want to use distributed DataLoader, please set"
-                    " 'distributed: False'. Or If you want to use distributed DataLoader,"
-                    " please set 'distributed: True' and launch multiple processes."
-                )
-        return iter(range(self.process_rank, len(self.whole_dataset), self.process_size))
-
-    def __len__(self):
-        """Return the length of dataset."""
-        return len(self.whole_dataset)
-
-
-class BatchSampler:
-    """Yield a batch of indices and number of batches."""
-
-    def __init__(self, sampler, batch_size, drop_last=True):
-        """Initialize BatchSampler.
-
-        Args:
-            sampler (Sampler): sampler used for generating batches
-            batch_size (int): size of batch
-            drop_last (bool, optional): whether to drop the last batch if it is incomplete. Defaults to True.
-        """
-        if isinstance(drop_last, bool):
-            self.drop_last = drop_last
-        else:
-            raise ValueError("last_batch only support bool as input")
-
-        self.sampler = sampler
-        self.batch_size = batch_size
-        self.drop_last = drop_last
-
-    def __iter__(self):
-        """Yield data in iterative order."""
-        batch = []
-        for idx in self.sampler:
-            batch.append(idx)
-            if len(batch) == self.batch_size:
-                yield batch
-                batch = []
-        if len(batch) > 0 and not self.drop_last:
-            yield batch
-
-    def __len__(self):
-        """Return the number of batches."""
-        if self.drop_last:
-            return len(self.sampler) // self.batch_size
-        else:
-            return (len(self.sampler) + self.batch_size - 1) // self.batch_size
-
-
-class BaseDataLoader:
-    """Base class for TF DataLoaders.
-
-    _generate_dataloader is needed to create a dataloader object
-    from the general params like batch_size and sampler. The dynamic batching is just to
-    generate a new dataloader by setting batch_size and last_batch.
-    """
-
-    def __init__(
-        self,
-        dataset,
-        batch_size=1,
-        last_batch="rollover",
-        collate_fn=None,
-        sampler=None,
-        batch_sampler=None,
-        num_workers=0,
-        pin_memory=False,
-        shuffle=False,
-        distributed=False,
-    ):
-        """Initialize DefaultDataLoader.
-
-        Args:
-            dataset (object): dataset from which to load the data
-            batch_size (int, optional): number of samples per batch. Defaults to 1.
-            last_batch (str, optional): whether to drop the last batch if it is incomplete.
-                                        Support ['rollover', 'discard'], rollover means False, discard means True.
-                                        Defaults to 'rollover'.
-            collate_fn (callable, optional): merge data with outer dimension batch size. Defaults to None.
-            sampler (Sampler, optional): Sampler object to sample data. Defaults to None.
-            batch_sampler (BatchSampler, optional): BatchSampler object to generate batch of indices. Defaults to None.
-            num_workers (int, optional): number of subprocesses to use for data loading. Defaults to 0.
-            pin_memory (bool, optional): whether to copy data into pinned memory before returning. Defaults to False.
-            shuffle (bool, optional): whether to shuffle data. Defaults to False.
-            distributed (bool, optional): whether the dataloader is distributed. Defaults to False.
-        """
-        self.dataset = dataset
-        self.last_batch = last_batch
-        self.sampler = sampler
-        self.batch_sampler = batch_sampler
-        self.num_workers = num_workers
-        self.pin_memory = pin_memory
-        self.collate_fn = collate_fn
-        self.batch_size = batch_size
-        self.shuffle = shuffle
-        self.distributed = distributed
-        self.drop_last = False if last_batch == "rollover" else True
-        if self.collate_fn is None:
-            self.collate_fn = default_collate
-
-    def batch(self, batch_size, last_batch="rollover"):
-        """Set batch_size and last_batch."""
-        self.batch_size = batch_size
-        self.last_batch = last_batch
-
-    @property
-    def dataloader(self):
-        """Return dataloader."""
-        return self
-
-    def __iter__(self):
-        """Yield data in iterative order."""
-        return self._generate_dataloader(
-            self.dataset,
-            batch_size=self.batch_size,
-            last_batch=self.last_batch,
-            collate_fn=self.collate_fn,
-            sampler=self.sampler,
-            batch_sampler=self.batch_sampler,
-            num_workers=self.num_workers,
-            pin_memory=self.pin_memory,
-            shuffle=self.shuffle,
-            distributed=self.distributed,
-        )
-
-    def __len__(self):
-        """Get dataset length."""
-        try:
-            dataset_len = self.dataset.__len__()
-        except (AttributeError, TypeError):
-            dataset_len = 0
-            for _ in self.dataset:
-                dataset_len += 1
-        except Exception:
-            raise ValueError(
-                f"{self.dataset} is invalid, {self.dataset}"
-                " does not support calculating the length of its dataloader"
-            )
-        if self.drop_last is False:
-            dataloader_len = math.ceil(dataset_len / self.batch_size)
-        else:
-            dataloader_len = math.floor(dataset_len / self.batch_size)
-        return dataloader_len
-
-    def _generate_dataloader(
-        self,
-        dataset,
-        batch_size,
-        last_batch,
-        collate_fn,
-        sampler,
-        batch_sampler,
-        num_workers,
-        pin_memory,
-        shuffle,
-        distributed,
-    ):
-        """Yield batches from the dataset using the configured sampler.
-
-        Args:
-            dataset: Dataset to iterate.
-            batch_size (int): Batch size.
-            last_batch: Last batch handling mode.
-            collate_fn (Callable): Function to collate batch samples.
-            sampler: Sampler instance (unused; generated internally).
-            batch_sampler: Batch sampler instance (unused; generated internally).
-            num_workers (int): Worker count (unused for TF).
-            pin_memory (bool): Pin memory flag.
-            shuffle (bool): Whether to shuffle (handled by sampler).
-            distributed (bool): Whether to use distributed sampling.
-        """
-        sampler = self._generate_sampler(dataset, distributed)
-        self.batch_sampler = BatchSampler(sampler, batch_size, self.drop_last)
-
-        if self.dataset_type == "index":
-            self.fetcher = IndexFetcher(dataset, collate_fn, self.drop_last, distributed)
-        elif self.dataset_type == "iter":
-            self.fetcher = IterableFetcher(dataset, collate_fn, self.drop_last, distributed)
-
-        for batched_indices in self.batch_sampler:
-            try:
-                data = self.fetcher(batched_indices)
-                yield data
-            except StopIteration:
-                return
-
-    def _generate_sampler(self, dataset, distributed):
-        """Create a sampler based on dataset capabilities.
-
-        Args:
-            dataset: Dataset object to inspect.
-            distributed (bool): Whether to use distributed sampling.
-
-        Returns:
-            Sampler: IterableSampler or SequentialSampler depending on dataset type.
-        """
-        if hasattr(dataset, "__getitem__"):
-            self.dataset_type = "index"
-            return SequentialSampler(dataset, distributed)
-        elif hasattr(dataset, "__iter__"):
-            self.dataset_type = "iter"
-            return IterableSampler(dataset)
-        else:
-            raise ValueError("dataset type only support (index, iter)")
-
-
-class DummyDataset:  # pragma: no cover
-    """Dataset used for dummy data generation.
-
-    This Dataset is to construct a dataset from a specific shape.
-    The value range is calculated from: low * stand_normal(0, 1) + high.
-    (TODO) construct dummy data from real dataset or iteration of data.
-    """
-
-    def __init__(self, shape, low=-128.0, high=127.0, dtype="float32", label=True, transform=None, filter=None):
-        """Initialize `DummyDataset` class.
-
-        Args:
-            shape (list or tuple): Support create multi shape tensors, use list of tuples
-                for each tuple in the list, will create a such size tensor.
-            low (list or float, default=-128.): Low out the tensor value range from [0, 1]
-                to [0, low] or [low, 0] if low < 0, if float, will implement all tensors with same low value.
-            high (list or float, default=127.): High the tensor value by add all tensor element
-                value high. If list, length of list should be same with shape list.
-            dtype (list or str, default='float32'): Support multi tensor dtype setting.
-                If list, length of list should be same with shape list. If str, all tensors will
-                use same dtype. dtype supports 'float32', 'float16', 'uint8', 'int8', 'int32', 'int64', 'bool'.
-            label (bool, default=True): Whether to return 0 as label.
-            transform (transform object, default=None): Dummy dataset does not need transform.
-                If transform is not None, it will ignore it.
-            filter (Filter objects, default=None): Filter out examples according to specific conditions.
-        """
-        dtype_map = {
-            "float32": np.float32,
-            "float16": np.float16,
-            "uint8": np.uint8,
-            "int8": np.int8,
-            "int32": np.int32,
-            "int64": np.int64,
-            "bool": bool,
-            "string": str,
-        }
-
-        np.random.seed(9527)
-        self.transform = transform
-        self.label = label
-        if len(shape) == 0:
-            logger.info("No data in the dummy dataset.")
-        elif isinstance(shape, list):
-            # list tensor should same first dimension n
-            n = shape[0][0]
-            assert all(
-                isinstance(elem, tuple) and elem[0] == n for elem in shape
-            ), "each tensor shape should be tuple and same first dimension"
-
-            if isinstance(low, list):
-                assert len(low) == len(shape) and all(
-                    isinstance(elem, float) for elem in low
-                ), "low list should have same length with shape with element data type float"
-            else:
-                low = (low * np.ones(len(shape))).astype(float)
-
-            if isinstance(high, list):
-                assert len(high) == len(shape) and all(
-                    isinstance(elem, float) for elem in high
-                ), "high list should have same length with shape with element data type float"
-            else:
-                high = (high * np.ones(len(shape))).astype(float)
-
-            if isinstance(dtype, list):
-                assert len(dtype) == len(shape) and all(
-                    elem in dtype_map.keys() for elem in dtype
-                ), "high list should have same length with shape with element data type float"
-            else:
-                dtype = [dtype for i in range(0, len(shape))]
-
-        elif isinstance(shape, tuple):
-            shape = [shape]
-            if isinstance(low, float):
-                low = [low]
-            else:
-                assert (
-                    isinstance(low, list) and len(low) == 1 and isinstance(low[0], float)
-                ), "low should be float or list of float with length 1"
-
-            if isinstance(high, float):
-                high = [high]
-            else:
-                assert (
-                    isinstance(high, list) and len(high) == 1 and isinstance(high[0], float)
-                ), "high should be float or list of float with length 1"
-
-            if isinstance(dtype, str):
-                assert dtype in dtype_map.keys(), "dtype only support {}".format(dtype_map.keys())
-                dtype = [dtype]
-            else:
-                assert (
-                    isinstance(dtype, list) and len(dtype) == 1 and dtype[0] in dtype_map.keys()
-                ), "dtype should be str or list of str in supported dtypes"
-
-        self.dataset = []
-        for idx in range(0, len(shape)):
-            tensor = np.random.uniform(low=low[idx], high=high[idx], size=shape[idx])
-            tensor = tensor.astype(dtype_map[dtype[idx]])
-            self.dataset.append(tensor)
-
-        if len(self.dataset) == 1:
-            self.dataset = self.dataset[0]
-        else:
-            self.dataset = [elem for elem in zip(*self.dataset)]
-
-    def __len__(self):
-        """Return the length of dataset."""
-        return len(self.dataset)
-
-    def __getitem__(self, index):
-        """Return the item of dataset according to the given index."""
-        sample = self.dataset[index]
-        if self.transform is not None:
-            logger.warning("Dummy dataset does not need transform.")
-
-        if self.label:
-            return sample, 0
-        else:
-            return sample
-
-
-class DummyDatasetV2:  # pragma: no cover
-    """Dataset used for dummy_v2 data generation.
-
-    This Dataset is to construct a dataset from a input shape and label shape.
-    The value range is calculated from: low * stand_normal(0, 1) + high.
-    """
-
-    def __init__(
-        self, input_shape, label_shape=None, low=-128.0, high=127.0, dtype="float32", transform=None, filter=None
-    ):
-        """Initialize `DummyDataset` class.
-
-        Args:
-            sample_size (int): Total size of the dummy samples.
-            input_shape (list or tuple): Create single or multi input tensors,
-                tuple represent the sample shape of the dataset, e.g. an image size should be
-                represented as (224, 224, 3), list contains multiple tuple and represent multi input tensors.
-            label_shape (list or tuple): Create single or multi label tensors,
-                tuple represent the label shape of the dataset, e.g. an label size should be
-                represented as (1, ), list contains multiple tuple and represent multi label tensors.
-            low (list or float, default=-128.): Low out the tensor value range from [0, 1]
-                to [0, low] or [low, 0] if low < 0. If float, will implement all tensors with same low value.
-            high (list or float, default=127.): High the tensor value by add all tensor element value high.
-                If list, length of list should be same with shape list.
-            dtype (list or str, default='float32'): Support multi tensor dtype setting.
-                If list, length of list should be same with shape list.
-                If str, all tensors will use same dtype.
-                dtype supports 'float32', 'float16', 'uint8', 'int8','int32', 'int64', 'bool'.
-            transform (transform object, default=None): dummy_v2 dataset does not need transform.
-                If transform is not None, it will ignore it.
-            filter (Filter objects, default=None): Filter out examples according to specific conditions.
-        """
-        self.dtype_map = {
-            "float32": np.float32,
-            "float16": np.float16,
-            "uint8": np.uint8,
-            "int8": np.int8,
-            "int32": np.int32,
-            "int64": np.int64,
-            "bool": bool,
-        }
-
-        np.random.seed(9527)
-        self.transform = transform
-        self.input_shape = input_shape
-        self.label_shape = label_shape
-        self.low = low
-        self.high = high
-        self.dtype = dtype
-
-        if label_shape is None:
-            self.label_dim = 0
-        elif isinstance(label_shape, tuple):
-            self.label_dim = 1
-        else:
-            self.label_dim = len(label_shape)
-
-        self.input_dim = 1 if isinstance(input_shape, tuple) else len(input_shape)
-        self.total_dim = self.input_dim + self.label_dim
-
-        if isinstance(high, list):
-            assert len(high) == self.total_dim and all(
-                isinstance(elem, float) for elem in high
-            ), "high value list length should same with label dim + input_dim"
-        else:
-            self.high = (high * np.ones(self.total_dim)).astype(np.float32)
-
-        if isinstance(low, list):
-            assert len(low) == self.total_dim and all(
-                isinstance(elem, float) for elem in low
-            ), "low value list length should same with label dim + input_dim"
-        else:
-            self.low = (low * np.ones(self.total_dim)).astype(np.float32)
-
-        if isinstance(dtype, list):
-            assert len(dtype) == self.total_dim and all(
-                elem in self.dtype_map.keys() for elem in dtype
-            ), "dtype list length should same with label dim + input_dim"
-        else:
-            self.dtype = [self.dtype for i in range(0, self.total_dim)]
-
-        if isinstance(input_shape, tuple):
-            self.input_shape = [input_shape]
-
-        if isinstance(label_shape, tuple):
-            self.label_shape = [label_shape]
-
-    def __iter__(self):
-        """Yield data in iterative order."""
-        while True:
-            input_data = []
-            for idx in range(0, self.input_dim):
-                tensor = np.random.uniform(low=self.low[idx], high=self.high[idx], size=self.input_shape[idx])
-                tensor = tensor.astype(self.dtype_map[self.dtype[idx]])
-                input_data.append(tensor)
-
-            label = []
-            for idx in range(0, self.label_dim):
-                shift_idx = self.input_dim + idx
-                tensor = np.random.uniform(
-                    low=self.low[shift_idx], high=self.high[shift_idx], size=self.label_shape[idx]
-                )
-                tensor = tensor.astype(self.dtype_map[self.dtype[shift_idx]])
-                label.append(tensor)
-
-            if len(input_data) == 1:
-                input_data = input_data[0]
-
-            if len(label) == 1:
-                label = label[0]
-
-            if len(label) > 0:
-                yield input_data, label
-            else:
-                yield input_data
-
-    def __len__(self):
-        """Return the length of dataset."""
-        return sys.maxsize
diff --git a/neural_compressor/tensorflow/utils/model.py b/neural_compressor/tensorflow/utils/model.py
deleted file mode 100644
index 1bf4e6cc259..00000000000
--- a/neural_compressor/tensorflow/utils/model.py
+++ /dev/null
@@ -1,118 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""The Model API for wrapping all TF model formats."""
-
-import copy
-
-from neural_compressor.common.utils import DEFAULT_WORKSPACE
-from neural_compressor.tensorflow.utils.constants import TENSORFLOW_DEFAULT_CONFIG
-from neural_compressor.tensorflow.utils.model_wrappers import BaseModel, KerasModel, TensorflowModel, get_tf_model_type
-from neural_compressor.tensorflow.utils.utility import singleton
-
-
-@singleton
-class TensorflowGlobalConfig:
-    """A global config class for setting framework specific information."""
-
-    global_config = {
-        "device": "cpu",
-        "backend": "default",
-        "approach": "post_training_static_quant",
-        "random_seed": 1978,
-        "workspace_path": DEFAULT_WORKSPACE,
-        "format": "default",
-        "use_bf16": True,
-    }
-
-    def reset_global_config(self):
-        """Reset global config with default values."""
-        self.global_config = copy.deepcopy(TENSORFLOW_DEFAULT_CONFIG)
-        self.global_config["workspace_path"] = DEFAULT_WORKSPACE
-
-
-TFConfig = TensorflowGlobalConfig()
-
-
-class Model(object):  # pragma: no cover
-    """A wrapper to construct a Neural Compressor TF Model."""
-
-    def __new__(cls, root, **kwargs):
-        """Create a new instance object of Model.
-
-        Args:
-            root (object): raw model format. For Tensorflow model, could be path to frozen pb file,
-                path to ckpt or savedmodel folder, loaded estimator/graph_def/graph/keras model object.
-
-        Returns:
-            BaseModel: neural_compressor built-in model
-        """
-        from neural_compressor.tensorflow.utils import itex_installed
-
-        if isinstance(root, BaseModel):
-            return root
-
-        if kwargs.get("approach", None) == "quant_aware_training":
-            model_type = "keras_qat"
-        elif "modelType" in kwargs:
-            model_type = kwargs["modelType"]
-        else:
-            model_type = get_tf_model_type(root)
-
-        if model_type == "keras" and not itex_installed():
-            model_type = "saved_model"
-
-        model = TensorflowModel(model_type, root, **kwargs)
-        conf = kwargs.pop("conf", None)
-        cls.set_tf_config(conf, model)
-
-        return model
-
-    @staticmethod
-    def set_tf_config(conf, model):
-        """Set tf global config with model information."""
-        config = TFConfig.global_config
-        framework = "keras" if isinstance(model, KerasModel) else "tensorflow"
-
-        if conf and "device" in conf:
-            config["device"] = conf["device"]
-        if conf and "approach" in conf:
-            config["approach"] = conf["approach"]
-        if conf and "random_seed" in conf:
-            config["random_seed"] = conf["random_seed"]
-        if conf and "inputs" in conf:
-            config["inputs"] = conf["inputs"]
-        if conf and "outputs" in conf:
-            config["outputs"] = conf["outputs"]
-
-        if framework == "keras":
-            config["backend"] = "itex"
-            return
-
-        from neural_compressor.tensorflow.utils import itex_installed
-
-        if conf and "performance_only" in conf:
-            config["performance_only"] = conf["performance_only"]
-        if itex_installed():
-            config["backend"] = "itex"
-        if conf and "workspace_path" in conf:
-            config["workspace_path"] = conf["workspace_path"]
-        if conf and "recipes" in conf:
-            config["recipes"] = conf["recipes"]
-
-        for item in ["scale_propagation_max_pooling", "scale_propagation_concat"]:
-            if "recipes" in config and item not in config["recipes"]:
-                config["recipes"].update({item: True})
diff --git a/neural_compressor/tensorflow/utils/model_wrappers.py b/neural_compressor/tensorflow/utils/model_wrappers.py
deleted file mode 100644
index f7957121440..00000000000
--- a/neural_compressor/tensorflow/utils/model_wrappers.py
+++ /dev/null
@@ -1,1650 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""The concrete model wrappers for parsing all TF model formats."""
-
-import copy
-import datetime
-import importlib
-import inspect
-import json
-import os
-import shutil
-import sys
-import tempfile
-import time
-import zipfile
-from abc import abstractmethod
-
-import numpy as np
-import tensorflow as tf
-
-from neural_compressor.common import logger
-from neural_compressor.common.utils import DEFAULT_WORKSPACE
-from neural_compressor.tensorflow.utils.utility import version1_gte_version2, version1_lt_version2
-
-tensor_to_node = lambda s: list(set([x.split(":")[0] for x in s]))
-
-UNSAFE_KERAS_DESERIALIZATION_ENV = "NEURAL_COMPRESSOR_ALLOW_UNSAFE_KERAS_DESERIALIZATION"
-
-
-class UnsafeKerasModelError(ValueError):
-    """Raised when a Keras model file may execute arbitrary code while being deserialized."""
-
-
-def _allow_unsafe_keras_deserialization():
-    """Check whether the user explicitly allowed unsafe Keras deserialization."""
-    return os.environ.get(UNSAFE_KERAS_DESERIALIZATION_ENV, "0").lower() in ("1", "true", "yes")
-
-
-def _contains_arbitrary_python(config):
-    """Recursively look for serialized Python code (lambda bytecode) in a Keras model config."""
-    if isinstance(config, dict):
-        if config.get("class_name", None) == "__lambda__":
-            # a Python lambda serialized as marshalled bytecode by Keras 3
-            return True
-        if config.get("class_name", None) == "Lambda":
-            layer_config = config.get("config", {})
-            if isinstance(layer_config, dict):
-                function = layer_config.get("function", None)
-                # a lambda is serialized as marshalled bytecode by Keras 2, a plain string refers
-                # to a registered/named function which is not deserialized into new Python code
-                if layer_config.get("function_type", None) == "lambda" or isinstance(function, (list, tuple)):
-                    return True
-        return any(_contains_arbitrary_python(value) for value in config.values())
-    if isinstance(config, (list, tuple)):
-        return any(_contains_arbitrary_python(value) for value in config)
-    return False
-
-
-def _get_keras_model_config(model_path):
-    """Get the serialized config of a Keras model file without deserializing the model.
-
-    Args:
-        model_path (string): path of a keras model file (.keras or .h5).
-
-    Returns:
-        dict or None: the serialized model config, None if it can't be found.
-    """
-    if zipfile.is_zipfile(model_path):
-        with zipfile.ZipFile(model_path, "r") as zip_file:
-            if "config.json" not in zip_file.namelist():  # pragma: no cover
-                return None
-            with zip_file.open("config.json") as config_file:
-                return json.load(config_file)
-
-    import h5py
-
-    with h5py.File(model_path, "r") as h5_file:
-        model_config = h5_file.attrs.get("model_config", None)
-        if model_config is None:  # pragma: no cover
-            return None
-        if isinstance(model_config, bytes):  # pragma: no cover
-            model_config = model_config.decode("utf-8")
-        return json.loads(model_config)
-
-
-def _check_keras_model_safety(model_path):
-    """Refuse to load a Keras model file which would execute arbitrary Python code.
-
-    The legacy Keras (Keras 2) loaders deserialize `Lambda` layers from marshalled CPython
-    bytecode without any `safe_mode` gate, which allows a malicious model file to run
-    arbitrary code. Such files are rejected here unless the user explicitly opts in by
-    setting the NEURAL_COMPRESSOR_ALLOW_UNSAFE_KERAS_DESERIALIZATION environment variable.
-
-    Args:
-        model_path (string): path of a keras model file (.keras or .h5).
-
-    Raises:
-        UnsafeKerasModelError: if the model file contains serialized Python code.
-    """
-    if _allow_unsafe_keras_deserialization():  # pragma: no cover
-        logger.warning(
-            "Unsafe Keras deserialization is enabled by %s, arbitrary code contained " "in %s may be executed.",
-            UNSAFE_KERAS_DESERIALIZATION_ENV,
-            model_path,
-        )
-        return
-
-    try:
-        model_config = _get_keras_model_config(model_path)
-    except Exception as e:  # pragma: no cover
-        raise UnsafeKerasModelError(
-            "Failed to inspect the Keras model file {} for unsafe content: {}. "
-            "Loading is refused, set {}=1 to load it anyway if it comes from a trusted source.".format(
-                model_path, e, UNSAFE_KERAS_DESERIALIZATION_ENV
-            )
-        )
-
-    if _contains_arbitrary_python(model_config):
-        raise UnsafeKerasModelError(
-            "Refused to load the Keras model file {} because it contains a `Lambda` layer "
-            "storing arbitrary Python code, which would be executed while deserializing the model. "
-            "Only load such a model if it comes from a trusted source, by setting the "
-            "{} environment variable to 1.".format(model_path, UNSAFE_KERAS_DESERIALIZATION_ENV)
-        )
-
-
-def load_keras_model(model, **kwargs):
-    """Load a Keras model in a safer way than `tf.keras.models.load_model`.
-
-    `safe_mode=True` is requested when the installed Keras supports it and, since the legacy
-    Keras 2 loaders ignore it, the model file is also inspected beforehand.
-
-    Args:
-        model (string or tf.keras.Model): model path or model object.
-
-    Returns:
-        tf.keras.Model: the loaded keras model object.
-    """
-    if isinstance(model, str):
-        model_path = os.path.abspath(os.path.expanduser(model))
-        if os.path.isfile(model_path) and (model_path.endswith(".h5") or model_path.endswith(".keras")):
-            logger.warning_once(
-                "Loading a Keras model file deserializes its content, "
-                "please make sure it comes from a trusted source."
-            )
-            _check_keras_model_safety(model_path)
-
-    try:
-        supports_safe_mode = "safe_mode" in inspect.signature(tf.keras.models.load_model).parameters
-    except (TypeError, ValueError):  # pragma: no cover
-        supports_safe_mode = False
-
-    if supports_safe_mode:
-        kwargs.setdefault("safe_mode", not _allow_unsafe_keras_deserialization())
-
-    return tf.keras.models.load_model(model, **kwargs)
-
-
-def get_tf_model_type(model):
-    """The interface of getting type of tensorflow models."""
-    try:
-        os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
-        os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
-        model_type = get_model_type(model)
-    except UnsafeKerasModelError:
-        os.environ.pop("CUDA_DEVICE_ORDER", None)
-        os.environ.pop("CUDA_VISIBLE_DEVICES", None)
-        raise
-    except:  # pragma: no cover
-        os.environ.pop("CUDA_DEVICE_ORDER")
-        os.environ.pop("CUDA_VISIBLE_DEVICES")
-        raise TypeError(
-            "Tensorflow model format is not correctly detected. This could be"
-            + "caused by unsupported model or inappropriate framework installation."
-        )
-    else:
-        return model_type
-
-
-def get_model_type(model):
-    """Get Tensorflow mode type.
-
-    Args:
-        model (string or model object): model path or model object.
-
-    Returns:
-        string: model type
-    """
-    from neural_compressor.tensorflow.quantization.utils.utility import is_ckpt_format, is_saved_model_format
-
-    if isinstance(model, str):
-        model = os.path.abspath(os.path.expanduser(model))
-        if (
-            ((model.endswith(".h5") or model.endswith(".keras")) and os.path.isfile(model))
-            or is_saved_model_format(os.path.dirname(model))
-            or (os.path.isdir(model) and is_saved_model_format(model))
-        ):
-            if version1_lt_version2(tf.version.VERSION, "2.10.0"):  # pragma: no cover
-                logger.warning("keras model running on tensorflow 2.10.0 and" " lower not support intel ITEX.")
-            try:
-                model = load_keras_model(model)
-                if isinstance(model, tf.keras.Model) and hasattr(model, "to_json"):
-                    return "keras"
-                return "saved_model"  # pragma: no cover
-            except UnsafeKerasModelError:
-                raise
-            except:
-                pass
-    if isinstance(model, tf.keras.Model) and hasattr(model, "to_json"):
-        if json.loads(model.to_json())["class_name"] in ["Sequential", "Functional"]:
-            # Keras adaptor only support Sequential or Functional model
-            return "keras"
-        else:  # pragma: no cover
-            # otherwise, the backend will fallback to tensorflow_itex
-            return "saved_model"
-    if isinstance(model, tf.Graph):
-        return "graph"
-    elif isinstance(model, tf.compat.v1.GraphDef):
-        return "graph_def"
-    elif not version1_gte_version2(tf.version.VERSION, "2.16.1") and isinstance(
-        model, tf.compat.v1.estimator.Estimator
-    ):  # pragma: no cover
-        return "estimator"
-    elif isinstance(model, str):
-        model = os.path.abspath(os.path.expanduser(model))
-        if model.endswith(".pb") and os.path.isfile(model):
-            if is_saved_model_format(os.path.dirname(model)):  # pragma: no cover
-                return "saved_model"
-            else:
-                return "frozen_pb"
-        elif model.endswith(".ckpt") and os.path.isfile(model):  # pragma: no cover
-            return "slim"
-        elif os.path.isdir(model):
-            if is_ckpt_format(model):
-                return "checkpoint"
-            elif is_saved_model_format(model):
-                return "saved_model"
-        elif os.path.isfile(model + ".pb"):
-            return "frozen_pb"
-
-    raise ValueError("model {} has not recognized model type....".format(model))
-
-
-def validate_graph_node(graph_def, node_names):
-    """Validate nodes exist in the graph_def.
-
-    Args:
-        graph_def (tf.compat.v1.GraphDef): tf.compat.v1.GraphDef object.
-        node_names (list of string): node names to be validated.
-    """
-    if len(node_names) == 0:
-        return False
-    all_node_name = [node.name for node in graph_def.node]
-    for user_name in node_names:
-        if user_name not in all_node_name:
-            logger.warning(str("Node name {} specified in yaml doesn't exist in the model.").format(user_name))
-            return False
-    return True
-
-
-def validate_and_inference_input_output(graph_def, input_tensor_names, output_tensor_names):
-    """Validate and inference the input and output tensor names of graph_def.
-
-    Args:
-        graph_def (tf.compat.v1.GraphDef): tf.compat.v1.GraphDef object.
-        input_tensor_names (list of string): input_tensor_names of graph_def.
-        output_tensor_names (list of string): output_tensor_names of graph_def.
-
-    Returns:
-        input_tensor_names (list of string): validated input_tensor_names.
-        output_tensor_names (list of string): validated output_tensor_names.
-    """
-    from neural_compressor.tensorflow.quantization.utils.utility import get_input_output_node_names
-
-    temp_output_tensor_names = []
-    if validate_graph_node(graph_def, tensor_to_node(input_tensor_names)):
-        input_tensor_names = input_tensor_names
-    else:
-        input_tensor_names, temp_output_tensor_names = get_input_output_node_names(graph_def)
-
-    if validate_graph_node(graph_def, tensor_to_node(output_tensor_names)):
-        output_tensor_names = output_tensor_names
-    elif temp_output_tensor_names:
-        output_tensor_names = temp_output_tensor_names
-    else:  # pragma: no cover
-        _, output_tensor_names = get_input_output_node_names(graph_def)
-
-    return input_tensor_names, output_tensor_names
-
-
-def graph_session(model, input_tensor_names, output_tensor_names, **kwargs):
-    """Helper to build session with tf.compat.v1.Graph.
-
-    Args:
-        model (tf.compat.v1.Graph): tf.compat.v1.Graph object.
-        input_tensor_names (list of string): input_tensor_names of model.
-        output_tensor_names (list of string): output_tensor_names of model.
-
-    Returns:
-        sess (tf.compat.v1.Session): tf.compat.v1.Session object.
-        input_tensor_names (list of string): validated input_tensor_names.
-        output_tensor_names (list of string): validated output_tensor_names.
-    """
-    config = tf.compat.v1.ConfigProto()
-    config.use_per_session_threads = 1
-    config.inter_op_parallelism_threads = 1
-    sess = tf.compat.v1.Session(graph=model, config=config)
-
-    input_tensor_names, output_tensor_names = validate_and_inference_input_output(
-        model.as_graph_def(), input_tensor_names, output_tensor_names
-    )
-
-    return sess, input_tensor_names, output_tensor_names
-
-
-def graph_def_session(model, input_tensor_names, output_tensor_names, **kwargs):
-    """Build session with tf.compat.v1.GraphDef.
-
-    Args:
-        model (tf.compat.v1.GraphDef): tf.compat.v1.GraphDef object.
-        input_tensor_names (list of string): input_tensor_names of model.
-        output_tensor_names (list of string): output_tensor_names of model.
-
-    Returns:
-        sess (tf.compat.v1.Session): tf.compat.v1.Session object
-        input_tensor_names (list of string): validated input_tensor_names
-        output_tensor_names (list of string): validated output_tensor_names
-    """
-    device = kwargs.get("device")
-    graph = tf.Graph()
-    if version1_lt_version2(tf.version.VERSION, "2.0.0"):  # pragma: no cover
-        from tensorflow._api.v1.config import experimental
-
-        list_physical_devices = experimental.list_physical_devices
-    else:
-        list_physical_devices = tf.config.list_physical_devices
-
-    try:
-        with graph.as_default():
-            tf.import_graph_def(model, name="")
-    except:
-        input_tensor_names, output_tensor_names = validate_and_inference_input_output(
-            model, input_tensor_names, output_tensor_names
-        )
-        from neural_compressor.tensorflow.quantization.utils.utility import (
-            fix_ref_type_of_graph_def,
-            strip_unused_nodes,
-        )
-
-        model = fix_ref_type_of_graph_def(model)
-        input_node_names = tensor_to_node(input_tensor_names)
-        output_node_names = tensor_to_node(output_tensor_names)
-        model = strip_unused_nodes(model, input_node_names, output_node_names)
-        with graph.as_default():
-            tf.import_graph_def(model, name="")
-
-    return graph_session(graph, input_tensor_names, output_tensor_names, **kwargs)
-
-
-def frozen_pb_session(model, input_tensor_names, output_tensor_names, **kwargs):
-    """Build session with frozen pb.
-
-    Args:
-        model (string): model path.
-        input_tensor_names (list of string): input_tensor_names of model.
-        output_tensor_names (list of string): output_tensor_names of model.
-
-    Returns:
-        sess (tf.compat.v1.Session): tf.compat.v1.Session object.
-        input_tensor_names (list of string): validated input_tensor_names.
-        output_tensor_names (list of string): validated output_tensor_names.
-    """
-    graph_def = tf.compat.v1.GraphDef()
-    model = model if model.endswith(".pb") else model + ".pb"
-    with open(model, "rb") as f:
-        graph_def.ParseFromString(f.read())
-    return graph_def_session(graph_def, input_tensor_names, output_tensor_names, **kwargs)
-
-
-def _contains_function_with_implements_attr(saved_model_proto):
-    """Check whether SavedModel functions declare implementation attributes.
-
-    Args:
-        saved_model_proto: Loaded SavedModel protocol buffer.
-
-    Returns:
-        bool: True if a function contains _implements or api_implements attributes.
-    """
-    meta_graph = saved_model_proto.meta_graphs[0]
-    for function in meta_graph.graph_def.library.function:
-        if function.attr.get("_implements", None) or function.attr.get("api_implements", None):  # pragma: no cover
-            return True
-    return False
-
-
-def load_saved_model(model, saved_model_tags, input_tensor_names, output_tensor_names):  # pragma: no cover
-    """Load graph_def from saved model with the default serving signature key.
-
-    Args:
-        model: Directory of the SavedModel.
-        saved_model_tags: Set of tags identifying the MetaGraphDef within the
-            SavedModel to analyze.
-        input_tensor_names (list of string): input_tensor_names of model.
-        output_tensor_names (list of string): output_tensor_names of model.
-
-    Returns:
-        graph_def: The loaded GraphDef.
-        input_tensors: List of input tensors.
-        output_tensors: List of output tensors.
-    """
-    config = tf.compat.v1.ConfigProto()
-    config.use_per_session_threads = 1
-    config.inter_op_parallelism_threads = 1
-    if not os.listdir(os.path.join(model, "variables")):
-        sess = tf.compat.v1.Session(graph=tf.Graph(), config=config)
-        loader = tf.compat.v1.saved_model.loader.load(sess, ["serve"], model)
-        if len(input_tensor_names) == 0:
-            input_tensor_names = [i.name for _, i in loader.signature_def["serving_default"].inputs.items()]
-        else:
-            assert validate_graph_node(
-                sess.graph.as_graph_def(), tensor_to_node(input_tensor_names)
-            ), "tensor names {} not in the graph".format(input_tensor_names)
-
-        if len(output_tensor_names) == 0:
-            output_tensor_names = [i.name for _, i in loader.signature_def["serving_default"].outputs.items()]
-        else:
-            assert validate_graph_node(
-                sess.graph.as_graph_def(), tensor_to_node(output_tensor_names)
-            ), "tensor names {} not in the graph".format(output_tensor_names)
-
-        return sess.graph.as_graph_def(), input_tensor_names, output_tensor_names
-    else:
-        from tensorflow.core.protobuf import config_pb2, meta_graph_pb2
-        from tensorflow.python.eager import context
-        from tensorflow.python.framework.convert_to_constants import convert_variables_to_constants_v2
-        from tensorflow.python.grappler import tf_optimizer
-        from tensorflow.python.saved_model import load, signature_constants, tag_constants
-        from tensorflow.python.training import saver
-
-        _saved_model = load.load(model, [tag_constants.SERVING])
-        func = _saved_model.signatures[signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY]
-        frozen_func = convert_variables_to_constants_v2(func)
-        grappler_meta_graph_def = saver.export_meta_graph(
-            graph_def=frozen_func.graph.as_graph_def(), graph=frozen_func.graph
-        )
-        if len(input_tensor_names) == 0:
-            input_tensor_names = [i.name.split(":")[0] for i in frozen_func.inputs]
-        if len(output_tensor_names) == 0:
-            output_tensor_names = [i.name.split(":")[0] for i in frozen_func.outputs]
-        # Add a collection 'train_op' so that Grappler knows the outputs.
-        fetch_collection = meta_graph_pb2.CollectionDef()
-        for array in frozen_func.inputs + frozen_func.outputs:
-            fetch_collection.node_list.value.append(array.name)
-            grappler_meta_graph_def.collection_def["train_op"].CopyFrom(fetch_collection)
-        grappler_session_config = config_pb2.ConfigProto()
-        rewrite_options = grappler_session_config.graph_options.rewrite_options
-        rewrite_options.min_graph_nodes = -1
-        opt = tf_optimizer.OptimizeGraph(grappler_session_config, grappler_meta_graph_def, graph_id=b"tf_graph")
-        return opt, input_tensor_names, output_tensor_names
-
-
-def _get_graph_from_saved_model_v3(model, input_tensor_names, output_tensor_names):
-    """The version 3 function that get graph from saved_model.
-
-    Args:
-        model (string or tf.keras.Model): model path or tf.keras.Model object.
-        input_tensor_names (list of string): input tensor names of the model.
-        output_tensor_names (list of string): output tensor names of the model.
-
-    Returns:
-        graph_def (tf.compat.v1.Session): tf.compat.v1.Session object.
-        inputs (list of string): validated input names.
-        outputs (list of string): validated output names.
-    """
-    from neural_compressor.adaptor.tf_utils.util import parse_saved_model
-
-    if isinstance(model, tf.keras.Model):  # pragma: no cover
-        save_folder = "/tmp_model.keras" if version1_gte_version2(tf.version.VERSION, "2.16.1") else "/saved_model"
-        tmp_dir = DEFAULT_WORKSPACE + save_folder
-        model.save(tmp_dir)
-        model = tmp_dir
-    graph_def, _, _, _, input_names, output_names = parse_saved_model(
-        model, True, input_tensor_names, output_tensor_names
-    )
-
-    return graph_def, input_names, output_names
-
-
-def _get_graph_from_saved_model_v2(saved_model_dir, input_tensor_names, output_tensor_names):
-    """The version 2 function that get graph from the original keras model.
-
-    Args:
-        saved_model_dir (string): model path of a temporary saved_model.
-        input_tensor_names (list of string): input tensor names of the model.
-        output_tensor_names (list of string): output tensor names of the model.
-
-    Returns:
-        graph_def (tf.compat.v1.Session): tf.compat.v1.Session object.
-        input_names (list of string): validated input names.
-        output_names (list of string): validated output names.
-    """
-    from tensorflow.python.saved_model import signature_constants, tag_constants
-
-    saved_model_exported_names = [signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY]
-    saved_model_tags = set([tag_constants.SERVING])
-
-    return load_saved_model(saved_model_dir, saved_model_tags, input_tensor_names, output_tensor_names)
-
-
-def _get_graph_from_original_keras_v2(model):  # pragma: no cover
-    """The version 2 function that get graph from the original keras model.
-
-    Args:
-        model (string or tf.keras.Model): model path or tf.keras.Model object.
-
-    Returns:
-        graph_def (tf.compat.v1.Session): tf.compat.v1.Session object.
-        input_names (list of string): validated input names.
-        output_names (list of string): validated output names.
-    """
-    from tensorflow.lite.python.convert import OpsSet
-    from tensorflow.lite.python.util import (
-        get_grappler_config,
-        model_input_signature,
-        run_graph_optimizations,
-        trace_model_call,
-    )
-    from tensorflow.python.eager import def_function
-    from tensorflow.python.framework import convert_to_constants, dtypes
-
-    input_signature = None
-    # If the model's call is not a `tf.function`, then we need to first get its
-    # input signature from `model_input_signature` method.
-    if not isinstance(model.call, def_function.Function):
-        input_signature = model_input_signature(model, keep_original_batch_size=False)
-
-    func = trace_model_call(model, input_signature)
-    concrete_func = func.get_concrete_function()
-    funcs = [concrete_func]
-
-    frozen_func, graph_def = convert_to_constants.convert_variables_to_constants_v2_as_graph(
-        funcs[0], lower_control_flow=False
-    )
-
-    input_tensors = [tensor for tensor in frozen_func.inputs if tensor.dtype != dtypes.resource]
-    output_tensors = frozen_func.outputs
-    # Grappler will also try to lower while loop into switch merge
-    # representation which is undesired for Ophints, so we simply remove
-    # those attributes to prevent Grappler from doing so.
-    graph = convert_to_constants.disable_lower_using_switch_merge(graph_def)
-    # Run function inlining optimization to ensure any models generated
-    # through the from_frozen_graph path have been inlined.
-    # grappler_config = get_grappler_config(['function'])
-    # graph_def = run_graph_optimizations(
-    #             graph,
-    #             input_tensors,
-    #             output_tensors,
-    #             config=grappler_config)
-    input_names = [tensor.name.split(":")[0] for tensor in input_tensors]
-    output_names = [tensor.name.split(":")[0] for tensor in output_tensors]
-    return graph_def, input_names, output_names
-
-
-def _check_keras_format(model, saved_model_dir):  # pragma: no cover
-    """Decide which method will be used to get graph from the saved_model .
-
-    Args:
-        model (string or tf.keras.Model): model path or tf.keras.Model object.
-        saved_model_dir (string): the path to save a temporary saved_model.
-
-    Returns:
-        graph_def (tf.compat.v1.Session): tf.compat.v1.Session object.
-        inputs (list of string): validated input names.
-        outputs (list of string): validated output names.
-    """
-    from tensorflow.python import saved_model
-    from tensorflow.python.saved_model import save_options
-    from tensorflow.python.saved_model.load import load
-    from tensorflow.python.saved_model.loader_impl import parse_saved_model_with_debug_info
-
-    version = "saved_model_v2"
-    try:
-        saved_model.save(model, saved_model_dir, options=save_options.SaveOptions(save_debug_info=True))
-    except:
-        return "trackable_object"
-    saved_model_proto, _ = parse_saved_model_with_debug_info(saved_model_dir)
-    saved_model_version = saved_model_proto.saved_model_schema_version
-    if saved_model_version == 0:
-        return "saved_model_v1"
-    if saved_model_version not in [1, 2]:
-        raise ValueError("SavedModel file format({0}) is not supported".format(saved_model_version))
-    return version
-
-
-def _get_graph_from_saved_model_v1(model):
-    """The version 1 function that get graph from saved_model.
-
-    Args:
-        model (string or tf.keras.Model): model path or tf.keras.Model object.
-
-    Returns:
-        graph_def (tf.compat.v1.Session): tf.compat.v1.Session object.
-        inputs (list of string): validated input names.
-        outputs (list of string): validated output names.
-    """
-    from tensorflow.lite.python.convert_saved_model import get_inputs_outputs, get_meta_graph_def, get_signature_def
-    from tensorflow.python.client import session
-    from tensorflow.python.framework import ops
-    from tensorflow.python.saved_model import constants, signature_constants, tag_constants
-
-    saved_model_tags = set([tag_constants.SERVING])
-    signature_key = signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY
-
-    meta_graph = get_meta_graph_def(model, saved_model_tags)
-    signature_def = get_signature_def(meta_graph, signature_key)
-    inputs, outputs = get_inputs_outputs(signature_def)  # pragma: no cover
-    # Check SavedModel for assets directory.
-    collection_def = meta_graph.collection_def
-    if constants.ASSETS_KEY in collection_def:  # pragma: no cover
-        raise ValueError("SavedModels with assets/ directory are not supported.")
-
-    from tensorflow.compat.v1 import graph_util as tf_graph_util
-    from tensorflow.python.saved_model import loader
-
-    graph = ops.Graph()
-    import tensorflow as tf
-
-    with session.Session(graph=graph) as sess:
-        loader.load(sess, meta_graph.meta_info_def.tags, model)
-        sess.run(tf.compat.v1.global_variables_initializer())
-        sess.run(tf.compat.v1.tables_initializer())
-        output_nodes = list(set([output.split(":")[0] for output in outputs]))
-        node_ops = [node.op for node in graph.as_graph_def().node]
-        if "MakeIterator" in node_ops:  # pragma: no cover
-            output_nodes.append("MakeIterator")
-        table_ops = tf.compat.v1.get_collection(tf.compat.v1.GraphKeys.TABLE_INITIALIZERS)
-        # For table initialization
-        for table_op in table_ops:  # pragma: no cover
-            output_nodes.append(table_op.name)
-        if len(table_ops) > 0:  # pragma: no cover
-            output_nodes.append("init_all_tables")
-        graph_def = tf_graph_util.convert_variables_to_constants(sess, graph.as_graph_def(), output_nodes)
-    return graph_def, inputs, outputs
-
-
-def try_loading_keras(model, input_tensor_names, output_tensor_names):  # pragma: no cover
-    """Try different ways of loading keras models.
-
-    Args:
-        model (string or tf.keras.Model): model path or tf.keras.Model object.
-        input_tensor_names (list of string): input tensor names of the model.
-        output_tensor_names (list of string): output tensor names of the model.
-
-    Returns:
-        graph_def (tf.compat.v1.Session): tf.compat.v1.Session object.
-        input_names (list of string): validated input names.
-        output_names (list of string): validated output names.
-    """
-    temp_dir = tempfile.mkdtemp()
-    if not isinstance(model, tf.keras.Model):
-        model = load_keras_model(model)
-    keras_format = _check_keras_format(model, temp_dir)
-
-    if keras_format == "saved_model_v2":
-        try:
-            graph_def, input_names, output_names = _get_graph_from_saved_model_v2(
-                temp_dir, input_tensor_names, output_tensor_names
-            )
-            if "_FusedBatchNormEx" in [node.op for node in graph_def.node]:
-                keras_format = "trackable_object"
-        except:
-            keras_format = "trackable_object"
-
-    if keras_format == "trackable_object":
-        try:
-            graph_def, input_names, output_names = _get_graph_from_original_keras_v2(model)
-        except:
-            keras_format = "saved_model_v1"
-
-    if keras_format == "saved_model_v1":  # pragma: no cover
-        try:
-            tf.keras.backend.set_learning_phase(0)
-            graph_def, input_names, output_names = _get_graph_from_saved_model_v1(model)
-        except:
-            raise ValueError("Not supported keras model type...")
-
-    shutil.rmtree(temp_dir, True)
-    return graph_def, input_names, output_names
-
-
-def keras_session(model, input_tensor_names, output_tensor_names, **kwargs):
-    """Build session with keras model.
-
-    Args:
-        model (string or tf.keras.Model): model path or tf.keras.Model object.
-        input_tensor_names (list of string): input_tensor_names of model.
-        output_tensor_names (list of string): output_tensor_names of model.
-
-    Returns:
-        sess (tf.compat.v1.Session): tf.compat.v1.Session object.
-        input_tensor_names (list of string): validated input_tensor_names.
-        output_tensor_names (list of string): validated output_tensor_names.
-    """
-    if tf.version.VERSION > "2.1.0":
-        try:
-            graph_def, input_names, output_names = _get_graph_from_saved_model_v3(
-                model, input_tensor_names, output_tensor_names
-            )
-        except:
-            graph_def, input_names, output_names = try_loading_keras(model, input_tensor_names, output_tensor_names)
-    # tensorflow 1.x use v1 convert method
-    else:
-        tf.keras.backend.set_learning_phase(0)
-        graph_def, input_names, output_names = _get_graph_from_saved_model_v1(model)
-
-    return graph_def_session(graph_def, input_names, output_names, **kwargs)
-
-
-def slim_session(model, input_tensor_names, output_tensor_names, **kwargs):  # pragma: no cover
-    """Build session with slim model.
-
-    Args:
-        model (string): model path.
-        input_tensor_names (list of string): input_tensor_names of model.
-        output_tensor_names (list of string): output_tensor_names of model.
-
-    Returns:
-        sess (tf.compat.v1.Session): tf.compat.v1.Session object.
-        input_tensor_names (list of string): validated input_tensor_names.
-        output_tensor_names (list of string): validated output_tensor_names.
-    """
-    assert version1_lt_version2(tf.version.VERSION, "2.0.0"), "slim model only used in tensorflow 1.x"
-    from neural_compressor.tensorflow.utils.utility import TFSlimNetsFactory
-
-    factory = TFSlimNetsFactory()
-    assert "name" in kwargs, "model name should be set in slim checkpoint...."
-    assert kwargs["name"] in factory.default_slim_models, "only support topology {}".format(factory.default_slim_models)
-    net = copy.deepcopy(factory.networks_map[kwargs["name"]])
-    model_func = net.pop("model")
-    arg_scope = net.pop("arg_scope")()
-    inputs_shape = net.pop("input_shape")
-    kwargs = net
-    import tf_slim as slim
-
-    with tf.Graph().as_default():
-        images = tf.compat.v1.placeholder(name="input", dtype=tf.float32, shape=inputs_shape)
-        with tf.compat.v1.Session() as sess:
-            with slim.arg_scope(arg_scope) as scope:  # pylint: disable=not-context-manager
-                model_func(images, is_training=False, **kwargs)
-            graph_def = sess.graph.as_graph_def()
-            output_tensor_names = output_tensor_names if len(output_tensor_names) > 0 else [graph_def.node[-1].name]
-
-            from tensorflow.python.tools.freeze_graph import freeze_graph_with_def_protos
-
-            graph_def = freeze_graph_with_def_protos(
-                input_graph_def=graph_def,
-                input_saver_def=None,
-                input_checkpoint=model,
-                output_node_names=",".join(output_tensor_names),
-                restore_op_name="save/restore_all",
-                filename_tensor_name="save/Const:0",
-                output_graph="",
-                clear_devices=True,
-                initializer_nodes="",
-            )
-
-    return graph_def_session(graph_def, ["input"], output_tensor_names, **kwargs)
-
-
-def checkpoint_session(model, input_tensor_names, output_tensor_names, **kwargs):
-    """Build session with ckpt model.
-
-    Args:
-        model (string): model path.
-        input_tensor_names (list of string): input_tensor_names of model.
-        output_tensor_names (list of string): validated output_tensor_names of model.
-
-    Returns:
-        sess (tf.compat.v1.Session): tf.compat.v1.Session object.
-        input_tensor_names (list of string): validated input_tensor_names.
-        output_tensor_names (list of string): validated output_tensor_names.
-    """
-    assert (
-        output_tensor_names is not None and len(output_tensor_names) > 0
-    ), "outputs should not be None of checkpoint...."
-
-    ckpt_prefix = [os.path.splitext(i)[0] for i in os.listdir(model) if i.endswith(".meta")][0]
-
-    config = tf.compat.v1.ConfigProto()
-    config.use_per_session_threads = 1
-    config.inter_op_parallelism_threads = 1
-    graph = tf.Graph()
-    sess = tf.compat.v1.Session(graph=graph, config=config)
-    if version1_lt_version2(tf.version.VERSION, "2.0.0"):  # pragma: no cover
-        from tensorflow._api.v1.config import experimental
-
-        list_physical_devices = experimental.list_physical_devices
-    else:
-        list_physical_devices = tf.config.list_physical_devices
-
-    with graph.as_default():
-        device = kwargs.get("device")
-        if device == "cpu":
-            cpus = list_physical_devices("CPU")
-            node_device = cpus[0].name.replace("physical_device:", "")
-            with graph.device(node_device):
-                saver = tf.compat.v1.train.import_meta_graph(
-                    os.path.join(model, ckpt_prefix + ".meta"), clear_devices=True
-                )
-        else:  # pragma: no cover
-            saver = tf.compat.v1.train.import_meta_graph(os.path.join(model, ckpt_prefix + ".meta"), clear_devices=True)
-
-        sess.run(tf.compat.v1.global_variables_initializer())
-        saver.restore(sess, os.path.join(model, ckpt_prefix))
-
-    from neural_compressor.tensorflow.quantization.utils.utility import get_input_output_node_names
-
-    if validate_graph_node(sess.graph.as_graph_def(), tensor_to_node(input_tensor_names)):
-        input_tensor_names = input_tensor_names
-    else:
-        input_tensor_names, _ = get_input_output_node_names(sess.graph.as_graph_def())
-    return sess, input_tensor_names, output_tensor_names
-
-
-def estimator_session(model, input_tensor_names, output_tensor_names, **kwargs):  # pragma: no cover
-    """Build session with estimator model.
-
-    Args:
-        model (tf.estimator.Estimator): tf.estimator.Estimator object.
-        input_tensor_names (list of string): input_tensor_names of model.
-        output_tensor_names (list of string): output_tensor_names of model.
-        kwargs (dict): other required parameters, like input_fn.
-
-    Returns:
-        sess (tf.compat.v1.Session): tf.compat.v1.Session object.
-        input_tensor_names (list of string): validated input_tensor_names.
-        output_tensor_names (list of string): validated output_tensor_names.
-    """
-    assert "input_fn" in kwargs, "input func should be supplied for estimator session...."
-    with tf.Graph().as_default() as g:
-        features, input_hooks = model._get_features_from_input_fn(kwargs["input_fn"], tf.estimator.ModeKeys.PREDICT)
-        estimator_spec = model._call_model_fn(features, None, tf.estimator.ModeKeys.PREDICT, model.config)
-
-        if len(output_tensor_names) == 0:
-            outputs = (
-                [tensor.name for tensor in estimator_spec.predictions.values()]
-                if isinstance(estimator_spec.predictions, dict)
-                else [estimator_spec.predictions.name]
-            )
-        else:
-            outputs = output_tensor_names
-
-        logger.info("Estimator output tensor names are {}.".format(outputs))
-        with tf.compat.v1.Session(graph=g) as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            # Freezing a graph requires output_node_names, which can be found in
-            # estimator_spec.predictions that contains prediction tensors as a
-            # dictionary
-            # When a model uses Iterator, we need to have 'MakeIterator' (default
-            # name used by TF) in the output_node_names as well.
-            output_nodes = list(set([output.split(":")[0] for output in outputs]))
-            if "MakeIterator" in [node.op for node in g.as_graph_def().node]:
-                output_nodes.append("MakeIterator")
-
-            graph_def = tf.compat.v1.graph_util.convert_variables_to_constants(sess, g.as_graph_def(), output_nodes)
-
-        return graph_def_session(graph_def, input_tensor_names, outputs, **kwargs)
-
-
-def saved_model_session(model, input_tensor_names, output_tensor_names, **kwargs):
-    """Build session with saved model.
-
-    Args:
-        model (string): model path.
-        input_tensor_names (list of string): input_tensor_names of model.
-        output_tensor_names (list of string): output_tensor_names of model.
-
-    Returns:
-        sess (tf.compat.v1.Session): tf.compat.v1.Session object.
-        input_tensor_names (list of string): validated input_tensor_names.
-        output_tensor_names (list of string): validated output_tensor_names.
-    """
-    try:
-        graph_def, input_names, output_names = _get_graph_from_saved_model_v3(
-            model, input_tensor_names, output_tensor_names
-        )
-    except:
-        try:
-            graph_def, input_names, output_names = _get_graph_from_saved_model_v2(
-                model, input_tensor_names, output_tensor_names
-            )
-        except:
-            graph_def, input_names, output_names = _get_graph_from_saved_model_v1(model)
-
-    assert graph_def is not None, "Can not parse the saved model..."
-
-    return graph_def_session(graph_def, input_names, output_names, **kwargs)
-
-
-# it's necessary that a session with input output tensors to run the model
-SESSIONS = {
-    "frozen_pb": frozen_pb_session,
-    "graph_def": graph_def_session,
-    "graph": graph_session,
-    "saved_model": saved_model_session,
-    "llm_saved_model": saved_model_session,
-    "keras": keras_session,
-    "checkpoint": checkpoint_session,
-    "estimator": estimator_session,
-    "slim": slim_session,
-}
-
-
-class BaseModel:
-    """Base class of all neural_compressor.model, will play graph role."""
-
-    def __init__(self, model, **kwargs):
-        """Initialize a BaseModel.
-
-        Args:
-            model (object): raw model format. For Tensorflow model, could be path to frozen pb file,
-                path to ckpt or savedmodel folder, loaded estimator/graph_def/graph/keras model object.
-        """
-        self.component = None
-
-    @property
-    def model(self):
-        """Return model itself."""
-        raise NotImplementedError
-
-    @property
-    def graph_info(self):
-        """Return a dict with content 'Node: Node_type'."""
-        raise NotImplementedError
-
-    @abstractmethod
-    def save(self, root, *args, **kwargs):
-        """Abstract method of model saving."""
-        raise NotImplementedError
-
-    @abstractmethod
-    def export(
-        self,
-        save_path: str,
-        conf,
-    ):
-        """Abstract method of model conversion to ONNX."""
-        raise NotImplementedError
-
-    @abstractmethod
-    def framework(self):
-        """Abstract method of model framework."""
-        raise NotImplementedError
-
-
-class TensorflowBaseModel(BaseModel):
-    """Build Tensorflow Base Model."""
-
-    def __init__(self, model, **kwargs):
-        """Initialize a Tensorflow model.
-
-        Args:
-            model (string or tensorflow model object): model path or model object.
-        """
-        self._model = model
-        self._name = ""
-        self._weights = None
-        self.kwargs = kwargs
-        self._graph_info = {}
-        self._input_tensor_names = []
-        self._output_tensor_names = []
-        self._model_type = ""
-        self._sess = None
-        self._iter_op = None
-        self._workspace_path = ""
-        self._q_config = None
-        self._model_path = None if not isinstance(model, str) else model
-
-    @property
-    def model_path(self):
-        """Return model path."""
-        return self._model_path
-
-    @model_path.setter
-    def model_path(self, path):
-        """Set model path."""
-        self._model_path = path
-
-    def framework(self):
-        """Return framework."""
-        return "tensorflow"
-
-    @property
-    def name(self):
-        """Renturn name."""
-        return self._name
-
-    @name.setter
-    def name(self, name):
-        """Set name."""
-        self.kwargs.update({"name": name})
-        self._name = name
-
-    @property
-    def weights(self):
-        """Return weights."""
-        return self._weights
-
-    @weights.setter
-    def weights(self, new_weights):
-        """Set weights."""
-        self._weights = new_weights
-
-    @property
-    def q_config(self):
-        """Return q_config."""
-        return self._q_config
-
-    @q_config.setter
-    def q_config(self, q_config):
-        """Set q_config."""
-        self._q_config = q_config
-
-    @property
-    def workspace_path(self):
-        """Return workspace path."""
-        return self._workspace_path
-
-    @workspace_path.setter
-    def workspace_path(self, path):
-        """Set workspace path."""
-        self._workspace_path = path
-
-    @property
-    def model_type(self):
-        """Return model type."""
-        return self._model_type
-
-    @model_type.setter
-    def model_type(self, model_type):
-        """Set model type."""
-        assert model_type in SESSIONS, "model type not supported...."
-        self._model_type = model_type
-
-    @property
-    def model(self):
-        """Return model itself."""
-        return self.graph
-
-    @property
-    def graph_def(self):
-        """Return graph definition."""
-        return self.graph.as_graph_def()
-
-    @property
-    def graph_info(self):
-        """Return graph info."""
-        self._graph_info = {}
-        for node in self.graph_def.node:
-            self._graph_info[node.name] = node.op
-        return self._graph_info
-
-    @property
-    def sess(self):
-        """Return Session object."""
-        if self._sess is None:
-            self._load_sess(self._model, **self.kwargs)
-        return self._sess
-
-    @property
-    def graph(self):
-        """Return model graph."""
-        return self.sess.graph
-
-    @graph_def.setter
-    def graph_def(self, graph_def):
-        """Set graph definition."""
-        if self._sess is not None:
-            self._sess.close()
-        output_sess = SESSIONS["graph_def"](
-            graph_def, self._input_tensor_names, self._output_tensor_names, **self.kwargs
-        )
-
-        self._sess = output_sess[0]
-        self._input_tensor_names = output_sess[1]
-        self._output_tensor_names = output_sess[2]
-        self.model_type = "graph_def"
-
-    def _load_sess(self, model, **kwargs):
-        """Load a TensorFlow session for the wrapped model.
-
-        Args:
-            model: Model path or graph object.
-            **kwargs: Additional session creation arguments.
-
-        Returns:
-            tf.compat.v1.Session: Initialized session object.
-        """
-        if self.name:
-            kwargs.update({"name": self.name})
-        # assert self.model_type, 'model type not set....'
-        output_sess = SESSIONS[self.model_type](model, self._input_tensor_names, self._output_tensor_names, **kwargs)
-        self._sess = output_sess[0]
-        self._input_tensor_names = output_sess[1]
-        self._output_tensor_names = output_sess[2]
-
-        tf.compat.v1.get_variable_scope().reuse_variables()
-        return self._sess
-
-    @property
-    def iter_op(self):
-        """Return model iter op list."""
-        self._iter_op = []
-        if self._sess is None:  # pragma: no cover
-            self._load_sess(self._model, **self.kwargs)
-        op_list = [node.op for node in self._sess.graph.as_graph_def().node]
-        if "MakeIterator" in op_list:  # pragma: no cover
-            self._iter_op.append(self._sess.graph.get_operation_by_name("MakeIterator"))
-        return self._iter_op
-
-    @property
-    def input_tensor_names(self):
-        """Return input tensor names."""
-        if self._sess is None:
-            self._load_sess(self._model, **self.kwargs)
-        return copy.deepcopy(self._input_tensor_names)
-
-    @input_tensor_names.setter
-    def input_tensor_names(self, tensor_names):
-        """Set input tensor names."""
-        if len(tensor_names) == 0:  # pragma: no cover
-            logger.warning("Input tensor names is empty.")
-            return
-        if self._sess is not None:
-            assert validate_graph_node(
-                self.graph_def, tensor_to_node(tensor_names)
-            ), "tensor names {} not in graph".format(tensor_names)
-        self._input_tensor_names = tensor_names
-
-    @property
-    def output_tensor_names(self):
-        """Return output tensor names."""
-        if len(self._output_tensor_names) == 0:
-            self._load_sess(self._model, **self.kwargs)
-        return copy.deepcopy(self._output_tensor_names)
-
-    @output_tensor_names.setter
-    def output_tensor_names(self, tensor_names):
-        """Set output tensor names."""
-        if len(tensor_names) == 0:  # pragma: no cover
-            logger.warning("Output tensor names should not be empty.")
-            return
-        if self._sess is not None:
-            assert validate_graph_node(
-                self.graph_def, tensor_to_node(tensor_names)
-            ), "tensor names {} not in graph".format(tensor_names)
-        self._output_tensor_names = tensor_names
-
-    # input/output node names and input/output tensor
-    # come from input/output tensor names, so do not support assign these values
-    @property
-    def input_node_names(self):
-        """Return input node names."""
-        return copy.deepcopy(tensor_to_node(self.input_tensor_names))
-
-    @property
-    def output_node_names(self):
-        """Return output node names."""
-        output_node_names = tensor_to_node(self.output_tensor_names)
-        iter_op_list = self.iter_op
-        if iter_op_list != []:  # pragma: no cover
-            output_node_names += [iter_op.name for iter_op in iter_op_list]
-        return copy.deepcopy(output_node_names)
-
-    @property
-    def input_tensor(self):
-        """Return input tensor."""
-        from neural_compressor.tensorflow.quantization.utils.utility import get_tensor_by_name
-
-        return [get_tensor_by_name(self.graph, x) for x in self.input_tensor_names]
-
-    @property
-    def output_tensor(self):
-        """Return output tensor."""
-        from neural_compressor.tensorflow.quantization.utils.utility import get_tensor_by_name
-
-        return [get_tensor_by_name(self.graph, x) for x in self.output_tensor_names]
-
-    def save(self, root=None):
-        """Save Tensorflow model."""
-        if not root:  # pragma: no cover
-            root = DEFAULT_WORKSPACE + "/save.pb"
-        root = os.path.abspath(os.path.expanduser(root))
-        # if not have suffix, default append .pb
-        os.makedirs(os.path.dirname(root), exist_ok=True)
-        pb_file = root if os.path.split(root)[-1].endswith(".pb") else root + ".pb"
-        f = tf.io.gfile.GFile(pb_file, "wb")
-        f.write(self.graph_def.SerializeToString())
-        logger.info("Save quantized model to {}.".format(pb_file))
-
-
-class TensorflowSavedModelModel(TensorflowBaseModel):
-    """Build Tensorflow saved model."""
-
-    def __init__(self, model, **kwargs):
-        """Initialize a Tensorflow model.
-
-        Args:
-            model (string or tensorflow model object): model path or model object.
-        """
-        super(TensorflowSavedModelModel, self).__init__(model, **kwargs)
-        self._auto_trackable = None
-
-    def get_all_weight_names(self):
-        """Get weight names of model.
-
-        Returns:
-            list: weight names list.
-        """
-        import tensorflow as tf
-
-        names = []
-        for index, layer in enumerate(load_keras_model(self._model).layers):
-            if len(layer.weights):
-                names.append(index)
-        return names
-
-    def update_weights(self, tensor_name, new_tensor):
-        """Update model weights."""
-        pass
-
-    def get_weight(self, tensor_name):
-        """Return model weight with a given tensor name.
-
-        Args:
-            tensor_name (str): name of a tensor.
-        """
-        return self.weights[tensor_name]
-
-    @property
-    def model(self):
-        """Return model in AutoTrackable object."""
-        if self._auto_trackable:  # pragma: no cover
-            return self._auto_trackable
-
-        root = os.path.abspath(os.path.expanduser(DEFAULT_WORKSPACE))
-        root += str(time.time())
-        if os.path.exists(root):  # pragma: no cover
-            shutil.rmtree(root)
-        os.makedirs(root, exist_ok=True)
-        if not self._sess:
-            self._load_sess(self._model, **self.kwargs)
-        _, builder = self.build_saved_model(root)
-        builder.save()
-        model = tf.saved_model.load(root)
-        shutil.rmtree(root)
-        self._auto_trackable = model
-        return model
-
-    @model.setter
-    def model(self, input_model):
-        """Set model in AutoTrackable object."""
-        self._auto_trackable = input_model
-
-    def build_saved_model(self, root=None):
-        """Build Tensorflow saved model.
-
-        Args:
-            root (str, optional): path to saved model. Defaults to None.
-
-        Returns:
-            root (str): path to saved model.
-            builder (tf.compat.v1.saved_model.builder.SavedModelBuilder): builds
-                the SavedModel protocol buffer and saves variables and assets.
-        """
-        if not root:  # pragma: no cover
-            root = DEFAULT_WORKSPACE
-        root = os.path.abspath(os.path.expanduser(root))
-        if os.path.exists(root):
-            import shutil
-
-            shutil.rmtree(root)
-
-        os.makedirs(root, exist_ok=True)
-
-        from tensorflow.python.saved_model import signature_constants, tag_constants
-
-        from neural_compressor.tensorflow.quantization.utils.utility import get_tensor_by_name
-
-        builder = tf.compat.v1.saved_model.builder.SavedModelBuilder(root)
-        sigs = {}
-        with tf.compat.v1.Session(graph=tf.Graph()) as sess:
-            # (TODO) not directly use self._sess.graph, use self.graph
-            tf.import_graph_def(self.graph.as_graph_def(), name="")
-            g = tf.compat.v1.get_default_graph()
-            inp = [get_tensor_by_name(g, x) for x in self._input_tensor_names]
-            out = [get_tensor_by_name(g, x) for x in self._output_tensor_names]
-            sigs[signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY] = (
-                tf.compat.v1.saved_model.signature_def_utils.predict_signature_def(
-                    {k: v for k, v in zip(self._input_tensor_names, inp)},
-                    {k: v for k, v in zip(self._output_tensor_names, out)},
-                )
-            )
-            builder.add_meta_graph_and_variables(sess, [tag_constants.SERVING], signature_def_map=sigs)
-        return root, builder
-
-    def save(self, root=None):
-        """Save Tensorflow model."""
-        root, builder = self.build_saved_model(root)
-        builder.save()
-        logger.info("Save quantized model to {}.".format(root))
-
-
-class TensorflowLLMModel(TensorflowSavedModelModel):
-    """The class Tensorflow saved model whose GraphDef exceeding maximum protobuf size of 2GB."""
-
-    def __init__(self, model, **kwargs):
-        """Initialize a Tensorflow model.
-
-        Args:
-            model (string or tensorflow model object): model path or model object.
-        """
-        super(TensorflowLLMModel, self).__init__(model, **kwargs)
-
-        self._model_path = self.kwargs.get("model_path", None)
-        self._weight_name_mapping = self.kwargs.get("weight_name_mapping", None)
-        self._sq_weight_scale_dict = self.kwargs.get("sq_weight_scale_dict", None)
-        self._weight_tensor_minmax_dict = {}
-        self._model_type = "llm_saved_model"
-
-        from neural_compressor.tensorflow.quantization.utils.utility import parse_saved_model
-
-        (
-            self._graph_def,
-            self._saved_model,
-            self.func,
-            self.frozen_func,
-            self._input_tensor_names,
-            self._output_tensor_names,
-        ) = parse_saved_model(model)
-
-    @property
-    def model_path(self):
-        """Return model path.
-
-        The model path in this class is used as a temp path for intermediate model
-        """
-        return self._model_path
-
-    @model_path.setter
-    def model_path(self, path):
-        """Set model path.
-
-        The model path in this class is used as a temp path for intermediate model
-        """
-        self.kwargs.update({"model_path": path})
-        self._model_path = path
-
-    @property
-    def graph_def(self):
-        """Return graph_def."""
-        return self._graph_def
-
-    @graph_def.setter
-    def graph_def(self, graph_def):
-        """Set graph definition."""
-        self._graph_def = graph_def
-        # the attributes of some nodes can't be correctly read if don't import the graph_def
-        tf.import_graph_def(self._graph_def, name="")
-
-    @property
-    def model(self):
-        """Return model in AutoTrackable Format."""
-        if self._sq_weight_scale_dict:
-            self.adjust_weight(self.graph_def)
-        if not self._auto_trackable:
-            self._auto_trackable = tf.saved_model.load(self._model)
-        return self._auto_trackable
-
-    @property
-    def weight_name_mapping(self):
-        """Return weight_name_mapping function."""
-        if not self._weight_name_mapping:  # pragma: no cover
-            self._weight_name_mapping = self.kwargs.get("weight_name_mapping", None)
-        assert self._weight_name_mapping is not None, "weight_name_mapping should not be None!"
-        return self._weight_name_mapping
-
-    @weight_name_mapping.setter
-    def weight_name_mapping(self, weight_name_mapping):
-        """Set weight_name_mapping function."""
-        self.kwargs.update({"weight_name_mapping": weight_name_mapping})
-        self._weight_name_mapping = weight_name_mapping
-
-    @property
-    def sq_weight_scale_dict(self):
-        """Return dict of weight scaler for smooth quantization."""
-        if not self._sq_weight_scale_dict:  # pragma: no cover
-            self._sq_weight_scale_dict = self.kwargs.get("sq_weight_scale_dict", None)
-        assert self._weight_name_mapping is not None, "sq_weight_scale_dict should not be None!"
-        return self._sq_weight_scale_dict
-
-    @sq_weight_scale_dict.setter
-    def sq_weight_scale_dict(self, sq_weight_scale_dict):
-        """Set dict of weight scaler for smooth quantization."""
-        self.kwargs.update({"sq_weight_scale_dict": sq_weight_scale_dict})
-        self._sq_weight_scale_dict = sq_weight_scale_dict
-
-    @property
-    def weight_tensor_minmax_dict(self):
-        """Return dict of weight scaler for smooth quantization."""
-        return self._weight_tensor_minmax_dict
-
-    @property
-    def input_tensor_names(self):
-        """Return input tensor names."""
-        return copy.deepcopy(self._input_tensor_names)
-
-    @input_tensor_names.setter
-    def input_tensor_names(self, tensor_names):
-        """Set input tensor names."""
-        if len(tensor_names) == 0:  # pragma: no cover
-            logger.warning("Input tensor names is empty.")
-            return
-
-        assert validate_graph_node(
-            self._graph_def, tensor_to_node(tensor_names)
-        ), "tensor names {} not in graph".format(tensor_names)
-        self._input_tensor_names = tensor_names
-
-    @property
-    def output_tensor_names(self):
-        """Return output tensor names."""
-        return copy.deepcopy(self._output_tensor_names)
-
-    @output_tensor_names.setter
-    def output_tensor_names(self, tensor_names):
-        """Set output tensor names."""
-        if len(tensor_names) == 0:  # pragma: no cover
-            logger.warning("Output tensor names is empty.")
-            return
-        if self._graph_def is not None:
-            assert validate_graph_node(
-                self.graph_def, tensor_to_node(tensor_names)
-            ), "tensor names {} not in graph".format(tensor_names)
-        self._output_tensor_names = tensor_names
-
-    @property
-    def output_node_names(self):
-        """Return output node names."""
-        output_node_names = tensor_to_node(self.output_tensor_names)
-        return copy.deepcopy(output_node_names)
-
-    def adjust_weight(self, graph_def):
-        """Adjust weight of LLM saved_model by scale."""
-        from tensorflow.python.saved_model import load, tag_constants
-
-        from neural_compressor.tensorflow.quantization.utils.utility import reconstruct_saved_model
-
-        reconstruct_saved_model(graph_def, self.func, self.frozen_func, self._saved_model, self.model_path)
-        model = load.load(self.model_path, [tag_constants.SERVING])
-
-        for idx, weight_tensor in enumerate(model.variables):
-            parsed_weight_name = self.weight_name_mapping(weight_tensor.name)
-            if parsed_weight_name in self.sq_weight_scale_dict:
-                if len(weight_tensor.shape) == 4:  # pragma: no cover
-                    shape_parm = [0, 1, 3, 2]
-                elif len(weight_tensor.shape) == 2:
-                    shape_parm = [1, 0]
-                weight_array = np.transpose(weight_tensor, shape_parm)
-                weight_array *= self.sq_weight_scale_dict[parsed_weight_name]
-                weight_array = np.transpose(weight_array, shape_parm)
-                tf.compat.v1.assign(model.variables[idx], weight_array)
-            else:
-                weight_array = weight_tensor
-
-            if parsed_weight_name not in self._weight_tensor_minmax_dict:
-                self._weight_tensor_minmax_dict[parsed_weight_name] = [np.min(weight_array), np.max(weight_array)]
-        self._auto_trackable = model
-
-    def save(self, root=None):
-        """Save the model to the root path."""
-        import shutil
-
-        from neural_compressor.tensorflow.quantization.utils.utility import parse_saved_model, reconstruct_saved_model
-
-        if not root:  # pragma: no cover
-            root = DEFAULT_WORKSPACE
-        root = os.path.abspath(os.path.expanduser(root))
-        if os.path.exists(root):  # pragma: no cover
-            shutil.rmtree(root)
-        os.makedirs(root, exist_ok=True)
-
-        self.adjust_weight(self._graph_def)
-        graph_def, _saved_model, func, frozen_func, _, _ = parse_saved_model(self._auto_trackable)
-        reconstruct_saved_model(graph_def, func, frozen_func, _saved_model, root)
-        logger.info("Save quantized model to {}.".format(root))
-        # delete the LLM file saved in this temporary path
-        shutil.rmtree(self.model_path, ignore_errors=True)
-
-
-class TensorflowCheckpointModel(TensorflowBaseModel):
-    """Build Tensorflow checkpoint model."""
-
-    @property
-    def graph_def(self):
-        """Return graph definition."""
-        if self.model_type == "graph_def":  # pragma: no cover
-            return self.sess.graph.as_graph_def()
-        from tensorflow.compat.v1 import graph_util
-
-        from neural_compressor.tensorflow.quantization.utils.utility import _parse_ckpt_bn_input
-
-        graph_def = self.sess.graph.as_graph_def()
-        graph_def = _parse_ckpt_bn_input(graph_def)
-        return graph_util.convert_variables_to_constants(
-            sess=self._sess, input_graph_def=graph_def, output_node_names=self.output_node_names
-        )
-
-    @graph_def.setter
-    def graph_def(self, graph_def):
-        """Set graph definition."""
-        if self._sess is not None:
-            self._sess.close()
-        output_sess = SESSIONS["graph_def"](
-            graph_def, self._input_tensor_names, self._output_tensor_names, **self.kwargs
-        )
-        self._sess = output_sess[0]
-        self._input_tensor_names = output_sess[1]
-        self._output_tensor_names = output_sess[2]
-        self.model_type = "graph_def"
-
-    @property
-    def model(self):
-        """Return the model itself to avoid the initialization issue."""
-        return self
-
-
-class KerasModel(BaseModel):
-    """Build Keras model."""
-
-    def __init__(self, model, **kwargs):
-        """Initialize a Keras model.
-
-        Args:
-            model (string or keras model object): model path or model object.
-        """
-        self.component = None
-        self._model = model
-        if not isinstance(model, tf.keras.Model):
-            self._model_object = load_keras_model(self._model)
-        else:
-            self._model_object = self._model
-        self._q_config = None
-
-    @property
-    def q_config(self):
-        """Return q_config."""
-        return self._q_config
-
-    @q_config.setter
-    def q_config(self, q_config):
-        """Set q_config."""
-        self._q_config = q_config
-
-    @property
-    def model(self):
-        """Return model itself."""
-        return self._model_object
-
-    @property
-    def graph_info(self):
-        """Return graph info."""
-        # (TODO) get the graph info
-        return None
-
-    @abstractmethod
-    def save(self, root, *args, **kwargs):
-        """Save Keras model."""
-        self._model_object.save(root)
-        logger.info("Save quantized model to {}.".format(root))
-
-    @property
-    def input_node_names(self):
-        """Return input node names."""
-        names = (
-            self.model.input_names
-            if version1_lt_version2(tf.version.VERSION, "2.16.1")
-            else [tensor.name for tensor in self.model.inputs]
-        )
-
-        return names
-
-    @property
-    def output_node_names(self):
-        """Return output node names."""
-        names = (
-            self.model.output_names
-            if version1_lt_version2(tf.version.VERSION, "2.16.1")
-            else [tensor.name for tensor in self.model.outputs]
-        )
-
-        return names
-
-
-TENSORFLOW_MODELS = {
-    "frozen_pb": TensorflowBaseModel,
-    "graph_def": TensorflowBaseModel,
-    "graph": TensorflowBaseModel,
-    "checkpoint": TensorflowCheckpointModel,
-    "estimator": TensorflowBaseModel,
-    "slim": TensorflowBaseModel,
-    "saved_model": TensorflowSavedModelModel,
-    "AutoTrackable": TensorflowSavedModelModel,
-    "llm_saved_model": TensorflowLLMModel,
-    "keras": KerasModel,
-}
-
-
-class TensorflowModel(object):
-    """A wrapper to construct a Tensorflow Model."""
-
-    def __new__(cls, model_type, root, **kwargs):
-        """Create a new instance object of TensorflowModel.
-
-        Args:
-            model_type (str): model type.
-            root (str): model path.
-
-        Returns:
-            tensorflow model object: tensorflow model.
-        """
-        os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
-        os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
-        model = TENSORFLOW_MODELS[model_type](root, **kwargs)
-        model.model_type = model_type
-        return model
diff --git a/neural_compressor/tensorflow/utils/utility.py b/neural_compressor/tensorflow/utils/utility.py
deleted file mode 100644
index f500e46b47f..00000000000
--- a/neural_compressor/tensorflow/utils/utility.py
+++ /dev/null
@@ -1,456 +0,0 @@
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""The utility functions and classes for Tensorflow."""
-
-import importlib
-import logging
-import os
-import pickle
-import subprocess
-import sys
-import time
-from functools import reduce
-from typing import Callable, Dict
-
-import cpuinfo
-import numpy as np
-import psutil
-from pkg_resources import parse_version
-
-from neural_compressor.common.utils import Statistics, logger
-
-# Dictionary to store a mapping between algorithm names and corresponding algo implementation(function)
-algos_mapping: Dict[str, Callable] = {}
-
-
-def version1_lt_version2(version1, version2):
-    """Check whether version1 is less than version2."""
-    return parse_version(version1) < parse_version(version2)
-
-
-def version1_gt_version2(version1, version2):
-    """Check whether version1 is greater than version2."""
-    return parse_version(version1) > parse_version(version2)
-
-
-def version1_eq_version2(version1, version2):
-    """Check whether version1 is equal to version2."""
-    return parse_version(version1) == parse_version(version2)
-
-
-def version1_gte_version2(version1, version2):
-    """Check whether version1 is greater than version2 or is equal to it."""
-    return parse_version(version1) > parse_version(version2) or parse_version(version1) == parse_version(version2)
-
-
-def version1_lte_version2(version1, version2):
-    """Check whether version1 is less than version2 or is equal to it."""
-    return parse_version(version1) < parse_version(version2) or parse_version(version1) == parse_version(version2)
-
-
-def register_algo(name):
-    """Decorator function to register algorithms in the algos_mapping dictionary.
-
-    Usage example:
-        @register_algo(name=example_algo)
-        def example_algo(model: tf.keras.Model, quant_config: StaticQuantConfig) -> tf.keras.Model:
-            ...
-    Args:
-        name (str): The name under which the algorithm function will be registered.
-
-    Returns:
-        decorator: The decorator function to be used with algorithm functions.
-    """
-
-    def decorator(algo_func):
-        """Register the algorithm function in the global mapping.
-
-        Args:
-            algo_func (Callable): Algorithm implementation to register.
-
-        Returns:
-            Callable: The original algorithm function.
-        """
-        algos_mapping[name] = algo_func
-        return algo_func
-
-    return decorator
-
-
-def deep_get(dictionary, keys, default=None):
-    """Get the dot key's item in nested dict.
-
-    Usage example:
-       person = {'person':{'name':{'first':'John'}}}
-       deep_get(person, "person.name.first") will output 'John'.
-    Args:
-        dictionary (dict): The dict object to get keys
-        keys (dict): The deep keys
-        default (object): The return item if key not exists
-
-    Returns:
-        item: the item of the deep dot keys
-    """
-    return reduce(lambda d, key: d.get(key, default) if isinstance(d, dict) else default, keys.split("."), dictionary)
-
-
-def itex_installed():
-    """Check if the Intel® Extension for TensorFlow has been installed."""
-    try:
-        import intel_extension_for_tensorflow
-
-        return True
-    except:
-        return False
-
-
-def dump_elapsed_time(customized_msg=""):
-    """Get the elapsed time for decorated functions.
-
-    Args:
-        customized_msg (string, optional): The parameter passed to decorator. Defaults to None.
-    """
-
-    def f(func):
-        """Wrap the function to log elapsed execution time."""
-
-        def fi(*args, **kwargs):
-            """Execute the function and log elapsed time."""
-            start = time.time()
-            res = func(*args, **kwargs)
-            end = time.time()
-            logging.getLogger("neural_compressor").info(
-                "%s elapsed time: %s ms"
-                % (customized_msg if customized_msg else func.__qualname__, round((end - start) * 1000, 2))
-            )
-            return res
-
-        return fi
-
-    return f
-
-
-def combine_histogram(old_hist, arr):
-    """Collect layer histogram for arr and combine it with old histogram."""
-    new_max = np.max(arr)
-    new_min = np.min(arr)
-    new_th = max(abs(new_min), abs(new_max))
-    old_hist, old_hist_edges, old_min, old_max, old_th = old_hist
-    if new_th <= old_th:
-        hist, _ = np.histogram(arr, bins=len(old_hist), range=(-old_th, old_th))
-        return (old_hist + hist, old_hist_edges, min(old_min, new_min), max(old_max, new_max), old_th)
-    else:
-        old_num_bins = len(old_hist)
-        old_step = 2 * old_th / old_num_bins
-        half_increased_bins = int((new_th - old_th) // old_step + 1)
-        new_num_bins = half_increased_bins * 2 + old_num_bins
-        new_th = half_increased_bins * old_step + old_th
-        hist, hist_edges = np.histogram(arr, bins=new_num_bins, range=(-new_th, new_th))
-        hist[half_increased_bins : new_num_bins - half_increased_bins] += old_hist
-        return (hist, hist_edges, min(old_min, new_min), max(old_max, new_max), new_th)
-
-
-def get_all_fp32_data(data):
-    """Get all the fp32 data."""
-    return [float(i) for i in data.replace("[", " ").replace("]", " ").split(" ") if i.strip() and len(i) < 32]
-
-
-def get_tensor_histogram(tensor_data, bins=2048):
-    """Get the histogram of the tensor data."""
-    max_val = np.max(tensor_data)
-    min_val = np.min(tensor_data)
-    th = max(abs(min_val), abs(max_val))
-    hist, hist_edges = np.histogram(tensor_data, bins=2048, range=(-th, th))
-    return (hist, hist_edges, min_val, max_val, th)
-
-
-def singleton(cls):
-    """Not displayed in API Docs.
-
-    Singleton decorator.
-    """
-    instances = {}
-
-    def _singleton(*args, **kw):
-        """Create a singleton object."""
-        if cls not in instances:
-            instances[cls] = cls(*args, **kw)
-        return instances[cls]
-
-    return _singleton
-
-
-def disable_random(seed=1):
-    """A Decorator to disable tf random seed."""
-    import tensorflow as tf
-
-    def decorator(func):
-        """Decorate a function to disable TensorFlow randomness."""
-
-        def wrapper(*args, **kw):
-            """Reset graph state and run the wrapped function."""
-            tf.compat.v1.disable_eager_execution()
-            tf.compat.v1.reset_default_graph()
-            tf.compat.v1.set_random_seed(seed)
-            return func(*args, **kw)
-
-        return wrapper
-
-    return decorator
-
-
-def valid_keras_format(model):
-    """Check if the input model is Sequential or Functional model."""
-    import keras
-
-    if isinstance(model, keras.src.models.Sequential) or isinstance(model, keras.src.models.Functional):
-        return True
-
-    return False
-
-
-@singleton
-class CpuInfo(object):
-    """Get CPU Info."""
-
-    def __init__(self):
-        """Get whether the cpu numerical format is bf16, the number of sockets, cores and cores per socket."""
-        self._bf16 = False
-        self._vnni = False
-        info = cpuinfo.get_cpu_info()
-        if "arch" in info and "X86" in info["arch"]:
-            cpuid = cpuinfo.CPUID()
-            max_extension_support = cpuid.get_max_extension_support()
-            if max_extension_support >= 7:
-                ecx = cpuid._run_asm(
-                    b"\x31\xc9",  # xor ecx, ecx
-                    b"\xb8\x07\x00\x00\x00" b"\x0f\xa2" b"\x89\xc8" b"\xc3",  # mov eax, 7  # cpuid  # mov ax, cx  # ret
-                )
-                self._vnni = bool(ecx & (1 << 11))
-                eax = cpuid._run_asm(
-                    b"\xb9\x01\x00\x00\x00",  # mov ecx, 1
-                    b"\xb8\x07\x00\x00\x00" b"\x0f\xa2" b"\xc3",  # mov eax, 7  # cpuid  # ret
-                )
-                self._bf16 = bool(eax & (1 << 5))
-        if "arch" in info and "ARM" in info["arch"]:  # pragma: no cover
-            self._sockets = 1
-        else:
-            self._sockets = self.get_number_of_sockets()
-        self._cores = psutil.cpu_count(logical=False)
-        self._cores_per_socket = int(self._cores / self._sockets)
-
-    @property
-    def bf16(self):
-        """Get whether it is bf16."""
-        return self._bf16
-
-    @property
-    def vnni(self):
-        """Get whether it is vnni."""
-        return self._vnni
-
-    @property
-    def cores_per_socket(self):
-        """Get the cores per socket."""
-        return self._cores_per_socket
-
-    def get_number_of_sockets(self) -> int:
-        """Get number of sockets in platform."""
-        cmd = "cat /proc/cpuinfo | grep 'physical id' | sort -u | wc -l"
-        if psutil.WINDOWS:
-            cmd = r'wmic cpu get DeviceID | C:\Windows\System32\find.exe /C "CPU"'
-
-        with subprocess.Popen(
-            args=cmd,
-            shell=True,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            universal_newlines=False,
-        ) as proc:
-            proc.wait()
-            if proc.stdout:
-                for line in proc.stdout:
-                    return int(line.decode("utf-8", errors="ignore").strip())
-        return 0
-
-
-class CaptureOutputToFile(object):
-    """Not displayed in API Docs.
-
-    Capture the output to file.
-    """
-
-    def __init__(self, tmp_file_path, stream=sys.stderr):
-        """Open a temporary file."""
-        self.orig_stream_fileno = stream.fileno()
-        self.tmp_file = open(tmp_file_path, "w")
-
-    def __enter__(self):
-        """Duplicate the file descriptor to the stream."""
-        self.orig_stream_dup = os.dup(self.orig_stream_fileno)
-        os.dup2(self.tmp_file.fileno(), self.orig_stream_fileno)
-
-    def __exit__(self, type, value, traceback):
-        """Duplicate the stream descriptor to the file."""
-        os.close(self.orig_stream_fileno)
-        os.dup2(self.orig_stream_dup, self.orig_stream_fileno)
-        os.close(self.orig_stream_dup)
-        self.tmp_file.close()
-
-    def __del__(self):
-        """Ensure the file is closed if __exit__ was never called."""
-        if hasattr(self, "tmp_file") and not self.tmp_file.closed:
-            self.tmp_file.close()
-
-
-@singleton
-class TFSlimNetsFactory(object):  # pragma: no cover
-    """TF-Slim nets factory."""
-
-    def __init__(self):
-        """Initialize a TFSlimNetsFactory."""
-        # tf_slim only support specific models by default
-        self.default_slim_models = [
-            "alexnet_v2",
-            "overfeat",
-            "vgg_a",
-            "vgg_16",
-            "vgg_19",
-            "inception_v1",
-            "inception_v2",
-            "inception_v3",
-            "resnet_v1_50",
-            "resnet_v1_101",
-            "resnet_v1_152",
-            "resnet_v1_200",
-            "resnet_v2_50",
-            "resnet_v2_101",
-            "resnet_v2_152",
-            "resnet_v2_200",
-        ]
-
-        from tf_slim.nets import alexnet, inception, overfeat, resnet_v1, resnet_v2, vgg
-
-        self.networks_map = {
-            "alexnet_v2": {
-                "model": alexnet.alexnet_v2,
-                "input_shape": [None, 224, 224, 3],
-                "num_classes": 1001,
-                "arg_scope": alexnet.alexnet_v2_arg_scope,
-            },
-            "overfeat": {
-                "model": overfeat.overfeat,
-                "input_shape": [None, 224, 224, 3],
-                "num_classes": 1001,
-                "arg_scope": overfeat.overfeat_arg_scope,
-            },
-            "vgg_a": {
-                "model": vgg.vgg_a,
-                "input_shape": [None, 224, 224, 3],
-                "num_classes": 1000,
-                "arg_scope": vgg.vgg_arg_scope,
-            },
-            "vgg_16": {
-                "model": vgg.vgg_16,
-                "input_shape": [None, 224, 224, 3],
-                "num_classes": 1000,
-                "arg_scope": vgg.vgg_arg_scope,
-            },
-            "vgg_19": {
-                "model": vgg.vgg_19,
-                "input_shape": [None, 224, 224, 3],
-                "num_classes": 1000,
-                "arg_scope": vgg.vgg_arg_scope,
-            },
-            "inception_v1": {
-                "model": inception.inception_v1,
-                "input_shape": [None, 224, 224, 3],
-                "num_classes": 1001,
-                "arg_scope": inception.inception_v1_arg_scope,
-            },
-            "inception_v2": {
-                "model": inception.inception_v2,
-                "input_shape": [None, 224, 224, 3],
-                "num_classes": 1001,
-                "arg_scope": inception.inception_v2_arg_scope,
-            },
-            "inception_v3": {
-                "model": inception.inception_v3,
-                "input_shape": [None, 299, 299, 3],
-                "num_classes": 1001,
-                "arg_scope": inception.inception_v3_arg_scope,
-            },
-            "resnet_v1_50": {
-                "model": resnet_v1.resnet_v1_50,
-                "input_shape": [None, 224, 224, 3],
-                "num_classes": 1000,
-                "arg_scope": resnet_v1.resnet_arg_scope,
-            },
-            "resnet_v1_101": {
-                "model": resnet_v1.resnet_v1_101,
-                "input_shape": [None, 224, 224, 3],
-                "num_classes": 1000,
-                "arg_scope": resnet_v1.resnet_arg_scope,
-            },
-            "resnet_v1_152": {
-                "model": resnet_v1.resnet_v1_152,
-                "input_shape": [None, 224, 224, 3],
-                "num_classes": 1000,
-                "arg_scope": resnet_v1.resnet_arg_scope,
-            },
-            "resnet_v1_200": {
-                "model": resnet_v1.resnet_v1_200,
-                "input_shape": [None, 224, 224, 3],
-                "num_classes": 1000,
-                "arg_scope": resnet_v1.resnet_arg_scope,
-            },
-            "resnet_v2_50": {
-                "model": resnet_v2.resnet_v2_50,
-                "input_shape": [None, 224, 224, 3],
-                "num_classes": 1001,
-                "arg_scope": resnet_v2.resnet_arg_scope,
-            },
-            "resnet_v2_101": {
-                "model": resnet_v2.resnet_v2_101,
-                "input_shape": [None, 224, 224, 3],
-                "num_classes": 1001,
-                "arg_scope": resnet_v2.resnet_arg_scope,
-            },
-            "resnet_v2_152": {
-                "model": resnet_v2.resnet_v2_152,
-                "input_shape": [None, 224, 224, 3],
-                "num_classes": 1001,
-                "arg_scope": resnet_v2.resnet_arg_scope,
-            },
-            "resnet_v2_200": {
-                "model": resnet_v2.resnet_v2_200,
-                "input_shape": [None, 224, 224, 3],
-                "num_classes": 1001,
-                "arg_scope": resnet_v2.resnet_arg_scope,
-            },
-        }
-
-    def register(self, name, model_func, input_shape, arg_scope, **kwargs):
-        """Register a model to TFSlimNetsFactory.
-
-        Args:
-            name (str): name of a model.
-            model_func (_type_): model that built from slim.
-            input_shape (_type_): input tensor shape.
-            arg_scope (_type_): slim arg scope that needed.
-        """
-        net_info = {"model": model_func, "input_shape": input_shape, "arg_scope": arg_scope}
-        net = {name: {**net_info, **kwargs}}
-        self.networks_map.update(net)
-        self.default_slim_models.append(name)
diff --git a/neural_compressor/torch/algorithms/weight_only/save_load.py b/neural_compressor/torch/algorithms/weight_only/save_load.py
index a190a4a311a..228f5f2afc6 100644
--- a/neural_compressor/torch/algorithms/weight_only/save_load.py
+++ b/neural_compressor/torch/algorithms/weight_only/save_load.py
@@ -898,7 +898,7 @@ def _get_resolved_archive_file(self, **kwargs):
                         is_sharded = True
 
                 if resolved_archive_file is None:  # pragma: no cover
-                    # Otherwise, maybe there is a TF or Flax model file.  We try those to give a helpful error
+                    # Otherwise, maybe there is a Flax model file.  We try it to give a helpful error
                     # message.
                     has_file_kwargs = {
                         "revision": cached_file_kwargs.get("revision"),
diff --git a/neural_compressor/transformers/models/modeling_auto.py b/neural_compressor/transformers/models/modeling_auto.py
index 64a10dbb66d..8e0ec8e3913 100644
--- a/neural_compressor/transformers/models/modeling_auto.py
+++ b/neural_compressor/transformers/models/modeling_auto.py
@@ -395,14 +395,12 @@ def load_low_bit(cls, pretrained_model_name_or_path, *model_args, **kwargs):
             from transformers.modeling_utils import _get_resolved_checkpoint_files
 
             gguf_file = kwargs.pop("gguf_file", None)
-            from_tf = kwargs.pop("from_tf", False)
             from_flax = kwargs.pop("from_flax", False)
             checkpoint_files, sharded_metadata = _get_resolved_checkpoint_files(
                 pretrained_model_name_or_path=pretrained_model_name_or_path,
                 subfolder=subfolder,
                 variant=variant,
                 gguf_file=gguf_file,
-                from_tf=from_tf,
                 from_flax=from_flax,
                 use_safetensors=use_safetensors,
                 cache_dir=cache_dir,
@@ -549,7 +547,7 @@ def load_low_bit(cls, pretrained_model_name_or_path, *model_args, **kwargs):
                                 is_sharded = True
 
                         if resolved_archive_file is None:
-                            # Otherwise, maybe there is a TF or Flax model file.  We try those to give a helpful error
+                            # Otherwise, maybe there is a Flax model file.  We try it to give a helpful error
                             # message.
                             has_file_kwargs = {
                                 "revision": revision,
diff --git a/requirements_tf.txt b/requirements_tf.txt
deleted file mode 100644
index f8075c2a068..00000000000
--- a/requirements_tf.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-prettytable
-psutil
-py-cpuinfo
-pydantic
-pyyaml
-tensorflow
diff --git a/setup.py b/setup.py
index 43a2fd88e19..f93934ef2cc 100644
--- a/setup.py
+++ b/setup.py
@@ -43,7 +43,7 @@ def get_build_version():
     assert False, "Error: Could not open '%s' due %s\n" % (filepath, error)
 
 PKG_INSTALL_CFG = {
-    # pip install neural-compressor, install the whole package with all APIs, including PyTorch, TensorFlow and JAX APIs.
+    # pip install neural-compressor, install the whole package with all APIs, including PyTorch and JAX APIs.
     "neural_compressor": {
         "project_name": "neural_compressor",
         "include_packages": find_packages(
@@ -52,7 +52,6 @@ def get_build_version():
         "package_data": {"": ["*.json", "*.yaml"]},
         "extras_require": {
             "pt": fetch_requirements("requirements_pt.txt"),
-            "tf": fetch_requirements("requirements_tf.txt"),
             "jax": fetch_requirements("requirements_jax.txt"),
         },
     },
@@ -74,20 +73,6 @@ def get_build_version():
         "package_data": {"": ["*.json"]},
         "install_requires": fetch_requirements("requirements_pt.txt"),
     },
-    # pip install neural-compressor-tf, install TensorFlow API.
-    "neural_compressor_tf": {
-        "project_name": "neural_compressor_tf",
-        "include_packages": find_packages(
-            include=[
-                "neural_compressor.common",
-                "neural_compressor.common.*",
-                "neural_compressor.tensorflow",
-                "neural_compressor.tensorflow.*",
-            ],
-        ),
-        "package_data": {"": ["*.yaml"]},
-        "install_requires": fetch_requirements("requirements_tf.txt"),
-    },
     # 3.x JAX binary build config, pip install neural-compressor-jax, install 3.x JAX API.
     "neural_compressor_jax": {
         "project_name": "neural_compressor_jax",
@@ -112,9 +97,6 @@ def get_build_version():
     if os.environ.get("INC_PT_ONLY", False):
         cfg_key = "neural_compressor_pt"
         only_set.append("INC_PT_ONLY")
-    if os.environ.get("INC_TF_ONLY", False):
-        cfg_key = "neural_compressor_tf"
-        only_set.append("INC_TF_ONLY")
     if os.environ.get("INC_JAX_ONLY", False):
         cfg_key = "neural_compressor_jax"
         only_set.append("INC_JAX_ONLY")
@@ -125,9 +107,6 @@ def get_build_version():
     if "pt" in sys.argv:
         sys.argv.remove("pt")
         cfg_key = "neural_compressor_pt"
-    if "tf" in sys.argv:
-        sys.argv.remove("tf")
-        cfg_key = "neural_compressor_tf"
     if "jax" in sys.argv:
         sys.argv.remove("jax")
         cfg_key = "neural_compressor_jax"
diff --git a/test/common/test_common.py b/test/common/test_common.py
index 90a5db3c315..2f49247e94b 100644
--- a/test/common/test_common.py
+++ b/test/common/test_common.py
@@ -12,7 +12,6 @@
 ├── 3x
 │   ├── common
 │   ├── onnxrt
-│   ├── tensorflow
 │   └── torch
 
 For each fwk CI:
@@ -22,12 +21,6 @@
     │   ├── common
     │   ├── onnxrt
 
-tensorflow_included_folder:
-    ├── 3x
-    │   ├── common
-    │   ├── tensorflow
-
-
 torch_included_folder:
     ├── 3x
     │   ├── common
diff --git a/test/tensorflow/keras/requirements.txt b/test/tensorflow/keras/requirements.txt
deleted file mode 100644
index 2b9ebaa4d0e..00000000000
--- a/test/tensorflow/keras/requirements.txt
+++ /dev/null
@@ -1 +0,0 @@
-intel-extension-for-tensorflow[cpu]
diff --git a/test/tensorflow/keras/test_config.py b/test/tensorflow/keras/test_config.py
deleted file mode 100644
index 6e617cf0584..00000000000
--- a/test/tensorflow/keras/test_config.py
+++ /dev/null
@@ -1,341 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import math
-import os
-import shutil
-import unittest
-
-import keras
-import numpy as np
-import tensorflow as tf
-
-from neural_compressor.common import Logger
-from neural_compressor.tensorflow.utils import version1_gte_version2
-
-logger = Logger().get_logger()
-
-
-def build_model():
-    # Load MNIST dataset
-    mnist = keras.datasets.mnist
-
-    # 60000 images in train and 10000 images in test, but we don't need so much for ut
-    (train_images, train_labels), (test_images, test_labels) = mnist.load_data()
-    train_images, train_labels = train_images[:1000], train_labels[:1000]
-    test_images, test_labels = test_images[:200], test_labels[:200]
-
-    # Normalize the input image so that each pixel value is between 0 to 1.
-    train_images = train_images / 255.0
-    test_images = test_images / 255.0
-
-    # Define the model architecture.
-    model = keras.Sequential(
-        [
-            keras.layers.InputLayer(input_shape=(28, 28)),
-            keras.layers.Reshape(target_shape=(28, 28, 1)),
-            keras.layers.Conv2D(filters=12, kernel_size=(3, 3), activation="relu", name="conv2d"),
-            keras.layers.MaxPooling2D(pool_size=(2, 2)),
-            keras.layers.Flatten(),
-            keras.layers.Dense(10, name="dense"),
-        ]
-    )
-    # Train the digit classification model
-    model.compile(
-        optimizer="adam", loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=["accuracy"]
-    )
-
-    model.fit(
-        train_images,
-        train_labels,
-        epochs=1,
-        validation_split=0.1,
-    )
-
-    _, baseline_model_accuracy = model.evaluate(test_images, test_labels, verbose=0)
-
-    print("Baseline test accuracy:", baseline_model_accuracy)
-    if version1_gte_version2(tf.__version__, "2.16.1"):
-        model.save("baseline_model.keras")
-    else:
-        model.save("baseline_model")
-
-
-class Dataset(object):
-    def __init__(self, batch_size=1):
-        self.batch_size = batch_size
-        mnist = keras.datasets.mnist
-        (train_images, train_labels), (test_images, test_labels) = mnist.load_data()
-        train_images, train_labels = train_images[:1000], train_labels[:1000]
-        test_images, test_labels = test_images[:200], test_labels[:200]
-        # Normalize the input image so that each pixel value is between 0 to 1.
-        self.train_images = train_images / 255.0
-        self.test_images = test_images / 255.0
-        self.train_labels = train_labels
-        self.test_labels = test_labels
-
-    def __len__(self):
-        return len(self.test_images)
-
-    def __getitem__(self, idx):
-        return self.test_images[idx], self.test_labels[idx]
-
-
-class MyDataloader:
-    def __init__(self, dataset, batch_size=1):
-        self.dataset = dataset
-        self.batch_size = batch_size
-        self.length = math.ceil(len(dataset) / self.batch_size)
-
-    def __iter__(self):
-        for _, (images, labels) in enumerate(self.dataset):
-            images = np.expand_dims(images, axis=0)
-            labels = np.expand_dims(labels, axis=0)
-            yield (images, labels)
-
-    def __len__(self):
-        return self.length
-
-
-class TestTF3xNewApi(unittest.TestCase):
-    @classmethod
-    def setUpClass(self):
-        build_model()
-        os.environ["ITEX_ONEDNN_GRAPH"] = "1"
-        self.fp32_model_path = (
-            "baseline_model.keras" if version1_gte_version2(tf.__version__, "2.16.1") else "baseline_model"
-        )
-
-    @classmethod
-    def tearDownClass(self):
-        if self.fp32_model_path.endswith(".keras"):
-            os.remove(self.fp32_model_path)
-        else:
-            shutil.rmtree(self.fp32_model_path, ignore_errors=True)
-        os.environ["ITEX_ONEDNN_GRAPH"] = "0"
-
-    def test_static_quant_from_dict_default(self):
-        logger.info("test_static_quant_from_dict_default")
-        from neural_compressor.tensorflow import quantize_model
-        from neural_compressor.tensorflow.keras import get_default_static_quant_config
-
-        calib_dataloader = MyDataloader(dataset=Dataset())
-        fp32_model = keras.models.load_model(self.fp32_model_path)
-        qmodel = quantize_model(fp32_model, get_default_static_quant_config(), calib_dataloader)
-        self.assertIsNotNone(qmodel)
-
-        for layer in qmodel.layers:
-            if layer.name == "dense":
-                self.assertEqual(layer.__class__.__name__, "QDense")
-            if layer.name == "conv2d":
-                self.assertEqual(layer.__class__.__name__, "QConv2D")
-
-    def test_static_quant_from_dict_beginner(self):
-        logger.info("test_static_quant_from_dict_beginner")
-        from neural_compressor.tensorflow import quantize_model
-
-        quant_config = {
-            "static_quant": {
-                "global": {
-                    "weight_dtype": "int8",
-                    "weight_sym": True,
-                    "weight_granularity": "per_tensor",
-                    "act_dtype": "int8",
-                    "act_sym": True,
-                    "act_granularity": "per_tensor",
-                },
-            }
-        }
-        calib_dataloader = MyDataloader(dataset=Dataset())
-        fp32_model = keras.models.load_model(self.fp32_model_path)
-        qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-        self.assertIsNotNone(qmodel)
-
-        for layer in qmodel.layers:
-            if layer.name == "dense":
-                self.assertEqual(layer.__class__.__name__, "QDense")
-            if layer.name == "conv2d":
-                self.assertEqual(layer.__class__.__name__, "QConv2D")
-
-    def test_static_quant_from_class_default(self):
-        logger.info("test_static_quant_from_class_default")
-        from neural_compressor.tensorflow import quantize_model
-        from neural_compressor.tensorflow.keras import StaticQuantConfig
-
-        calib_dataloader = MyDataloader(dataset=Dataset())
-        fp32_model = keras.models.load_model(self.fp32_model_path)
-        quant_config = StaticQuantConfig()
-        qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-        self.assertIsNotNone(qmodel)
-
-        for layer in qmodel.layers:
-            if layer.name == "dense":
-                self.assertEqual(layer.__class__.__name__, "QDense")
-            if layer.name == "conv2d":
-                self.assertEqual(layer.__class__.__name__, "QConv2D")
-
-    def test_static_quant_from_class_beginner(self):
-        logger.info("test_static_quant_from_class_beginner")
-        from neural_compressor.tensorflow import quantize_model
-        from neural_compressor.tensorflow.keras import StaticQuantConfig
-
-        calib_dataloader = MyDataloader(dataset=Dataset())
-        fp32_model = keras.models.load_model(self.fp32_model_path)
-        quant_config = StaticQuantConfig(
-            weight_dtype="int8",
-            weight_sym=True,
-            weight_granularity="per_channel",
-            act_dtype="int8",
-            act_sym=True,
-            act_granularity="per_channel",
-        )
-        qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-        self.assertIsNotNone(qmodel)
-
-        for layer in qmodel.layers:
-            if layer.name == "dense":
-                self.assertEqual(layer.__class__.__name__, "QDense")
-            if layer.name == "conv2d":
-                self.assertEqual(layer.__class__.__name__, "QConv2D")
-
-    def test_static_quant_from_dict_advance(self):
-        logger.info("test_static_quant_from_dict_advance")
-        from neural_compressor.tensorflow import quantize_model
-
-        calib_dataloader = MyDataloader(dataset=Dataset())
-        fp32_model = keras.models.load_model(self.fp32_model_path)
-        quant_config = {
-            "static_quant": {
-                "global": {
-                    "weight_dtype": "int8",
-                    "weight_sym": True,
-                    "weight_granularity": "per_tensor",
-                    "act_dtype": "int8",
-                    "act_sym": True,
-                    "act_granularity": "per_tensor",
-                },
-                "local": {
-                    "dense": {
-                        "weight_dtype": "fp32",
-                        "act_dtype": "fp32",
-                    }
-                },
-            }
-        }
-        qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-        self.assertIsNotNone(qmodel)
-
-        for layer in qmodel.layers:
-            if layer.name == "conv2d":
-                self.assertEqual(layer.__class__.__name__, "QConv2D")
-
-    def test_static_quant_from_class_advance(self):
-        logger.info("test_static_quant_from_class_advance")
-        from neural_compressor.tensorflow import quantize_model
-        from neural_compressor.tensorflow.keras import StaticQuantConfig
-
-        calib_dataloader = MyDataloader(dataset=Dataset())
-        quant_config = StaticQuantConfig(
-            weight_dtype="int8",
-            weight_sym=True,
-            weight_granularity="per_channel",
-            act_dtype="int8",
-            act_sym=True,
-            act_granularity="per_channel",
-        )
-        dense_config = StaticQuantConfig(
-            weight_dtype="fp32",
-            act_dtype="fp32",
-        )
-        quant_config.set_local("dense", dense_config)
-        # get model and quantize
-        fp32_model = keras.models.load_model(self.fp32_model_path)
-        qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-        self.assertIsNotNone(qmodel)
-
-        for layer in qmodel.layers:
-            if layer.name == "conv2d":
-                self.assertEqual(layer.__class__.__name__, "QConv2D")
-
-    def test_config_from_dict(self):
-        logger.info("test_config_from_dict")
-        from neural_compressor.tensorflow.keras import StaticQuantConfig
-
-        quant_config = {
-            "static_quant": {
-                "global": {
-                    "weight_dtype": "int8",
-                    "weight_sym": True,
-                    "weight_granularity": "per_tensor",
-                    "act_dtype": "int8",
-                    "act_sym": True,
-                    "act_granularity": "per_tensor",
-                },
-                "local": {
-                    "dense": {
-                        "weight_dtype": "fp32",
-                        "act_dtype": "fp32",
-                    }
-                },
-            }
-        }
-        config = StaticQuantConfig.from_dict(quant_config["static_quant"])
-        self.assertIsNotNone(config.local_config)
-
-    def test_config_to_dict(self):
-        logger.info("test_config_to_dict")
-        from neural_compressor.tensorflow.keras import StaticQuantConfig
-
-        quant_config = StaticQuantConfig(
-            weight_dtype="int8",
-            weight_sym=True,
-            weight_granularity="per_channel",
-            act_dtype="int8",
-            act_sym=True,
-            act_granularity="per_channel",
-        )
-        dense_config = StaticQuantConfig(
-            weight_dtype="fp32",
-            act_dtype="fp32",
-        )
-        quant_config.set_local("dense", dense_config)
-        config_dict = quant_config.to_dict()
-        self.assertIn("global", config_dict)
-        self.assertIn("local", config_dict)
-
-
-class TestQuantConfigForAutotune(unittest.TestCase):
-    def test_expand_config(self):
-        # test the expand functionalities, the user is not aware it
-        from neural_compressor.tensorflow.keras import StaticQuantConfig
-
-        quant_configs = StaticQuantConfig(
-            weight_dtype="int8",
-            weight_sym=True,
-            weight_granularity=["per_channel", "per_tensor"],
-            act_dtype="int8",
-            act_sym=True,
-            act_granularity="per_channel",
-        )
-
-        expand_config_list = StaticQuantConfig.expand(quant_configs)
-        self.assertEqual(expand_config_list[0].weight_granularity, "per_channel")
-        self.assertEqual(expand_config_list[1].weight_granularity, "per_tensor")
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/keras/test_layers.py b/test/tensorflow/keras/test_layers.py
deleted file mode 100644
index b43b3fd8bf7..00000000000
--- a/test/tensorflow/keras/test_layers.py
+++ /dev/null
@@ -1,213 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import math
-import os
-import shutil
-import unittest
-
-import keras
-import numpy as np
-import tensorflow as tf
-
-from neural_compressor.common import Logger
-from neural_compressor.tensorflow.utils import version1_gte_version2
-
-logger = Logger().get_logger()
-
-
-def build_model1():
-    # Load MNIST dataset
-    mnist = keras.datasets.mnist
-
-    # 60000 images in train and 10000 images in test, but we don't need so much for ut
-    (train_images, train_labels), (test_images, test_labels) = mnist.load_data()
-    train_images, train_labels = train_images[:1000], train_labels[:1000]
-    test_images, test_labels = test_images[:200], test_labels[:200]
-
-    # Normalize the input image so that each pixel value is between 0 to 1.
-    train_images = train_images / 255.0
-    test_images = test_images / 255.0
-
-    # Define the model architecture.
-    model = keras.Sequential(
-        [
-            keras.layers.InputLayer(input_shape=(28, 28)),
-            keras.layers.Reshape(target_shape=(28, 28, 1)),
-            keras.layers.DepthwiseConv2D(3, 3, activation="relu", name="conv2d"),
-            keras.layers.MaxPooling2D(pool_size=(2, 2)),
-            keras.layers.Flatten(),
-            keras.layers.Dense(10, name="dense"),
-        ]
-    )
-    # Train the digit classification model
-    model.compile(
-        optimizer="adam", loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=["accuracy"]
-    )
-
-    model.fit(
-        train_images,
-        train_labels,
-        epochs=1,
-        validation_split=0.1,
-    )
-
-    _, baseline_model_accuracy = model.evaluate(test_images, test_labels, verbose=0)
-
-    print("Baseline test accuracy:", baseline_model_accuracy)
-    if version1_gte_version2(tf.__version__, "2.16.1"):
-        model.save("baseline_model1.keras")
-    else:
-        model.save("baseline_model1")
-
-
-def build_model2():
-    # Load MNIST dataset
-    mnist = keras.datasets.mnist
-
-    # 60000 images in train and 10000 images in test, but we don't need so much for ut
-    (train_images, train_labels), (test_images, test_labels) = mnist.load_data()
-    train_images, train_labels = train_images[:1000], train_labels[:1000]
-    test_images, test_labels = test_images[:200], test_labels[:200]
-
-    # Normalize the input image so that each pixel value is between 0 to 1.
-    train_images = train_images / 255.0
-    test_images = test_images / 255.0
-
-    # Define the model architecture.
-    model = keras.Sequential(
-        [
-            keras.layers.InputLayer(input_shape=(28, 28)),
-            keras.layers.Reshape(target_shape=(28, 28, 1)),
-            keras.layers.SeparableConv2D(3, 3, activation="relu"),
-            keras.layers.AveragePooling2D(pool_size=(2, 2)),
-            keras.layers.Flatten(),
-            keras.layers.Dense(10, name="dense"),
-        ]
-    )
-    # Train the digit classification model
-    model.compile(
-        optimizer="adam", loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=["accuracy"]
-    )
-
-    model.fit(
-        train_images,
-        train_labels,
-        epochs=1,
-        validation_split=0.1,
-    )
-
-    _, baseline_model_accuracy = model.evaluate(test_images, test_labels, verbose=0)
-
-    print("Baseline test accuracy:", baseline_model_accuracy)
-    if version1_gte_version2(tf.__version__, "2.16.1"):
-        model.save("baseline_model2.keras")
-    else:
-        model.save("baseline_model2")
-
-
-class Dataset(object):
-    def __init__(self, batch_size=1):
-        self.batch_size = batch_size
-        mnist = keras.datasets.mnist
-        (train_images, train_labels), (test_images, test_labels) = mnist.load_data()
-        train_images, train_labels = train_images[:1000], train_labels[:1000]
-        test_images, test_labels = test_images[:200], test_labels[:200]
-        # Normalize the input image so that each pixel value is between 0 to 1.
-        self.train_images = train_images / 255.0
-        self.test_images = test_images / 255.0
-        self.train_labels = train_labels
-        self.test_labels = test_labels
-
-    def __len__(self):
-        return len(self.test_images)
-
-    def __getitem__(self, idx):
-        return self.test_images[idx], self.test_labels[idx]
-
-
-class MyDataloader:
-    def __init__(self, dataset, batch_size=1):
-        self.dataset = dataset
-        self.batch_size = batch_size
-        self.length = math.ceil(len(dataset) / self.batch_size)
-
-    def __iter__(self):
-        for _, (images, labels) in enumerate(self.dataset):
-            images = np.expand_dims(images, axis=0)
-            labels = np.expand_dims(labels, axis=0)
-            yield (images, labels)
-
-    def __len__(self):
-        return self.length
-
-
-class TestTF3xNewApi(unittest.TestCase):
-    @classmethod
-    def setUpClass(self):
-        build_model1()
-        build_model2()
-        os.environ["ITEX_ONEDNN_GRAPH"] = "1"
-        self.fp32_model_path1 = (
-            "baseline_model1.keras" if version1_gte_version2(tf.__version__, "2.16.1") else "baseline_model1"
-        )
-        self.fp32_model_path2 = (
-            "baseline_model2.keras" if version1_gte_version2(tf.__version__, "2.16.1") else "baseline_model2"
-        )
-
-    @classmethod
-    def tearDownClass(self):
-        if self.fp32_model_path1.endswith(".keras"):
-            os.remove(self.fp32_model_path1)
-            os.remove(self.fp32_model_path2)
-        else:
-            shutil.rmtree(self.fp32_model_path1, ignore_errors=True)
-            shutil.rmtree(self.fp32_model_path2, ignore_errors=True)
-        os.environ["ITEX_ONEDNN_GRAPH"] = "0"
-
-    def test_depthwise_conv2d(self):
-        logger.info("test_static_quant_from_dict_default")
-        from neural_compressor.tensorflow import quantize_model
-        from neural_compressor.tensorflow.keras import get_default_static_quant_config
-
-        calib_dataloader = MyDataloader(dataset=Dataset())
-        fp32_model = keras.models.load_model(self.fp32_model_path1)
-        qmodel = quantize_model(fp32_model, get_default_static_quant_config(), calib_dataloader)
-        self.assertIsNotNone(qmodel)
-
-        for layer in qmodel.layers:
-            if layer.name == "conv2d":
-                self.assertEqual(layer.__class__.__name__, "QDepthwiseConv2D")
-                break
-
-    def test_seprable_conv2d(self):
-        logger.info("test_static_quant_from_dict_default")
-        from neural_compressor.tensorflow import quantize_model
-        from neural_compressor.tensorflow.keras import get_default_static_quant_config
-
-        calib_dataloader = MyDataloader(dataset=Dataset())
-        fp32_model = keras.models.load_model(self.fp32_model_path2)
-        qmodel = quantize_model(fp32_model, get_default_static_quant_config(), calib_dataloader)
-        self.assertIsNotNone(qmodel)
-
-        for layer in qmodel.layers:
-            if layer.name == "conv2d":
-                self.assertEqual(layer.__class__.__name__, "QSeparableConv2D")
-                break
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/keras/test_model_wrappers.py b/test/tensorflow/keras/test_model_wrappers.py
deleted file mode 100644
index e4d906e27a2..00000000000
--- a/test/tensorflow/keras/test_model_wrappers.py
+++ /dev/null
@@ -1,99 +0,0 @@
-"""Tests for model."""
-
-import os
-import platform
-import unittest
-
-import numpy as np
-import tensorflow as tf
-from pkg_resources import parse_version
-
-from neural_compressor.tensorflow.utils.model import Model
-
-
-def build_keras():
-    from tensorflow import keras
-
-    (train_images, train_labels), (_, _) = keras.datasets.fashion_mnist.load_data()
-
-    train_images = train_images.astype(np.float32) / 255.0
-
-    # Create Keras model
-    model = keras.Sequential(
-        [
-            keras.layers.InputLayer(input_shape=(28, 28), name="input"),
-            keras.layers.Reshape(target_shape=(28, 28, 1)),
-            keras.layers.Conv2D(filters=12, kernel_size=(3, 3), activation="relu"),
-            keras.layers.Conv2D(filters=12, kernel_size=(3, 3), activation="relu"),
-            keras.layers.Conv2D(filters=12, kernel_size=(3, 3), activation="relu"),
-            keras.layers.Conv2D(filters=12, kernel_size=(3, 3), activation="relu"),
-            keras.layers.Conv2D(filters=12, kernel_size=(3, 3), activation="relu"),
-            keras.layers.MaxPooling2D(pool_size=(2, 2)),
-            keras.layers.Flatten(),
-            keras.layers.Dense(10, activation="softmax", name="output"),
-        ]
-    )
-
-    # Compile model with optimizer
-    opt = keras.optimizers.Adam(learning_rate=0.01)
-    model.compile(optimizer=opt, loss="sparse_categorical_crossentropy", metrics=["accuracy"])
-
-    # # Train model
-    model.fit(x={"input": train_images[0:100]}, y={"output": train_labels[0:100]}, epochs=1)
-    return model
-
-
-class TestModelWrappers(unittest.TestCase):
-    @classmethod
-    def setUpClass(self):
-        self.model = build_keras()
-
-    @classmethod
-    def tearDownClass(self):
-        os.remove("simple_model.h5")
-        os.remove("keras_model.h5")
-        os.remove("simple_model.keras")
-        os.remove("keras_model.keras")
-
-    def test_keras_h5_model(self):
-        if parse_version(tf.version.VERSION) < parse_version("2.3.0"):
-            return
-        keras_model = self.model
-        keras_model.save("./simple_model.h5")
-        # load from path
-        model = Model("./simple_model.h5")
-
-        assert isinstance(model.model, tf.keras.Model)
-        self.assertGreaterEqual(len(model.output_node_names), 1)
-        self.assertGreaterEqual(len(model.input_node_names), 1)
-
-        model.save("./keras_model.h5")
-
-        self.assertEqual(os.path.isfile("./keras_model.h5"), True)
-
-    def test_keras_model(self):
-        if parse_version(tf.version.VERSION) < parse_version("2.3.0"):
-            return
-
-        keras_model = self.model
-        model = Model(keras_model)
-
-        self.assertEqual(isinstance(model.model, tf.keras.Model), True)
-        self.assertGreaterEqual(len(model.output_node_names), 1)
-        self.assertGreaterEqual(len(model.input_node_names), 1)
-
-        keras_model.save("./simple_model.keras")
-        self.assertEqual(os.path.isfile("./simple_model.keras"), True)
-        model = Model("./simple_model.keras")
-
-        self.assertEqual(isinstance(model.model, tf.keras.Model), True)
-        self.assertGreaterEqual(len(model.output_node_names), 1)
-        self.assertGreaterEqual(len(model.input_node_names), 1)
-
-        model.save("./keras_model.keras")
-
-        self.assertEqual(os.path.isfile("./keras_model.keras"), True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/newapi/test_bias_correction_newapi.py b/test/tensorflow/quantization/ptq/newapi/test_bias_correction_newapi.py
deleted file mode 100644
index d011ecbf55c..00000000000
--- a/test/tensorflow/quantization/ptq/newapi/test_bias_correction_newapi.py
+++ /dev/null
@@ -1,181 +0,0 @@
-import os
-import unittest
-
-import tensorflow as tf
-import yaml
-from tensorflow.compat.v1 import graph_util
-
-import neural_compressor
-from neural_compressor.tensorflow.algorithms.static_quant.tensorflow import TensorflowQuery
-from neural_compressor.tensorflow.quantization.utils.quantize_graph.quantize_graph_for_intel_cpu import (
-    QuantizeGraphForIntel,
-)
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper
-from neural_compressor.tensorflow.quantization.utils.transform_graph.bias_correction import BiasCorrection
-from neural_compressor.tensorflow.utils import disable_random
-
-
-class TestBiasCorrectionNewApi(unittest.TestCase):
-    @disable_random()
-    def test_bias_correction_new_api(self):
-        tf.compat.v1.disable_eager_execution()
-        x = tf.compat.v1.placeholder(tf.float32, [1, 224, 224, 3], name="input")
-
-        if tf.version.VERSION <= "2.1.0":
-            x = tf.nn.relu(x)
-        conv1_weights = tf.compat.v1.get_variable(
-            "weights1", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv1 = tf.nn.conv2d(x, conv1_weights, strides=[1, 1, 1, 1], padding="SAME")
-        normed = tf.nn.bias_add(
-            conv1,
-            tf.constant(
-                [
-                    3.0,
-                    1.2,
-                    1.0,
-                    2,
-                    3,
-                    4,
-                    5,
-                    6,
-                    7,
-                    8,
-                    0,
-                    1,
-                    4.0,
-                    5.2,
-                    8.1,
-                    2,
-                    4,
-                    5,
-                    8,
-                    9,
-                    10,
-                    12,
-                    11,
-                    2,
-                    5.0,
-                    7.2,
-                    3.2,
-                    3,
-                    4,
-                    5,
-                    7,
-                    8,
-                ]
-            ),
-        )
-        relu1 = tf.nn.relu(normed, name="Relu_1")
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[relu1.name.split(":")[0]]
-            )
-            fp32_graph_def = QuantizeGraphHelper.remove_training_nodes(
-                output_graph_def, protected_nodes=[relu1.name.split(":")[0]]
-            )
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 224, 224, 3), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-        correct_graph_def = BiasCorrection(
-            qmodel.graph_def, fp32_graph_def, "weight_empirical", True
-        ).do_transformation()
-
-        self.assertEqual(len(correct_graph_def.node), len(qmodel.graph_def.node))
-
-
-class TestBiasCorrectionOldApi(unittest.TestCase):
-    @disable_random()
-    def test_bias_correction_old_api(self):
-        tf.compat.v1.disable_eager_execution()
-        x = tf.compat.v1.placeholder(tf.float32, [1, 224, 224, 3], name="input")
-
-        if tf.version.VERSION <= "2.1.0":
-            x = tf.nn.relu(x)
-        conv_weights = tf.compat.v1.get_variable(
-            "weights", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME")
-        normed = tf.nn.bias_add(
-            conv,
-            tf.constant(
-                [
-                    3.0,
-                    1.2,
-                    1.0,
-                    2,
-                    3,
-                    4,
-                    5,
-                    6,
-                    7,
-                    8,
-                    0,
-                    1,
-                    4.0,
-                    5.2,
-                    8.1,
-                    2,
-                    4,
-                    5,
-                    8,
-                    9,
-                    10,
-                    12,
-                    11,
-                    2,
-                    5.0,
-                    7.2,
-                    3.2,
-                    3,
-                    4,
-                    5,
-                    7,
-                    8,
-                ]
-            ),
-        )
-        relu = tf.nn.relu(normed, name="Relu_0")
-        op_wise_sequences = TensorflowQuery(
-            local_config_file=neural_compressor.__path__[0] + "/tensorflow/algorithms/static_quant/tensorflow.yaml"
-        ).get_eightbit_patterns()
-
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[relu.name.split(":")[0]]
-            )
-            output_graph_def = QuantizeGraphHelper.remove_training_nodes(
-                output_graph_def, protected_nodes=[relu.name.split(":")[0]]
-            )
-            inputs = [x.name.split(":")[0]]
-            outputs = [relu.name.split(":")[0]]
-            op_wise_config = {
-                "Conv2D": (False, "minmax", False, 7.0),
-            }
-
-            int8_graph_def, _, _ = QuantizeGraphForIntel(
-                output_graph_def, inputs, outputs, op_wise_config, op_wise_sequences, "cpu"
-            ).do_transform()
-
-        correct_graph_def = BiasCorrection(int8_graph_def, output_graph_def).do_transformation()
-        self.assertEqual(len(correct_graph_def.node), len(int8_graph_def.node))
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/newapi/test_big_saved_model.py b/test/tensorflow/quantization/ptq/newapi/test_big_saved_model.py
deleted file mode 100644
index e2325d56930..00000000000
--- a/test/tensorflow/quantization/ptq/newapi/test_big_saved_model.py
+++ /dev/null
@@ -1,143 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2023 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import math
-import os
-import shutil
-import time
-import unittest
-
-import numpy as np
-import tensorflow as tf
-from tensorflow import keras
-
-
-def build_model():
-    # Load MNIST dataset
-    mnist = keras.datasets.mnist
-    # 60000 images in train and 10000 images in test, but we don't need so much for ut
-    (train_images, train_labels), (test_images, test_labels) = mnist.load_data()
-    train_images, train_labels = train_images[:1000], train_labels[:1000]
-    test_images, test_labels = test_images[:200], test_labels[:200]
-    # Normalize the input image so that each pixel value is between 0 to 1.
-    train_images = train_images / 255.0
-    test_images = test_images / 255.0
-
-    # Define the model architecture.
-    model = keras.Sequential(
-        [
-            keras.layers.InputLayer(input_shape=(28, 28)),
-            keras.layers.Reshape(target_shape=(28, 28, 1)),
-            keras.layers.Conv2D(filters=12, kernel_size=(3, 3), activation="relu"),
-            keras.layers.MaxPooling2D(pool_size=(2, 2)),
-            keras.layers.Flatten(),
-            keras.layers.Dense(10),
-        ]
-    )
-    # Train the digit classification model
-    model.compile(
-        optimizer="adam", loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=["accuracy"]
-    )
-
-    model.fit(
-        train_images,
-        train_labels,
-        epochs=1,
-        validation_split=0.1,
-    )
-
-    _, baseline_model_accuracy = model.evaluate(test_images, test_labels, verbose=0)
-
-    print("Baseline test accuracy:", baseline_model_accuracy)
-    tf.saved_model.save(model, "baseline_model")
-
-
-class Dataset(object):
-    def __init__(self, batch_size=100):
-        mnist = keras.datasets.mnist
-        # 60000 images in train and 10000 images in test, but we don't need so much for ut
-        (train_images, train_labels), (test_images, test_labels) = mnist.load_data()
-        train_images, train_labels = train_images[:1000], train_labels[:1000]
-        test_images, test_labels = test_images[:200], test_labels[:200]
-        # Normalize the input image so that each pixel value is between 0 to 1.
-        self.train_images = train_images / 255.0
-        self.test_images = test_images / 255.0
-        self.train_labels = train_labels
-        self.test_labels = test_labels
-
-    def __len__(self):
-        return len(self.test_images)
-
-    def __getitem__(self, idx):
-        return self.test_images[idx].astype(np.float32), self.test_labels[idx]
-
-
-class TestBigSavedModel(unittest.TestCase):
-    @classmethod
-    def setUpClass(self):
-        build_model()
-
-    @classmethod
-    def tearDownClass(self):
-        shutil.rmtree("baseline_model", ignore_errors=True)
-        shutil.rmtree("int8_model", ignore_errors=True)
-
-    def test_newapi_sq_big_saved_model(self):
-        def weight_name_mapping(name):
-            """The function that maps name from AutoTrackable variables to graph nodes."""
-            name = name.replace("dense", "StatefulPartitionedCall/sequential/dense/MatMul")
-            name = name.replace("conv2d", "StatefulPartitionedCall/sequential/conv2d/Conv2D")
-            index = name.find("kernel")
-            if index != -1:
-                name = name.replace(name[index:], "ReadVariableOp")
-            return name
-
-        from neural_compressor.tensorflow import Model, SmoothQuantConfig, quantize_model
-        from neural_compressor.tensorflow.utils import BaseDataLoader
-
-        model = Model("baseline_model", modelType="llm_saved_model")
-        model.weight_name_mapping = weight_name_mapping
-        output_node_names = model.output_node_names
-
-        self.assertEqual(output_node_names, ["Identity"])
-
-        sq_config = SmoothQuantConfig(alpha=0.6, op_types=["MatMul"])
-        static_config = {
-            "static_quant": {
-                "local": {
-                    "StatefulPartitionedCall/sequential/conv2d/Conv2D": {
-                        "weight_dtype": "fp32",
-                        "act_dtype": "fp32",
-                    },
-                },
-            },
-        }
-
-        calib_dataloader = BaseDataLoader(dataset=Dataset())
-        q_model = quantize_model(model, [sq_config, static_config], calib_dataloader)
-        q_model.save("int8_model")
-
-        quant_count = 0
-        for i in q_model.graph_def.node:
-            if i.op == "QuantizeV2":
-                quant_count += 1
-
-        self.assertEqual(quant_count, 3)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/newapi/test_graph_biasadd_add_fusion.py b/test/tensorflow/quantization/ptq/newapi/test_graph_biasadd_add_fusion.py
deleted file mode 100644
index 3a82ff4ca3e..00000000000
--- a/test/tensorflow/quantization/ptq/newapi/test_graph_biasadd_add_fusion.py
+++ /dev/null
@@ -1,91 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import os
-import unittest
-
-import numpy as np
-import tensorflow as tf
-import yaml
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.tensorflow.algorithms.static_quant.tensorflow import TensorflowQuery
-from neural_compressor.tensorflow.utils import disable_random
-
-
-class TestConvBiasAddAddFusion(unittest.TestCase):
-    @disable_random()
-    def test_conv_biasadd_add_relu_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(top_relu, conv_weights, strides=[1, 2, 2, 1], padding="SAME")
-        normed = tf.nn.bias_add(conv, tf.constant([3.0, 1.2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 12, 2, 3, 4]))
-        add = normed + tf.constant([3.0])
-        relu = tf.nn.relu6(add)
-        mul1 = tf.math.multiply(relu, tf.constant([0.1]))
-        mul2 = tf.math.multiply(mul1, tf.constant([0.8]), name="op_to_store")
-
-        out_name = mul2.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.fuse_biasadd_add import (
-                FuseBiasAddAndAddOptimizer,
-            )
-
-            output_graph_def = FuseBiasAddAndAddOptimizer(output_graph_def).do_transformation()
-
-            found_addv2 = False
-            for i in output_graph_def.node:
-                if i.op.find("AddV2") != -1:
-                    found_addv2 = True
-                    break
-
-            self.assertEqual(found_addv2, False)
-
-    def test_conv_biasadd_add_relu_no_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-
-        conv_weights2 = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(top_relu, conv_weights2, strides=[1, 2, 2, 1], padding="SAME")
-        normed2 = tf.nn.bias_add(conv2, tf.constant([3.0, 1.2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 12, 2, 3, 4]))
-        add_y = tf.compat.v1.get_variable("add_y", [16], initializer=tf.compat.v1.random_normal_initializer())
-        add = normed2 + add_y
-        relu = tf.nn.relu6(add)
-        mul1 = tf.math.multiply(relu, tf.constant([0.1]))
-        mul2 = tf.math.multiply(mul1, tf.constant([0.8]), name="op_to_store")
-
-        out_name = mul2.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.fuse_biasadd_add import (
-                FuseBiasAddAndAddOptimizer,
-            )
-
-            output_graph_def = FuseBiasAddAndAddOptimizer(output_graph_def).do_transformation()
-
-            found_addv2 = False
-            for i in output_graph_def.node:
-                if i.op.find("AddV2") != -1:
-                    found_addv2 = True
-                    break
-
-            self.assertEqual(found_addv2, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/newapi/test_graph_conv_fusion_newapi.py b/test/tensorflow/quantization/ptq/newapi/test_graph_conv_fusion_newapi.py
deleted file mode 100644
index ec09ce9981a..00000000000
--- a/test/tensorflow/quantization/ptq/newapi/test_graph_conv_fusion_newapi.py
+++ /dev/null
@@ -1,966 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import os
-import unittest
-
-import numpy as np
-import tensorflow as tf
-import yaml
-from pkg_resources import parse_version
-from tensorflow.compat.v1 import graph_util
-from tensorflow.python.framework import function
-
-from neural_compressor.tensorflow.algorithms.static_quant.tensorflow import TensorflowQuery
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.fold_batch_norm import (
-    FoldBatchNormNodesOptimizer,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.strip_unused_nodes import (
-    StripUnusedNodesOptimizer,
-)
-from neural_compressor.tensorflow.quantization.utils.quantize_graph.qdq.optimize_qdq import OptimizeQDQGraph
-from neural_compressor.tensorflow.utils import disable_random, version1_gte_version2
-
-
-class TestConvBiasAddAddReluFusion(unittest.TestCase):
-    @disable_random()
-    def test_conv_single_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(top_relu, paddings, "CONSTANT")
-        conv1_weights = tf.compat.v1.get_variable(
-            "weight_conv1", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv1 = tf.nn.conv2d(x_pad, conv1_weights, strides=[1, 2, 2, 1], padding="VALID")
-        matmul_weights = tf.compat.v1.get_variable(
-            "weight_matmul", [1, 28, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        matmul = tf.linalg.matmul(conv1, matmul_weights)
-        conv2_weights = tf.compat.v1.get_variable(
-            "weight_conv2", [7, 7, 32, 1], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(matmul, conv2_weights, strides=[1, 2, 2, 1], padding="VALID")
-        leaky_relu = tf.nn.leaky_relu(conv2, name="op_to_store")
-
-        out_name = leaky_relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import Model, quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-            qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-            find_single_qconv = []
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv2D":
-                    find_single_qconv.append(i.attr["fused_ops"].list.s == [b"Requantize"])
-
-            self.assertEqual(find_single_qconv, [False, False])
-
-    @disable_random()
-    def test_spacetobatchnd_conv2d_batchtospacend_fusion(self):
-        i = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        x = tf.space_to_batch_nd(i, block_shape=[2, 2], paddings=[[0, 0], [0, 0]])
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        y = tf.compat.v1.batch_to_space_nd(conv, block_shape=[2, 2], crops=[[0, 0], [0, 0]])
-        out = tf.identity(y, name="op_to_store")
-        out_name = out.name.split(":")[0]
-
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_op = False
-            for i in qmodel.graph_def.node:
-                if i.op == "SpaceToBatchND" or i.op == "BatchToSpaceND":
-                    found_op = True
-                    break
-
-            self.assertEqual(found_op, False)
-
-    @disable_random()
-    def test_conv_relu_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(top_relu, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        relu = tf.nn.relu(conv)
-
-        relu6 = tf.nn.relu6(relu, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = True
-            for i in qmodel.graph_def.node:
-                if i.op == "Relu":
-                    found_conv_fusion = False
-                    break
-
-            self.assertEqual(found_conv_fusion, False)
-
-    @disable_random()
-    def test_conv_biasadd_relu6_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        relu6 = tf.nn.relu6(normed, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = True
-            for i in qmodel.graph_def.node:
-                if i.op == "Relu6":
-                    found_conv_fusion = False
-                    break
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv_biasadd_swishf32_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        @function.Defun(tf.float32, func_name="swish_f32")
-        def swish_f32(x):
-            return tf.nn.silu(x, beta=1.0)
-
-        swish = swish_f32(normed, name="swish_f32_output_node")
-
-        out_name = swish.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = True
-            for i in qmodel.graph_def.node:
-                if i.op == "swish_f32":
-                    found_conv_fusion = False
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv_addv2_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        conv1_weights = tf.compat.v1.get_variable(
-            "weight_conv1", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv1 = tf.nn.conv2d(x, conv1_weights, strides=[1, 2, 2, 1], padding="SAME")
-        conv2_weights = tf.compat.v1.get_variable(
-            "weight_conv2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(x, conv2_weights, strides=[1, 2, 2, 1], padding="SAME")
-        sumadd = tf.raw_ops.AddV2(x=conv1, y=conv2, name="addv2")
-
-        out_name = sumadd.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op.find("QuantizedConv2D") != -1:
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv_biasadd_add_relu_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        conv_weights2 = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(top_relu, conv_weights2, strides=[1, 2, 2, 1], padding="SAME")
-        normed2 = tf.nn.bias_add(conv2, tf.constant([3.0, 1.2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 12, 2, 3, 4]))
-        relu = tf.nn.relu(normed2 + tf.constant([3.0]))
-        relu6 = tf.nn.relu6(relu, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op.find("QuantizedConv2D") != -1:
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv_biasadd_addv2_relu_fallback_fusion_1(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.leaky_relu(x)
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-        # relu = tf.nn.relu(normed)
-
-        conv_weights2 = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(top_relu, conv_weights2, strides=[1, 2, 2, 1], padding="SAME")
-        normed2 = (
-            tf.keras.layers.BatchNormalization()(conv2)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv2)
-        )
-        # relu2 = tf.nn.relu(normed2)
-        add = tf.raw_ops.AddV2(x=normed, y=normed2, name="addv2")
-        relu = tf.nn.relu(add)
-        relu6 = tf.nn.relu6(relu, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv2D" and i.attr["fused_ops"].list.s == [
-                    b"BiasAdd",
-                    b"Sum",
-                    b"Relu",
-                    b"Requantize",
-                ]:
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv_biasadd_addv2_relu_fallback_fusion_2(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(top_relu, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-        # relu = tf.nn.relu(normed)
-
-        conv_weights2 = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(top_relu, conv_weights2, strides=[1, 2, 2, 1], padding="SAME")
-        normed2 = (
-            tf.keras.layers.BatchNormalization()(conv2)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv2)
-        )
-        # relu2 = tf.nn.relu(normed2)
-        add = tf.raw_ops.AddV2(x=normed, y=normed2, name="addv2")
-        relu = tf.nn.relu(add)
-        relu6 = tf.nn.relu6(relu, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-            found_conv_fusion = []
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv2D" and i.attr["fused_ops"].list.s == [b"BiasAdd", b"Requantize"]:
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv_fusion_with_last_matmul(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        # paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        # x_pad = tf.pad(top_relu, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(top_relu, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        relu = tf.nn.relu(normed)
-        pooling = tf.nn.max_pool(relu, ksize=1, strides=[1, 2, 2, 1], padding="SAME")
-        reshape = tf.reshape(pooling, [-1, 3136])
-
-        y_data = np.random.random([3136, 1])
-
-        y = tf.constant(y_data, dtype=tf.float32, shape=[3136, 1])
-        z = tf.matmul(reshape, y)
-        relu1 = tf.nn.relu(z)
-        y_data_1 = np.random.random([1, 1])
-        y_1 = tf.constant(y_data_1, dtype=tf.float32, shape=[1, 1])
-
-        z_2nd_matmul = tf.matmul(relu1, y_1)
-        relu6 = tf.nn.relu6(z_2nd_matmul, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            quantize_v2_count = 0
-            for i in qmodel.graph_def.node:
-                if i.op == "QuantizeV2":
-                    quantize_v2_count += 1
-                    break
-
-            self.assertEqual(quantize_v2_count, 1)
-
-    @disable_random()
-    def test_conv_fusion_with_last_conv(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(top_relu, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        relu = tf.nn.relu(normed)
-        pooling = tf.nn.max_pool(relu, ksize=1, strides=[1, 2, 2, 1], padding="SAME")
-        conv_weights_2 = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(pooling, conv_weights_2, strides=[1, 2, 2, 1], padding="VALID")
-        conv_weights_3 = tf.compat.v1.get_variable(
-            "weight3", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        relu2 = tf.nn.relu(conv2)
-        conv3 = tf.nn.conv2d(relu2, conv_weights_3, strides=[1, 2, 2, 1], padding="VALID")
-
-        relu3 = tf.nn.relu(conv3)
-        relu6 = tf.nn.relu6(relu3, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            quantize_v2_count = 0
-            for i in qmodel.graph_def.node:
-                if i.op == "QuantizeV2":
-                    quantize_v2_count += 1
-                    break
-
-            self.assertEqual(quantize_v2_count, 1)
-
-    @disable_random()
-    def test_conv_fusion_with_max_pooling(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-
-        relu = tf.nn.relu(x)
-        pooling = tf.nn.max_pool(relu, ksize=1, strides=[1, 2, 2, 1], padding="SAME")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(pooling, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        biasadd = (
-            tf.keras.layers.BatchNormalization(name="op_to_store")(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv, name="op_to_store")
-        )
-        out_name = biasadd.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            quantized_pool_data_type = None
-            quantized_conv_data_type = None
-            for i in qmodel.graph_def.node:
-                if i.op.find("QuantizedMaxPool") != -1:
-                    quantized_pool_data_type = i.attr["T"].type
-                if i.op.find("QuantizedConv2D") != -1:
-                    quantized_conv_data_type = i.attr["Tinput"].type
-
-            self.assertNotEqual(quantized_pool_data_type, None)
-            self.assertEqual(quantized_pool_data_type, quantized_conv_data_type)
-
-    @disable_random()
-    def test_conv3d_addv2_relu_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight_conv3d_1", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add = tf.raw_ops.AddV2(x=conv3d_1, y=tf.constant(np.random.randn(32), dtype=tf.float32), name="addv2")
-        relu = tf.nn.relu(add)
-        conv3d_2_weights = tf.compat.v1.get_variable(
-            "weight_conv3d_2", [3, 3, 3, 32, 1], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_2 = tf.nn.conv3d(relu, conv3d_2_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-
-        out_name = conv3d_2.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_sumadd_fusion = False
-            found_conv_biasadd_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    if b"Sum" in i.attr["fused_ops"].list.s:
-                        found_conv_sumadd_fusion = True
-                    if i.attr["fused_ops"].list.s == [b"BiasAdd", b"Relu", b"Requantize"]:
-                        found_conv_biasadd_fusion = True
-
-            self.assertEqual(found_conv_sumadd_fusion, False)
-            self.assertEqual(found_conv_biasadd_fusion, True)
-
-    # conv2d + dummybiasadd + addv2 fusion
-    @disable_random()
-    def test_conv_add_addn_non_const_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv2d_1_weights = tf.compat.v1.get_variable(
-            "weight1", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2d_1 = tf.nn.conv2d(top_relu, conv2d_1_weights, strides=[1, 2, 2, 1], padding="SAME")
-        conv2d_2_weights = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2d_2 = tf.nn.conv2d(top_relu, conv2d_2_weights, strides=[1, 2, 2, 1], padding="SAME")
-        add_1 = tf.raw_ops.AddV2(x=conv2d_1, y=conv2d_2, name="addv2_1")
-        conv2d_3_weights = tf.compat.v1.get_variable(
-            "weight3", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2d_3 = tf.nn.conv2d(top_relu, conv2d_3_weights, strides=[1, 2, 2, 1], padding="SAME")
-        add = tf.raw_ops.AddV2(x=add_1, y=conv2d_3, name="addv2_2")
-        out_name = add.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv2D" and i.attr["fused_ops"].list.s == [
-                    b"BiasAdd",
-                    b"Sum",
-                    b"Requantize",
-                ]:
-                    found_conv_fusion = True
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    @unittest.skipIf(
-        tf.__version__ not in ["2.11.0202242", "2.11.0202250", "2.11.0202317", "2.11.0202323"],
-        "deconv2d quantization only support 2.11",
-    )
-    def test_deconv2d_biasadd_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 2, 2, 1], name="input")
-        conv_weights2 = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 1, 1], initializer=tf.compat.v1.random_normal_initializer()
-        )
-
-        conv2 = tf.nn.conv2d_transpose(
-            x, conv_weights2, output_shape=[1, 2, 2, 1], strides=[1, 1, 1, 1], padding="SAME"
-        )
-
-        normed2 = tf.nn.bias_add(conv2, tf.constant([3.0]))
-        out = tf.identity(normed2)
-
-        out_name = out.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 2, 2, 1), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_deconv2d_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op.find("_FusedQuantizedDeconv2D") != -1:
-                    found_deconv2d_fusion = True
-                    break
-
-            self.assertEqual(found_deconv2d_fusion, True)
-
-    @disable_random()
-    @unittest.skipIf(
-        tf.__version__ not in ["2.11.0202242", "2.11.0202250", "2.11.0202317", "2.11.0202323"],
-        "deconv2d quantization only support 2.11",
-    )
-    def test_single_deconv2d_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 2, 2, 1], name="input")
-        conv_weights2 = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 1, 1], initializer=tf.compat.v1.random_normal_initializer()
-        )
-
-        conv2 = tf.nn.conv2d_transpose(
-            x, conv_weights2, output_shape=[1, 2, 2, 1], strides=[1, 1, 1, 1], padding="SAME"
-        )
-
-        out = tf.identity(conv2)
-
-        out_name = out.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 2, 2, 1), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_deconv2d_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op.find("_FusedQuantizedDeconv2D") != -1:
-                    found_deconv2d_fusion = True
-                    break
-
-            self.assertEqual(found_deconv2d_fusion, True)
-
-    @disable_random()
-    @unittest.skipIf(
-        tf.__version__ not in ["2.11.0202242", "2.11.0202250", "2.11.0202317", "2.11.0202323"],
-        "deconv2d quantization only support 2.11",
-    )
-    def test_deconv3d_biasadd_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 2, 2, 2, 1], name="input")
-        conv3d_weights = tf.compat.v1.get_variable(
-            "weight_conv3d_1", [3, 3, 3, 1, 1], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d = tf.nn.conv3d_transpose(
-            x, conv3d_weights, output_shape=[1, 2, 2, 2, 1], strides=[1, 1, 1, 1, 1], padding="SAME"
-        )
-
-        normed2 = tf.nn.bias_add(conv3d, tf.constant([3.0]))
-        out = tf.identity(normed2)
-
-        out_name = out.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 2, 2, 2, 1), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_deconv3d_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op.find("_FusedQuantizedDeconv3D") != -1:
-                    found_deconv3d_fusion = True
-                    break
-
-            self.assertEqual(found_deconv3d_fusion, True)
-
-    @disable_random()
-    @unittest.skipIf(
-        tf.__version__ not in ["2.11.0202242", "2.11.0202250", "2.11.0202317", "2.11.0202323"],
-        "deconv2d quantization only support 2.11",
-    )
-    def test_single_deconv3d_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 2, 2, 2, 1], name="input")
-        conv3d_weights = tf.compat.v1.get_variable(
-            "weight_conv3d_1", [3, 3, 3, 1, 1], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d = tf.nn.conv3d_transpose(
-            x, conv3d_weights, output_shape=[1, 2, 2, 2, 1], strides=[1, 1, 1, 1, 1], padding="SAME"
-        )
-
-        out = tf.identity(conv3d)
-
-        out_name = out.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 2, 2, 2, 1), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_deconv3d_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op.find("_FusedQuantizedDeconv3D") != -1:
-                    found_deconv3d_fusion = True
-                    break
-
-            self.assertEqual(found_deconv3d_fusion, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/newapi/test_graph_conv_requantize_fusion.py b/test/tensorflow/quantization/ptq/newapi/test_graph_conv_requantize_fusion.py
deleted file mode 100644
index db29ab7ed50..00000000000
--- a/test/tensorflow/quantization/ptq/newapi/test_graph_conv_requantize_fusion.py
+++ /dev/null
@@ -1,1147 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import logging
-import os
-import unittest
-
-import numpy as np
-import tensorflow as tf
-import yaml
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.tensorflow.algorithms.static_quant.tensorflow import TensorflowQuery
-from neural_compressor.tensorflow.utils import disable_random, version1_gte_version2
-
-
-class TestConvRequantizedFusionNewAPI(unittest.TestCase):
-    @disable_random()
-    def test_conv_biasadd_relu6_fusion(self):
-        logging.getLogger().info("test_conv_biasadd_relu6_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight0", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        relu6 = tf.nn.relu6(normed, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = True
-            for i in qmodel.graph_def.node:
-                if i.op == "Relu6":
-                    found_conv_fusion = False
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_single_conv3d_fusion(self):
-        logging.getLogger().info("test_single_conv3d_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 64, 64, 64, 1], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight1", [4, 4, 4, 1, 64], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv3d(x_pad, conv_weights, strides=[1, 2, 2, 2, 1], padding="VALID", name="op_to_store")
-
-        out_name = conv.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 64, 64, 64, 1), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv3d_biasadd_fusion(self):
-        logging.getLogger().info("test_conv3d_biasadd_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 64, 64, 64, 1], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight2", [4, 4, 4, 1, 64], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv3d(x_pad, conv_weights, strides=[1, 2, 2, 2, 1], padding="VALID")
-        relu6 = tf.nn.relu6(conv, name="op_to_store")
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 64, 64, 64, 1), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_relu_fusion(self):
-        logging.getLogger().info("test_conv3d_add_relu_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 64, 64, 64, 1], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight6", [4, 4, 4, 1, 64], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv1_weights = tf.compat.v1.get_variable(
-            "weight7", [4, 4, 4, 1, 64], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv3d(x, conv_weights, strides=[1, 2, 2, 2, 1], padding="VALID")
-        conv1 = tf.nn.conv3d(x, conv1_weights, strides=[1, 2, 2, 2, 1], padding="VALID")
-        add = conv + conv1
-        relu = tf.nn.relu(add)
-
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import Model, quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 64, 64, 64, 1), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-            qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D" and i.attr["fused_ops"].list.s == [b"BiasAdd", b"Dequantize"]:
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv2d_biasadd_elu_fusion(self):
-        input = tf.compat.v1.placeholder(tf.float32, shape=(1, 3, 3, 1), name="input")
-        weight = tf.compat.v1.constant(np.random.random((2, 2, 1, 1)).astype(np.float32), name="weight")
-        bias = tf.constant(np.random.random((1)), name="bias", dtype=tf.float32)
-        conv = tf.nn.conv2d(input=input, filters=weight, strides=[1, 1, 1, 1], padding="VALID", name="conv")
-        bias_add = tf.nn.bias_add(conv, bias, name="bias_add")
-        res = tf.nn.elu(bias_add, name="res")
-        output = tf.nn.softmax(res, name="op_to_store")
-
-        out_name = output.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import Model, quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 3, 3, 1), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-            qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-            self.assertNotEqual(qmodel, None)
-
-            elu_fused = False
-            for node in qmodel.graph_def.node:
-                if node.name == "conv_eightbit_requantize_dequantize":
-                    if b"Elu" in node.attr["fused_ops"].list.s:
-                        elu_fused = True
-
-            self.assertEqual(elu_fused, True)
-
-    @disable_random()
-    def test_conv3d_add_const_fusion(self):
-        logging.getLogger().info("test_conv3d_add_const_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 64, 64, 64, 1], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight11", [4, 4, 4, 1, 64], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv3d(x, conv_weights, strides=[1, 2, 2, 2, 1], padding="VALID")
-        add = conv + tf.constant(
-            [
-                [
-                    [
-                        [
-                            [
-                                0.000015179151887423359,
-                                0.000022200847524800338,
-                                -0.000009995766049541999,
-                                -0.0000022956028260523453,
-                                0.000008830029400996864,
-                                0.0000017190360495078494,
-                                0.000019561824956326745,
-                                0.00014721050683874637,
-                                -0.000005871841494808905,
-                                0.000004377178811409976,
-                                -0.000006191140982991783,
-                                0.000009258330464945175,
-                                -0.000009839599442784674,
-                                0.000008547322067897767,
-                                0.000004629391241905978,
-                                2.345327061448188e-7,
-                                0.000015179151887423359,
-                                0.000022200847524800338,
-                                -0.000009995766049541999,
-                                -0.0000022956028260523453,
-                                0.000008830029400996864,
-                                0.0000017190360495078494,
-                                0.000019561824956326745,
-                                0.00014721050683874637,
-                                -0.000005871841494808905,
-                                0.000004377178811409976,
-                                -0.000006191140982991783,
-                                0.000009258330464945175,
-                                -0.000009839599442784674,
-                                0.000008547322067897767,
-                                0.000004629391241905978,
-                                2.345327061448188e-7,
-                                0.000015179151887423359,
-                                0.000022200847524800338,
-                                -0.000009995766049541999,
-                                -0.0000022956028260523453,
-                                0.000008830029400996864,
-                                0.0000017190360495078494,
-                                0.000019561824956326745,
-                                0.00014721050683874637,
-                                -0.000005871841494808905,
-                                0.000004377178811409976,
-                                -0.000006191140982991783,
-                                0.000009258330464945175,
-                                -0.000009839599442784674,
-                                0.000008547322067897767,
-                                0.000004629391241905978,
-                                2.345327061448188e-7,
-                                0.000015179151887423359,
-                                0.000022200847524800338,
-                                -0.000009995766049541999,
-                                -0.0000022956028260523453,
-                                0.000008830029400996864,
-                                0.0000017190360495078494,
-                                0.000019561824956326745,
-                                0.00014721050683874637,
-                                -0.000005871841494808905,
-                                0.000004377178811409976,
-                                -0.000006191140982991783,
-                                0.000009258330464945175,
-                                -0.000009839599442784674,
-                                0.000008547322067897767,
-                                0.000004629391241905978,
-                                2.345327061448188e-7,
-                            ]
-                        ]
-                    ]
-                ]
-            ]
-        )
-
-        out_name = add.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import Model, quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 64, 64, 64, 1), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-            qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-            found_conv_fusion = True
-            for i in qmodel.graph_def.node:
-                if i.op == "AddV2":
-                    found_conv_fusion = False
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv_add_add_fusion(self):
-        logging.getLogger().info("test_conv_add_add_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight12", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-        add = normed + tf.constant(np.random.randn(16), dtype=tf.float32)
-        relu6 = tf.nn.relu6(add, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = True
-            for i in qmodel.graph_def.node:
-                if i.op == "Add":
-                    found_conv_fusion = False
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_single_conv2d_fusion(self):
-        logging.getLogger().info("test_single_conv2d_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight13", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        out_name = conv.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv2D":
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_addn_const_relu_fusion(self):
-        logging.getLogger().info("test_conv3d_add_addn_const_relu_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight14", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add_1 = tf.raw_ops.AddV2(x=conv3d_1, y=tf.constant(np.random.randn(32), dtype=tf.float32), name="addv2")
-        var = tf.compat.v1.get_variable(
-            "add_y", [1, 64, 32, 32, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        add = tf.raw_ops.AddV2(x=add_1, y=var, name="addv2_1")
-        relu = tf.nn.relu(add)
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_sumadd_fusion = False
-            found_conv_biasadd_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    if str(b"Sum") in str(i.attr["fused_ops"].list.s):
-                        found_conv_sumadd_fusion = True
-                    if str(i.attr["fused_ops"].list.s) == str([b"BiasAdd", b"Sum", b"Relu"]):
-                        found_conv_biasadd_fusion = True
-
-            self.assertEqual(found_conv_sumadd_fusion, False)
-            self.assertEqual(found_conv_biasadd_fusion, False)
-
-    @disable_random()
-    def test_conv3d_add_const_addn_relu_fusion(self):
-        logging.getLogger().info("test_conv3d_add_const_addn_relu_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight15", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add_1 = tf.raw_ops.AddV2(x=conv3d_1, y=tf.constant(np.random.randn(32), dtype=tf.float32), name="addv2_2")
-        conv3d_2_weights = tf.compat.v1.get_variable(
-            "weight16", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_2 = tf.nn.conv3d(top_relu, conv3d_2_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add = tf.raw_ops.AddV2(x=add_1, y=conv3d_2, name="addv2_3")
-        relu = tf.nn.relu(add)
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_sumadd_fusion = False
-            found_conv_biasadd_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    if str(b"Sum") in str(i.attr["fused_ops"].list.s):
-                        found_conv_sumadd_fusion = True
-                    if str(i.attr["fused_ops"].list.s) == str([b"BiasAdd", b"Sum", b"Relu"]):
-                        found_conv_biasadd_fusion = True
-
-            self.assertEqual(found_conv_sumadd_fusion, True)
-            self.assertEqual(found_conv_biasadd_fusion, False)
-
-    @disable_random()
-    def test_conv3d_add_addn_fusion(self):
-        logging.getLogger().info("test_conv3d_add_addn_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight15", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add_1 = tf.raw_ops.AddV2(x=conv3d_1, y=tf.constant(np.random.randn(32), dtype=tf.float32), name="addv2_4")
-        conv3d_2_weights = tf.compat.v1.get_variable(
-            "weight16", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_2 = tf.nn.conv3d(top_relu, conv3d_2_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add = tf.raw_ops.AddV2(x=add_1, y=conv3d_2, name="addv2_5")
-        out_name = add.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    found_conv_fusion = True
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_addn_relu_fusion(self):
-        logging.getLogger().info("test_conv3d_add_addn_relu_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight17", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_2_weights = tf.compat.v1.get_variable(
-            "weight18", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        conv3d_2 = tf.nn.conv3d(top_relu, conv3d_2_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add_1 = tf.raw_ops.AddV2(x=conv3d_1, y=conv3d_2, name="addv2_6")
-        conv3d_3_weights = tf.compat.v1.get_variable(
-            "weight19", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_2 = tf.nn.conv3d(top_relu, conv3d_3_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add = tf.raw_ops.AddV2(x=add_1, y=conv3d_2, name="addv2_7")
-        relu = tf.nn.relu(add)
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_relu_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "Relu":
-                    found_relu_fusion = True
-
-            self.assertEqual(found_relu_fusion, True)
-
-    @disable_random()
-    def test_conv3d_relu_fusion(self):
-        logging.getLogger().info("test_conv3d_relu_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 64, 64, 64, 1], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight20", [4, 4, 4, 1, 64], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv3d(x_pad, conv_weights, strides=[1, 2, 2, 2, 1], padding="VALID")
-        relu = tf.nn.leaky_relu(conv)
-
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 64, 64, 64, 1), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_fusion(self):
-        logging.getLogger().info("test_conv3d_add_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight21", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        conv3d_2_weights = tf.compat.v1.get_variable(
-            "weight22", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_2 = tf.nn.conv3d(top_relu, conv3d_2_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add = tf.raw_ops.AddV2(x=conv3d_1, y=conv3d_2, name="addv2_8")
-        out_name = add.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    found_conv_fusion = True
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_const_addn_relu_requantize_fusion(self):
-        logging.getLogger().info("test_conv3d_add_const_addn_relu_requantize_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight23", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        y_const = tf.constant(np.random.randn(1, 1, 1, 1, 32), dtype=tf.float32)
-        add_1 = tf.raw_ops.AddV2(x=conv3d_1, y=y_const, name="addv2_9")
-        conv3d_2_weights = tf.compat.v1.get_variable(
-            "weight24", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_2 = tf.nn.conv3d(top_relu, conv3d_2_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add_2 = tf.raw_ops.AddV2(x=add_1, y=conv3d_2, name="addv2_10")
-        relu = tf.nn.relu(add_2)
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_sumadd_fusion = False
-            found_conv_biasadd_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    if str(b"Sum") in str(i.attr["fused_ops"].list.s):
-                        found_conv_sumadd_fusion = True
-                    if str(i.attr["fused_ops"].list.s) == str([b"BiasAdd", b"Sum", b"Relu", b"Requantize"]):
-                        found_conv_biasadd_fusion = True
-
-            self.assertEqual(found_conv_sumadd_fusion, True)
-            self.assertEqual(found_conv_biasadd_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_const_addn_fusion(self):
-        logging.getLogger().info("test_conv3d_add_const_addn_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight25", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        y_const = tf.constant(np.random.randn(1, 1, 1, 1, 32), dtype=tf.float32)
-        add_1 = tf.raw_ops.AddV2(x=conv3d_1, y=y_const, name="addv2_11")
-        conv3d_2_weights = tf.compat.v1.get_variable(
-            "weight26", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_2 = tf.nn.conv3d(top_relu, conv3d_2_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add_2 = tf.raw_ops.AddV2(x=add_1, y=conv3d_2, name="addv2_12")
-        out_name = add_2.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    found_conv_fusion = True
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_no_relu_fusion(self):
-        logging.getLogger().info("test_conv3d_add_no_relu_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight27", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        y_const = tf.constant(np.random.randn(1, 1, 1, 1, 32), dtype=tf.float32)
-        add = tf.raw_ops.AddV2(x=conv3d_1, y=y_const, name="addv2_13")
-        pooling = tf.nn.max_pool(add, ksize=1, strides=[1, 2, 2, 2, 1], padding="SAME")
-        out_name = pooling.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_const_relu_fusion(self):
-        logging.getLogger().info("test_conv3d_add_const_relu_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight28", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        y_const = tf.constant(np.random.randn(1, 1, 1, 1, 32), dtype=tf.float32)
-        add = tf.raw_ops.AddV2(x=conv3d_1, y=y_const, name="addv2_10")
-        relu = tf.nn.relu(add)
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv2d_add_const_leakyrelu_add_fusion(self):
-        logging.getLogger().info("test_conv2d_add_const_leakyrelu_add_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv2d_1_weights = tf.compat.v1.get_variable(
-            "weight29", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2d_1 = tf.nn.conv2d(top_relu, conv2d_1_weights, strides=[1, 2, 2, 1], padding="SAME")
-        y_const = tf.constant(np.random.randn(16), dtype=tf.float32)
-        add_1 = tf.raw_ops.AddV2(x=conv2d_1, y=y_const, name="addv2_11")
-        relu = tf.nn.leaky_relu(add_1)
-        conv2d_2_weights = tf.compat.v1.get_variable(
-            "weight30", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2d_2 = tf.nn.conv2d(top_relu, conv2d_2_weights, strides=[1, 2, 2, 1], padding="SAME")
-        add_2 = tf.raw_ops.AddV2(x=relu, y=conv2d_2, name="addv2_12")
-        out_name = add_2.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv2D":
-                    found_conv_fusion = True
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_const_leakyrelu_add_fusion(self):
-        logging.getLogger().info("test_conv3d_add_const_leakyrelu_add_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight31", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        y_const = tf.constant(np.random.randn(1, 1, 1, 1, 32), dtype=tf.float32)
-        add_1 = tf.raw_ops.AddV2(x=conv3d_1, y=y_const, name="addv2_13")
-        relu = tf.nn.leaky_relu(add_1)
-        conv3d_2_weights = tf.compat.v1.get_variable(
-            "weight32", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_2 = tf.nn.conv3d(top_relu, conv3d_2_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add_2 = tf.raw_ops.AddV2(x=relu, y=conv3d_2, name="addv2_14")
-        out_name = add_2.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    found_conv_fusion = True
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_addn_non_const_fusion(self):
-        logging.getLogger().info("test_conv3d_add_addn_non_const_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight33", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        conv3d_2_weights = tf.compat.v1.get_variable(
-            "weight34", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_2 = tf.nn.conv3d(top_relu, conv3d_2_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add_1 = tf.raw_ops.AddV2(x=conv3d_1, y=conv3d_2, name="addv2_15")
-        conv3d_3_weights = tf.compat.v1.get_variable(
-            "weight35", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_3 = tf.nn.conv3d(top_relu, conv3d_3_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add = tf.raw_ops.AddV2(x=add_1, y=conv3d_3, name="addv2_16")
-        out_name = add.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    found_conv_fusion = True
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_const_elu_add_fusion(self):
-        logging.getLogger().info("test_conv3d_add_const_elufusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv3d_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d = tf.nn.conv3d(top_relu, conv3d_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        y_const = tf.constant(np.random.randn(1, 1, 1, 1, 32), dtype=tf.float32)
-        add = tf.raw_ops.AddV2(x=conv3d, y=y_const, name="addv2")
-        elu = tf.nn.elu(add)
-        output = tf.nn.softmax(elu, name="op_to_store")
-        out_name = output.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    found_conv_fusion = True
-
-            self.assertEqual(found_conv_fusion, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/newapi/test_graph_depthwiseconv_fusion.py b/test/tensorflow/quantization/ptq/newapi/test_graph_depthwiseconv_fusion.py
deleted file mode 100644
index dd1e2fc1212..00000000000
--- a/test/tensorflow/quantization/ptq/newapi/test_graph_depthwiseconv_fusion.py
+++ /dev/null
@@ -1,260 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import os
-import unittest
-
-import numpy as np
-import tensorflow as tf
-import yaml
-from tensorflow.compat.v1 import graph_util
-from tensorflow.core.framework import attr_value_pb2, graph_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.utils import disable_random, version1_gte_version2
-
-
-def build_Conv2dBiasAddAddRelu6MulMul():
-    input_node = node_def_pb2.NodeDef()
-    input_node.name = "input"
-    input_node.op = "Placeholder"
-    input_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-
-    conv1_weight_node = node_def_pb2.NodeDef()
-    conv1_weight_node.name = "conv1_weights"
-    conv1_weight_node.op = "Const"
-    conv1_weight_value = np.float32(np.abs(np.random.randn(3, 3, 3, 32)))
-    conv1_weight_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    conv1_weight_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(
-                conv1_weight_value, conv1_weight_value.dtype.type, conv1_weight_value.shape
-            )
-        )
-    )
-
-    conv1_node = node_def_pb2.NodeDef()
-    conv1_node.name = "conv1"
-    conv1_node.op = "Conv2D"
-    conv1_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    conv1_node.input.extend([input_node.name, conv1_weight_node.name])
-    conv1_node.attr["strides"].CopyFrom(
-        attr_value_pb2.AttrValue(list=attr_value_pb2.AttrValue.ListValue(i=[1, 1, 1, 1]))
-    )
-    conv1_node.attr["dilations"].CopyFrom(
-        attr_value_pb2.AttrValue(list=attr_value_pb2.AttrValue.ListValue(i=[1, 1, 1, 1]))
-    )
-    conv1_node.attr["padding"].CopyFrom(attr_value_pb2.AttrValue(s=b"SAME"))
-    conv1_node.attr["data_format"].CopyFrom(attr_value_pb2.AttrValue(s=b"NHWC"))
-
-    bias_node = node_def_pb2.NodeDef()
-    bias_node.name = "conv1_bias"
-    bias_node.op = "Const"
-    bias_value = np.float32(np.abs(np.random.randn(32)))
-    bias_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    bias_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(bias_value, bias_value.dtype.type, bias_value.shape)
-        )
-    )
-
-    bias_add_node = node_def_pb2.NodeDef()
-    bias_add_node.name = "conv1_bias_add"
-    bias_add_node.op = "BiasAdd"
-    bias_add_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    bias_add_node.attr["data_format"].CopyFrom(attr_value_pb2.AttrValue(s=b"NHWC"))
-    bias_add_node.input.extend([conv1_node.name, bias_node.name])
-
-    offset_node = node_def_pb2.NodeDef()
-    offset_node.name = "offset"
-    offset_node.op = "Const"
-    offset_value = np.float32(np.abs(np.random.randn(1)))
-    offset_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    offset_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(offset_value, offset_value.dtype.type, offset_value.shape)
-        )
-    )
-
-    add_node = node_def_pb2.NodeDef()
-    add_node.op = "Add"
-    add_node.name = "add/hard_swish"
-    add_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    add_node.input.extend([bias_add_node.name, offset_node.name])
-
-    relu_node = node_def_pb2.NodeDef()
-    relu_node.op = "Relu6"
-    relu_node.name = "relu6/hard_swish"
-    relu_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    relu_node.input.extend([add_node.name])
-
-    mul_node = node_def_pb2.NodeDef()
-    mul_node.op = "Mul"
-    mul_node.name = "mul/hard_swish"
-    mul_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    mul_node.input.extend([bias_add_node.name, relu_node.name])
-
-    offset1_node = node_def_pb2.NodeDef()
-    offset1_node.name = "mul1_offset"
-    offset1_node.op = "Const"
-    offset1_value = np.float32(np.abs(np.random.randn(1)))
-    offset1_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    offset1_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(offset1_value, offset1_value.dtype.type, offset1_value.shape)
-        )
-    )
-
-    mul1_node = node_def_pb2.NodeDef()
-    mul1_node.op = "Mul"
-    mul1_node.name = "mul1/hard_swish"
-    mul1_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    mul1_node.input.extend([mul_node.name, offset1_node.name])
-
-    test_graph = graph_pb2.GraphDef()
-
-    test_graph.node.extend(
-        [
-            input_node,
-            conv1_weight_node,
-            conv1_node,
-            bias_node,
-            bias_add_node,
-            add_node,
-            relu_node,
-            offset_node,
-            offset1_node,
-            mul_node,
-            mul1_node,
-        ]
-    )
-    return test_graph
-
-
-class TestConvBiasAddAddReluFusion(unittest.TestCase):
-    @disable_random()
-    def test_depthwiseconv_biasadd_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.depthwise_conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="VALID")
-
-        normed = (
-            tf.keras.layers.BatchNormalization(name="op_to_store")(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv, name="op_to_store")
-        )
-        out_name = normed.name.split(":")[0]
-
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedDepthwiseConv2D":
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_depthwiseConv2dNative_BiasAddAddRelu6MulMul_fusion(self):
-        fp32_graph_def = build_Conv2dBiasAddAddRelu6MulMul()
-
-        from neural_compressor.tensorflow import quantize_model
-        from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-        dataset = DummyDataset(shape=(100, 224, 224, 3), label=True)
-        calib_dataloader = BaseDataLoader(dataset)
-        quant_config = {
-            "static_quant": {
-                "global": {
-                    "weight_dtype": "int8",
-                    "weight_sym": True,
-                    "weight_granularity": "per_tensor",
-                    "weight_algorithm": "minmax",
-                },
-            }
-        }
-        qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-        found_conv_fusion = False
-        for i in qmodel.graph_def.node:
-            if i.op == "_FusedQuantizedConv2D":
-                found_conv_fusion = True
-                break
-
-        self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_depthwiseconv_biasadd_leakyrelu_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.depthwise_conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="VALID")
-
-        normed = (
-            tf.keras.layers.BatchNormalization(name="op_to_store")(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv, name="op_to_store")
-        )
-
-        leakyrelu = tf.nn.leaky_relu(normed)
-        out_name = leakyrelu.name.split(":")[0]
-
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedDepthwiseConv2D":
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/newapi/test_graph_dequantize_cast_optimizer_newapi.py b/test/tensorflow/quantization/ptq/newapi/test_graph_dequantize_cast_optimizer_newapi.py
deleted file mode 100644
index f42a2d8cc06..00000000000
--- a/test/tensorflow/quantization/ptq/newapi/test_graph_dequantize_cast_optimizer_newapi.py
+++ /dev/null
@@ -1,96 +0,0 @@
-import os
-import unittest
-
-import numpy as np
-import tensorflow as tf
-import yaml
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.bf16.dequantize_cast_optimizer import (
-    DequantizeCastOptimizer,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import disable_random
-
-
-def build_fake_graphdef(set_min_first=False, dq_multi_outputs=False):
-    tf.compat.v1.disable_eager_execution()
-
-    input = tf.compat.v1.placeholder(tf.float32, shape=(32, 224, 224, 3), name="input")
-    graph_def = tf.compat.v1.get_default_graph().as_graph_def(add_shapes=True)
-
-    min_input = Helper.create_constant_node("test_min", value=0.0, dtype=dtypes.float32)
-
-    max_input = Helper.create_constant_node("test_max", value=[1], dtype=dtypes.float32)
-
-    quant_v2_node = Helper.create_node("QuantizeV2", "test_quantize", [input.name, min_input.name, max_input.name])
-
-    dequantize_node = Helper.create_node(
-        "Dequantize", "test_dequantize", [quant_v2_node.name, quant_v2_node.name + ":1", quant_v2_node.name + ":2"]
-    )
-    if set_min_first:
-        Helper.set_attr_string(dequantize_node, "mode", b"MIN_FIRST")
-
-    cast_node = Helper.create_node("Cast", "test_cast", [dequantize_node.name])
-    Helper.set_attr_dtype(cast_node, "DstT", dtypes.bfloat16)
-    Helper.set_attr_dtype(cast_node, "SrcT", dtypes.float32)
-    Helper.set_attr_bool(cast_node, "Truncate", False)
-
-    dentity_node = Helper.create_node("Identity", "output", [cast_node.name])
-    Helper.set_attr_dtype(dentity_node, "T", dtypes.bfloat16)
-
-    graph_def.node.extend(
-        [
-            min_input,
-            max_input,
-            quant_v2_node,
-            dequantize_node,
-            cast_node,
-            dentity_node,
-        ]
-    )
-
-    if dq_multi_outputs:
-        dentity_node_2 = Helper.create_node("Identity", "id_1", [dequantize_node.name])
-        Helper.set_attr_dtype(dentity_node_2, "T", dtypes.float32)
-        graph_def.node.extend([dentity_node_2])
-
-    return graph_def
-
-
-class TestDequantizeCastOptimizer(unittest.TestCase):
-    @disable_random()
-    def test_dequantize_cast_normal(self):
-        graph_def = build_fake_graphdef()
-        converted_graph_def = DequantizeCastOptimizer(graph_def).do_transformation()
-        for i in converted_graph_def.node:
-            self.assertNotEqual(i.op, "Cast")
-
-    @disable_random()
-    def test_dequantize_cast_min_first(self):
-        graph_def = build_fake_graphdef(set_min_first=True)
-        converted_graph_def = DequantizeCastOptimizer(graph_def).do_transformation()
-        hasCast = False
-        # Remove MIN_FIRST limitation for spr-base, so the "Cast" will be removed now
-        for i in converted_graph_def.node:
-            if i.op == "Cast":
-                hasCast = True
-                break
-
-        self.assertEqual(hasCast, False)
-
-    @disable_random()
-    def test_dequantize_cast_multiple_outputs(self):
-        graph_def = build_fake_graphdef(dq_multi_outputs=True)
-        converted_graph_def = DequantizeCastOptimizer(graph_def).do_transformation()
-        hasCast = False
-        for i in converted_graph_def.node:
-            if i.op == "Cast":
-                hasCast = True
-                break
-
-        self.assertEqual(hasCast, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/newapi/test_graph_dq_cast_fusion.py b/test/tensorflow/quantization/ptq/newapi/test_graph_dq_cast_fusion.py
deleted file mode 100644
index 1116e8c0bbc..00000000000
--- a/test/tensorflow/quantization/ptq/newapi/test_graph_dq_cast_fusion.py
+++ /dev/null
@@ -1,63 +0,0 @@
-import os
-import unittest
-
-import numpy as np
-import tensorflow as tf
-import yaml
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.tensorflow.utils import disable_random
-
-
-class TestDqCastFusion(unittest.TestCase):
-    @classmethod
-    def setUpClass(self):
-        os.environ["FORCE_BF16"] = "1"
-
-    @classmethod
-    def tearDownClass(self):
-        os.environ["FORCE_BF16"] = "0"
-
-    @disable_random()
-    def test_dq_all_outputs_bf16(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        conv_weights = tf.constant(np.random.random((1, 3, 16, 16)).astype(np.float32), name="y")
-        conv = tf.nn.conv2d(x, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        conv_reshape1 = tf.reshape(conv, [1, 28, 27, 16])
-        conv_reshape2 = tf.reshape(conv, [1, 28, 27, 16])
-        out = tf.math.add(conv_reshape1, conv_reshape2, name="op_to_store")
-        out_name = out.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-        from neural_compressor.tensorflow import quantize_model
-        from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-        dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-        calib_dataloader = BaseDataLoader(dataset)
-        quant_config = {
-            "static_quant": {
-                "global": {
-                    "weight_dtype": "int8",
-                    "weight_sym": True,
-                    "weight_granularity": "per_tensor",
-                    "weight_algorithm": "minmax",
-                },
-            }
-        }
-        qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-        found_cast = False
-        for node in qmodel.graph_def.node:
-            if node.op == "Cast":
-                found_cast = True
-                break
-
-        self.assertEqual(found_cast, False)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/newapi/test_graph_fuse_pad_conv_fp32.py b/test/tensorflow/quantization/ptq/newapi/test_graph_fuse_pad_conv_fp32.py
deleted file mode 100644
index a1afebc2753..00000000000
--- a/test/tensorflow/quantization/ptq/newapi/test_graph_fuse_pad_conv_fp32.py
+++ /dev/null
@@ -1,109 +0,0 @@
-import os
-import unittest
-
-import tensorflow as tf
-import yaml
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.tensorflow.utils import disable_random, version1_gte_version2
-
-
-class TestFoldPadConv(unittest.TestCase):
-    @disable_random()
-    def test_fold_pad_conv(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-        relu = tf.nn.relu(normed, name="op_to_store")
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_pad = False
-            for i in qmodel.graph_def.node:
-                if i.op == "Pad":
-                    found_pad = True
-                    break
-
-            self.assertEqual(found_pad, False)
-
-    @disable_random()
-    def test_fold_non_const_pad_conv(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        vec = tf.raw_ops.DataFormatVecPermute(x=paddings, src_format="NHWC", dst_format="NHWC")
-        x_pad = tf.pad(x, vec, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-        relu = tf.nn.relu(normed, name="op_to_store")
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_pad = False
-            for i in qmodel.graph_def.node:
-                if i.op == "Pad":
-                    found_pad = True
-                    break
-
-            self.assertEqual(found_pad, False)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_bn_fusion.py b/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_bn_fusion.py
deleted file mode 100644
index 4c1d18ca4b0..00000000000
--- a/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_bn_fusion.py
+++ /dev/null
@@ -1,461 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import logging
-import os
-import unittest
-
-import numpy as np
-import tensorflow as tf
-import yaml
-from tensorflow.compat.v1 import graph_util
-from tensorflow.core.framework import attr_value_pb2
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.common import logger
-from neural_compressor.tensorflow.utils import CpuInfo, disable_random, version1_gte_version2
-
-
-class TestTensorflowQdqConvFusion(unittest.TestCase):
-    @disable_random()
-    def test_bn_relu_depthwiseconv_biasadd_relu6_fusion(self):
-        logger.info("test_bn_relu_depthwiseconv_biasadd_relu6_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        normed_0 = (
-            tf.keras.layers.BatchNormalization()(x)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(x)
-        )
-        relu = tf.nn.relu(normed_0, name="op_to_store_0")
-        conv = tf.compat.v1.nn.depthwise_conv2d_native(relu, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed_1 = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-        relu6 = tf.nn.relu6(normed_1, name="op_to_store_1")
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-        from neural_compressor.tensorflow import Model, quantize_model
-        from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-        dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-        calib_dataloader = BaseDataLoader(dataset)
-        quant_config = {
-            "static_quant": {
-                "global": {
-                    "weight_dtype": "int8",
-                    "weight_sym": True,
-                    "weight_granularity": "per_tensor",
-                    "weight_algorithm": "minmax",
-                },
-            }
-        }
-        fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-        qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-        conv_input_type = True
-        found_fusion = True
-        qbn_num = 0
-        dq_num = 0
-        for i in qmodel.graph_def.node:
-            if i.op == "_FusedQuantizedDepthwiseConv2D" and i.attr["Thost_inputs"].list.type != [
-                11,
-                11,
-                1,
-                1,
-                1,
-                1,
-                1,
-                1,
-                1,
-            ]:
-                conv_input_type = False
-                break
-            if i.op in ["Relu", "Relu6", "FusedBatchNormV3"]:
-                found_fusion = False
-                break
-            if i.op == "_QuantizedFusedBatchNorm":
-                qbn_num += 1
-            if i.op == "Dequantize":
-                dq_num += 1
-
-        self.assertEqual(conv_input_type, True)
-        self.assertEqual(found_fusion, True)
-        self.assertEqual(qbn_num, 1)
-        self.assertEqual(dq_num, 0)
-
-    @disable_random()
-    def test_training_bn_relu_depthwiseconv_biasadd_relu6_fusion(self):
-        logger.info("test_training_bn_relu_depthwiseconv_biasadd_relu6_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        normed_0 = (
-            tf.keras.layers.BatchNormalization()(x)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(x, training=True)
-        )
-        relu = tf.nn.relu(normed_0, name="op_to_store_0")
-        conv = tf.compat.v1.nn.depthwise_conv2d_native(relu, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed_1 = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-        relu6 = tf.nn.relu6(normed_1, name="op_to_store_1")
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-        from neural_compressor.tensorflow import Model, quantize_model
-        from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-        dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-        calib_dataloader = BaseDataLoader(dataset)
-        quant_config = {
-            "static_quant": {
-                "global": {
-                    "weight_dtype": "int8",
-                    "weight_sym": True,
-                    "weight_granularity": "per_tensor",
-                    "weight_algorithm": "minmax",
-                },
-            }
-        }
-        fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-        qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-        bn_num, bf16_bn_num, qbn_num, dq_num = 0, 0, 0, 0
-        for i in qmodel.graph_def.node:
-            if i.op == "FusedBatchNormV3":
-                bn_num += 1
-                if i.attr["T"].type == dtypes.bfloat16.as_datatype_enum:
-                    bf16_bn_num += 1
-            if i.op == "_QuantizedFusedBatchNorm":
-                qbn_num += 1
-            if i.op == "Dequantize":
-                dq_num += 1
-
-        self.assertEqual(bn_num, 1)
-        self.assertEqual(qbn_num, 0)
-        self.assertEqual(dq_num, 0)
-        bf16_enabled = bool(CpuInfo().bf16 or os.getenv("FORCE_BF16") == "1")
-        if bf16_enabled:
-            self.assertEqual(bf16_bn_num, 1)
-
-    @disable_random()
-    def test_bn_leakyrelu_conv_biasadd_relu(self):
-        logger.info("test_bn_leakyrelu_conv_biasadd_relu")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        normed_0 = (
-            tf.keras.layers.BatchNormalization()(x)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(x)
-        )
-        leaky_relu = tf.nn.leaky_relu(normed_0, alpha=0.3, name="op_to_store_0")
-        conv = tf.nn.conv2d(leaky_relu, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed_1 = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-        relu = tf.nn.relu(normed_1, name="op_to_store_1")
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-        from neural_compressor.tensorflow import Model, quantize_model
-        from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-        dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-        calib_dataloader = BaseDataLoader(dataset)
-        quant_config = {
-            "static_quant": {
-                "global": {
-                    "weight_dtype": "int8",
-                    "weight_sym": True,
-                    "weight_granularity": "per_tensor",
-                    "weight_algorithm": "minmax",
-                },
-            }
-        }
-        fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-        qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-        conv_input_type = True
-        found_fusion = True
-        qbn_num = 0
-        dq_num = 0
-        qbn_output_max_name = "batch_normalization/FusedBatchNormV3_eightbit_quantized_bn/frozen_bn_output_max"
-        for i in qmodel.graph_def.node:
-            if i.op == "_FusedQuantizedConv2D" and i.attr["Thost_inputs"].list.type != [11, 11, 1, 1, 1, 1, 1, 1, 1]:
-                conv_input_type = False
-                break
-            if i.op in ["Relu", "LeakyRelu", "FusedBatchNormV3"]:
-                found_fusion = False
-                break
-            if i.op == "_QuantizedFusedBatchNorm":
-                is_offset_const = i.attr["is_offset_const"].b
-                is_mean_const = i.attr["is_mean_const"].b
-                qbn_alpha = i.attr["alpha"].f
-                frozen_qbn_output_max = i.input[8]
-                qbn_num += 1
-            if i.name == qbn_output_max_name:
-                frozen_qbn_output_max_value = i.attr["value"].tensor.float_val[0]
-            if i.op == "Dequantize":
-                dq_num += 1
-
-        self.assertEqual(conv_input_type, True)
-        self.assertEqual(found_fusion, True)
-        self.assertEqual(qbn_num, 1)
-        self.assertEqual(dq_num, 0)
-        self.assertEqual(is_offset_const, True)
-        self.assertEqual(is_mean_const, True)
-        self.assertEqual(round(qbn_alpha, 7), 0.3)
-        self.assertEqual(frozen_qbn_output_max, qbn_output_max_name)
-        self.assertGreater(frozen_qbn_output_max_value, 126)
-
-    @disable_random()
-    def test_bn_relu_conv_biasadd_relu(self):
-        logger.info("test_bn_relu_conv_biasadd_relu")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        normed_0 = (
-            tf.keras.layers.BatchNormalization()(x)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(x)
-        )
-        relu_0 = tf.nn.relu(normed_0, name="op_to_store_0")
-        conv = tf.nn.conv2d(relu_0, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed_1 = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-        relu_1 = tf.nn.relu(normed_1, name="op_to_store_1")
-        out_name = relu_1.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-        from neural_compressor.tensorflow import Model, quantize_model
-        from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-        dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-        calib_dataloader = BaseDataLoader(dataset)
-        quant_config = {
-            "static_quant": {
-                "global": {
-                    "weight_dtype": "int8",
-                    "weight_sym": True,
-                    "weight_granularity": "per_tensor",
-                    "weight_algorithm": "minmax",
-                },
-            }
-        }
-        fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-        qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-        conv_input_type = True
-        found_fusion = True
-        qbn_num = 0
-        dq_num = 0
-        qbn_output_max_name = "batch_normalization/FusedBatchNormV3_eightbit_quantized_bn/frozen_bn_output_max"
-        for i in qmodel.graph_def.node:
-            if i.op == "_FusedQuantizedConv2D" and i.attr["Thost_inputs"].list.type != [11, 11, 1, 1, 1, 1, 1, 1, 1]:
-                conv_input_type = False
-                break
-            if i.op in ["Relu", "FusedBatchNormV3"]:
-                found_fusion = False
-                break
-            if i.op == "_QuantizedFusedBatchNorm":
-                is_offset_const = i.attr["is_offset_const"].b
-                is_mean_const = i.attr["is_mean_const"].b
-                frozen_qbn_output_max = i.input[8]
-                qbn_num += 1
-            if i.name == qbn_output_max_name:
-                frozen_qbn_output_max_value = i.attr["value"].tensor.float_val[0]
-            if i.op == "Dequantize":
-                dq_num += 1
-
-        self.assertEqual(conv_input_type, True)
-        self.assertEqual(found_fusion, True)
-        self.assertEqual(qbn_num, 1)
-        self.assertEqual(dq_num, 0)
-        self.assertEqual(is_offset_const, True)
-        self.assertEqual(is_mean_const, True)
-        self.assertEqual(frozen_qbn_output_max, qbn_output_max_name)
-        self.assertGreater(frozen_qbn_output_max_value, 126)
-
-
-class TestTensorflowQdqConvFusionNormal(unittest.TestCase):
-    @disable_random()
-    def test_bn_performance_only_false(self):
-        logger.info("test_bn_performance_only_false")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        normed_0 = (
-            tf.keras.layers.BatchNormalization()(x)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(x)
-        )
-        relu_0 = tf.nn.relu(normed_0, name="op_to_store_0")
-        conv = tf.nn.conv2d(relu_0, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed_1 = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-        relu_1 = tf.nn.relu6(normed_1, name="op_to_store_1")
-        out_name = relu_1.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-        from neural_compressor.tensorflow import quantize_model
-        from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-        dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-        calib_dataloader = BaseDataLoader(dataset)
-        quant_config = {
-            "static_quant": {
-                "global": {
-                    "weight_dtype": "int8",
-                    "weight_sym": True,
-                    "weight_granularity": "per_tensor",
-                    "weight_algorithm": "minmax",
-                },
-            }
-        }
-        qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-        found_fusion = True
-        qconv_num = 0
-        qbn_num = 0
-        dq_num = 0
-        for i in qmodel.graph_def.node:
-            if i.op in ["Relu6"]:
-                found_fusion = False
-                break
-            if i.op == "_FusedQuantizedConv2D":
-                qconv_num += 1
-            if i.op == "_QuantizedFusedBatchNorm":
-                qbn_num += 1
-            if i.op == "Dequantize":
-                dq_num += 1
-
-        self.assertEqual(found_fusion, True)
-        self.assertEqual(qconv_num, 1)
-        self.assertEqual(qbn_num, 0)
-        self.assertEqual(dq_num, 1)
-
-    @disable_random()
-    def test_bnex_performance_only_false(self):
-        logger.info("test_bnex_performance_only_false")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        conv_weights_0 = tf.compat.v1.get_variable(
-            "weight_0", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        normed_0 = (
-            tf.keras.layers.BatchNormalization()(x)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(x)
-        )
-        relu_0 = tf.nn.relu(normed_0, name="op_to_store_0")
-        conv_0 = tf.nn.conv2d(relu_0, conv_weights_0, strides=[1, 2, 2, 1], padding="VALID")
-        normed_1 = (
-            tf.keras.layers.BatchNormalization()(conv_0)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv_0)
-        )
-        conv_weights_1 = tf.compat.v1.get_variable(
-            "weight_1", [5, 5, 16, 2], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv_1 = tf.nn.conv2d(normed_1, conv_weights_1, strides=[1, 3, 3, 1], padding="VALID")
-        relu_1 = tf.nn.relu6(conv_1, name="op_to_store_1")
-        out_name = relu_1.name.split(":")[0]
-        """graph_def = tf.compat.v1.get_default_graph().as_graph_def()
-        for node in graph_def.node:
-
-        if node.name == "batch_normalization_1/FusedBatchNormV3":
-                node.op = "_FusedBatchNormEx"
-        with tf.Graph().as_default() as graph:
-            tf.import_graph_def(graph_def, name='')
-        """
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-        for node in fp32_graph_def.node:
-            if node.name == "batch_normalization_1/FusedBatchNormV3":
-                node.op = "_FusedBatchNormEx"
-                node.attr["activation_mode"].CopyFrom(attr_value_pb2.AttrValue(s=b"Relu"))
-
-        from neural_compressor.tensorflow import quantize_model
-        from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-        dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-        calib_dataloader = BaseDataLoader(dataset)
-        quant_config = {
-            "static_quant": {
-                "global": {
-                    "weight_dtype": "int8",
-                    "weight_sym": True,
-                    "weight_granularity": "per_tensor",
-                    "weight_algorithm": "minmax",
-                },
-            }
-        }
-        qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-        found_fusion = True
-        qconv_num = 0
-        qbn_num = 0
-        dq_num = 0
-        for i in qmodel.graph_def.node:
-            if i.op in ["Relu6", "_FusedBatchNormEx"]:
-                found_fusion = False
-                break
-            if i.op == "_FusedQuantizedConv2D":
-                qconv_num += 1
-            if i.op == "_QuantizedFusedBatchNorm":
-                qbn_num += 1
-            if i.op == "Dequantize":
-                dq_num += 1
-
-        self.assertEqual(found_fusion, True)
-        self.assertEqual(qconv_num, 2)
-        self.assertEqual(qbn_num, 0)
-        self.assertEqual(dq_num, 1)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_concat_fusion.py b/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_concat_fusion.py
deleted file mode 100644
index 5f089532759..00000000000
--- a/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_concat_fusion.py
+++ /dev/null
@@ -1,226 +0,0 @@
-#
-#
-#  -*- coding: utf-8 -*-
-import os
-import unittest
-
-import tensorflow as tf
-import yaml
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.tensorflow.quantization.utils.quantize_graph.quantize_graph_for_intel_cpu import (
-    QuantizeGraphForIntel,
-)
-from neural_compressor.tensorflow.quantization.utils.utility import read_graph
-from neural_compressor.tensorflow.utils import disable_random, version1_gte_version2
-
-
-class TestTensorflowQdqConcatFusion(unittest.TestCase):
-    mb_model_url = (
-        "https://storage.googleapis.com/intel-optimized-tensorflow/models/v1_8/inceptionv3_fp32_pretrained_model.pb"
-    )
-    pb_path = "/tmp/.neural_compressor/inceptionv3_fp32.pb"
-
-    @classmethod
-    def setUpClass(self):
-        if not os.path.exists(self.pb_path):
-            os.system("mkdir -p /tmp/.neural_compressor && wget {} -O {} ".format(self.mb_model_url, self.pb_path))
-
-    def test_tensorflow_concat_quantization(self):
-        fp32_graph_def = read_graph(self.pb_path)
-
-        from neural_compressor.tensorflow import Model, quantize_model
-        from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-        dataset = DummyDataset(shape=(100, 299, 299, 3), label=True)
-        calib_dataloader = BaseDataLoader(dataset)
-        quant_config = {
-            "static_quant": {
-                "global": {
-                    "weight_dtype": "int8",
-                    "weight_sym": True,
-                    "weight_granularity": "per_tensor",
-                    "weight_algorithm": "minmax",
-                },
-            }
-        }
-        fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-        qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-        found_quantized_concat_node = False
-        target_concat_node_name = "v0/cg/incept_v3_a0/concat_eightbit_quantized_concatv2"
-        from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-
-        cur_graph = GraphAnalyzer()
-        cur_graph.graph = qmodel.graph_def
-        graph_info = cur_graph.parse_graph()
-        found_quantized_concat_node = target_concat_node_name in graph_info
-
-        self.assertEqual(found_quantized_concat_node, True)
-        min_out, max_out = [], []
-        for input_conv_name in graph_info[target_concat_node_name].node.input[:4]:
-            min_freezed_out_name = graph_info[input_conv_name].node.input[-2]
-            max_freezed_out_name = graph_info[input_conv_name].node.input[-1]
-            min_freezed_out_value = (graph_info[min_freezed_out_name].node.attr["value"].tensor.float_val)[0]
-            max_freezed_out_value = (graph_info[max_freezed_out_name].node.attr["value"].tensor.float_val)[0]
-            min_out.append(min_freezed_out_value)
-            max_out.append(max_freezed_out_value)
-
-        self.assertEqual(len(set(min_out)), 1)
-        self.assertEqual(len(set(max_out)), 1)
-
-    @disable_random()
-    def test_concat_with_different_input_type(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 128, 16], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [2, 2, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv_bias = tf.compat.v1.get_variable("bias", [16], initializer=tf.compat.v1.random_normal_initializer())
-        x = tf.nn.relu(x)
-        sqrt = tf.math.sqrt(x)
-        relu_sqrt = tf.nn.relu(sqrt)
-        conv = tf.nn.conv2d(relu_sqrt, conv_weights, strides=[1, 2, 2, 1], padding="SAME", name="last")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        relu = tf.nn.relu(normed)
-        conv1 = tf.nn.conv2d(x, conv_weights, strides=[1, 2, 2, 1], padding="SAME", name="last")
-        conv_bias = tf.nn.bias_add(conv1, conv_bias)
-        concat = tf.concat([relu, conv_bias], 1)
-        pool = tf.nn.avg_pool(concat, ksize=1, strides=[1, 2, 2, 1], name="avgpool", padding="SAME")
-        final_node = tf.nn.relu(pool, name="op_to_store")
-        out_name = final_node.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 128, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            quantized_concat = False
-            for i in qmodel.graph_def.node:
-                if i.op == "QuantizedConcatV2":
-                    quantized_concat = True
-            self.assertEqual(quantized_concat, False)
-
-    @disable_random()
-    def test_concat_with_same_input_type(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 128, 16], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [2, 2, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv_bias = tf.compat.v1.get_variable("bias", [16], initializer=tf.compat.v1.random_normal_initializer())
-        conv1_bias = tf.compat.v1.get_variable("bias1", [16], initializer=tf.compat.v1.random_normal_initializer())
-        x = tf.nn.relu(x)
-        sqrt = tf.math.sqrt(x)
-        relu_sqrt = tf.nn.relu(sqrt)
-        conv = tf.nn.conv2d(relu_sqrt, conv_weights, strides=[1, 2, 2, 1], padding="SAME", name="last")
-        conv_bias = tf.nn.bias_add(conv, conv_bias)
-        relu1 = tf.nn.relu(conv_bias)
-
-        conv1 = tf.nn.conv2d(x, conv_weights, strides=[1, 2, 2, 1], padding="SAME", name="last")
-        conv1_bias = tf.nn.bias_add(conv1, conv1_bias)
-        relu2 = tf.nn.relu(conv1_bias)
-        concat = tf.concat([relu1, relu2], 1)
-        pool = tf.nn.avg_pool(concat, ksize=1, strides=[1, 2, 2, 1], name="avgpool", padding="SAME")
-        final_node = tf.nn.relu(pool, name="op_to_store")
-        out_name = final_node.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 128, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            quantized_concat = False
-            for i in qmodel.graph_def.node:
-                if i.op == "QuantizedConcatV2":
-                    quantized_concat = True
-
-            self.assertEqual(quantized_concat, True)
-
-    @disable_random()
-    def test_concat_with_qint8_and_fp32_input_type(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 128, 16], name="input")
-        bias = tf.compat.v1.get_variable("bias", [16], initializer=tf.compat.v1.random_normal_initializer())
-
-        bias_add = tf.nn.bias_add(x, bias)
-
-        pool = tf.nn.avg_pool(x, ksize=1, strides=[1, 1, 1, 1], name="avgpool", padding="SAME")
-        concat = tf.concat([bias_add, pool], 1)
-        final_node = tf.nn.relu(concat, name="op_to_store")
-        out_name = final_node.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import Model, quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 128, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-            qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-            dtype = None
-            quantized_concat = False
-            from tensorflow.python.framework import dtypes
-
-            for i in qmodel.graph_def.node:
-                if i.op == "QuantizedConcatV2":
-                    dtype = dtypes.DType(i.attr["T"].type)
-                    quantized_concat = True
-
-            self.assertEqual(quantized_concat, True)
-            self.assertEqual(dtype, dtypes.qint8)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_conv3d_fusion.py b/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_conv3d_fusion.py
deleted file mode 100644
index 40bb75e0fdb..00000000000
--- a/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_conv3d_fusion.py
+++ /dev/null
@@ -1,1000 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import logging
-import os
-import unittest
-
-import numpy as np
-import tensorflow as tf
-import yaml
-from pkg_resources import parse_version
-from tensorflow.compat.v1 import graph_util
-from tensorflow.python.framework import function
-
-from neural_compressor.tensorflow.algorithms.static_quant.tensorflow import TensorflowQuery
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.fold_batch_norm import (
-    FoldBatchNormNodesOptimizer,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.strip_unused_nodes import (
-    StripUnusedNodesOptimizer,
-)
-from neural_compressor.tensorflow.quantization.utils.quantize_graph.quantize_graph_for_intel_cpu import (
-    QuantizeGraphForIntel,
-)
-from neural_compressor.tensorflow.utils import disable_random
-
-
-class TestTensorflowQdqConvFusion(unittest.TestCase):
-    @disable_random()
-    def test_conv3d_addv2_relu_fusion(self):
-        logging.getLogger().info("test_conv3d_addv2_relu_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight_conv3d_1", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add = tf.raw_ops.AddV2(x=conv3d_1, y=tf.constant(np.random.randn(32), dtype=tf.float32), name="addv2")
-        relu = tf.nn.relu(add)
-        conv3d_2_weights = tf.compat.v1.get_variable(
-            "weight_conv3d_2", [3, 3, 3, 32, 1], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_2 = tf.nn.conv3d(relu, conv3d_2_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-
-        out_name = conv3d_2.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_sumadd_fusion = False
-            found_conv_biasadd_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    if b"Sum" in i.attr["fused_ops"].list.s:
-                        found_conv_sumadd_fusion = True
-                    if i.attr["fused_ops"].list.s == [b"BiasAdd", b"Relu", b"Requantize"]:
-                        found_conv_biasadd_fusion = True
-
-            self.assertEqual(found_conv_sumadd_fusion, False)
-            self.assertEqual(found_conv_biasadd_fusion, True)
-
-    @disable_random()
-    def test_single_conv3d_fusion(self):
-        logging.getLogger().info("test_single_conv3d_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 64, 64, 64, 1], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [4, 4, 4, 1, 64], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv3d(x_pad, conv_weights, strides=[1, 2, 2, 2, 1], padding="VALID")
-        mul = tf.multiply(conv, 2.0, name="op_to_store")
-        out_name = mul.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import Model, quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 64, 64, 64, 1), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-            qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            found_dequantize_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    found_conv_fusion = True
-                if str(i.attr["fused_ops"].list.s) == str([b"Dequantize"]):
-                    found_dequantize_fusion = True
-
-            self.assertEqual(found_conv_fusion, True)
-            self.assertEqual(found_dequantize_fusion, True)
-
-    @disable_random()
-    def test_conv3d_biasadd_fusion(self):
-        logging.getLogger().info("test_conv3d_biasadd_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 64, 64, 64, 1], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [4, 4, 4, 1, 64], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv3d(x_pad, conv_weights, strides=[1, 2, 2, 2, 1], padding="VALID")
-        y_const = tf.constant(np.random.randn(1, 1, 1, 1, 64), dtype=tf.float32)
-        add = tf.raw_ops.AddV2(x=conv, y=y_const, name="addv2")
-        out_name = add.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import Model, quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 64, 64, 64, 1), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-            qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            found_dequantize_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    found_conv_fusion = True
-                if str(i.attr["fused_ops"].list.s) == str([b"BiasAdd", b"Dequantize"]):
-                    found_dequantize_fusion = True
-
-            self.assertEqual(found_conv_fusion, True)
-            self.assertEqual(found_dequantize_fusion, True)
-
-    def test_conv3d_relu6_fusion(self):
-        logging.getLogger().info("test_conv3d_biasadd_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 64, 64, 64, 1], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [4, 4, 4, 1, 64], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv3d(x_pad, conv_weights, strides=[1, 2, 2, 2, 1], padding="VALID")
-        relu6 = tf.nn.relu6(conv, name="op_to_store")
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import Model, quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 64, 64, 64, 1), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-            qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            found_requantize_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    found_conv_fusion = True
-                if str(i.attr["fused_ops"].list.s) == str([b"BiasAdd", b"Relu", b"Dequantize"]):
-                    found_requantize_fusion = True
-
-            self.assertEqual(found_conv_fusion, True)
-            self.assertEqual(found_requantize_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_relu_fusion(self):
-        logging.getLogger().info("test_conv3d_add_relu_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 64, 64, 64, 1], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight1", [4, 4, 4, 1, 64], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv1_weights = tf.compat.v1.get_variable(
-            "weight2", [4, 4, 4, 1, 64], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv3d(x, conv_weights, strides=[1, 2, 2, 2, 1], padding="VALID")
-        conv1 = tf.nn.conv3d(x, conv1_weights, strides=[1, 2, 2, 2, 1], padding="VALID")
-        add = conv + conv1
-        relu = tf.nn.relu(add)
-
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 64, 64, 64, 1), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_const_fusion(self):
-        logging.getLogger().info("test_conv3d_add_const_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 64, 64, 64, 1], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [4, 4, 4, 1, 64], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv3d(x, conv_weights, strides=[1, 2, 2, 2, 1], padding="VALID")
-        add = conv + tf.constant(
-            [
-                [
-                    [
-                        [
-                            [
-                                0.000015179151887423359,
-                                0.000022200847524800338,
-                                -0.000009995766049541999,
-                                -0.0000022956028260523453,
-                                0.000008830029400996864,
-                                0.0000017190360495078494,
-                                0.000019561824956326745,
-                                0.00014721050683874637,
-                                -0.000005871841494808905,
-                                0.000004377178811409976,
-                                -0.000006191140982991783,
-                                0.000009258330464945175,
-                                -0.000009839599442784674,
-                                0.000008547322067897767,
-                                0.000004629391241905978,
-                                2.345327061448188e-7,
-                                0.000015179151887423359,
-                                0.000022200847524800338,
-                                -0.000009995766049541999,
-                                -0.0000022956028260523453,
-                                0.000008830029400996864,
-                                0.0000017190360495078494,
-                                0.000019561824956326745,
-                                0.00014721050683874637,
-                                -0.000005871841494808905,
-                                0.000004377178811409976,
-                                -0.000006191140982991783,
-                                0.000009258330464945175,
-                                -0.000009839599442784674,
-                                0.000008547322067897767,
-                                0.000004629391241905978,
-                                2.345327061448188e-7,
-                                0.000015179151887423359,
-                                0.000022200847524800338,
-                                -0.000009995766049541999,
-                                -0.0000022956028260523453,
-                                0.000008830029400996864,
-                                0.0000017190360495078494,
-                                0.000019561824956326745,
-                                0.00014721050683874637,
-                                -0.000005871841494808905,
-                                0.000004377178811409976,
-                                -0.000006191140982991783,
-                                0.000009258330464945175,
-                                -0.000009839599442784674,
-                                0.000008547322067897767,
-                                0.000004629391241905978,
-                                2.345327061448188e-7,
-                                0.000015179151887423359,
-                                0.000022200847524800338,
-                                -0.000009995766049541999,
-                                -0.0000022956028260523453,
-                                0.000008830029400996864,
-                                0.0000017190360495078494,
-                                0.000019561824956326745,
-                                0.00014721050683874637,
-                                -0.000005871841494808905,
-                                0.000004377178811409976,
-                                -0.000006191140982991783,
-                                0.000009258330464945175,
-                                -0.000009839599442784674,
-                                0.000008547322067897767,
-                                0.000004629391241905978,
-                                2.345327061448188e-7,
-                            ]
-                        ]
-                    ]
-                ]
-            ]
-        )
-
-        out_name = add.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 64, 64, 64, 1), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = True
-            for i in qmodel.graph_def.node:
-                if i.op == "AddV2":
-                    found_conv_fusion = False
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_addn_const_relu_fusion(self):
-        logging.getLogger().info("test_conv3d_add_addn_const_relu_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add_1 = tf.raw_ops.AddV2(x=conv3d_1, y=tf.constant(np.random.randn(32), dtype=tf.float32), name="addv2_1")
-        var = tf.compat.v1.get_variable(
-            "add_y", [1, 64, 32, 32, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        add_2 = tf.raw_ops.AddV2(x=add_1, y=var, name="addv2_2")
-        relu = tf.nn.relu(add_2)
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_sumadd_fusion = False
-            found_conv_biasadd_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    if str(b"Sum") in str(i.attr["fused_ops"].list.s):
-                        found_conv_sumadd_fusion = True
-                    if str(i.attr["fused_ops"].list.s) == str([b"BiasAdd", b"Sum", b"Relu"]):
-                        found_conv_biasadd_fusion = True
-
-            self.assertEqual(found_conv_sumadd_fusion, False)
-            self.assertEqual(found_conv_biasadd_fusion, False)
-
-    @disable_random()
-    def test_conv3d_add_const_addn_relu_fusion(self):
-        logging.getLogger().info("test_conv3d_add_const_addn_relu_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight1", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add_1 = tf.raw_ops.AddV2(x=conv3d_1, y=tf.constant(np.random.randn(32), dtype=tf.float32), name="addv2_1")
-        conv3d_2_weights = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_2 = tf.nn.conv3d(top_relu, conv3d_2_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add = tf.raw_ops.AddV2(x=add_1, y=conv3d_2, name="addv2_2")
-        relu = tf.nn.relu(add)
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_sumadd_fusion = False
-            found_conv_biasadd_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    if str(b"Sum") in str(i.attr["fused_ops"].list.s):
-                        found_conv_sumadd_fusion = True
-                    if str(i.attr["fused_ops"].list.s) == str([b"BiasAdd", b"Sum", b"Relu"]):
-                        found_conv_biasadd_fusion = True
-
-            self.assertEqual(found_conv_sumadd_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_addn_fusion(self):
-        logging.getLogger().info("test_conv3d_add_addn_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight1", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add_1 = tf.raw_ops.AddV2(x=conv3d_1, y=tf.constant(np.random.randn(32), dtype=tf.float32), name="addv2_4")
-        conv3d_2_weights = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_2 = tf.nn.conv3d(top_relu, conv3d_2_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add = tf.raw_ops.AddV2(x=add_1, y=conv3d_2, name="addv2")
-        out_name = add.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D" and i.attr["fused_ops"].list.s == [
-                    b"BiasAdd",
-                    b"Sum",
-                    b"Requantize",
-                ]:
-                    found_conv_fusion = True
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_addn_relu_fusion(self):
-        logging.getLogger().info("test_conv3d_add_addn_relu_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight1", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_2_weights = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        conv3d_2 = tf.nn.conv3d(top_relu, conv3d_2_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add_1 = tf.raw_ops.AddV2(x=conv3d_1, y=conv3d_2, name="addv2_1")
-        conv3d_3_weights = tf.compat.v1.get_variable(
-            "weight3", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_2 = tf.nn.conv3d(top_relu, conv3d_3_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add = tf.raw_ops.AddV2(x=add_1, y=conv3d_2, name="addv2_2")
-        relu = tf.nn.relu(add)
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_relu_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D" and i.attr["fused_ops"].list.s == [
-                    b"BiasAdd",
-                    b"Sum",
-                    b"Relu",
-                    b"Requantize",
-                ]:
-                    found_relu_fusion = True
-
-            self.assertEqual(found_relu_fusion, True)
-
-    @disable_random()
-    def test_conv3d_leakyrelu_fusion(self):
-        logging.getLogger().info("test_conv3d_relu_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 64, 64, 64, 1], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [4, 4, 4, 1, 64], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv3d(x_pad, conv_weights, strides=[1, 2, 2, 2, 1], padding="VALID")
-        relu = tf.nn.leaky_relu(conv)
-
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import Model, quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 64, 64, 64, 1), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-            qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D" and i.attr["fused_ops"].list.s == [
-                    b"BiasAdd",
-                    b"LeakyRelu",
-                    b"Dequantize",
-                ]:
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_fusion(self):
-        logging.getLogger().info("test_conv3d_add_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight1", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        conv3d_2_weights = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_2 = tf.nn.conv3d(top_relu, conv3d_2_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add = tf.raw_ops.AddV2(x=conv3d_1, y=conv3d_2, name="addv2")
-        out_name = add.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D" and i.attr["fused_ops"].list.s == [
-                    b"BiasAdd",
-                    b"Sum",
-                    b"Requantize",
-                ]:
-                    found_conv_fusion = True
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_const_addn_relu_requantize_fusion(self):
-        logging.getLogger().info("test_conv3d_add_const_addn_relu_requantize_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight1", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        y_const = tf.constant(np.random.randn(1, 1, 1, 1, 32), dtype=tf.float32)
-        add_1 = tf.raw_ops.AddV2(x=conv3d_1, y=y_const, name="addv2_1")
-        conv3d_2_weights = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_2 = tf.nn.conv3d(top_relu, conv3d_2_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add_2 = tf.raw_ops.AddV2(x=add_1, y=conv3d_2, name="addv2_2")
-        relu = tf.nn.relu(add_2)
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_sumadd_fusion = False
-            found_conv_biasadd_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    if str(b"Sum") in str(i.attr["fused_ops"].list.s):
-                        found_conv_sumadd_fusion = True
-                    if str(i.attr["fused_ops"].list.s) == str([b"BiasAdd", b"Sum", b"Relu", b"Requantize"]):
-                        found_conv_biasadd_fusion = True
-
-            self.assertEqual(found_conv_sumadd_fusion, True)
-            self.assertEqual(found_conv_biasadd_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_const_addn_fusion(self):
-        logging.getLogger().info("test_conv3d_add_const_addn_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight1", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        y_const = tf.constant(np.random.randn(1, 1, 1, 1, 32), dtype=tf.float32)
-        add_1 = tf.raw_ops.AddV2(x=conv3d_1, y=y_const, name="addv2_1")
-        conv3d_2_weights = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_2 = tf.nn.conv3d(top_relu, conv3d_2_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add_2 = tf.raw_ops.AddV2(x=add_1, y=conv3d_2, name="addv2_2")
-        out_name = add_2.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    found_conv_fusion = True
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_no_relu_fusion(self):
-        logging.getLogger().info("test_conv3d_add_no_relu_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        y_const = tf.constant(np.random.randn(1, 1, 1, 1, 32), dtype=tf.float32)
-        add = tf.raw_ops.AddV2(x=conv3d_1, y=y_const, name="addv2")
-        pooling = tf.nn.max_pool(add, ksize=1, strides=[1, 2, 2, 2, 1], padding="SAME")
-        out_name = pooling.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_const_relu_fusion(self):
-        logging.getLogger().info("test_conv3d_add_const_relu_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        y_const = tf.constant(np.random.randn(1, 1, 1, 1, 32), dtype=tf.float32)
-        add = tf.raw_ops.AddV2(x=conv3d_1, y=y_const, name="addv2")
-        relu = tf.nn.relu(add)
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_const_leakyrelu_add_fusion(self):
-        logging.getLogger().info("test_conv3d_add_const_leakyrelu_add_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight1", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        y_const = tf.constant(np.random.randn(1, 1, 1, 1, 32), dtype=tf.float32)
-        add_1 = tf.raw_ops.AddV2(x=conv3d_1, y=y_const, name="addv2_1")
-        relu = tf.nn.leaky_relu(add_1)
-        conv3d_2_weights = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_2 = tf.nn.conv3d(top_relu, conv3d_2_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add_2 = tf.raw_ops.AddV2(x=relu, y=conv3d_2, name="addv2_2")
-        out_name = add_2.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D":
-                    found_conv_fusion = True
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv3d_add_addn_non_const_fusion(self):
-        logging.getLogger().info("test_conv3d_add_addn_non_const_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv3d_1_weights = tf.compat.v1.get_variable(
-            "weight1", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        conv3d_2_weights = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_2 = tf.nn.conv3d(top_relu, conv3d_2_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add_1 = tf.raw_ops.AddV2(x=conv3d_1, y=conv3d_2, name="addv2_1")
-        conv3d_3_weights = tf.compat.v1.get_variable(
-            "weight3", [3, 3, 3, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv3d_3 = tf.nn.conv3d(top_relu, conv3d_3_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add = tf.raw_ops.AddV2(x=add_1, y=conv3d_3, name="addv2_2")
-        out_name = add.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 128, 64, 64, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv3D" and str(i.attr["fused_ops"].list.s) == str(
-                    [b"BiasAdd", b"Sum", b"Requantize"]
-                ):
-                    found_conv_fusion = True
-
-            self.assertEqual(found_conv_fusion, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_conv_fusion.py b/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_conv_fusion.py
deleted file mode 100644
index 895ee8471fe..00000000000
--- a/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_conv_fusion.py
+++ /dev/null
@@ -1,1158 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import logging
-import os
-import unittest
-
-import numpy as np
-import tensorflow as tf
-import yaml
-from tensorflow.compat.v1 import graph_util
-from tensorflow.python.framework import function
-
-from neural_compressor.tensorflow.utils import disable_random, version1_gte_version2
-
-
-class TestTensorflowQdqConvFusion(unittest.TestCase):
-    @disable_random()
-    def test_fold_pad_conv(self):
-        logging.getLogger().info("test_fold_pad_conv")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-        relu = tf.nn.relu(normed, name="op_to_store")
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_pad = False
-            for i in qmodel.graph_def.node:
-                if i.op == "Pad":
-                    found_pad = True
-                    break
-
-            self.assertEqual(found_pad, False)
-
-    @disable_random()
-    def test_conv_relu_fusion(self):
-        logging.getLogger().info("test_conv_relu_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(top_relu, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        relu = tf.nn.relu(conv)
-
-        relu6 = tf.nn.relu6(relu, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = True
-            for i in qmodel.graph_def.node:
-                if i.op == "Relu":
-                    found_conv_fusion = False
-                    break
-
-            self.assertEqual(found_conv_fusion, False)
-
-    @disable_random()
-    def test_conv_biasadd_relu6_fusion(self):
-        logging.getLogger().info("test_conv_biasadd_relu6_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        relu6 = tf.nn.relu6(normed, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = True
-            for i in qmodel.graph_def.node:
-                if i.op == "Relu6":
-                    found_conv_fusion = False
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv_biasadd_swishf32_fusion(self):
-        logging.getLogger().info("test_conv_biasadd_swishf32_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        @function.Defun(tf.float32, func_name="swish_f32")
-        def swish_f32(x):
-            return tf.nn.silu(x, beta=1.0)
-
-        swish = swish_f32(normed, name="swish_f32_output_node")
-
-        out_name = swish.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = True
-            for i in qmodel.graph_def.node:
-                if i.op == "swish_f32":
-                    found_conv_fusion = False
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv_addv2_fusion(self):
-        logging.getLogger().info("test_conv_addv2_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        conv1_weights = tf.compat.v1.get_variable(
-            "weight_conv1", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv1 = tf.nn.conv2d(x, conv1_weights, strides=[1, 2, 2, 1], padding="SAME")
-        conv2_weights = tf.compat.v1.get_variable(
-            "weight_conv2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(x, conv2_weights, strides=[1, 2, 2, 1], padding="SAME")
-        sumadd = tf.raw_ops.AddV2(x=conv1, y=conv2, name="addv2")
-
-        out_name = sumadd.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op.find("QuantizedConv2D") != -1:
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv_biasadd_add_relu_fusion(self):
-        logging.getLogger().info("test_conv_biasadd_add_relu_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        conv_weights2 = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(top_relu, conv_weights2, strides=[1, 2, 2, 1], padding="SAME")
-        normed2 = tf.nn.bias_add(conv2, tf.constant([3.0, 1.2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 12, 2, 3, 4]))
-        relu = tf.nn.relu(normed2 + tf.constant([3.0]))
-        relu6 = tf.nn.relu6(relu, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op.find("QuantizedConv2D") != -1:
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv_biasadd_addv2_relu_fallback_fusion_1(self):
-        logging.getLogger().info("test_conv_biasadd_addv2_relu_fallback_fusion_1")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.leaky_relu(x)
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-        # relu = tf.nn.relu(normed)
-
-        conv_weights2 = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(top_relu, conv_weights2, strides=[1, 2, 2, 1], padding="SAME")
-        normed2 = (
-            tf.keras.layers.BatchNormalization()(conv2)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv2)
-        )
-        # relu2 = tf.nn.relu(normed2)
-        add = tf.raw_ops.AddV2(x=normed, y=normed2, name="addv2")
-        relu = tf.nn.relu(add)
-        relu6 = tf.nn.relu6(relu, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv2D" and i.attr["fused_ops"].list.s == [
-                    b"BiasAdd",
-                    b"Sum",
-                    b"Relu",
-                    b"Requantize",
-                ]:
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv_fusion_with_last_conv(self):
-        logging.getLogger().info("test_conv_fusion_with_last_conv")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(top_relu, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        relu = tf.nn.relu(normed)
-        pooling = tf.nn.max_pool(relu, ksize=1, strides=[1, 2, 2, 1], padding="SAME")
-        conv_weights_2 = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(pooling, conv_weights_2, strides=[1, 2, 2, 1], padding="VALID")
-        conv_weights_3 = tf.compat.v1.get_variable(
-            "weight3", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        relu2 = tf.nn.relu(conv2)
-        conv3 = tf.nn.conv2d(relu2, conv_weights_3, strides=[1, 2, 2, 1], padding="VALID")
-
-        relu3 = tf.nn.relu(conv3)
-        relu6 = tf.nn.relu6(relu3, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import Model, quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-            qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-            quantize_v2_count = 0
-            for i in qmodel.graph_def.node:
-                if i.op == "QuantizeV2":
-                    quantize_v2_count += 1
-                    break
-
-            self.assertEqual(quantize_v2_count, 1)
-
-    @disable_random()
-    def test_conv_fusion_with_max_pooling(self):
-        logging.getLogger().info("test_conv_fusion_with_max_pooling")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-
-        relu = tf.nn.relu(x)
-        pooling = tf.nn.max_pool(relu, ksize=1, strides=[1, 2, 2, 1], padding="SAME")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(pooling, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        biasadd = (
-            tf.keras.layers.BatchNormalization(name="op_to_store")(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv, name="op_to_store")
-        )
-        out_name = biasadd.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            quantized_pool_data_type = None
-            quantized_conv_data_type = None
-            for i in qmodel.graph_def.node:
-                if i.op.find("QuantizedMaxPool") != -1:
-                    quantized_pool_data_type = i.attr["T"].type
-                if i.op.find("QuantizedConv2D") != -1:
-                    quantized_conv_data_type = i.attr["Tinput"].type
-
-            self.assertNotEqual(quantized_pool_data_type, None)
-            self.assertEqual(quantized_pool_data_type, quantized_conv_data_type)
-
-    @disable_random()
-    def test_conv_biasadd_fusion(self):
-        logging.getLogger().info("test_conv_biasadd_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(top_relu, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization(name="op_to_store")(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv, name="op_to_store")
-        )
-
-        out_name = normed.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = True
-            for i in qmodel.graph_def.node:
-                if i.op == "batch_normalization/FusedBatchNormV3":
-                    found_conv_fusion = False
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_depthwiseconv_biasadd_fusion(self):
-        logging.getLogger().info("test_depthwiseconv_biasadd_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.depthwise_conv2d(top_relu, conv_weights, strides=[1, 1, 1, 1], padding="VALID")
-
-        normed = (
-            tf.keras.layers.BatchNormalization(name="op_to_store")(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv, name="op_to_store")
-        )
-
-        out_name = normed.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = True
-            for i in qmodel.graph_def.node:
-                if i.op == "batch_normalization/FusedBatchNormV3":
-                    found_conv_fusion = False
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv_biasadd_relu_fusion(self):
-        logging.getLogger().info("test_conv_biasadd_relu_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        relu = tf.nn.relu(normed, name="op_to_store")
-
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = True
-            for i in qmodel.graph_def.node:
-                if i.op == "Relu":
-                    found_conv_fusion = False
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv_biasadd_leakyrelu_fusion(self):
-        logging.getLogger().info("test_conv_biasadd_leakyrelu_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        leaky_relu = tf.nn.leaky_relu(normed, name="op_to_store")
-
-        out_name = leaky_relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = True
-            for i in qmodel.graph_def.node:
-                if i.op == "Leaky_Relu":
-                    found_conv_fusion = False
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_depthwiseconv_biasadd_relu6_fusion(self):
-        logging.getLogger().info("test_depthwiseconv_biasadd_relu6_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.compat.v1.nn.depthwise_conv2d_native(x, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        relu6 = tf.nn.relu6(normed, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = True
-            for i in qmodel.graph_def.node:
-                if i.op == "Relu6":
-                    found_conv_fusion = False
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_depthwiseconv_biasadd_relu_fusion(self):
-        logging.getLogger().info("test_depthwiseconv_biasadd_relu_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.compat.v1.nn.depthwise_conv2d_native(x, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        relu6 = tf.nn.relu6(normed, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = True
-            for i in qmodel.graph_def.node:
-                if i.op == "Relu":
-                    found_conv_fusion = False
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv_single_fusion(self):
-        logging.getLogger().info("test_conv_single_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(top_relu, paddings, "CONSTANT")
-        conv1_weights = tf.compat.v1.get_variable(
-            "weight_conv1", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv1 = tf.nn.conv2d(x_pad, conv1_weights, strides=[1, 2, 2, 1], padding="VALID")
-        matmul_weights = tf.compat.v1.get_variable(
-            "weight_matmul", [1, 28, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        matmul = tf.matmul(conv1, matmul_weights)
-        conv2_weights = tf.compat.v1.get_variable(
-            "weight_conv2", [7, 7, 32, 1], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(matmul, conv2_weights, strides=[1, 2, 2, 1], padding="VALID")
-        leaky_relu = tf.nn.leaky_relu(conv2, name="op_to_store")
-
-        out_name = leaky_relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import Model, quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-            qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-            find_single_qconv = []
-            for i in qmodel.graph_def.node:
-                # BatchMatMul Quantization disabled
-                if i.op == "_FusedQuantizedConv2D":
-                    find_single_qconv.append(i.attr["fused_ops"].list.s == [b"Requantize"])
-
-            self.assertEqual(find_single_qconv, [False, False])
-
-    @disable_random()
-    def test_conv_fusion_with_last_matmul(self):
-        logging.getLogger().info("test_conv_fusion_with_last_matmul")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        # paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        # x_pad = tf.pad(top_relu, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(top_relu, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        relu = tf.nn.relu(normed)
-        pooling = tf.nn.max_pool(relu, ksize=1, strides=[1, 2, 2, 1], padding="SAME")
-        reshape = tf.reshape(pooling, [-1, 3136])
-
-        y_data = np.random.random([3136, 1])
-
-        y = tf.constant(y_data, dtype=tf.float32, shape=[3136, 1])
-        z = tf.raw_ops.MatMul(a=reshape, b=y, name="matmul_1")
-        relu1 = tf.nn.relu(z)
-        y_data_1 = np.random.random([1, 1])
-        y_1 = tf.constant(y_data_1, dtype=tf.float32, shape=[1, 1])
-
-        z_2nd_matmul = tf.raw_ops.MatMul(a=relu1, b=y_1, name="matmul_2")
-        relu6 = tf.nn.relu6(z_2nd_matmul, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            quantize_v2_count = 0
-            for i in qmodel.graph_def.node:
-                if i.op == "QuantizeV2":
-                    quantize_v2_count += 1
-                    break
-
-            self.assertEqual(quantize_v2_count, 1)
-
-    @disable_random()
-    def test_conv2d_add_const_leakyrelu_add_fusion(self):
-        logging.getLogger().info("test_conv2d_add_const_leakyrelu_add_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv2d_1_weights = tf.compat.v1.get_variable(
-            "weight1", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2d_1 = tf.nn.conv2d(top_relu, conv2d_1_weights, strides=[1, 2, 2, 1], padding="SAME")
-        y_const = tf.constant(np.random.randn(16), dtype=tf.float32)
-        add_1 = tf.raw_ops.AddV2(x=conv2d_1, y=y_const, name="addv2_1")
-        relu = tf.nn.leaky_relu(add_1)
-        conv2d_2_weights = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2d_2 = tf.nn.conv2d(top_relu, conv2d_2_weights, strides=[1, 2, 2, 1], padding="SAME")
-        add_2 = tf.raw_ops.AddV2(x=relu, y=conv2d_2, name="addv2_2")
-        out_name = add_2.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv2D":
-                    found_conv_fusion = True
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_depthwiseconv_biasadd_leakyrelu_fusion(self):
-        logging.getLogger().info("test_depthwiseconv_biasadd_leakyrelu_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.compat.v1.nn.depthwise_conv2d_native(x, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        leaky_relu = tf.nn.leaky_relu(normed, name="op_to_store")
-
-        out_name = leaky_relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = True
-            for i in qmodel.graph_def.node:
-                if i.op == "Relu":
-                    found_conv_fusion = False
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv_biasadd_addv2_relu_fallback_fusion_2(self):
-        logging.getLogger().info("test_conv_biasadd_addv2_relu_fallback_fusion_2")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(top_relu, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-        # relu = tf.nn.relu(normed)
-
-        conv_weights2 = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(top_relu, conv_weights2, strides=[1, 2, 2, 1], padding="SAME")
-        normed2 = (
-            tf.keras.layers.BatchNormalization()(conv2)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv2)
-        )
-        # relu2 = tf.nn.relu(normed2)
-        add = tf.raw_ops.AddV2(x=normed, y=normed2, name="addv2")
-        relu = tf.nn.relu(add)
-        relu6 = tf.nn.relu6(relu, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedConv2D" and i.attr["fused_ops"].list.s == [b"BiasAdd", b"Requantize"]:
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    # fuse conv + biasadd + elu
-    @disable_random()
-    def test_conv_biasadd_elu_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        elu = tf.nn.elu(normed, name="op_to_store")
-
-        out_name = elu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = True
-            for i in qmodel.graph_def.node:
-                if i.op == "Elu":
-                    found_conv_fusion = False
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    # fuse conv + biasadd + sigmoid
-    @disable_random()
-    def test_conv_biasadd_sigmoid_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        sigmoid = tf.math.sigmoid(normed, name="op_to_store")
-
-        out_name = sigmoid.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = True
-            for i in qmodel.graph_def.node:
-                if i.op == "Sigmoid":
-                    found_conv_fusion = False
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_depthwiseconv_fusion.py b/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_depthwiseconv_fusion.py
deleted file mode 100644
index 99b71cf1d56..00000000000
--- a/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_depthwiseconv_fusion.py
+++ /dev/null
@@ -1,309 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import os
-import unittest
-
-import numpy as np
-import tensorflow as tf
-import yaml
-from tensorflow.compat.v1 import graph_util
-from tensorflow.core.framework import attr_value_pb2, graph_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.utils import disable_random, version1_gte_version2
-
-
-def build_conv2d_biasadd_add_relu6_mul_mul():
-    input_node = node_def_pb2.NodeDef()
-    input_node.name = "input"
-    input_node.op = "Placeholder"
-    input_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-
-    conv1_weight_node = node_def_pb2.NodeDef()
-    conv1_weight_node.name = "conv1_weights"
-    conv1_weight_node.op = "Const"
-    conv1_weight_value = np.float32(np.abs(np.random.randn(3, 3, 3, 32)))
-    conv1_weight_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    conv1_weight_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(
-                conv1_weight_value, conv1_weight_value.dtype.type, conv1_weight_value.shape
-            )
-        )
-    )
-
-    conv1_node = node_def_pb2.NodeDef()
-    conv1_node.name = "conv1"
-    conv1_node.op = "Conv2D"
-    conv1_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    conv1_node.input.extend([input_node.name, conv1_weight_node.name])
-    conv1_node.attr["strides"].CopyFrom(
-        attr_value_pb2.AttrValue(list=attr_value_pb2.AttrValue.ListValue(i=[1, 1, 1, 1]))
-    )
-    conv1_node.attr["dilations"].CopyFrom(
-        attr_value_pb2.AttrValue(list=attr_value_pb2.AttrValue.ListValue(i=[1, 1, 1, 1]))
-    )
-    conv1_node.attr["padding"].CopyFrom(attr_value_pb2.AttrValue(s=b"SAME"))
-    conv1_node.attr["data_format"].CopyFrom(attr_value_pb2.AttrValue(s=b"NHWC"))
-
-    bias_node = node_def_pb2.NodeDef()
-    bias_node.name = "conv1_bias"
-    bias_node.op = "Const"
-    bias_value = np.float32(np.abs(np.random.randn(32)))
-    bias_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    bias_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(bias_value, bias_value.dtype.type, bias_value.shape)
-        )
-    )
-
-    bias_add_node = node_def_pb2.NodeDef()
-    bias_add_node.name = "conv1_bias_add"
-    bias_add_node.op = "BiasAdd"
-    bias_add_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    bias_add_node.attr["data_format"].CopyFrom(attr_value_pb2.AttrValue(s=b"NHWC"))
-    bias_add_node.input.extend([conv1_node.name, bias_node.name])
-
-    offset_node = node_def_pb2.NodeDef()
-    offset_node.name = "offset"
-    offset_node.op = "Const"
-    offset_value = np.float32(np.abs(np.random.randn(1)))
-    offset_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    offset_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(offset_value, offset_value.dtype.type, offset_value.shape)
-        )
-    )
-
-    add_node = node_def_pb2.NodeDef()
-    add_node.op = "Add"
-    add_node.name = "add/hard_swish"
-    add_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    add_node.input.extend([bias_add_node.name, offset_node.name])
-
-    relu_node = node_def_pb2.NodeDef()
-    relu_node.op = "Relu6"
-    relu_node.name = "relu6/hard_swish"
-    relu_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    relu_node.input.extend([add_node.name])
-
-    mul_node = node_def_pb2.NodeDef()
-    mul_node.op = "Mul"
-    mul_node.name = "mul/hard_swish"
-    mul_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    mul_node.input.extend([bias_add_node.name, relu_node.name])
-
-    offset1_node = node_def_pb2.NodeDef()
-    offset1_node.name = "mul1_offset"
-    offset1_node.op = "Const"
-    offset1_value = np.float32(np.abs(np.random.randn(1)))
-    offset1_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    offset1_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(offset1_value, offset1_value.dtype.type, offset1_value.shape)
-        )
-    )
-
-    mul1_node = node_def_pb2.NodeDef()
-    mul1_node.op = "Mul"
-    mul1_node.name = "mul1/hard_swish"
-    mul1_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    mul1_node.input.extend([mul_node.name, offset1_node.name])
-
-    test_graph = graph_pb2.GraphDef()
-
-    test_graph.node.extend(
-        [
-            input_node,
-            conv1_weight_node,
-            conv1_node,
-            bias_node,
-            bias_add_node,
-            add_node,
-            relu_node,
-            offset_node,
-            offset1_node,
-            mul_node,
-            mul1_node,
-        ]
-    )
-    return test_graph
-
-
-class TestConv2DBiasAddAddReluFusion(unittest.TestCase):
-    @disable_random()
-    def test_single_depthwiseconv2d_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.depthwise_conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="VALID")
-        out_name = conv.name.split(":")[0]
-
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import Model, quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-            qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            found_dequantize_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedDepthwiseConv2D":
-                    found_conv_fusion = True
-                if str(i.attr["fused_ops"].list.s) == str([b"Dequantize"]):
-                    found_dequantize_fusion = True
-
-            self.assertEqual(found_conv_fusion, True)
-            self.assertEqual(found_dequantize_fusion, True)
-
-    @disable_random()
-    def test_depthwiseconv2d_biasadd_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.depthwise_conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="VALID")
-
-        normed = (
-            tf.keras.layers.BatchNormalization(name="op_to_store")(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv, name="op_to_store")
-        )
-        out_name = normed.name.split(":")[0]
-
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import Model, quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-            qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            found_dequantize_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedDepthwiseConv2D":
-                    found_conv_fusion = True
-                if str(i.attr["fused_ops"].list.s) == str([b"BiasAdd", b"Dequantize"]):
-                    found_dequantize_fusion = True
-
-            self.assertEqual(found_conv_fusion, True)
-            self.assertEqual(found_dequantize_fusion, True)
-
-    @disable_random()
-    def test_depthwiseconv2dnative_biasadd_add_relu6_mul_mul_fusion(self):
-        fp32_graph_def = build_conv2d_biasadd_add_relu6_mul_mul()
-
-        from neural_compressor.tensorflow import Model, quantize_model
-        from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-        dataset = DummyDataset(shape=(100, 224, 224, 3), label=True)
-        calib_dataloader = BaseDataLoader(dataset)
-        quant_config = {
-            "static_quant": {
-                "global": {
-                    "weight_dtype": "int8",
-                    "weight_sym": True,
-                    "weight_granularity": "per_tensor",
-                    "weight_algorithm": "minmax",
-                },
-            }
-        }
-        fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-        qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-        found_conv_fusion = False
-        for i in qmodel.graph_def.node:
-            if i.op == "_FusedQuantizedConv2D":
-                found_conv_fusion = True
-                break
-
-        self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_depthwiseconv2d_biasadd_leakyrelu_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.depthwise_conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="VALID")
-
-        normed = (
-            tf.keras.layers.BatchNormalization(name="op_to_store")(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv, name="op_to_store")
-        )
-
-        leakyrelu = tf.nn.leaky_relu(normed)
-        out_name = leakyrelu.name.split(":")[0]
-
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_FusedQuantizedDepthwiseConv2D":
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_matmul_fusion.py b/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_matmul_fusion.py
deleted file mode 100644
index 7a221c8cc76..00000000000
--- a/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_matmul_fusion.py
+++ /dev/null
@@ -1,1399 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import os
-import unittest
-
-import numpy as np
-import tensorflow.compat.v1 as tf
-import yaml
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.utils import disable_random
-
-
-class TestGraphMatMulFusion(unittest.TestCase):
-    @disable_random()
-    def test_matmul_biasadd_relu_requantize_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            z = tf.nn.bias_add(z, [1, 2])
-            z = tf.nn.relu(z, name="op_to_store")
-            found_quantized_matmul = False
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul" and i.attr["fused_ops"].list.s == [
-                        b"BiasAdd",
-                        b"Relu",
-                        b"Dequantize",
-                    ]:
-                        found_quantized_matmul = True
-                        break
-                self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_first_matmul_biasadd_relu_fusion(self):
-        x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-        y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-        x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-        y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-        z = tf.matmul(x, y)
-        z = tf.nn.bias_add(z, [1, 2])
-        z = tf.nn.relu(z, name="op_to_store")
-
-        with tf.Session() as sess:
-            sess.run(z, feed_dict={x: x_data, y: y_data})
-            fp32_graph_def = sess.graph.as_graph_def()
-
-            from neural_compressor.tensorflow import Model, quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(2, 2), label=True)
-            calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-            qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-            found_quantized_matmul = False
-            for i in qmodel.graph_def.node:
-                if (
-                    i.op == "QuantizeV2"
-                    and i.name == "MatMul_eightbit_quantize_x"
-                    and i.attr["T"].type == dtypes.quint8
-                ):
-                    found_quantized_matmul = True
-                    break
-
-            self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_biasadd_requantize_dequantize_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            z = tf.nn.bias_add(z, [1, 2])
-            z = tf.identity(z, name="op_to_store")
-            found_quantized_matmul = False
-
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul" and i.attr["fused_ops"].list.s == [b"BiasAdd", b"Dequantize"]:
-                        found_quantized_matmul = True
-                        break
-
-            self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_biasadd_requantize_dequantize_last_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            z = tf.nn.bias_add(z, [1, 2], name="op_to_store")
-            found_quantized_matmul = False
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if (
-                        i.op == "_QuantizedMatMul"
-                        and i.name == "op_to_store"
-                        and i.attr["fused_ops"].list.s == [b"BiasAdd", b"Dequantize"]
-                    ):
-                        found_quantized_matmul = True
-                        break
-            self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_fusion_with_transpose_b_true(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y, name="no_quant_matmul", transpose_b=True)
-            z = tf.nn.relu6(z, name="op_to_store")
-            found_quantized_matmul = False
-
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul":
-                        found_quantized_matmul = True
-                        break
-
-            self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_dummybiasadd_relu6_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y, name="quant_matmul")
-            z = tf.nn.relu6(z, name="op_to_store")
-            found_quantized_matmul = False
-
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul" and i.name == "op_to_store":
-                        found_quantized_matmul = True
-                        break
-
-            self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_with_reshape_transpose(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            transpose = tf.transpose(y, perm=[1, 0])
-            reshape = tf.reshape(transpose, [2, 2])
-            z = tf.matmul(x, reshape, name="no_quant_matmul")
-            z = tf.nn.bias_add(z, [1, 2], name="op_to_store")
-            found_quantized_matmul = True
-
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "MatMul":
-                        found_quantized_matmul = False
-                        break
-
-            self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_with_add(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            transpose = tf.transpose(y, perm=[1, 0])
-            reshape = tf.reshape(transpose, [2, 2])
-            z = tf.matmul(x, reshape, name="no_quant_matmul")
-            z = tf.math.add(z, [1, 2], name="op_to_store")
-            found_quantized_matmul = True
-
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "MatMul":
-                        found_quantized_matmul = False
-                        break
-
-            self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_biasadd_requantize_dequantize_fusion_with_softmax(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            biasadd = tf.nn.bias_add(z, [1, 2])
-            biasadd1 = tf.nn.bias_add(biasadd, [1, 1])
-
-            y1 = tf.constant(x_data, dtype=tf.float32, shape=[2, 2])
-            matmul1 = tf.matmul(biasadd1, y1)
-
-            biasadd2 = tf.nn.bias_add(matmul1, [1, 1])
-
-            z = tf.nn.softmax(biasadd2, name="op_to_store")
-            found_quantized_matmul = False
-            if tf.version.VERSION < "2.2.0":
-                found_quantized_matmul = False
-            else:
-                with tf.Session() as sess:
-                    sess.run(z, feed_dict={x: x_data, y: y_data})
-                    fp32_graph_def = sess.graph.as_graph_def()
-
-                    from neural_compressor.tensorflow import quantize_model
-                    from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                    dataset = DummyDataset(shape=(2, 2), label=True)
-                    calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                    quant_config = {
-                        "static_quant": {
-                            "global": {
-                                "weight_dtype": "int8",
-                                "weight_sym": True,
-                                "weight_granularity": "per_tensor",
-                                "weight_algorithm": "minmax",
-                            },
-                        }
-                    }
-                    qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-                    count = 0
-                    for i in qmodel.model.as_graph_def().node:
-                        if i.op == "_QuantizedMatMul":
-                            count += 1
-                    found_quantized_matmul = bool(count > 1)
-
-            self.assertEqual(found_quantized_matmul, False)
-
-    def test_matmul_biasadd_relu_non_const_weight(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.matmul(x, x, name="quant_matmul_non_const_weight")
-            biasadd = tf.nn.bias_add(y, [1, 2])
-            z = tf.nn.relu(biasadd)
-            found_quantized_matmul = True
-
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "MatMul":
-                        found_quantized_matmul = False
-                        break
-
-            self.assertEqual(found_quantized_matmul, True)
-
-    def test_matmul_biasadd_non_const_weight(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.matmul(x, x, name="quant_matmul_non_const_weight")
-            z = tf.nn.bias_add(y, [1, 2])
-            found_quantized_matmul = True
-
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "MatMul":
-                        found_quantized_matmul = False
-                        break
-
-            self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_with_dummy_biasadd(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y, name="no_quant_matmul")
-            z = tf.identity(z, name="op_to_store")
-            found_quantized_matmul = True
-
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "MatMul":
-                        found_quantized_matmul = False
-                        break
-
-            self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_first_matmul_addv2_relu_fusion(self):
-        x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-        y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-        x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-        y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-        a = tf.matmul(x, y)
-        b = tf.matmul(x, y)
-        c = tf.nn.relu(b)
-        add = tf.raw_ops.AddV2(x=a, y=c, name="addv2")
-        z = tf.nn.relu(add, name="op_to_store")
-
-        with tf.Session() as sess:
-            sess.run(z, feed_dict={x: x_data, y: y_data})
-            fp32_graph_def = sess.graph.as_graph_def()
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(2, 2), label=True)
-            calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_quantized_matmul = False
-            for i in qmodel.graph_def.node:
-                if i.op == "_QuantizedMatMul":
-                    found_quantized_matmul = True
-                    break
-
-            self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_biasadd_relu6_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            z = tf.nn.bias_add(z, [1, 2])
-            z = tf.nn.relu6(z, name="op_to_store")
-            found_quantized_matmul = False
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul" and i.attr["fused_ops"].list.s == [
-                        b"BiasAdd",
-                        b"Relu6",
-                        b"Dequantize",
-                    ]:
-                        found_quantized_matmul = True
-                        break
-
-                self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_biasadd_leakyrelu_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            z = tf.nn.bias_add(z, [1, 2])
-            z = tf.nn.leaky_relu(z, name="op_to_store")
-            found_quantized_matmul = False
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul" and i.attr["fused_ops"].list.s == [
-                        b"BiasAdd",
-                        b"LeakyRelu",
-                        b"Dequantize",
-                    ]:
-                        found_quantized_matmul = True
-                        break
-
-                self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_biasadd_geluapproximate_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            z = tf.nn.bias_add(z, [1, 2])
-            z = tf.nn.gelu(z, approximate=True, name="op_to_store")
-            found_quantized_matmul = False
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul" and i.attr["fused_ops"].list.s == [
-                        b"BiasAdd",
-                        b"GeluApproximate",
-                        b"Dequantize",
-                    ]:
-                        found_quantized_matmul = True
-                        break
-
-                self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_biasadd_geluexact_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            z = tf.nn.bias_add(z, [1, 2])
-            z = tf.nn.gelu(z, name="op_to_store")
-            found_quantized_matmul = False
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul" and i.attr["fused_ops"].list.s == [
-                        b"BiasAdd",
-                        b"GeluExact",
-                        b"Dequantize",
-                    ]:
-                        found_quantized_matmul = True
-                        break
-
-                self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_biasadd_elu_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            z = tf.nn.bias_add(z, [1, 2])
-            z = tf.nn.elu(z, name="op_to_store")
-            found_quantized_matmul = False
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul" and i.attr["fused_ops"].list.s == [b"BiasAdd", b"Elu", b"Dequantize"]:
-                        found_quantized_matmul = True
-                        break
-
-                self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_biasadd_tanh_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            z = tf.nn.bias_add(z, [1, 2])
-            z = tf.math.tanh(z, name="op_to_store")
-            found_quantized_matmul = False
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul" and i.attr["fused_ops"].list.s == [
-                        b"BiasAdd",
-                        b"Tanh",
-                        b"Dequantize",
-                    ]:
-                        found_quantized_matmul = True
-                        break
-
-                self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_biasadd_sigmoid_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            z = tf.nn.bias_add(z, [1, 2])
-            z = tf.math.sigmoid(z, name="op_to_store")
-            found_quantized_matmul = False
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul" and i.attr["fused_ops"].list.s == [
-                        b"BiasAdd",
-                        b"Sigmoid",
-                        b"Dequantize",
-                    ]:
-                        found_quantized_matmul = True
-                        break
-
-                self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_dummy_biasadd_relu_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y, name="quant_matmul")
-            z = tf.nn.relu(z, name="op_to_store")
-            found_quantized_matmul = False
-
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul" and i.attr["fused_ops"].list.s == [
-                        b"BiasAdd",
-                        b"Relu",
-                        b"Dequantize",
-                    ]:
-                        found_quantized_matmul = True
-                        break
-
-                self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_dummy_biasadd_relu6_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            z = tf.nn.relu6(z, name="op_to_store")
-            found_quantized_matmul = False
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul" and i.attr["fused_ops"].list.s == [
-                        b"BiasAdd",
-                        b"Relu6",
-                        b"Dequantize",
-                    ]:
-                        found_quantized_matmul = True
-                        break
-
-                self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_dummy_biasadd_leakyrelu_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            z = tf.nn.leaky_relu(z, name="op_to_store")
-            found_quantized_matmul = False
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul" and i.attr["fused_ops"].list.s == [
-                        b"BiasAdd",
-                        b"LeakyRelu",
-                        b"Dequantize",
-                    ]:
-                        found_quantized_matmul = True
-                        break
-
-                self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_dummy_biasadd_geluapproximate_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            z = tf.nn.gelu(z, approximate=True, name="op_to_store")
-            found_quantized_matmul = False
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul" and i.attr["fused_ops"].list.s == [
-                        b"BiasAdd",
-                        b"GeluApproximate",
-                        b"Dequantize",
-                    ]:
-                        found_quantized_matmul = True
-                        break
-
-                self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_dummy_biasadd_geluexact_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            z = tf.nn.gelu(z, approximate=False, name="op_to_store")
-            found_quantized_matmul = False
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul" and i.attr["fused_ops"].list.s == [
-                        b"BiasAdd",
-                        b"GeluExact",
-                        b"Dequantize",
-                    ]:
-                        found_quantized_matmul = True
-                        break
-
-                self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_dummy_biasadd_elu_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            z = tf.nn.elu(z, name="op_to_store")
-            found_quantized_matmul = False
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul" and i.attr["fused_ops"].list.s == [b"BiasAdd", b"Elu", b"Dequantize"]:
-                        found_quantized_matmul = True
-                        break
-
-                self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_dummy_biasadd_tanh_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            z = tf.math.tanh(z, name="op_to_store")
-            found_quantized_matmul = False
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul" and i.attr["fused_ops"].list.s == [
-                        b"BiasAdd",
-                        b"Tanh",
-                        b"Dequantize",
-                    ]:
-                        found_quantized_matmul = True
-                        break
-
-                self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_dummy_biasadd_sigmoid_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            z = tf.math.sigmoid(z, name="op_to_store")
-            found_quantized_matmul = False
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul" and i.attr["fused_ops"].list.s == [
-                        b"BiasAdd",
-                        b"Sigmoid",
-                        b"Dequantize",
-                    ]:
-                        found_quantized_matmul = True
-                        break
-
-                self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_add_const_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            transpose = tf.transpose(y, perm=[1, 0])
-            reshape = tf.reshape(transpose, [2, 2])
-            z = tf.matmul(x, reshape, name="quant_matmul")
-            z = tf.math.add(z, [1, 2], name="op_to_store")
-            found_quantized_matmul = False
-
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul" and i.attr["fused_ops"].list.s == [b"BiasAdd", b"Dequantize"]:
-                        found_quantized_matmul = True
-                        break
-
-                self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_add_non_const_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            transpose = tf.transpose(y, perm=[1, 0])
-            reshape = tf.reshape(transpose, [2, 2])
-            z = tf.matmul(x, reshape, name="quant_matmul")
-            z = tf.math.add(z, x, name="addv2")
-            z = tf.nn.relu(z, name="op_to_store")
-            found_quantized_matmul = False
-
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul" and i.attr["fused_ops"].list.s == [b"Dequantize"]:
-                        found_quantized_matmul = True
-                        break
-                self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_biasadd_add_const_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            z = tf.nn.bias_add(z, [1, 2])
-            z = tf.math.add(z, [1, 2], name="op_to_store")
-            found_quantized_matmul = False
-
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul" and i.attr["fused_ops"].list.s == [b"BiasAdd", b"Dequantize"]:
-                        found_quantized_matmul = True
-                        break
-
-                self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_biasadd_add_non_const_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            z = tf.nn.bias_add(z, [1, 2])
-            z = tf.math.add(z, x, name="op_to_store")
-            found_quantized_matmul = False
-
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                fp32_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import Model, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = {
-                    "static_quant": {
-                        "global": {
-                            "weight_dtype": "int8",
-                            "weight_sym": True,
-                            "weight_granularity": "per_tensor",
-                            "weight_algorithm": "minmax",
-                        },
-                    }
-                }
-                fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-                qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "_QuantizedMatMul" and i.attr["fused_ops"].list.s == [b"BiasAdd", b"Dequantize"]:
-                        found_quantized_matmul = True
-                        break
-
-                self.assertEqual(found_quantized_matmul, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_new_conv_fusion.py b/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_new_conv_fusion.py
deleted file mode 100644
index ece8a5ddfab..00000000000
--- a/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_new_conv_fusion.py
+++ /dev/null
@@ -1,126 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import logging
-import os
-import unittest
-
-import tensorflow as tf
-import yaml
-from tensorflow.compat.v1 import graph_util
-from tensorflow.python.framework import function
-
-from neural_compressor.tensorflow.utils import disable_random, version1_gte_version2
-
-
-class TestTensorflowNewQdqConvFusion(unittest.TestCase):
-    @disable_random()
-    def test_conv_biasadd_add_leakyrelu_fusion(self):
-        logging.getLogger().info("test_conv_biasadd_add_leakyrelu_fusion")
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x, conv_weights, strides=[1, 2, 2, 1], padding="SAME")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-        conv2_weights = tf.compat.v1.get_variable(
-            "weight_conv2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(x, conv2_weights, strides=[1, 2, 2, 1], padding="SAME")
-        sumadd = tf.raw_ops.AddV2(x=normed, y=conv2, name="addv2")
-        leaky_relu = tf.nn.leaky_relu(sumadd, name="op_to_store")
-
-        out_name = leaky_relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = True
-            for i in qmodel.graph_def.node:
-                if i.op == "LeakyRelu":
-                    found_conv_fusion = False
-                    break
-
-            self.assertEqual(found_conv_fusion, False)
-
-    @disable_random()
-    def test_resizebilinear_bf16_input(self):
-        os.environ["FORCE_BF16"] = "1"
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(top_relu, paddings, "CONSTANT")
-        conv1_weights = tf.compat.v1.get_variable(
-            "weight_conv1", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv1 = tf.nn.conv2d(x_pad, conv1_weights, strides=[1, 2, 2, 1], padding="VALID")
-        matmul_weights = tf.compat.v1.get_variable(
-            "weight_matmul", [1, 28, 16, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        matmul = tf.linalg.matmul(conv1, matmul_weights)
-        conv2_weights = tf.compat.v1.get_variable(
-            "weight_conv2", [7, 7, 32, 1], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(matmul, conv2_weights, strides=[1, 2, 2, 1], padding="VALID")
-        leaky_relu = tf.nn.leaky_relu(conv2, name="op_to_store")
-        resize_bili1 = tf.raw_ops.ResizeBilinear(images=leaky_relu, size=(28, 28))
-        resize_bili2 = tf.raw_ops.ResizeBilinear(images=resize_bili1, size=(14, 14))
-        out_name = resize_bili2.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import Model, quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-            qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-            bf16_matmul = False
-            for i in qmodel.graph_def.node:
-                if i.op == "BatchMatMulV2" and i.attr["T"].type == 14:
-                    bf16_matmul = True
-
-            self.assertEqual(bf16_matmul, True)
-            os.environ["FORCE_BF16"] = "0"
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_pooling_fusion.py b/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_pooling_fusion.py
deleted file mode 100644
index 65e577b9e93..00000000000
--- a/test/tensorflow/quantization/ptq/newapi/test_graph_qdq_pooling_fusion.py
+++ /dev/null
@@ -1,111 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import os
-import unittest
-
-import numpy as np
-import tensorflow.compat.v1 as tf
-import yaml
-from tensorflow.compat.v1 import graph_util
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.utils import disable_random, version1_gte_version2
-
-
-class TestGraphQDQPoolingFusion(unittest.TestCase):
-    @disable_random()
-    def test_qdq_maxpool_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 30, 30, 1], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [2, 2, 1, 1], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv_bias = tf.compat.v1.get_variable("bias", [1], initializer=tf.compat.v1.random_normal_initializer())
-        x = tf.nn.relu(x)
-        conv = tf.nn.conv2d(x, conv_weights, strides=[1, 2, 2, 1], padding="SAME", name="last")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        relu = tf.nn.relu(normed)
-        relu2 = tf.nn.relu(relu)
-        pool = tf.nn.max_pool(relu2, ksize=1, strides=[1, 2, 2, 1], name="maxpool", padding="SAME")
-        conv1 = tf.nn.conv2d(pool, conv_weights, strides=[1, 2, 2, 1], padding="SAME", name="last")
-        conv_bias = tf.nn.bias_add(conv1, conv_bias)
-        x = tf.nn.relu(conv_bias)
-        final_node = tf.nn.relu(x, name="op_to_store")
-
-        out_name = final_node.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 30, 30, 1), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = StaticQuantConfig()
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_quantized_maxpool = False
-            for i in qmodel.graph_def.node:
-                if i.op == "QuantizedMaxPool":
-                    found_quantized_maxpool = True
-                    break
-
-            self.assertEqual(found_quantized_maxpool, True)
-
-    @disable_random()
-    def test_qdq_avgpool_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 30, 30, 1], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [2, 2, 1, 1], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv_bias = tf.compat.v1.get_variable("bias", [1], initializer=tf.compat.v1.random_normal_initializer())
-        x = tf.nn.relu(x)
-        conv = tf.nn.conv2d(x, conv_weights, strides=[1, 2, 2, 1], padding="SAME", name="last")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        relu = tf.nn.relu(normed)
-        relu2 = tf.nn.relu(relu)
-        pool = tf.nn.avg_pool(relu2, ksize=1, strides=[1, 2, 2, 1], name="avgpool", padding="SAME")
-        conv1 = tf.nn.conv2d(pool, conv_weights, strides=[1, 2, 2, 1], padding="SAME", name="last")
-        conv_bias = tf.nn.bias_add(conv1, conv_bias)
-        x = tf.nn.relu(conv_bias)
-        final_node = tf.nn.relu(x, name="op_to_store")
-
-        out_name = final_node.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 30, 30, 1), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = StaticQuantConfig()
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_quantized_avgpool = False
-            for i in qmodel.graph_def.node:
-                if i.op == "QuantizedAvgPool":
-                    found_quantized_avgpool = True
-                    break
-
-            self.assertEqual(found_quantized_avgpool, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/newapi/test_use_reshape_transpose.py b/test/tensorflow/quantization/ptq/newapi/test_use_reshape_transpose.py
deleted file mode 100644
index 20a7d1475fd..00000000000
--- a/test/tensorflow/quantization/ptq/newapi/test_use_reshape_transpose.py
+++ /dev/null
@@ -1,118 +0,0 @@
-import imp
-import os
-import unittest
-
-import numpy as np
-import tensorflow.compat.v1 as tf
-import yaml
-from numpy.core.fromnumeric import squeeze
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.tensorflow.utils import disable_random
-
-
-class TestFuseReshapeTransposeOptimizer(unittest.TestCase):
-    @disable_random()
-    def test_fuse_enter_reshape_transpose(self):
-        x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-        y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-        x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-        y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-        enter = tf.raw_ops.Enter(data=y, frame_name="test")
-        enter_perm = tf.raw_ops.Enter(data=[1, 0], frame_name="test", is_constant=True)
-        transpose = tf.transpose(enter, perm=enter_perm)
-        enter_reshape = tf.raw_ops.Enter(data=[2, 2], frame_name="test", is_constant=True)
-        reshape = tf.reshape(transpose, enter_reshape)
-        x_enter = tf.raw_ops.Enter(data=x, frame_name="test")
-        z = tf.raw_ops.MatMul(a=x_enter, b=reshape, name="matmul_1")
-        z = tf.raw_ops.Exit(data=z)
-        found_quantized_matmul = True
-        found_transpose = False
-        found_reshape = False
-
-        with tf.Session() as sess:
-            sess.run(z, feed_dict={x: x_data, y: y_data})
-            fp32_graph_def = sess.graph.as_graph_def()
-
-            from neural_compressor.tensorflow import Model, quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(2, 2), label=True)
-            calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-            qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-            for i in qmodel.graph_def.node:
-                if i.op == "MatMul":
-                    found_quantized_matmul = False
-                if i.op == "Transpose":
-                    found_transpose = True
-                if i.op == "Reshape":
-                    found_reshape = True
-
-            self.assertEqual(found_quantized_matmul, True)
-            self.assertEqual(found_transpose, False)
-            self.assertEqual(found_reshape, False)
-
-    @disable_random()
-    def test_fuse_reshape_transpose(self):
-        x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-        y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-        x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-        y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-        transpose = tf.transpose(y, perm=[1, 0])
-        reshape = tf.reshape(transpose, [2, 2])
-        z = tf.raw_ops.MatMul(a=x, b=reshape, name="matmul_2")
-        z = tf.nn.bias_add(z, [1, 2], name="op_to_store")
-        found_quantized_matmul = True
-        found_transpose = False
-        found_reshape = False
-
-        with tf.Session() as sess:
-            sess.run(z, feed_dict={x: x_data, y: y_data})
-            fp32_graph_def = sess.graph.as_graph_def()
-
-            from neural_compressor.tensorflow import Model, quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(2, 2), label=True)
-            calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-
-            fp32_model = Model(fp32_graph_def, conf={"performance_only": True})
-            qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-
-            for i in qmodel.graph_def.node:
-                if i.op == "MatMul":
-                    found_quantized_matmul = False
-                if i.op == "Transpose":
-                    found_transpose = True
-                if i.op == "Reshape":
-                    found_reshape = True
-
-            self.assertEqual(found_quantized_matmul, True)
-            self.assertEqual(found_transpose, False)
-            self.assertEqual(found_reshape, False)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_auto_input_output.py b/test/tensorflow/quantization/ptq/test_auto_input_output.py
deleted file mode 100644
index 0d19b111ee5..00000000000
--- a/test/tensorflow/quantization/ptq/test_auto_input_output.py
+++ /dev/null
@@ -1,54 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import os
-import platform
-import unittest
-
-from neural_compressor.tensorflow import Model as TensorflowModel
-from neural_compressor.tensorflow.algorithms.static_quant.tensorflow import TensorFlowAdaptor
-from neural_compressor.tensorflow.utils.model_wrappers import validate_graph_node
-
-
-class TestTFAutoDetectInputOutput(unittest.TestCase):
-    mb_model_url = (
-        "https://storage.googleapis.com/intel-optimized-tensorflow/models/v1_6/mobilenet_v1_1.0_224_frozen.pb"
-    )
-    pb_path = "/tmp/.neural_compressor/mobilenet_fp32.pb"
-    platform = platform.system().lower()
-    if platform == "windows":
-        pb_path = "C:\\tmp\\.neural_compressor\\mobilenet_fp32.pb"
-
-    @classmethod
-    def setUpClass(self):
-        self.saved_flag = True
-        if not os.path.exists(self.pb_path):
-            try:
-                if self.platform == "linux":
-                    os.system(
-                        "mkdir -p /tmp/.neural_compressor && wget {} -O {} ".format(self.mb_model_url, self.pb_path)
-                    )
-                elif self.platform == "windows":
-                    os.system("md C:\\tmp\.neural_compressor && cd C:\\tmp\.neural_compressor")
-                    from urllib import request
-
-                    if not self.mb_model_url.startswith(("http://", "https://")):
-                        raise ValueError("Only http/https URLs are supported.")
-                    request.urlretrieve(self.mb_model_url)  # nosec B310
-            except Exception as e:
-                self.saved_flag = False
-
-    def testAutoDetectInputOutput(self):
-        if self.saved_flag:
-            model = TensorflowModel(self.pb_path)
-            outputs = model.output_node_names
-            inputs = model.input_node_names
-            output_validate = validate_graph_node(model.graph_def, outputs)
-            self.assertTrue(output_validate)
-
-            input_validate = validate_graph_node(model.graph_def, inputs)
-            self.assertTrue(input_validate)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_bf16_convert.py b/test/tensorflow/quantization/ptq/test_bf16_convert.py
deleted file mode 100644
index 9be90fcbf84..00000000000
--- a/test/tensorflow/quantization/ptq/test_bf16_convert.py
+++ /dev/null
@@ -1,339 +0,0 @@
-import os
-import platform
-import shutil
-import unittest
-from unittest import result
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.core.framework import attr_value_pb2, graph_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.bf16.bf16_convert import BF16Convert
-from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-
-def create_test_graph(bf16_graph=True):
-    input_node = node_def_pb2.NodeDef()
-    input_node.name = "input"
-    input_node.op = "Placeholder"
-    input_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-
-    conv1_weight_node = node_def_pb2.NodeDef()
-    conv1_weight_node.name = "conv1_weights"
-    conv1_weight_node.op = "Const"
-    conv1_weight_value = np.float32(np.abs(np.random.randn(3, 3, 3, 32)))
-    conv1_weight_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    conv1_weight_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(
-                conv1_weight_value, conv1_weight_value.dtype.type, conv1_weight_value.shape
-            )
-        )
-    )
-
-    conv1_node = node_def_pb2.NodeDef()
-    conv1_node.name = "conv1"
-    conv1_node.op = "Conv2D"
-    conv1_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    conv1_node.input.extend([input_node.name, conv1_weight_node.name])
-    conv1_node.attr["strides"].CopyFrom(
-        attr_value_pb2.AttrValue(list=attr_value_pb2.AttrValue.ListValue(i=[1, 1, 1, 1]))
-    )
-    conv1_node.attr["dilations"].CopyFrom(
-        attr_value_pb2.AttrValue(list=attr_value_pb2.AttrValue.ListValue(i=[1, 1, 1, 1]))
-    )
-    conv1_node.attr["padding"].CopyFrom(attr_value_pb2.AttrValue(s=b"SAME"))
-    conv1_node.attr["data_format"].CopyFrom(attr_value_pb2.AttrValue(s=b"NHWC"))
-
-    bias_node = node_def_pb2.NodeDef()
-    bias_node.name = "conv1_bias"
-    bias_node.op = "Const"
-    bias_value = np.float32(np.abs(np.random.randn(32)))
-    bias_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    bias_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(bias_value, bias_value.dtype.type, bias_value.shape)
-        )
-    )
-
-    bias_add_node = node_def_pb2.NodeDef()
-    bias_add_node.name = "conv1_bias_add"
-    bias_add_node.op = "BiasAdd"
-    bias_add_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    bias_add_node.input.extend([conv1_node.name, bias_node.name])
-    bias_add_node.attr["data_format"].CopyFrom(attr_value_pb2.AttrValue(s=b"NHWC"))
-
-    if bf16_graph:
-        cast_node = node_def_pb2.NodeDef()
-        cast_node.op = "Cast"
-        cast_node.name = "cast"
-        cast_node.attr["SrcT"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-        cast_node.attr["DstT"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.bfloat16.as_datatype_enum))
-        cast_node.input.extend([bias_add_node.name])
-
-    relu_node = node_def_pb2.NodeDef()
-    relu_node.op = "Relu"
-    relu_node.name = "relu"
-    relu_node.attr["T"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            type=dtypes.bfloat16.as_datatype_enum if bf16_graph else dtypes.float32.as_datatype_enum
-        )
-    )
-    relu_node.input.extend([cast_node.name if bf16_graph else bias_add_node.name])
-
-    if bf16_graph:
-        cast2_node = node_def_pb2.NodeDef()
-        cast2_node.op = "Cast"
-        cast2_node.name = "cast2"
-        cast2_node.attr["SrcT"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.bfloat16.as_datatype_enum))
-        cast2_node.attr["DstT"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-        cast2_node.input.extend([relu_node.name])
-
-    conv2_weight_node = node_def_pb2.NodeDef()
-    conv2_weight_node.name = "conv2_weights"
-    conv2_weight_node.op = "Const"
-    conv2_weight_value = np.float32(np.abs(np.random.randn(3, 3, 32, 32)))
-    conv2_weight_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    conv2_weight_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(
-                conv2_weight_value, conv2_weight_value.dtype.type, conv2_weight_value.shape
-            )
-        )
-    )
-
-    conv2_node = node_def_pb2.NodeDef()
-    conv2_node.name = "conv2"
-    conv2_node.op = "Conv2D"
-    conv2_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    conv2_node.input.extend([cast2_node.name if bf16_graph else relu_node.name, conv2_weight_node.name])
-    conv2_node.attr["strides"].CopyFrom(
-        attr_value_pb2.AttrValue(list=attr_value_pb2.AttrValue.ListValue(i=[1, 1, 1, 1]))
-    )
-    conv2_node.attr["dilations"].CopyFrom(
-        attr_value_pb2.AttrValue(list=attr_value_pb2.AttrValue.ListValue(i=[1, 1, 1, 1]))
-    )
-    conv2_node.attr["padding"].CopyFrom(attr_value_pb2.AttrValue(s=b"SAME"))
-    conv2_node.attr["data_format"].CopyFrom(attr_value_pb2.AttrValue(s=b"NHWC"))
-
-    bias_node2 = node_def_pb2.NodeDef()
-    bias_node2.name = "conv2_bias"
-    bias_node2.op = "Const"
-    bias_value2 = np.float32(np.abs(np.random.randn(32)))
-    bias_node2.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    bias_node2.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(bias_value2, bias_value2.dtype.type, bias_value2.shape)
-        )
-    )
-
-    bias_add_node2 = node_def_pb2.NodeDef()
-    bias_add_node2.name = "conv2_bias_add"
-    bias_add_node2.op = "BiasAdd"
-    bias_add_node2.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    bias_add_node2.input.extend([conv2_node.name, bias_node2.name])
-    bias_add_node2.attr["data_format"].CopyFrom(attr_value_pb2.AttrValue(s=b"NHWC"))
-
-    relu_node2 = node_def_pb2.NodeDef()
-    relu_node2.op = "Relu"
-    relu_node2.name = "relu2"
-    relu_node2.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    relu_node2.input.extend([bias_add_node2.name])
-
-    log_node = node_def_pb2.NodeDef()
-    log_node.name = "log1"
-    log_node.op = "Log"
-    log_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    log_node.input.extend([relu_node2.name])
-
-    conv3_weight_node = node_def_pb2.NodeDef()
-    conv3_weight_node.name = "conv3_weights"
-    conv3_weight_node.op = "Const"
-    conv3_weight_value = np.float32(np.abs(np.random.randn(3, 3, 32, 32)))
-    conv3_weight_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    conv3_weight_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(
-                conv3_weight_value, conv3_weight_value.dtype.type, conv3_weight_value.shape
-            )
-        )
-    )
-
-    conv3_node = node_def_pb2.NodeDef()
-    conv3_node.name = "conv3"
-    conv3_node.op = "Conv2D"
-    conv3_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    conv3_node.input.extend([log_node.name, conv3_weight_node.name])
-    conv3_node.attr["strides"].CopyFrom(
-        attr_value_pb2.AttrValue(list=attr_value_pb2.AttrValue.ListValue(i=[1, 1, 1, 1]))
-    )
-    conv3_node.attr["dilations"].CopyFrom(
-        attr_value_pb2.AttrValue(list=attr_value_pb2.AttrValue.ListValue(i=[1, 1, 1, 1]))
-    )
-    conv3_node.attr["padding"].CopyFrom(attr_value_pb2.AttrValue(s=b"SAME"))
-    conv3_node.attr["data_format"].CopyFrom(attr_value_pb2.AttrValue(s=b"NHWC"))
-
-    identity_node = node_def_pb2.NodeDef()
-    identity_node.name = "final"
-    identity_node.op = "Identity"
-    identity_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    identity_node.input.extend([conv3_node.name])
-
-    test_graph = graph_pb2.GraphDef()
-
-    if bf16_graph:
-        test_graph.node.extend(
-            [
-                input_node,
-                conv1_weight_node,
-                conv1_node,
-                bias_node,
-                bias_add_node,
-                cast_node,
-                relu_node,
-                cast2_node,
-                conv2_weight_node,
-                conv2_node,
-                bias_node2,
-                bias_add_node2,
-                log_node,
-                relu_node2,
-                conv3_weight_node,
-                conv3_node,
-                identity_node,
-            ]
-        )
-    else:
-        test_graph.node.extend(
-            [
-                input_node,
-                conv1_weight_node,
-                conv1_node,
-                bias_node,
-                bias_add_node,
-                relu_node,
-                conv2_weight_node,
-                conv2_node,
-                bias_node2,
-                bias_add_node2,
-                log_node,
-                relu_node2,
-                conv3_weight_node,
-                conv3_node,
-                identity_node,
-            ]
-        )
-    return test_graph
-
-
-class TestBF16Convert(unittest.TestCase):
-    rn50_fp32_pb_url = (
-        "https://storage.googleapis.com/intel-optimized-tensorflow/models/v1_6/resnet50_fp32_pretrained_model.pb"
-    )
-    pb_path = "/tmp/.neural_compressor/resnet50_fp32_pretrained_model.pb"
-    platform = platform.system().lower()
-    if platform == "windows":
-        pb_path = "C:\\tmp\.neural_compressor\\resnet50_fp32_pretrained_model.pb"
-
-    @classmethod
-    def setUpClass(self):
-        if not os.path.exists(self.pb_path):
-            if self.platform == "linux":
-                os.system(
-                    "mkdir -p /tmp/.neural_compressor && wget {} -O {} ".format(self.rn50_fp32_pb_url, self.pb_path)
-                )
-            elif self.platform == "windows":
-                os.system("md C:\\tmp\.neural_compressor && cd C:\\tmp\.neural_compressor")
-                from urllib import request
-
-                if not self.rn50_fp32_pb_url.startswith(("http://", "https://")):
-                    raise ValueError("Only http/https URLs are supported.")
-                request.urlretrieve(self.rn50_fp32_pb_url)  # nosec B310
-
-        self.input_graph = tf.compat.v1.GraphDef()
-        with open(self.pb_path, "rb") as f:
-            self.input_graph.ParseFromString(f.read())
-        self.test_graph = create_test_graph()
-        self.test_fp32_graph = create_test_graph(False)
-
-    @classmethod
-    def tearDownClass(self):
-        shutil.rmtree("saved", ignore_errors=True)
-
-    def test_bf16_transpose_b_matmul(self):
-        from tensorflow.core.framework import attr_value_pb2
-
-        from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-
-        os.environ["FORCE_BF16"] = "1"
-        DT_BFLOAT16 = attr_value_pb2.AttrValue(type=dtypes.bfloat16.as_datatype_enum)
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=float)
-            x = tf.compat.v1.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y, name="no_quant_matmul", transpose_b=True)
-            z = tf.nn.relu6(z, name="op_to_store")
-            is_bf16 = False
-            with tf.compat.v1.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                float_graph_def = sess.graph.as_graph_def()
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = StaticQuantConfig()
-                qmodel = quantize_model(float_graph_def, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "MatMul" and i.attr["T"] == DT_BFLOAT16:
-                        is_bf16 = True
-                        break
-
-            self.assertEqual(is_bf16, True)
-            os.environ["FORCE_BF16"] = "0"
-
-    @unittest.skipIf(tf.__version__ < "2.0", "currently bf16 convert does not support 1.15up3")
-    def test_rn50_convert(self):
-        bf16_nodes = [node.name for node in self.input_graph.node if node.op in ["Conv2D", "AvgPool", "MatMul"]]
-        bf16_nodes.remove("v0/resnet_v13/conv14/conv2d/Conv2D")
-        rn50_bf16_converter = BF16Convert(self.input_graph, ["v0/resnet_v13/conv14/conv2d/Conv2D"], bf16_nodes)
-        rn50_bf16_converter.do_transformation()
-        new_conv11 = rn50_bf16_converter.cur_graph.node_name_details["v0/resnet_v13/conv11/conv2d/Conv2D"].node
-        new_conv14 = rn50_bf16_converter.cur_graph.node_name_details["v0/resnet_v13/conv14/conv2d/Conv2D"].node
-        new_conv52 = rn50_bf16_converter.cur_graph.node_name_details["v0/resnet_v115/conv52/conv2d/Conv2D"].node
-        self.assertEqual(new_conv11.attr["T"].type, new_conv52.attr["T"].type)
-        self.assertNotEqual(new_conv11.attr["T"].type, new_conv14.attr["T"].type)
-
-    @unittest.skipIf(tf.__version__ < "2.0", "currently bf16 convert does not support 1.15up3")
-    def test_do_transform(self):
-        bf16_converter = BF16Convert(self.test_graph, ["conv3"], ["conv2", "relu2"])
-        new_graph = bf16_converter.do_transformation()
-        new_conv2 = bf16_converter.cur_graph.node_name_details["conv2"].node
-        new_conv3 = bf16_converter.cur_graph.node_name_details["conv3"].node
-        new_relu2 = bf16_converter.cur_graph.node_name_details["relu2"].node
-        self.assertEqual(new_conv2.attr["T"].type, dtypes.bfloat16)
-        self.assertEqual(new_relu2.attr["T"].type, dtypes.bfloat16)
-        self.assertEqual(new_conv3.attr["T"].type, dtypes.float32)
-
-    def test_bf16_fallback(self):
-        os.environ["FORCE_BF16"] = "1"
-        from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-
-        dataset = DummyDataset(shape=(1, 224, 224, 3), label=True)
-        calib_dataloader = BaseDataLoader(dataset)
-        quant_config = StaticQuantConfig()
-        qmodel = quantize_model(self.test_fp32_graph, quant_config, calib_dataloader)
-
-        cast_op_count = 0
-        for node in qmodel.graph_def.node:
-            if node.op == "Cast":
-                cast_op_count += 1
-
-        self.assertTrue(cast_op_count == 0)
-        os.environ["FORCE_BF16"] = "0"
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_bias_correction.py b/test/tensorflow/quantization/ptq/test_bias_correction.py
deleted file mode 100644
index ebb2fac9d1f..00000000000
--- a/test/tensorflow/quantization/ptq/test_bias_correction.py
+++ /dev/null
@@ -1,66 +0,0 @@
-import unittest
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.compat.v1 import graph_util
-
-import neural_compressor
-from neural_compressor.tensorflow.algorithms.static_quant.tensorflow import TensorflowQuery
-from neural_compressor.tensorflow.quantization.utils.quantize_graph.quantize_graph_for_intel_cpu import (
-    QuantizeGraphForIntel,
-)
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper
-from neural_compressor.tensorflow.quantization.utils.transform_graph.bias_correction import BiasCorrection
-from neural_compressor.tensorflow.utils import version1_gte_version2
-
-
-class TestBiasCorrection(unittest.TestCase):
-    def test_bias_correction(self):
-        tf.compat.v1.disable_eager_execution()
-        x = tf.compat.v1.placeholder(tf.float32, [1, 224, 224, 3], name="input")
-
-        if tf.version.VERSION <= "2.1.0":
-            x = tf.nn.relu(x)
-
-        conv_weights = (
-            tf.Variable(np.random.rand(3, 3, 3, 32).tolist(), name="weight")
-            if version1_gte_version2(tf.version.VERSION, "2.16.1")
-            else tf.compat.v1.get_variable(
-                "weight", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-            )
-        )
-        conv_bias = (
-            tf.Variable(np.random.rand(32).tolist(), name="bias")
-            if version1_gte_version2(tf.version.VERSION, "2.16.1")
-            else tf.compat.v1.get_variable("bias", [32], initializer=tf.compat.v1.random_normal_initializer())
-        )
-        conv1 = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME")
-        conv_bias = tf.nn.bias_add(conv1, conv_bias)
-        relu = tf.nn.relu(conv_bias, name="Relu_1")
-        op_wise_sequences = TensorflowQuery(
-            local_config_file=neural_compressor.__path__[0] + "/tensorflow/algorithms/static_quant/tensorflow.yaml"
-        ).get_eightbit_patterns()
-
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[relu.name.split(":")[0]]
-            )
-            output_graph_def = QuantizeGraphHelper.remove_training_nodes(
-                output_graph_def, protected_nodes=[relu.name.split(":")[0]]
-            )
-            inputs = [x.name.split(":")[0]]
-            outputs = [relu.name.split(":")[0]]
-            op_wise_config = {
-                "Conv2D": (False, "minmax", False, 7.0),
-            }
-
-            int8_graph_def, _, _ = QuantizeGraphForIntel(
-                output_graph_def, inputs, outputs, op_wise_config, op_wise_sequences, "cpu"
-            ).do_transform()
-        correct_graph_def = BiasCorrection(int8_graph_def, output_graph_def).do_transformation()
-        self.assertEqual(len(correct_graph_def.node), len(int8_graph_def.node))
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_data_pipline.py b/test/tensorflow/quantization/ptq/test_data_pipline.py
deleted file mode 100644
index f7e81580816..00000000000
--- a/test/tensorflow/quantization/ptq/test_data_pipline.py
+++ /dev/null
@@ -1,63 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import unittest
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper
-from neural_compressor.tensorflow.quantization.utils.utility import get_tensor_by_name, iterator_sess_run
-from neural_compressor.tensorflow.utils import version1_gte_version2
-
-
-class TestDataPipelineConvert(unittest.TestCase):
-    def test_data_pipeline(self):
-        tf.compat.v1.disable_eager_execution()
-        raw_dataset = np.ones([100, 224, 224, 3], dtype=np.float32)
-        tf_dataset = tf.compat.v1.data.Dataset.from_tensor_slices(raw_dataset)
-        tf_dataset = tf_dataset.batch(1)
-        ds_iterator = tf_dataset.make_initializable_iterator()
-        iter_tensors = ds_iterator.get_next()
-
-        conv_weights = (
-            tf.Variable(np.random.rand(3, 3, 3, 32).tolist(), name="weight")
-            if version1_gte_version2(tf.version.VERSION, "2.16.1")
-            else tf.compat.v1.get_variable(
-                "weight", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-            )
-        )
-        conv_bias = (
-            tf.Variable(np.random.rand(32).tolist(), name="bias")
-            if version1_gte_version2(tf.version.VERSION, "2.16.1")
-            else tf.compat.v1.get_variable("bias", [32], initializer=tf.compat.v1.random_normal_initializer())
-        )
-        conv1 = tf.nn.conv2d(iter_tensors, conv_weights, strides=[1, 1, 1, 1], padding="SAME")
-        conv_bias = tf.math.add(conv1, conv_bias)
-        relu = tf.nn.relu(conv_bias, name="Relu_1")
-
-        output_names = [relu.name.split(":")[0], "MakeIterator"]
-
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=output_names
-            )
-            output_graph_def = QuantizeGraphHelper.remove_training_nodes(output_graph_def, protected_nodes=output_names)
-        graph = tf.Graph()
-        with graph.as_default():
-            tf.import_graph_def(output_graph_def, name="")
-        print("graph has been generated....")
-
-        iter_op = graph.get_operation_by_name("MakeIterator")
-        output_tensor = get_tensor_by_name(graph, output_names[0])
-        sess = tf.compat.v1.Session(graph=graph)
-        preds = iterator_sess_run(sess, iter_op, feed_dict={}, output_tensor=output_tensor)
-
-        assert preds is not None
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_fold_batch_norm.py b/test/tensorflow/quantization/ptq/test_fold_batch_norm.py
deleted file mode 100644
index 09008209f0c..00000000000
--- a/test/tensorflow/quantization/ptq/test_fold_batch_norm.py
+++ /dev/null
@@ -1,78 +0,0 @@
-import copy
-import unittest
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.fold_batch_norm import (
-    FoldBatchNormNodesOptimizer,
-)
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper
-from neural_compressor.tensorflow.utils import version1_gte_version2
-
-
-class TestFoldBatchnorm(unittest.TestCase):
-    if not version1_gte_version2(tf.__version__, "2.16.1"):
-        tf.compat.v1.disable_eager_execution()
-        x = tf.compat.v1.placeholder(tf.float32, [1, 224, 224, 3], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv_bias = tf.compat.v1.get_variable("bias", [32], initializer=tf.compat.v1.random_normal_initializer())
-        beta = tf.compat.v1.get_variable(name="beta", shape=[32], initializer=tf.compat.v1.random_normal_initializer())
-        gamma = tf.compat.v1.get_variable(
-            name="gamma", shape=[32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv1 = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME")
-        conv_bias = tf.nn.bias_add(conv1, conv_bias)
-        normed = tf.compat.v1.layers.batch_normalization(conv_bias)
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[normed.name.split(":")[0]]
-            )
-            output_graph_def = QuantizeGraphHelper.remove_training_nodes(
-                output_graph_def, protected_nodes=[normed.name.split(":")[0]]
-            )
-            graph_def = copy.deepcopy(output_graph_def)
-            fold_graph_def = FoldBatchNormNodesOptimizer(output_graph_def).do_transformation()
-
-    @unittest.skipIf(
-        version1_gte_version2(tf.version.VERSION, "2.16.1"),
-        "The TF BN is deleted after 2.16.1 while the fusion of Keras BN is not supported now",
-    )
-    def test_fold_output_values(self):
-        input_data = np.random.randn(1, 224, 224, 3)
-        graph = tf.compat.v1.Graph()
-        fold_graph = tf.compat.v1.Graph()
-        with graph.as_default():
-            tf.compat.v1.import_graph_def(self.graph_def, name="")
-
-        with tf.compat.v1.Session(graph=graph) as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            x = graph.get_tensor_by_name("input:0")
-            normed = graph.get_tensor_by_name("batch_normalization/FusedBatchNormV3:0")
-            y = sess.run(normed, feed_dict={x: input_data})
-
-        with fold_graph.as_default():
-            tf.compat.v1.import_graph_def(self.fold_graph_def, name="")
-        with tf.compat.v1.Session(graph=fold_graph) as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            x = fold_graph.get_tensor_by_name("input:0")
-            normed = fold_graph.get_tensor_by_name("batch_normalization/FusedBatchNormV3:0")
-            y_fold = sess.run(normed, feed_dict={x: input_data})
-
-        assert np.allclose(y, y_fold, rtol=1e-05, atol=1e-05)
-
-    @unittest.skipIf(
-        version1_gte_version2(tf.version.VERSION, "2.16.1"),
-        "The TF BN is deleted after 2.16.1 while the fusion of Keras BN is not supported now",
-    )
-    def test_do_transform(self):
-        for node in self.fold_graph_def.node:
-            assert node.op not in ["FusedBatchNormV3"]
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_fold_const.py b/test/tensorflow/quantization/ptq/test_fold_const.py
deleted file mode 100644
index 49abd442ef0..00000000000
--- a/test/tensorflow/quantization/ptq/test_fold_const.py
+++ /dev/null
@@ -1,193 +0,0 @@
-import unittest
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.core.framework import attr_value_pb2, graph_pb2, node_def_pb2
-from tensorflow.python.framework import tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.fold_constant import (
-    GraphFoldConstantOptimizer,
-)
-
-
-class TestFoldConstant(unittest.TestCase):
-    x_node = node_def_pb2.NodeDef()
-    x_node.name = "placeholder"
-    x_node.op = "Placeholder"
-
-    input0_node = node_def_pb2.NodeDef()
-    input0_node.name = "input0"
-    input0_node.op = "Const"
-    input0_value = np.float32(np.abs(np.random.randn(4, 3, 2)))
-    input0_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(input0_value, input0_value.dtype.type, input0_value.shape)
-        )
-    )
-
-    input1_node = node_def_pb2.NodeDef()
-    input1_node.name = "input1"
-    input1_node.op = "Const"
-    input1_value = np.float32(np.abs(np.random.randn(4, 1, 1)))
-    input1_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(input1_value, input1_value.dtype.type, input1_value.shape)
-        )
-    )
-
-    add_node = node_def_pb2.NodeDef()
-    add_node.op = "Add"
-    add_node.name = "add"
-    add_node.input.extend([input0_node.name, input1_node.name])
-
-    input2_node = node_def_pb2.NodeDef()
-    input2_node.name = "input2"
-    input2_node.op = "Const"
-    input2_value = np.float32(np.abs(np.random.randn(1)))
-    input2_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(input2_value, input2_value.dtype.type, input2_value.shape)
-        )
-    )
-
-    input3_node = node_def_pb2.NodeDef()
-    input3_node.name = "input3"
-    input3_node.op = "Const"
-    input3_value = np.float32(np.abs(np.random.randn(1)))
-    input3_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(input3_value, input3_value.dtype.type, input3_value.shape)
-        )
-    )
-
-    switch_node = node_def_pb2.NodeDef()
-    switch_node.name = "switch"
-    switch_node.op = "Switch"
-
-    input4_node = node_def_pb2.NodeDef()
-    input4_node.name = "input4"
-    input4_node.op = "Const"
-    input4_value = np.float32(np.abs(np.random.randn(1)))
-    input4_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(input4_value, input4_value.dtype.type, input4_value.shape)
-        )
-    )
-    input4_node.input.extend([switch_node.name])
-
-    input5_node = node_def_pb2.NodeDef()
-    input5_node.name = "input5"
-    input5_node.op = "Const"
-    input5_value = np.float32(np.abs(np.random.randn(1)))
-    input5_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(input5_value, input5_value.dtype.type, input5_value.shape)
-        )
-    )
-    input5_node.input.extend([switch_node.name])
-
-    cond_end = node_def_pb2.NodeDef()
-    cond_end.name = "cond"
-    cond_end.op = "Add"
-    cond_end.input.extend([input4_node.name, input5_node.name])
-
-    mul_node = node_def_pb2.NodeDef()
-    mul_node.op = "Mul"
-    mul_node.name = "mul"
-    mul_node.input.extend([add_node.name, input3_node.name])
-
-    sqrt_node = node_def_pb2.NodeDef()
-    sqrt_node.name = "rsqrt"
-    sqrt_node.op = "Rsqrt"
-    sqrt_node.input.extend([mul_node.name])
-
-    relu_node = node_def_pb2.NodeDef()
-    relu_node.op = "Relu"
-    relu_node.name = "relu"
-    relu_node.input.extend([sqrt_node.name])
-
-    block_node = node_def_pb2.NodeDef()
-    block_node.name = "block_output"
-    block_node.op = "Add"
-    block_node.input.extend([x_node.name, relu_node.name])
-
-    res_node = node_def_pb2.NodeDef()
-    res_node.name = "res_add"
-    res_node.op = "Add"
-    res_node.input.extend([sqrt_node.name, input2_node.name])
-
-    end_node = node_def_pb2.NodeDef()
-    end_node.name = "end"
-    end_node.op = "Add"
-    end_node.input.extend([block_node.name, res_node.name])
-
-    graph_def = graph_pb2.GraphDef()
-    graph_def.node.extend(
-        [
-            x_node,
-            input0_node,
-            input1_node,
-            input2_node,
-            input3_node,
-            add_node,
-            mul_node,
-            sqrt_node,
-            relu_node,
-            block_node,
-            res_node,
-            end_node,
-        ]
-    )
-
-    def test_fold_constant(self):
-        graph = self.graph_def
-        rewriter = GraphFoldConstantOptimizer(graph)
-        new_graph = rewriter.do_transformation()
-
-        for node in new_graph.node:
-            assert node.name in ["placeholder", "block_output", "rsqrt_const", "relu", "res_add_const", "end"]
-
-    def test_condition_fold_constant(self):
-        graph_def = graph_pb2.GraphDef()
-        graph_def.node.extend([self.cond_end, self.input4_node, self.input5_node, self.switch_node])
-        rewriter = GraphFoldConstantOptimizer(graph_def)
-        new_graph = rewriter.do_transformation()
-        for node in new_graph.node:
-            assert node.name in ["switch", "cond", "input4", "input5"]
-
-    def test_slice_int_input(self):
-        graph_def = graph_pb2.GraphDef()
-        index0_node = node_def_pb2.NodeDef()
-        index0_node.name = "index0"
-        index0_node.op = "Const"
-        index0_value = np.array(3).astype(np.int32).reshape(())
-        index0_node.attr["value"].CopyFrom(
-            attr_value_pb2.AttrValue(
-                tensor=tensor_util.make_tensor_proto(index0_value, index0_value.dtype.type, index0_value.shape)
-            )
-        )
-
-        index1_node = node_def_pb2.NodeDef()
-        index1_node.name = "index1"
-        index1_node.op = "Const"
-        index1_value = np.array(1).astype(np.int32).reshape(())
-        index1_node.attr["value"].CopyFrom(
-            attr_value_pb2.AttrValue(
-                tensor=tensor_util.make_tensor_proto(index1_value, index1_value.dtype.type, index1_value.shape)
-            )
-        )
-
-        minus_node = node_def_pb2.NodeDef()
-        minus_node.name = "sub"
-        minus_node.op = "Sub"
-        minus_node.input.extend([index0_node.name, index1_node.name])
-
-        graph_def.node.extend([index0_node, index1_node, minus_node])
-        rewriter = GraphFoldConstantOptimizer(graph_def)
-        new_graph = rewriter.do_transformation()
-        with tf.compat.v1.Session() as sess:
-            tf.compat.v1.import_graph_def(new_graph)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_gpu.py b/test/tensorflow/quantization/ptq/test_gpu.py
deleted file mode 100644
index e3358940dd5..00000000000
--- a/test/tensorflow/quantization/ptq/test_gpu.py
+++ /dev/null
@@ -1,107 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import logging
-import os
-import platform
-import sys
-import unittest
-from importlib.abc import MetaPathFinder
-
-import cpuinfo
-import tensorflow as tf
-
-
-class TestTensorflowGpu(unittest.TestCase):
-    mb_model_url = (
-        "https://storage.googleapis.com/intel-optimized-tensorflow/models/v1_6/mobilenet_v1_1.0_224_frozen.pb"
-    )
-    pb_path = "/tmp/.neural_compressor/mobilenet_fp32.pb"
-    platforms = platform.system().lower()
-    if platforms == "windows":
-        pb_path = "C:\\tmp\\.neural_compressor\\mobilenet_fp32.pb"
-
-    @classmethod
-    def setUpClass(cls):
-        if not os.path.exists(cls.pb_path):
-            if cls.platforms == "linux":
-                os.system("mkdir -p /tmp/.neural_compressor && wget {} -O {} ".format(cls.mb_model_url, cls.pb_path))
-            elif cls.platforms == "windows":
-                os.system("md C:\\tmp\.neural_compressor && cd C:\\tmp\.neural_compressor")
-                from urllib import request
-
-                if not cls.mb_model_url.startswith(("http://", "https://")):
-                    raise ValueError("Only http/https URLs are supported.")
-                request.urlretrieve(cls.mb_model_url)  # nosec B310
-        cls.log_env = os.environ.get("LOGLEVEL")
-        cls.logger_root = logging.getLogger()
-        cls.logger_nc = logging.getLogger("neural_compressor")
-        cls.logger_root.setLevel(logging.CRITICAL)
-        cls.logger_nc.setLevel(logging.DEBUG)
-        cls.logger_root_level = cls.logger_root.level
-        cls.logger_nc.warning(f"CPU: {cpuinfo.get_cpu_info()['brand_raw']}")
-        cls.logger_nc.warning(f"Environment variable: LOGLEVEL = {cls.log_env}")
-        cls.logger_nc.warning(
-            f"Before importing neural_compressor: {sys.modules[__name__].__file__}-{cls.__name__}, "
-            f"Root_Logger_Level = {cls.logger_root.level}"
-        )
-        cls.logger_nc.warning(
-            f"Before importing neural_compressor: {sys.modules[__name__].__file__}-{cls.__name__}, "
-            f"NC_Logger_Level = {cls.logger_nc.level}"
-        )
-        import neural_compressor
-        from neural_compressor.tensorflow.algorithms.static_quant.tensorflow import TensorflowQuery
-
-        cls.op_wise_sequences = TensorflowQuery(
-            local_config_file=neural_compressor.__path__[0] + "/tensorflow/algorithms/static_quant/tensorflow.yaml"
-        ).get_eightbit_patterns()
-
-        cls.logger_nc.warning(
-            f"After importing neural_compressor: {sys.modules[__name__].__file__}-{cls.__name__}, "
-            f"Root_Logger_Level = {cls.logger_root.level}"
-        )
-        cls.logger_nc.warning(
-            f"After importing neural_compressor: {sys.modules[__name__].__file__}-{cls.__name__}, "
-            f"NC_Logger_Level = {cls.logger_nc.level}"
-        )
-
-    def test_tensorflow_gpu_conversion(self):
-        from neural_compressor.tensorflow.quantization.utils.graph_rewriter.int8.post_hostconst_converter import (
-            PostHostConstConverter,
-        )
-        from neural_compressor.tensorflow.quantization.utils.quantize_graph.quantize_graph_for_intel_cpu import (
-            QuantizeGraphForIntel,
-        )
-        from neural_compressor.tensorflow.quantization.utils.utility import read_graph
-
-        input_graph_def = read_graph(self.pb_path)
-        input_node_names = ["Placeholder"]
-        output_node_names = ["MobilenetV1/Predictions/Reshape_1"]
-        op_wise_config = {"MobilenetV1/MobilenetV1/Conv2d_1_pointwise/Conv2D": (False, "minmax", False, 7.0)}
-        tf.compat.v1.disable_eager_execution()
-
-        converter = QuantizeGraphForIntel(
-            input_graph_def, input_node_names, output_node_names, op_wise_config, self.op_wise_sequences, "gpu"
-        )
-        converted_pb, _, _ = converter.do_transform()
-        hostconst_pb = PostHostConstConverter(converted_pb).do_transformation()
-        target_node_name = "MobilenetV1/MobilenetV1/Conv2d_1_pointwise/Conv2D_eightbit_quantized_conv"
-
-        node_details = {}
-        for i in hostconst_pb.node:
-            node_details[i.name] = i
-
-        converted_flag = True if target_node_name in node_details else False
-        self.assertEqual(converted_flag, True)
-
-        target_node = node_details[target_node_name]
-        weights_min_node = node_details[target_node.input[-2]]
-        weights_max_node = node_details[target_node.input[-1]]
-        self.assertEqual(weights_max_node.op, "HostConst")
-        self.assertEqual(weights_min_node.op, "HostConst")
-
-        self.assertEqual(self.logger_root.level, self.logger_root_level)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_cac.py b/test/tensorflow/quantization/ptq/test_graph_cac.py
deleted file mode 100644
index 3bf896c0f59..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_cac.py
+++ /dev/null
@@ -1,146 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import unittest
-
-import tensorflow as tf
-from tensorflow.core.framework import graph_pb2
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.int8.scale_propagation import (
-    ScaleProPagationTransformer,
-)
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper
-
-
-class TestGraphScaleProPagation(unittest.TestCase):
-    def test_scale_propagation(self):
-        """Test scale propagation for below pattern
-        requantize + quantizedavgpool+ quantized conv2d + requantize."""
-        tf.compat.v1.disable_eager_execution()
-
-        input_constant_name = "input_constant"
-        relu_name = "relu"
-        float_graph_def = graph_pb2.GraphDef()
-        input_constant = QuantizeGraphHelper.create_constant_node(
-            input_constant_name, value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], dtype=dtypes.float32, shape=[1, 2, 6, 1]
-        )
-        float_graph_def.node.extend([input_constant])
-        requantize_min_name = "requantize_min_const"
-        requantize_min = QuantizeGraphHelper.create_constant_node(
-            requantize_min_name,
-            value=1,
-            dtype=dtypes.float32,
-        )
-        float_graph_def.node.extend([requantize_min])
-        requantize_max_name = "requantize_max_const"
-        requantize_max = QuantizeGraphHelper.create_constant_node(
-            requantize_max_name,
-            value=5,
-            dtype=dtypes.float32,
-        )
-        float_graph_def.node.extend([requantize_max])
-        relu_node = QuantizeGraphHelper.create_node(
-            "Requantize",
-            relu_name,
-            [
-                input_constant_name,
-                input_constant_name + ":1",
-                input_constant_name + ":2",
-                requantize_min_name,
-                requantize_max_name,
-            ],
-        )
-        QuantizeGraphHelper.set_attr_dtype(relu_node, "Tinput", dtypes.qint32)
-        QuantizeGraphHelper.set_attr_dtype(relu_node, "out_type", dtypes.quint8)
-        float_graph_def.node.extend([relu_node])
-
-        b_constant_name = "b_constant"
-        mat_mul_name = "mat_mul"
-        b_constant = QuantizeGraphHelper.create_constant_node(
-            b_constant_name,
-            value=[0],
-            dtype=dtypes.float32,
-            shape=[
-                1,
-            ],
-        )
-        float_graph_def.node.extend([b_constant])
-
-        avgpool_max_constant_name = "avgpool_max_constant"
-        mat_mul_name = "mat_mul"
-        avgpool_max = QuantizeGraphHelper.create_constant_node(
-            avgpool_max_constant_name,
-            value=[10],
-            dtype=dtypes.float32,
-            shape=[
-                1,
-            ],
-        )
-        float_graph_def.node.extend([avgpool_max])
-        quantized_avgpool = QuantizeGraphHelper.create_node(
-            "QuantizedAvgPool", mat_mul_name, [relu_name, b_constant_name, avgpool_max_constant_name]
-        )
-        QuantizeGraphHelper.set_attr_dtype(quantized_avgpool, "T", dtypes.float32)
-
-        float_graph_def.node.extend([quantized_avgpool])
-
-        bias_add_name = "bias_add"
-        offset_constant_name = "offset_constant"
-
-        offset_constant = QuantizeGraphHelper.create_constant_node(
-            offset_constant_name, value=[1, 2, 3, 4, 5, 6], dtype=dtypes.float32, shape=[6]
-        )
-        float_graph_def.node.extend([offset_constant])
-        bias_add_node = QuantizeGraphHelper.create_node(
-            "QuantizedConv2DWithBiasAndRelu", bias_add_name, [mat_mul_name, offset_constant_name]
-        )
-        QuantizeGraphHelper.set_attr_dtype(bias_add_node, "T", dtypes.float32)
-        float_graph_def.node.extend([bias_add_node])
-        post_min_value = -1
-        post_max_value = 7
-        post_requantize_min_name = "post_requantize_min_const"
-        post_requantize_min = QuantizeGraphHelper.create_constant_node(
-            post_requantize_min_name,
-            value=post_min_value,
-            dtype=dtypes.float32,
-        )
-        float_graph_def.node.extend([post_requantize_min])
-        post_requantize_max_name = "post_requantize_max_const"
-        post_requantize_max = QuantizeGraphHelper.create_constant_node(
-            post_requantize_max_name,
-            value=post_max_value,
-            dtype=dtypes.float32,
-        )
-        float_graph_def.node.extend([post_requantize_max])
-
-        post_requantize_name = "post_requantize"
-        post_requantize_node = QuantizeGraphHelper.create_node(
-            "Requantize",
-            post_requantize_name,
-            [
-                bias_add_name,
-                bias_add_name + ":1",
-                bias_add_name + ":2",
-                post_requantize_min_name,
-                post_requantize_max_name,
-            ],
-        )
-        float_graph_def.node.extend([post_requantize_node])
-
-        optimized_graph = ScaleProPagationTransformer(float_graph_def).do_transformation()
-        update_min_value = None
-        update_max_value = None
-        for node in optimized_graph.node:
-            if node.name == "relu_cac_requantize_min_value":
-                update_min_value = node.attr["value"].tensor.float_val[0]
-
-            if node.name == "relu_cac_requantize_max_value":
-                update_max_value = node.attr["value"].tensor.float_val[0]
-
-        self.assertEqual(update_min_value, post_min_value)
-        self.assertEqual(update_max_value, post_max_value)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_column_wise_mul.py b/test/tensorflow/quantization/ptq/test_graph_column_wise_mul.py
deleted file mode 100644
index 885e9392cac..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_column_wise_mul.py
+++ /dev/null
@@ -1,49 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import unittest
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.fuse_column_wise_mul import (
-    FuseColumnWiseMulOptimizer,
-)
-from neural_compressor.tensorflow.utils import disable_random
-
-
-class TestColumnWiseMulFusion(unittest.TestCase):
-    @disable_random()
-    def test_conv_mul_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(top_relu, paddings, "CONSTANT")
-        conv_weights = tf.constant(np.random.random((3, 3, 16, 16)), dtype=tf.float32)
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        mul_tensor = tf.constant([1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7], dtype=tf.float32)
-        mul = tf.math.multiply(conv, mul_tensor)
-        relu = tf.nn.relu(mul)
-        relu6 = tf.nn.relu6(relu, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-            output_graph_def = FuseColumnWiseMulOptimizer(output_graph_def).do_transformation()
-
-            found_mul = False
-
-            for i in output_graph_def.node:
-                if i.op == "Mul":
-                    found_mul = True
-                    break
-
-            self.assertEqual(found_mul, False)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_concat.py b/test/tensorflow/quantization/ptq/test_graph_concat.py
deleted file mode 100644
index e5ca34bd2a9..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_concat.py
+++ /dev/null
@@ -1,124 +0,0 @@
-#
-#
-#  -*- coding: utf-8 -*-
-import os
-import platform
-import unittest
-
-import tensorflow as tf
-from tensorflow.compat.v1 import graph_util
-
-import neural_compressor
-from neural_compressor.tensorflow.algorithms.static_quant.tensorflow import TensorflowQuery
-from neural_compressor.tensorflow.quantization.utils.quantize_graph.quantize_graph_for_intel_cpu import (
-    QuantizeGraphForIntel,
-)
-from neural_compressor.tensorflow.quantization.utils.utility import read_graph
-from neural_compressor.tensorflow.utils import disable_random
-
-
-class TestTensorflowConcat(unittest.TestCase):
-    mb_model_url = (
-        "https://storage.googleapis.com/intel-optimized-tensorflow/models/v1_8/inceptionv3_fp32_pretrained_model.pb"
-    )
-    pb_path = "/tmp/.neural_compressor/inceptionv3_fp32.pb"
-    platform = platform.system().lower()
-    if platform == "windows":
-        pb_path = "C:\\tmp\\.neural_compressor\\inceptionv3_fp32.pb"
-
-    @classmethod
-    def setUpClass(self):
-        if not os.path.exists(self.pb_path) and self.platform == "linux":
-            os.system("mkdir -p /tmp/.neural_compressor && wget {} -O {} ".format(self.mb_model_url, self.pb_path))
-        self.op_wise_sequences = TensorflowQuery(
-            local_config_file=neural_compressor.__path__[0] + "/tensorflow/algorithms/static_quant/tensorflow.yaml"
-        ).get_eightbit_patterns()
-
-    @unittest.skipIf(tf.__version__ < "2.0", "does not support on 1.15up3")
-    def test_tensorflow_concat_quantization(self):
-        from neural_compressor.tensorflow import quantize_model
-        from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-        fp32_graph_def = read_graph(self.pb_path)
-
-        dataset = DummyDataset(shape=(100, 299, 299, 3), label=True)
-        calib_dataloader = BaseDataLoader(dataset)
-        quant_config = {
-            "static_quant": {
-                "global": {
-                    "weight_dtype": "int8",
-                    "weight_sym": True,
-                    "weight_granularity": "per_tensor",
-                    "weight_algorithm": "minmax",
-                },
-            }
-        }
-        qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-        found_quantized_concat_node = False
-        target_concat_node_name = "v0/cg/incept_v3_a0/concat_eightbit_quantized_concatv2"
-        from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-
-        cur_graph = GraphAnalyzer()
-        cur_graph.graph = qmodel.graph_def
-        graph_info = cur_graph.parse_graph()
-        found_quantized_concat_node = target_concat_node_name in graph_info
-
-        self.assertEqual(found_quantized_concat_node, True)
-
-    @disable_random()
-    def test_concat_with_different_input_type(self):
-        from neural_compressor.tensorflow import quantize_model
-        from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset, version1_gte_version2
-
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 128, 16], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [2, 2, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv_bias = tf.compat.v1.get_variable("bias", [16], initializer=tf.compat.v1.random_normal_initializer())
-
-        x = tf.nn.relu(x)
-        sqrt = tf.math.sqrt(x)
-        relu_sqrt = tf.nn.relu(sqrt)
-        conv = tf.nn.conv2d(relu_sqrt, conv_weights, strides=[1, 2, 2, 1], padding="SAME", name="last")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        relu = tf.nn.relu(normed)
-        conv1 = tf.nn.conv2d(x, conv_weights, strides=[1, 2, 2, 1], padding="SAME", name="last")
-        conv_bias = tf.nn.bias_add(conv1, conv_bias)
-        concat = tf.concat([relu, conv_bias], 1)
-        final_node = tf.nn.relu(concat, name="op_to_store")
-        out_name = final_node.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            dataset = DummyDataset(shape=(100, 128, 128, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            quantized_concat = False
-            for i in qmodel.graph_def.node:
-                if i.op == "QuantizedConcatV2":
-                    quantized_concat = True
-            self.assertEqual(quantized_concat, False)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_conv_add_relu_fusion.py b/test/tensorflow/quantization/ptq/test_graph_conv_add_relu_fusion.py
deleted file mode 100644
index ddefcc78d7b..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_conv_add_relu_fusion.py
+++ /dev/null
@@ -1,61 +0,0 @@
-import os
-import unittest
-
-import tensorflow as tf
-from tensorflow.compat.v1 import graph_util
-
-import neural_compressor
-from neural_compressor.tensorflow.algorithms.static_quant.tensorflow import TensorflowQuery
-from neural_compressor.tensorflow.quantization.utils.quantize_graph.quantize_graph_for_intel_cpu import (
-    QuantizeGraphForIntel,
-)
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper
-from neural_compressor.tensorflow.utils import disable_random
-
-
-class TestConvAddRelu(unittest.TestCase):
-    @disable_random()
-    def test_conv_add_relu(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 224, 224, 3], name="input")
-
-        if tf.version.VERSION <= "2.1.0":
-            x = tf.nn.relu(x)
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv_bias = tf.compat.v1.get_variable("bias", [32], initializer=tf.compat.v1.random_normal_initializer())
-        conv1 = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME")
-        conv_bias = tf.nn.bias_add(conv1, conv_bias)
-        relu = tf.nn.relu(conv_bias, name="Relu_1")
-        op_wise_sequences = TensorflowQuery(
-            local_config_file=neural_compressor.__path__[0] + "/tensorflow/algorithms/static_quant/tensorflow.yaml"
-        ).get_eightbit_patterns()
-
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[relu.name.split(":")[0]]
-            )
-
-            output_graph_def = QuantizeGraphHelper.remove_training_nodes(
-                output_graph_def, protected_nodes=[relu.name.split(":")[0]]
-            )
-            inputs = [x.name.split(":")[0]]
-            outputs = [relu.name.split(":")[0]]
-            op_wise_config = {
-                "Conv2D": (False, "minmax", False, 7.0),
-            }
-
-            fold_graph_def, _, _ = QuantizeGraphForIntel(
-                output_graph_def, inputs, outputs, op_wise_config, op_wise_sequences, "cpu"
-            ).do_transform()
-            found_QuantizedConv2DWithBiasAndRelu = False
-            for i in fold_graph_def.node:
-                if i.op == "QuantizedConv2DWithBiasAndRelu":
-                    found_QuantizedConv2DWithBiasAndRelu = True
-                    break
-            self.assertEqual(found_QuantizedConv2DWithBiasAndRelu, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_conv_as_output.py b/test/tensorflow/quantization/ptq/test_graph_conv_as_output.py
deleted file mode 100644
index 3de83e3f13c..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_conv_as_output.py
+++ /dev/null
@@ -1,196 +0,0 @@
-import os
-import unittest
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.core.framework import attr_value_pb2, graph_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-
-
-def create_test_graph():
-    input_node = node_def_pb2.NodeDef()
-    input_node.name = "input"
-    input_node.op = "Placeholder"
-    input_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-
-    conv1_weight_node = node_def_pb2.NodeDef()
-    conv1_weight_node.name = "conv1_weights"
-    conv1_weight_node.op = "Const"
-    conv1_weight_value = np.float32(np.abs(np.random.randn(3, 3, 3, 32)))
-    conv1_weight_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    conv1_weight_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(
-                conv1_weight_value, conv1_weight_value.dtype.type, conv1_weight_value.shape
-            )
-        )
-    )
-
-    conv1_node = node_def_pb2.NodeDef()
-    conv1_node.name = "conv1"
-    conv1_node.op = "Conv2D"
-    conv1_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    conv1_node.input.extend([input_node.name, conv1_weight_node.name])
-    conv1_node.attr["strides"].CopyFrom(
-        attr_value_pb2.AttrValue(list=attr_value_pb2.AttrValue.ListValue(i=[1, 1, 1, 1]))
-    )
-    conv1_node.attr["dilations"].CopyFrom(
-        attr_value_pb2.AttrValue(list=attr_value_pb2.AttrValue.ListValue(i=[1, 1, 1, 1]))
-    )
-    conv1_node.attr["padding"].CopyFrom(attr_value_pb2.AttrValue(s=b"SAME"))
-    conv1_node.attr["data_format"].CopyFrom(attr_value_pb2.AttrValue(s=b"NHWC"))
-
-    bias_node = node_def_pb2.NodeDef()
-    bias_node.name = "conv1_bias"
-    bias_node.op = "Const"
-    bias_value = np.float32(np.abs(np.random.randn(32)))
-    bias_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    bias_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(bias_value, bias_value.dtype.type, bias_value.shape)
-        )
-    )
-
-    bias_add_node = node_def_pb2.NodeDef()
-    bias_add_node.name = "conv1_bias_add"
-    bias_add_node.op = "BiasAdd"
-    bias_add_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    bias_add_node.input.extend([conv1_node.name, bias_node.name])
-    bias_add_node.attr["data_format"].CopyFrom(attr_value_pb2.AttrValue(s=b"NHWC"))
-
-    relu_node = node_def_pb2.NodeDef()
-    relu_node.op = "Relu"
-    relu_node.name = "relu"
-    relu_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    relu_node.input.extend([bias_add_node.name])
-
-    conv2_weight_node = node_def_pb2.NodeDef()
-    conv2_weight_node.name = "conv2_weights"
-    conv2_weight_node.op = "Const"
-    conv2_weight_value = np.float32(np.abs(np.random.randn(3, 3, 32, 32)))
-    conv2_weight_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    conv2_weight_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(
-                conv2_weight_value, conv2_weight_value.dtype.type, conv2_weight_value.shape
-            )
-        )
-    )
-
-    conv2_node = node_def_pb2.NodeDef()
-    conv2_node.name = "conv2"
-    conv2_node.op = "Conv2D"
-    conv2_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    conv2_node.input.extend([relu_node.name, conv2_weight_node.name])
-    conv2_node.attr["strides"].CopyFrom(
-        attr_value_pb2.AttrValue(list=attr_value_pb2.AttrValue.ListValue(i=[1, 1, 1, 1]))
-    )
-    conv2_node.attr["dilations"].CopyFrom(
-        attr_value_pb2.AttrValue(list=attr_value_pb2.AttrValue.ListValue(i=[1, 1, 1, 1]))
-    )
-    conv2_node.attr["padding"].CopyFrom(attr_value_pb2.AttrValue(s=b"SAME"))
-    conv2_node.attr["data_format"].CopyFrom(attr_value_pb2.AttrValue(s=b"NHWC"))
-
-    bias_node2 = node_def_pb2.NodeDef()
-    bias_node2.name = "conv2_bias"
-    bias_node2.op = "Const"
-    bias_value2 = np.float32(np.abs(np.random.randn(32)))
-    bias_node2.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    bias_node2.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(bias_value2, bias_value2.dtype.type, bias_value2.shape)
-        )
-    )
-
-    bias_add_node2 = node_def_pb2.NodeDef()
-    bias_add_node2.name = "conv2_bias_add"
-    bias_add_node2.op = "BiasAdd"
-    bias_add_node2.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    bias_add_node2.input.extend([conv2_node.name, bias_node2.name])
-    bias_add_node2.attr["data_format"].CopyFrom(attr_value_pb2.AttrValue(s=b"NHWC"))
-
-    relu_node2 = node_def_pb2.NodeDef()
-    relu_node2.op = "Relu"
-    relu_node2.name = "relu2"
-    relu_node2.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    relu_node2.input.extend([bias_add_node2.name])
-
-    log_node = node_def_pb2.NodeDef()
-    log_node.name = "log1"
-    log_node.op = "Log"
-    log_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    log_node.input.extend([relu_node2.name])
-
-    conv3_weight_node = node_def_pb2.NodeDef()
-    conv3_weight_node.name = "conv3_weights"
-    conv3_weight_node.op = "Const"
-    conv3_weight_value = np.float32(np.abs(np.random.randn(3, 3, 32, 32)))
-    conv3_weight_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    conv3_weight_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(
-                conv3_weight_value, conv3_weight_value.dtype.type, conv3_weight_value.shape
-            )
-        )
-    )
-
-    conv3_node = node_def_pb2.NodeDef()
-    conv3_node.name = "conv3"
-    conv3_node.op = "Conv2D"
-    conv3_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    conv3_node.input.extend([log_node.name, conv3_weight_node.name])
-    conv3_node.attr["strides"].CopyFrom(
-        attr_value_pb2.AttrValue(list=attr_value_pb2.AttrValue.ListValue(i=[1, 1, 1, 1]))
-    )
-    conv3_node.attr["dilations"].CopyFrom(
-        attr_value_pb2.AttrValue(list=attr_value_pb2.AttrValue.ListValue(i=[1, 1, 1, 1]))
-    )
-    conv3_node.attr["padding"].CopyFrom(attr_value_pb2.AttrValue(s=b"SAME"))
-    conv3_node.attr["data_format"].CopyFrom(attr_value_pb2.AttrValue(s=b"NHWC"))
-
-    test_graph = graph_pb2.GraphDef()
-
-    test_graph.node.extend(
-        [
-            input_node,
-            conv1_weight_node,
-            conv1_node,
-            bias_node,
-            bias_add_node,
-            relu_node,
-            conv2_weight_node,
-            conv2_node,
-            bias_node2,
-            bias_add_node2,
-            log_node,
-            relu_node2,
-            conv3_weight_node,
-            conv3_node,
-        ]
-    )
-    return test_graph
-
-
-@unittest.skipIf(tf.__version__ < "2.8.0", "only support spr-base TF")
-class TestConvAsOutput(unittest.TestCase):
-    @classmethod
-    def setUpClass(self):
-        self.test_graph = create_test_graph()
-
-    def test_do_transform(self):
-        from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-        from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-        fp32_graph_def = create_test_graph()
-        dataset = DummyDataset(shape=(1, 224, 224, 3), label=True)
-        calib_dataloader = BaseDataLoader(dataset)
-        quant_config = StaticQuantConfig()
-        qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-        for node in qmodel.graph_def.node:
-            if node.name == "conv3_eightbit_requantize":
-                self.assertTrue("Quantized" in node.op)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_conv_fusion.py b/test/tensorflow/quantization/ptq/test_graph_conv_fusion.py
deleted file mode 100644
index 163514f113a..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_conv_fusion.py
+++ /dev/null
@@ -1,658 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import os
-import platform
-import unittest
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.compat.v1 import graph_util
-
-import neural_compressor
-from neural_compressor.tensorflow import quantize_model
-from neural_compressor.tensorflow.algorithms.static_quant.tensorflow import TensorflowQuery
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.fold_batch_norm import (
-    FoldBatchNormNodesOptimizer,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.strip_unused_nodes import (
-    StripUnusedNodesOptimizer,
-)
-from neural_compressor.tensorflow.quantization.utils.quantize_graph.quantize_graph_for_intel_cpu import (
-    QuantizeGraphForIntel,
-)
-from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset, disable_random, version1_gte_version2
-
-
-class TestConvBiasAddAddReluFusion(unittest.TestCase):
-
-    @disable_random()
-    def test_conv_relu_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(top_relu, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        relu = tf.nn.relu(conv)
-
-        relu6 = tf.nn.relu6(relu, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = True
-            for i in qmodel.graph_def.node:
-                if i.op == "Relu":
-                    found_conv_fusion = False
-                    break
-
-            self.assertEqual(found_conv_fusion, False)
-
-    @disable_random()
-    @unittest.skipIf(tf.__version__ < "2.0", "does not support on 1.15up3")
-    def test_depthwiseconv_biasadd_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(top_relu, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.depthwise_conv2d(x_pad, conv_weights, strides=[1, 1, 1, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization(name="op_to_store")(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv, name="op_to_store")
-        )
-        out_name = normed.name.split(":")[0]
-
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "QuantizedDepthwiseConv2DWithBias":
-                    found_conv_fusion = True
-                    break
-                if i.op == "QuantizedDepthwiseConv2D" and version1_gte_version2(tf.__version__, "2.16.1"):
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_depthwiseconv_biasadd_fusion_with_negative_input(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.depthwise_conv2d(x_pad, conv_weights, strides=[1, 1, 1, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization(name="op_to_store")(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv, name="op_to_store")
-        )
-        out_name = normed.name.split(":")[0]
-
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "QuantizedDepthwiseConv2DWithBias":
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, False)
-
-    @unittest.skipUnless(
-        bool(tf.version.VERSION.find("1.15.0-up") != -1 or tf.version.VERSION >= "2.1.0"),
-        "not supported the current tf version.",
-    )
-    @disable_random()
-    def test_conv_biasadd_relu6_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization(name="op_to_store")(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv, name="op_to_store")
-        )
-
-        relu6 = tf.nn.relu6(normed, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = True
-            for i in qmodel.graph_def.node:
-                if i.op == "Relu6":
-                    found_conv_fusion = False
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv_biasadd_add_relu_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-
-        conv_weights2 = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(top_relu, conv_weights2, strides=[1, 2, 2, 1], padding="SAME")
-        normed2 = tf.nn.bias_add(conv2, tf.constant([3.0, 1.2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 12, 2, 3, 4]))
-        relu = tf.nn.relu(normed2 + tf.constant([3.0]))
-        relu6 = tf.nn.relu6(relu, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op.find("QuantizedConv2D") != -1:
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv_squeeze_biasadd_relu_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-
-        conv_weights2 = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(top_relu, conv_weights2, strides=[1, 2, 2, 1], padding="SAME")
-        squeeze = tf.squeeze(conv2)
-        normed2 = tf.nn.bias_add(conv2, tf.constant([3.0, 1.2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 12, 2, 3, 4]))
-        relu = tf.nn.relu(normed2)
-        identity = tf.identity(relu, name="op_to_store")
-
-        out_name = identity.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            correct_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "QuantizedConv2DWithBiasAndReluAndRequantize":
-                    correct_conv_fusion = True
-                    break
-
-            self.assertEqual(correct_conv_fusion, True)
-
-    @disable_random()
-    def test_conv_biasadd_addv2_relu_fallback_fusion_1(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.leaky_relu(x)
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization(name="op_to_store")(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv, name="op_to_store")
-        )
-        # relu = tf.nn.relu(normed)
-
-        conv_weights2 = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(top_relu, conv_weights2, strides=[1, 2, 2, 1], padding="SAME")
-        normed2 = (
-            tf.keras.layers.BatchNormalization(name="op_to_store")(conv2)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv2, name="op_to_store")
-        )
-        # relu2 = tf.nn.relu(normed2)
-        add = tf.raw_ops.AddV2(x=normed, y=normed2, name="addv2")
-        relu = tf.nn.relu(add)
-        relu6 = tf.nn.relu6(relu, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "QuantizedConv2DWithBiasAndRequantize":
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv_biasadd_addv2_relu_fallback_fusion_2(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(top_relu, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization(name="op_to_store")(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv, name="op_to_store")
-        )
-        # relu = tf.nn.relu(normed)
-
-        conv_weights2 = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(top_relu, conv_weights2, strides=[1, 2, 2, 1], padding="SAME")
-        normed2 = (
-            tf.keras.layers.BatchNormalization(name="op_to_store")(conv2)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv2, name="op_to_store")
-        )
-        # relu2 = tf.nn.relu(normed2)
-        add = tf.raw_ops.AddV2(x=normed, y=normed2, name="addv2")
-        relu = tf.nn.relu(add)
-        relu6 = tf.nn.relu6(relu, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op == "QuantizedConv2DWithBiasSignedSumAndReluAndRequantize":
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-    @disable_random()
-    def test_conv_fusion_with_last_matmul(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        # paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        # x_pad = tf.pad(top_relu, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(top_relu, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization(name="op_to_store")(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv, name="op_to_store")
-        )
-
-        relu = tf.nn.relu(normed)
-        pooling = tf.nn.max_pool(relu, ksize=1, strides=[1, 2, 2, 1], padding="SAME")
-        reshape = tf.reshape(pooling, [-1, 3136])
-
-        y_data = np.random.random([3136, 1])
-
-        y = tf.constant(y_data, dtype=tf.float32, shape=[3136, 1])
-        z = tf.matmul(reshape, y)
-        relu1 = tf.nn.relu(z)
-        y_data_1 = np.random.random([1, 1])
-        y_1 = tf.constant(y_data_1, dtype=tf.float32, shape=[1, 1])
-
-        z_2nd_matmul = tf.matmul(relu1, y_1)
-        relu6 = tf.nn.relu6(z_2nd_matmul, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            quantize_v2_count = 0
-            for i in qmodel.graph_def.node:
-                if i.op == "QuantizeV2":
-                    quantize_v2_count += 1
-                    break
-
-            self.assertEqual(quantize_v2_count, 1)
-
-    @disable_random()
-    def test_conv_fusion_with_last_conv(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(top_relu, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization(name="op_to_store")(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv, name="op_to_store")
-        )
-
-        relu = tf.nn.relu(normed)
-        pooling = tf.nn.max_pool(relu, ksize=1, strides=[1, 2, 2, 1], padding="SAME")
-        conv_weights_2 = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(pooling, conv_weights_2, strides=[1, 2, 2, 1], padding="VALID")
-        conv_weights_3 = tf.compat.v1.get_variable(
-            "weight3", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        relu2 = tf.nn.relu(conv2)
-        conv3 = tf.nn.conv2d(relu2, conv_weights_3, strides=[1, 2, 2, 1], padding="VALID")
-
-        relu3 = tf.nn.relu(conv3)
-        relu6 = tf.nn.relu6(relu3, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            quantize_v2_count = 0
-            for i in qmodel.graph_def.node:
-                if i.op == "QuantizeV2":
-                    quantize_v2_count += 1
-                    break
-
-            self.assertEqual(quantize_v2_count, 1)
-
-    @disable_random()
-    def test_conv_fusion_with_max_pooling(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-
-        relu = tf.nn.relu(x)
-        pooling = tf.nn.max_pool(relu, ksize=1, strides=[1, 2, 2, 1], padding="SAME")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(pooling, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        biasadd = (
-            tf.keras.layers.BatchNormalization(name="op_to_store")(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv, name="op_to_store")
-        )
-        out_name = biasadd.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            quantized_pool_data_type = None
-            quantized_conv_data_type = None
-            for i in qmodel.graph_def.node:
-                if i.op.find("QuantizedMaxPool") != -1:
-                    quantized_pool_data_type = i.attr["T"].type
-                if i.op.find("QuantizedConv2D") != -1:
-                    quantized_conv_data_type = i.attr["Tinput"].type
-
-            self.assertNotEqual(quantized_pool_data_type, None)
-            self.assertEqual(quantized_pool_data_type, quantized_conv_data_type)
-
-
-class TestGraphConvFusion(unittest.TestCase):
-    rn50_fp32_pb_url = (
-        "https://storage.googleapis.com/intel-optimized-tensorflow/models/v1_6/resnet50_fp32_pretrained_model.pb"
-    )
-    pb_path = "/tmp/.neural_compressor/resnet50_fp32_pretrained_model.pb"
-    platform = platform.system().lower()
-    if platform == "windows":
-        pb_path = "C:\\tmp\.neural_compressor\\resnet50_fp32_pretrained_model.pb"
-    inputs = ["input"]
-    outputs = ["predict"]
-
-    op_wise_config = {
-        "v0/resnet_v13/conv14/conv2d/Conv2D": (False, "minmax", False, 7.0),
-        "v0/resnet_v13/conv11/conv2d/Conv2D": (False, "minmax", False, 7.0),
-        "v0/resnet_v17/conv27/conv2d/Conv2D": (False, "minmax", False, 7.0),
-    }
-
-    @classmethod
-    def setUpClass(self):
-        if not os.path.exists(self.pb_path):
-            if self.platform == "linux":
-                os.system(
-                    "mkdir -p /tmp/.neural_compressor && wget {} -O {} ".format(self.rn50_fp32_pb_url, self.pb_path)
-                )
-            elif self.platform == "windows":
-                os.system("md C:\\tmp\.neural_compressor && cd C:\\tmp\.neural_compressor")
-                from urllib import request
-
-                if not self.rn50_fp32_pb_url.startswith(("http://", "https://")):
-                    raise ValueError("Only http/https URLs are supported.")
-                request.urlretrieve(self.rn50_fp32_pb_url)  # nosec B310
-        self.input_graph = tf.compat.v1.GraphDef()
-        with open(self.pb_path, "rb") as f:
-            self.input_graph.ParseFromString(f.read())
-
-    def test_conv_biasadd_relu_fusion(self):
-        tf.compat.v1.disable_eager_execution()
-
-        self._tmp_graph_def = graph_util.remove_training_nodes(self.input_graph, self.outputs)
-
-        self._tmp_graph_def = StripUnusedNodesOptimizer(
-            self._tmp_graph_def, self.inputs, self.outputs
-        ).do_transformation()
-
-        self._tmp_graph_def = FoldBatchNormNodesOptimizer(self._tmp_graph_def).do_transformation()
-        op_wise_sequences = TensorflowQuery(
-            local_config_file=neural_compressor.__path__[0] + "/tensorflow/algorithms/static_quant/tensorflow.yaml"
-        ).get_eightbit_patterns()
-
-        output_graph, _, _ = QuantizeGraphForIntel(
-            self._tmp_graph_def, self.inputs, self.outputs, self.op_wise_config, op_wise_sequences, "cpu"
-        ).do_transform()
-
-        node_name_type_mapping = {}
-        for i in output_graph.node:
-            node_name_type_mapping[i.name] = i.op
-
-        should_disable_sum_node_name = "v0/resnet_v17/conv27/conv2d/Conv2D_eightbit_quantized_conv"
-        should_enable_sum_node_name = "v0/resnet_v13/conv11/conv2d/Conv2D_eightbit_quantized_conv"
-        should_disable_sum_flag = (
-            should_disable_sum_node_name in node_name_type_mapping
-            and node_name_type_mapping[should_disable_sum_node_name] == "QuantizedConv2DWithBias"
-        )
-        should_enable_sum_flag = (
-            should_enable_sum_node_name in node_name_type_mapping
-            and node_name_type_mapping[should_enable_sum_node_name] == "QuantizedConv2DWithBiasSumAndRelu"
-        )
-        self.assertEqual(should_enable_sum_flag, True)
-        self.assertEqual(should_disable_sum_flag, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_conv_math.py b/test/tensorflow/quantization/ptq/test_graph_conv_math.py
deleted file mode 100644
index 7689cbd4585..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_conv_math.py
+++ /dev/null
@@ -1,64 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-
-import unittest
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.fuse_conv_with_math import (
-    FuseConvWithMathOptimizer,
-)
-from neural_compressor.tensorflow.utils import disable_random
-
-
-class TestConvWithMath(unittest.TestCase):
-    @disable_random()
-    def test_convert_conv_with_math(self):
-        tf.compat.v1.disable_eager_execution()
-        x = tf.compat.v1.placeholder(tf.float32, [1, 224, 224, 3], name="input")
-
-        conv = tf.nn.conv2d(
-            x, tf.constant(np.random.random([3, 3, 3, 16]), dtype=tf.float32), strides=[1, 1, 1, 1], padding="SAME"
-        )
-        sub = tf.math.subtract(conv, tf.constant(np.random.random(16), dtype=tf.float32))
-        realdiv = tf.realdiv(sub, tf.constant(np.random.random(16), dtype=tf.float32))
-
-        mul = tf.math.multiply(realdiv, tf.constant(np.random.random(16), dtype=tf.float32))
-        conv_add = tf.nn.bias_add(mul, tf.constant(np.random.random(16), dtype=tf.float32), name="bias_add")
-
-        relu = tf.nn.relu(conv_add)
-        identity = tf.identity(relu)
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[identity.name.split(":")[0]]
-            )
-        fixed_input = np.random.random([1, 224, 224, 3])
-
-        default_g = tf.Graph()
-        with default_g.as_default():
-            tf.import_graph_def(graph_def, name="")
-        with tf.compat.v1.Session(graph=default_g) as sess:
-            output = sess.run(["Identity:0"], {"input:0": fixed_input})
-
-        post_graph = FuseConvWithMathOptimizer(graph_def).do_transformation()
-        g = tf.Graph()
-        with g.as_default():
-            tf.import_graph_def(post_graph, name="optimized")
-        with tf.compat.v1.Session(graph=g) as sess:
-            optimized_output = sess.run(["optimized/Identity:0"], {"optimized/input:0": fixed_input})
-
-        converted = True
-        for node in post_graph.node:
-            if node.op.find("Sub") != -1:
-                converted = False
-        self.assertEqual(converted, True)
-
-        self.assertEqual(np.allclose(output[0], optimized_output[0]), True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_convert_layout.py b/test/tensorflow/quantization/ptq/test_graph_convert_layout.py
deleted file mode 100644
index 35cbee2e32d..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_convert_layout.py
+++ /dev/null
@@ -1,42 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-
-import unittest
-
-import tensorflow as tf
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.convert_layout import ConvertLayoutOptimizer
-from neural_compressor.tensorflow.utils import version1_lt_version2
-
-
-class TestConvertLayout(unittest.TestCase):
-    def test_convert_layout(self):
-        if version1_lt_version2(tf.version.VERSION, "2.4.0"):
-            return
-        tf.compat.v1.disable_eager_execution()
-        with tf.device("/CPU:0"):
-            x = tf.compat.v1.placeholder(tf.float32, [1, 3, 224, 224], name="input")
-            conv_weights = tf.compat.v1.get_variable(
-                "weight", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-            )
-            conv = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME", data_format="NCHW")
-            relu = tf.nn.relu(conv)
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[relu.name.split(":")[0]]
-            )
-        outputs = [relu.name.split(":")[0]]
-
-        post_graph = ConvertLayoutOptimizer(graph_def, outputs).do_transformation()
-        converted = False
-        for node in post_graph.node:
-            if "data_format" in node.attr and node.attr["data_format"].s == b"NHWC":
-                converted = True
-        self.assertEqual(converted, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_convert_leakyrelu.py b/test/tensorflow/quantization/ptq/test_graph_convert_leakyrelu.py
deleted file mode 100644
index db79591211d..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_convert_leakyrelu.py
+++ /dev/null
@@ -1,144 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-
-import unittest
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.convert_leakyrelu import (
-    ConvertLeakyReluOptimizer,
-)
-from neural_compressor.tensorflow.utils import disable_random
-
-
-class TestConvertLeaklyRelu(unittest.TestCase):
-    @disable_random()
-    def test_convert_leakyrelu(self):
-        tf.compat.v1.disable_eager_execution()
-        x = tf.compat.v1.placeholder(tf.float32, [1, 3, 224, 224], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME", data_format="NCHW")
-        relu = tf.nn.relu(conv)
-        mul = tf.math.multiply(relu, tf.constant([0.1]))
-        maximum = tf.math.maximum(relu, mul)
-        identity = tf.identity(maximum)
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[identity.name.split(":")[0]]
-            )
-        post_graph = ConvertLeakyReluOptimizer(graph_def).do_transformation()
-        converted = False
-        for node in post_graph.node:
-            if node.op == "LeakyRelu":
-                converted = True
-        self.assertEqual(converted, True)
-
-    @disable_random()
-    def test_convert_leakyrelu_with_alpha_large_than_one(self):
-        tf.compat.v1.disable_eager_execution()
-        x = tf.compat.v1.placeholder(tf.float32, [1, 3, 224, 224], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME", data_format="NCHW")
-        relu = tf.nn.relu(conv)
-        mul = tf.math.multiply(relu, tf.constant([3.1]))
-        maximum = tf.math.maximum(relu, mul)
-        identity = tf.identity(maximum)
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[identity.name.split(":")[0]]
-            )
-        post_graph = ConvertLeakyReluOptimizer(graph_def).do_transformation()
-        converted = False
-        for node in post_graph.node:
-            if node.op == "LeakyRelu":
-                converted = True
-        self.assertEqual(converted, False)
-
-    @disable_random()
-    def test_convert_leakyrelu_with_invalid_maximum(self):
-        tf.compat.v1.disable_eager_execution()
-        x = tf.compat.v1.placeholder(tf.float32, [1, 3, 224, 224], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME", data_format="NCHW")
-        relu = tf.nn.relu(conv)
-        mul = tf.math.multiply(relu, tf.constant([2.1]))
-
-        maximum = tf.math.maximum(conv, mul)
-        identity = tf.identity(maximum)
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[identity.name.split(":")[0]]
-            )
-        post_graph = ConvertLeakyReluOptimizer(graph_def).do_transformation()
-        converted = False
-        for node in post_graph.node:
-            if node.op == "LeakyRelu":
-                converted = True
-        self.assertEqual(converted, False)
-
-    @disable_random()
-    def test_convert_leakyrelu_with_invalid_maximum_ndim(self):
-        tf.compat.v1.disable_eager_execution()
-        x = tf.compat.v1.placeholder(tf.float32, [1, 3, 12, 12], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME", data_format="NCHW")
-        mul = tf.math.multiply(conv, tf.constant(np.random.random((1, 32, 12, 12)).astype(np.float32)))
-
-        maximum = tf.math.maximum(conv, mul)
-        identity = tf.identity(maximum)
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[identity.name.split(":")[0]]
-            )
-
-        post_graph = ConvertLeakyReluOptimizer(graph_def).do_transformation()
-        converted = False
-        for node in post_graph.node:
-            if node.op == "LeakyRelu":
-                converted = True
-        self.assertEqual(converted, False)
-
-    @disable_random()
-    def test_convert_leakyrelu_with_invalid_mul(self):
-        tf.compat.v1.disable_eager_execution()
-        x = tf.compat.v1.placeholder(tf.float32, [1, 3, 224, 224], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME", data_format="NCHW")
-        relu = tf.nn.relu(conv)
-        const_identity = tf.identity(tf.constant([0.1]))
-        mul = tf.math.multiply(relu, const_identity)
-
-        maximum = tf.math.maximum(conv, mul)
-        identity = tf.identity(maximum)
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[identity.name.split(":")[0]]
-            )
-        post_graph = ConvertLeakyReluOptimizer(graph_def).do_transformation()
-        converted = False
-        for node in post_graph.node:
-            if node.op == "LeakyRelu":
-                converted = True
-        self.assertEqual(converted, False)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_convert_nan.py b/test/tensorflow/quantization/ptq/test_graph_convert_nan.py
deleted file mode 100644
index b2713c09f41..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_convert_nan.py
+++ /dev/null
@@ -1,54 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-
-import unittest
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.compat.v1 import graph_util
-from tensorflow.python.framework import tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.convert_nan_to_random import (
-    ConvertNanToRandom,
-)
-from neural_compressor.tensorflow.utils import disable_random
-
-
-class TestNanConvert(unittest.TestCase):
-    @disable_random()
-    def test_convert_nan_to_float(self):
-        tf.compat.v1.disable_eager_execution()
-        x = tf.compat.v1.placeholder(tf.float32, [1, 224, 224, 3], name="input")
-
-        conv = tf.nn.conv2d(
-            x, tf.constant(np.random.random([3, 3, 3, 16]), dtype=tf.float32), strides=[1, 1, 1, 1], padding="SAME"
-        )
-        sub = tf.math.subtract(conv, tf.constant(np.random.random(16), dtype=tf.float32))
-        realdiv = tf.realdiv(sub, tf.constant(np.random.random(16), dtype=tf.float32))
-
-        mul = tf.math.multiply(realdiv, tf.constant(np.random.random(16), dtype=tf.float32))
-
-        conv_add = tf.nn.bias_add(mul, tf.constant(np.full((16,), np.nan), dtype=tf.float32), name="bias_add")
-
-        relu = tf.nn.relu(conv_add)
-        identity = tf.identity(relu)
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[identity.name.split(":")[0]]
-            )
-
-        post_graph = ConvertNanToRandom(graph_def).do_transformation()
-
-        converted = True
-        for node in post_graph.node:
-            if node.op.find("Const") != -1:
-                const_content = tensor_util.MakeNdarray(node.attr["value"].tensor)
-                if np.any(np.isnan(const_content)):
-                    converted = False
-        self.assertEqual(converted, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_cse_optimization.py b/test/tensorflow/quantization/ptq/test_graph_cse_optimization.py
deleted file mode 100644
index ac3d30fc3cb..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_cse_optimization.py
+++ /dev/null
@@ -1,94 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import unittest
-
-import tensorflow as tf
-from tensorflow.core.framework import graph_pb2
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.graph_cse_optimizer import GraphCseOptimizer
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper
-from neural_compressor.tensorflow.utils import disable_random
-
-
-class TestGraphCommonSequenceElimated(unittest.TestCase):
-    @disable_random()
-    def test_graph_cse(self):
-        input_constant_name = "input_constant"
-        relu_name = "relu"
-        float_graph_def = graph_pb2.GraphDef()
-        input_constant = QuantizeGraphHelper.create_constant_node(
-            input_constant_name, value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], dtype=dtypes.float32, shape=[1, 2, 6, 1]
-        )
-        float_graph_def.node.extend([input_constant])
-        relu_node = QuantizeGraphHelper.create_node("Relu", relu_name, [input_constant_name])
-        QuantizeGraphHelper.set_attr_dtype(relu_node, "T", dtypes.float32)
-        float_graph_def.node.extend([relu_node])
-
-        b_constant_name = "b_constant"
-        mat_mul_name = "mat_mul"
-        identity_name = "identity"
-        b_constant = QuantizeGraphHelper.create_constant_node(
-            b_constant_name, value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], dtype=dtypes.float32, shape=[2, 6]
-        )
-        float_graph_def.node.extend([b_constant])
-
-        mat_mul_node = QuantizeGraphHelper.create_node("MatMul", mat_mul_name, [relu_name, b_constant_name])
-        QuantizeGraphHelper.set_attr_dtype(mat_mul_node, "T", dtypes.float32)
-        QuantizeGraphHelper.set_attr_bool(mat_mul_node, "transpose_a", False)
-        QuantizeGraphHelper.set_attr_bool(mat_mul_node, "transpose_b", False)
-        float_graph_def.node.extend([mat_mul_node])
-
-        identity_node = QuantizeGraphHelper.create_node("Identity", identity_name, [mat_mul_name])
-        float_graph_def.node.extend([identity_node])
-
-        bias_add_name = "bias_add"
-        offset_constant_name = "offset_constant"
-
-        offset_constant = QuantizeGraphHelper.create_constant_node(
-            offset_constant_name, value=[1, 2, 3, 4, 5, 6], dtype=dtypes.float32, shape=[6]
-        )
-        float_graph_def.node.extend([offset_constant])
-        bias_add_node = QuantizeGraphHelper.create_node("BiasAdd", bias_add_name, [identity_name, offset_constant_name])
-        QuantizeGraphHelper.set_attr_dtype(bias_add_node, "T", dtypes.float32)
-        float_graph_def.node.extend([bias_add_node])
-
-        post_relu_name = "post_relu"
-        post_relu_node = QuantizeGraphHelper.create_node("Relu", post_relu_name, [bias_add_name])
-        float_graph_def.node.extend([post_relu_node])
-
-        last_identity_node_name = "last_identity"
-        last_identity_node = QuantizeGraphHelper.create_node("Identity", last_identity_node_name, [post_relu_name])
-        float_graph_def.node.extend([last_identity_node])
-
-        left_relu_name = "final_left_relu"
-        left_relu_node = QuantizeGraphHelper.create_node("Relu", left_relu_name, [last_identity_node_name])
-        float_graph_def.node.extend([left_relu_node])
-        right_relu_name = "final_right_relu"
-        right_relu_node = QuantizeGraphHelper.create_node("Relu", right_relu_name, [last_identity_node_name])
-        float_graph_def.node.extend([right_relu_node])
-
-        cse_left_node_name = "cse_left_node"
-        cse_left_node = QuantizeGraphHelper.create_node("Identity", cse_left_node_name, [left_relu_name])
-        float_graph_def.node.extend([cse_left_node])
-
-        cse_right_node_name = "cse_right_node"
-        cse_right_node = QuantizeGraphHelper.create_node("Identity", cse_right_node_name, [right_relu_name])
-        float_graph_def.node.extend([cse_right_node])
-
-        # post_graph = QuantizeGraphHelper().graph_cse_optimization (
-        #     float_graph_def)
-        post_graph = GraphCseOptimizer(float_graph_def).do_transformation()
-
-        right_relu_optimized_flag = True
-        for i in post_graph.node:
-            if i.name == right_relu_name:
-                right_relu_optimized_flag = False
-                break
-
-        self.assertEqual(right_relu_optimized_flag, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_debug_mode.py b/test/tensorflow/quantization/ptq/test_graph_debug_mode.py
deleted file mode 100644
index 266e7e42af3..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_debug_mode.py
+++ /dev/null
@@ -1,63 +0,0 @@
-import logging
-import os
-import unittest
-
-import tensorflow as tf
-import yaml
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.tensorflow.utils import disable_random
-
-logger = logging.getLogger("neural_compressor")
-logger.setLevel(logging.DEBUG)
-
-
-class TestTensorflowGraphAdaptorDebugMode(unittest.TestCase):
-    @disable_random()
-    def test_graph_adaptor_debug_mode(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-
-        conv_weights = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(top_relu, conv_weights, strides=[1, 2, 2, 1], padding="SAME")
-        normed = tf.nn.bias_add(conv, tf.constant([3.0, 1.2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 12, 2, 3, 4]))
-        relu = tf.nn.relu(normed + tf.constant([3.0]))
-        relu6 = tf.nn.relu6(relu, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_fusion = False
-            for i in qmodel.graph_def.node:
-                if i.op.find("QuantizedConv2D") != -1:
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_dequantize_cast_optimizer.py b/test/tensorflow/quantization/ptq/test_graph_dequantize_cast_optimizer.py
deleted file mode 100644
index 8fb8e3a8604..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_dequantize_cast_optimizer.py
+++ /dev/null
@@ -1,99 +0,0 @@
-import os
-import unittest
-
-import numpy as np
-import tensorflow as tf
-import yaml
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.bf16.dequantize_cast_optimizer import (
-    DequantizeCastOptimizer,
-)
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import disable_random
-
-
-def build_fake_graphdef(set_min_first=False, dq_multi_outputs=False):
-    tf.compat.v1.disable_eager_execution()
-
-    input = tf.compat.v1.placeholder(tf.float32, shape=(32, 224, 224, 3), name="input")
-    graph_def = tf.compat.v1.get_default_graph().as_graph_def(add_shapes=True)
-
-    min_input = Helper.create_constant_node("test_min", value=0.0, dtype=dtypes.float32)
-
-    max_input = Helper.create_constant_node("test_max", value=[1], dtype=dtypes.float32)
-
-    quant_v2_node = Helper.create_node("QuantizeV2", "test_quantize", [input.name, min_input.name, max_input.name])
-
-    dequantize_node = Helper.create_node(
-        "Dequantize", "test_dequantize", [quant_v2_node.name, quant_v2_node.name + ":1", quant_v2_node.name + ":2"]
-    )
-    if set_min_first:
-        Helper.set_attr_string(dequantize_node, "mode", b"MIN_FIRST")
-
-    cast_node = Helper.create_node("Cast", "test_cast", [dequantize_node.name])
-    Helper.set_attr_dtype(cast_node, "DstT", dtypes.bfloat16)
-    Helper.set_attr_dtype(cast_node, "SrcT", dtypes.float32)
-    Helper.set_attr_bool(cast_node, "Truncate", False)
-
-    dentity_node = Helper.create_node("Identity", "output", [cast_node.name])
-    Helper.set_attr_dtype(dentity_node, "T", dtypes.bfloat16)
-
-    graph_def.node.extend(
-        [
-            min_input,
-            max_input,
-            quant_v2_node,
-            dequantize_node,
-            cast_node,
-            dentity_node,
-        ]
-    )
-
-    if dq_multi_outputs:
-        dentity_node_2 = Helper.create_node("Identity", "id_1", [dequantize_node.name])
-        Helper.set_attr_dtype(dentity_node_2, "T", dtypes.float32)
-        graph_def.node.extend([dentity_node_2])
-
-    return graph_def
-
-
-class TestDequantizeCastOptimizer(unittest.TestCase):
-    @disable_random()
-    def test_dequantize_cast_normal(self):
-        graph_def = build_fake_graphdef()
-        converted_graph_def = DequantizeCastOptimizer(graph_def).do_transformation()
-        for i in converted_graph_def.node:
-            if i.op == "Cast":
-                hasCast = True
-                break
-
-        self.assertEqual(hasCast, True)
-
-    @disable_random()
-    def test_dequantize_cast_min_first(self):
-        graph_def = build_fake_graphdef(set_min_first=True)
-        converted_graph_def = DequantizeCastOptimizer(graph_def).do_transformation()
-        hasCast = False
-        for i in converted_graph_def.node:
-            if i.op == "Cast":
-                hasCast = True
-                break
-
-        self.assertEqual(hasCast, True)
-
-    @disable_random()
-    def test_dequantize_cast_multiple_outputs(self):
-        graph_def = build_fake_graphdef(dq_multi_outputs=True)
-        converted_graph_def = DequantizeCastOptimizer(graph_def).do_transformation()
-        hasCast = False
-        for i in converted_graph_def.node:
-            if i.op == "Cast":
-                hasCast = True
-                break
-
-        self.assertEqual(hasCast, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_expanddims_optimizer.py b/test/tensorflow/quantization/ptq/test_graph_expanddims_optimizer.py
deleted file mode 100644
index 0d62c5d6e21..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_expanddims_optimizer.py
+++ /dev/null
@@ -1,43 +0,0 @@
-import os
-import unittest
-
-import numpy as np
-import tensorflow as tf
-import yaml
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.tensorflow.utils import disable_random
-
-
-class TestSwitchOptimizer(unittest.TestCase):
-    @disable_random()
-    def test_expanddims_optimizer(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-
-        conv_weights = tf.constant(np.random.random((3, 16, 16)).astype(np.float32), name="y")
-        conv_weights_expand = tf.expand_dims(conv_weights, axis=0, name="expanddims")
-        conv = tf.nn.conv2d(x_pad, conv_weights_expand, strides=[1, 2, 2, 1], padding="VALID")
-        out_name = conv.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-        from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.expanddims_optimizer import (
-            ExpandDimsOptimizer,
-        )
-
-        convert_graph = ExpandDimsOptimizer(output_graph_def).do_transformation()
-        handle_expanddims = True
-        for node in convert_graph.node:
-            if node.op == "Conv2D" and node.input[1] == "ExpandDims":
-                handle_expanddims = False
-                break
-        self.assertEqual(handle_expanddims, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_fetch_weight_from_reshape.py b/test/tensorflow/quantization/ptq/test_graph_fetch_weight_from_reshape.py
deleted file mode 100644
index 30fc7a0209e..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_fetch_weight_from_reshape.py
+++ /dev/null
@@ -1,142 +0,0 @@
-import os
-import unittest
-
-import numpy as np
-import tensorflow as tf
-import yaml
-from tensorflow.compat.v1 import graph_util
-from tensorflow.core.framework import attr_value_pb2, graph_pb2, node_def_pb2
-from tensorflow.python.framework import dtypes, tensor_util
-
-from neural_compressor.tensorflow.utils import disable_random
-
-
-def create_graph():
-    input_node = node_def_pb2.NodeDef()
-    input_node.name = "input"
-    input_node.op = "Placeholder"
-    input_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-
-    const_node_1 = node_def_pb2.NodeDef()
-    const_node_1.name = "const_1"
-    const_node_1.op = "Const"
-    const_value_1 = np.float32(np.random.randn(128))
-    const_node_1.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    const_node_1.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(const_value_1, const_value_1.dtype.type, const_value_1.shape)
-        )
-    )
-
-    const_node_2 = node_def_pb2.NodeDef()
-    const_node_2.name = "const_2"
-    const_node_2.op = "Const"
-    const_value_2 = np.float32(np.random.randn(128))
-    const_node_2.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    const_node_2.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(const_value_2, const_value_2.dtype.type, const_value_2.shape)
-        )
-    )
-
-    const_node_3 = node_def_pb2.NodeDef()
-    const_node_3.name = "const_3"
-    const_node_3.op = "Const"
-    const_value_3 = np.float32(np.random.randn(128))
-    const_node_3.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    const_node_3.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(const_value_3, const_value_3.dtype.type, const_value_3.shape)
-        )
-    )
-
-    const_node_4 = node_def_pb2.NodeDef()
-    const_node_4.name = "const_4"
-    const_node_4.op = "Const"
-    const_value_4 = np.float32(np.random.randn(128))
-    const_node_4.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    const_node_4.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(const_value_4, const_value_4.dtype.type, const_value_4.shape)
-        )
-    )
-
-    pack_node = node_def_pb2.NodeDef()
-    pack_node.name = "pack"
-    pack_node.op = "Pack"
-    pack_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    pack_node.attr["axis"].CopyFrom(attr_value_pb2.AttrValue(i=1))
-    pack_node.attr["N"].CopyFrom(attr_value_pb2.AttrValue(i=4))
-    pack_node.input.extend([const_node_1.name, const_node_2.name, const_node_3.name, const_node_4.name])
-
-    shape_node = node_def_pb2.NodeDef()
-    shape_node.name = "const_5"
-    shape_node.op = "Const"
-    value_4 = np.int32([1, 1, 128, 4])
-    shape_node.attr["dtype"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.qint32.as_datatype_enum))
-    shape_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(tensor=tensor_util.make_tensor_proto(value_4, value_4.dtype.type, value_4.shape))
-    )
-
-    reshape_node = node_def_pb2.NodeDef()
-    reshape_node.name = "reshape"
-    reshape_node.op = "Reshape"
-    reshape_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    reshape_node.attr["Tshape"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.int32.as_datatype_enum))
-    reshape_node.input.extend([pack_node.name, shape_node.name])
-
-    conv2_node = node_def_pb2.NodeDef()
-    conv2_node.name = "conv"
-    conv2_node.op = "Conv2D"
-    conv2_node.attr["T"].CopyFrom(attr_value_pb2.AttrValue(type=dtypes.float32.as_datatype_enum))
-    conv2_node.input.extend([input_node.name, reshape_node.name])
-    conv2_node.attr["strides"].CopyFrom(
-        attr_value_pb2.AttrValue(list=attr_value_pb2.AttrValue.ListValue(i=[1, 1, 1, 1]))
-    )
-    conv2_node.attr["dilations"].CopyFrom(
-        attr_value_pb2.AttrValue(list=attr_value_pb2.AttrValue.ListValue(i=[1, 1, 1, 1]))
-    )
-    conv2_node.attr["padding"].CopyFrom(attr_value_pb2.AttrValue(s=b"SAME"))
-    conv2_node.attr["data_format"].CopyFrom(attr_value_pb2.AttrValue(s=b"NHWC"))
-    test_graph = graph_pb2.GraphDef()
-
-    test_graph.node.extend(
-        [
-            input_node,
-            const_node_1,
-            const_node_2,
-            const_node_3,
-            const_node_4,
-            pack_node,
-            shape_node,
-            reshape_node,
-            conv2_node,
-        ]
-    )
-    return test_graph
-
-
-class TestFetchWeightFromReshapeOptimizer(unittest.TestCase):
-    @classmethod
-    def setUpClass(self):
-        self.test_graph = create_graph()
-
-    @disable_random()
-    def test_FetchWeightFromReshape_Optimizer(self):
-        from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.fetch_weight_from_reshape import (
-            FetchWeightFromReshapeOptimizer,
-        )
-
-        convert_graph = FetchWeightFromReshapeOptimizer(self.test_graph).do_transformation()
-
-        handled = False
-        for node in convert_graph.node:
-            if node.op == "Conv2D" and node.input[1] == "reshape/weight_0":
-                handled = True
-                break
-
-        self.assertEqual(handled, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_fold_bn.py b/test/tensorflow/quantization/ptq/test_graph_fold_bn.py
deleted file mode 100644
index 8be4f1ba0f0..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_fold_bn.py
+++ /dev/null
@@ -1,103 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import unittest
-
-import tensorflow as tf
-from tensorflow.core.framework import graph_pb2
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.fold_batch_norm import (
-    FoldBatchNormNodesOptimizer,
-)
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper
-from neural_compressor.tensorflow.utils import disable_random
-
-
-class TestGraphFoldBNWithInvalidParameter(unittest.TestCase):
-    @disable_random()
-    def test_graph_fold_bn(self):
-        input_constant_name = "input_constant"
-        relu_name = "relu"
-        float_graph_def = graph_pb2.GraphDef()
-        input_constant = QuantizeGraphHelper.create_constant_node(
-            input_constant_name, value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], dtype=dtypes.float32, shape=[1, 2, 6, 1]
-        )
-        float_graph_def.node.extend([input_constant])
-        relu_node = QuantizeGraphHelper.create_node("Relu", relu_name, [input_constant_name])
-        QuantizeGraphHelper.set_attr_dtype(relu_node, "T", dtypes.float32)
-        float_graph_def.node.extend([relu_node])
-
-        b_constant_name = "b_constant"
-        conv2d_name = "conv2d_1"
-        b_constant = QuantizeGraphHelper.create_constant_node(
-            b_constant_name, value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], dtype=dtypes.float32, shape=[1, 2, 3, 4]
-        )
-        float_graph_def.node.extend([b_constant])
-
-        conv2d_node = QuantizeGraphHelper.create_node("Conv2D", conv2d_name, [relu_name, b_constant_name])
-        QuantizeGraphHelper.set_attr_dtype(conv2d_node, "T", dtypes.float32)
-
-        float_graph_def.node.extend([conv2d_node])
-
-        bias_add_name = "bias_add"
-        offset_constant_name = "offset_constant"
-
-        offset_constant = QuantizeGraphHelper.create_constant_node(
-            offset_constant_name, value=[1, 2, 3, 4, 5, 6], dtype=dtypes.float32, shape=[6]
-        )
-        float_graph_def.node.extend([offset_constant])
-
-        bias_add_node = QuantizeGraphHelper.create_node("BiasAdd", bias_add_name, [conv2d_name, offset_constant_name])
-        QuantizeGraphHelper.set_attr_dtype(bias_add_node, "T", dtypes.float32)
-        float_graph_def.node.extend([bias_add_node])
-
-        bn_scale_name = "bn_scale"
-        bn_scale_node = QuantizeGraphHelper.create_constant_node(
-            bn_scale_name, value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], dtype=dtypes.float32, shape=[12, 1]
-        )
-        bn_offset_name = "bn_offset"
-        bn_offset_node = QuantizeGraphHelper.create_constant_node(
-            bn_offset_name, value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], dtype=dtypes.float32, shape=[12, 1]
-        )
-        bn_mean_name = "bn_mean"
-        bn_mean_node = QuantizeGraphHelper.create_constant_node(
-            bn_mean_name,
-            value=[
-                1,
-                2,
-            ],
-            dtype=dtypes.float32,
-            shape=[
-                2,
-            ],
-        )
-        bn_var_name = "bn_var"
-        bn_var_node = QuantizeGraphHelper.create_constant_node(bn_var_name, value=[], dtype=dtypes.float32, shape=[0])
-        fused_bn_node_name = "bn"
-        fused_bn_node = QuantizeGraphHelper.create_node(
-            "FusedBatchNormV3",
-            fused_bn_node_name,
-            [bias_add_name, bn_scale_name, bn_offset_name, bn_mean_name, bn_var_name],
-        )
-        QuantizeGraphHelper.set_attr_dtype(fused_bn_node, "T", dtypes.float32)
-        QuantizeGraphHelper.set_attr_dtype(fused_bn_node, "U", dtypes.float32)
-        float_graph_def.node.extend([fused_bn_node, bn_scale_node, bn_offset_node, bn_mean_node, bn_var_node])
-
-        post_relu_name = "post_relu"
-        post_relu_node = QuantizeGraphHelper.create_node("Relu", post_relu_name, [fused_bn_node_name])
-        float_graph_def.node.extend([post_relu_node])
-
-        post_graph = FoldBatchNormNodesOptimizer(float_graph_def).do_transformation()
-
-        bn_not_fused = False
-        for i in post_graph.node:
-            if i.op == "FusedBatchNormV3":
-                bn_not_fused = True
-                break
-
-        self.assertEqual(bn_not_fused, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_fuse_decomposed_bn.py b/test/tensorflow/quantization/ptq/test_graph_fuse_decomposed_bn.py
deleted file mode 100644
index 28d1a73e331..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_fuse_decomposed_bn.py
+++ /dev/null
@@ -1,181 +0,0 @@
-import unittest
-
-import numpy as np
-import tensorflow.compat.v1 as tf
-from tensorflow.python.framework import constant_op, dtypes, importer, ops, test_util
-from tensorflow.python.ops import math_ops  # pylint: disable=unused-import
-from tensorflow.python.ops import array_ops, gen_math_ops, nn_ops
-from tensorflow.python.platform import test
-from tensorflow.python.tools import optimize_for_inference_lib
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.fuse_decomposed_bn import (
-    FuseDecomposedBNOptimizer,
-)
-
-
-class OptimizeForInferenceTest(unittest.TestCase):
-    def count_batchnorm_relavant_ops(self, graph_def):
-        """Return the count of FusedBatchNorm op and the count of primitive
-        ops which may make up batchnorm computation in a given graph."""
-        batchnorm_count = 0
-        decompose_count = 0
-        for node in graph_def.node:
-            if node.op == "FusedBatchNorm":
-                batchnorm_count += 1
-            if node.op in ["Add", "Rsqrt", "Mul", "Sub"]:
-                decompose_count += 1
-        return batchnorm_count, decompose_count
-
-    @test_util.run_deprecated_v1
-    def create_base_for_fuse_batchnorm(self, pattern_match_mode="MATCH_ALL", use_reshape=True):
-        """Create testing graph and compute the result from original graph.
-        Args:
-            pattern_match_mode: A label string to indicate which batchnorm composition
-            pattern to create in the resulting graph.
-            "MATCH_ALL" - Create a graph matching the decomposed batchnorm pattern
-                            with full set of primitive ops.
-            "MATCH_NO_GAMMA" - Create a graph matching the decomposed batchnorm
-                                pattern when gamma factor is 1 and multiplication
-                                with gamma is omitted.
-            "NO_MATCH" - Create a graph with same set of primitive ops which makes
-                        up the decomposed batchnorm, but not matching the pattern.
-        Returns:
-            A GraphDef as original graph to run the decomposed batchnorm test cases.
-            Computation result from executing the original graph defined by GraphDef.
-        """
-        ops.reset_default_graph()
-        with tf.Session() as sess:
-            inputs = [1, 4, 2, 5, 3, 6, -1, -4, -2, -5, -3, -6]
-            input_op = constant_op.constant(np.array(inputs), shape=[1, 1, 6, 2], dtype=dtypes.float32)
-            weights = [1, 2, 3, 4, 0.1, 0.2, 0.3, 0.4]
-            weights_op = constant_op.constant(np.array(weights), shape=[1, 2, 2, 2], dtype=dtypes.float32)
-            conv_op = nn_ops.conv2d(input_op, weights_op, [1, 1, 1, 1], padding="SAME", name="conv_op")
-
-            const_op_1 = constant_op.constant(np.array([0.25, 0.5]), shape=[2], dtype=dtypes.float32)
-            if use_reshape:
-                const_op_1 = array_ops.reshape(const_op_1, shape=[1, 1, 1, 2])
-            const_op_2 = constant_op.constant(0.00001, dtype=dtypes.float32)
-            const_op_3 = constant_op.constant(np.array([10, 20]), shape=[2], dtype=dtypes.float32)
-            if use_reshape:
-                const_op_3 = array_ops.reshape(const_op_3, shape=[1, 1, 1, 2])
-            const_op_4 = constant_op.constant(np.array([0.1, 0.6]), shape=[2], dtype=dtypes.float32)
-            if use_reshape:
-                const_op_4 = array_ops.reshape(const_op_4, shape=[1, 1, 1, 2])
-
-            add_op_1 = gen_math_ops.add(const_op_1, const_op_2)
-            rsqrt_op = math_ops.rsqrt(add_op_1)
-
-            variable_op = None
-            if pattern_match_mode == "MATCH_NO_GAMMA":
-                variable_op = rsqrt_op
-            else:
-                const_op_5 = constant_op.constant(np.array([1.0, 2.0]), shape=[2], dtype=dtypes.float32)
-                if use_reshape:
-                    const_op_5 = array_ops.reshape(const_op_5, shape=[1, 1, 1, 2])
-                variable_op = math_ops.multiply(rsqrt_op, const_op_5)
-
-            mul_op_1 = math_ops.multiply(conv_op, variable_op)
-
-            mul_op_2 = None
-            if pattern_match_mode == "NO_MATCH":
-                const_op_6 = constant_op.constant(np.array([0.2, 0.5]), shape=[2], dtype=dtypes.float32)
-                mul_op_2 = math_ops.multiply(const_op_3, const_op_6)
-            else:
-                mul_op_2 = math_ops.multiply(const_op_3, variable_op)
-
-            sub_op = math_ops.subtract(const_op_4, mul_op_2)
-            gen_math_ops.add(mul_op_1, sub_op, name="output")
-
-            test_util.set_producer_version(ops.get_default_graph(), 8)
-
-            original_graph = sess.graph_def
-            original_result = sess.run(["output:0"])
-
-            return original_graph, original_result
-
-    def assertAllClose(self, first, second, rtol=1e-7, atol=0):
-        first_array = np.array(first)
-        second_array = np.array(second)
-        np.testing.assert_allclose(first_array, second_array, rtol, atol)
-
-    @test_util.run_deprecated_v1
-    def testFuseDecomposedBatchNorm_MatchAll(self):
-        for test_rehape in [False, True]:
-            original_graph_def, original_result = self.create_base_for_fuse_batchnorm("MATCH_ALL", test_rehape)
-
-            # Test correctness of fusing individual ops to FusedBatchNorm
-            optimized_graph_def = FuseDecomposedBNOptimizer(original_graph_def).do_transformation()
-
-            batchnorm_count, decompose_count = self.count_batchnorm_relavant_ops(optimized_graph_def)
-            self.assertEqual(batchnorm_count, 1)
-            self.assertEqual(decompose_count, 0)
-
-            with tf.Session() as sess:
-                _ = importer.import_graph_def(optimized_graph_def, input_map={}, name="optimized")
-                optimized_result = sess.run(["optimized/output:0"])
-
-            self.assertAllClose(original_result, optimized_result)
-
-            # Test correctness of fusing individual ops to FusedBatchNorm followed by
-            # folding FusedBatchNorm
-            optimized_graph_def = optimize_for_inference_lib.fold_batch_norms(optimized_graph_def)
-            for node in optimized_graph_def.node:
-                self.assertNotEqual("FusedBatchNorm", node.op)
-
-            with tf.Session() as sess:
-                _ = importer.import_graph_def(optimized_graph_def, input_map={}, name="optimized2")
-                optimized_result = sess.run(["optimized2/output:0"])
-
-            self.assertAllClose(original_result, optimized_result, rtol=1e-04, atol=1e-06)
-
-    @test_util.run_deprecated_v1
-    def testFuseDecomposedBatchNorm_MatchNoGamma(self):
-        for test_rehape in [False, True]:
-            original_graph_def, original_result = self.create_base_for_fuse_batchnorm("MATCH_NO_GAMMA", test_rehape)
-
-            # Test correctness of fusing individual ops to FusedBatchNorm
-            optimized_graph_def = FuseDecomposedBNOptimizer(original_graph_def).do_transformation()
-
-            batchnorm_count, decompose_count = self.count_batchnorm_relavant_ops(optimized_graph_def)
-            self.assertEqual(batchnorm_count, 1)
-            self.assertEqual(decompose_count, 0)
-
-            with tf.Session() as sess:
-                _ = importer.import_graph_def(optimized_graph_def, input_map={}, name="optimized")
-                optimized_result = sess.run(["optimized/output:0"])
-
-            self.assertAllClose(original_result, optimized_result)
-
-            # Test correctness of fusing individual ops to FusedBatchNorm followed by
-            # folding FusedBatchNorm
-            optimized_graph_def = optimize_for_inference_lib.fold_batch_norms(optimized_graph_def)
-            for node in optimized_graph_def.node:
-                self.assertNotEqual("FusedBatchNorm", node.op)
-
-            with tf.Session() as sess:
-                _ = importer.import_graph_def(optimized_graph_def, input_map={}, name="optimized2")
-                optimized_result = sess.run(["optimized2/output:0"])
-
-            self.assertAllClose(original_result, optimized_result, rtol=1e-04, atol=1e-06)
-
-    @test_util.run_deprecated_v1
-    def testFuseDecomposedBatchNorm_NonMatchCase(self):
-        for test_rehape in [False, True]:
-            original_graph_def, original_result = self.create_base_for_fuse_batchnorm("NO_MATCH", test_rehape)
-
-            # Test for not to fuse ops if graph has same types of ops but pattern mismatch
-            optimized_graph_def = FuseDecomposedBNOptimizer(original_graph_def).do_transformation()
-
-            batchnorm_count, math_op_count = self.count_batchnorm_relavant_ops(optimized_graph_def)
-            self.assertEqual(batchnorm_count, 0)
-            self.assertEqual(math_op_count, 7)
-
-            with tf.Session() as sess:
-                _ = importer.import_graph_def(optimized_graph_def, input_map={}, name="optimized")
-                optimized_result = sess.run(["optimized/output:0"])
-
-            self.assertAllClose(original_result, optimized_result)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_fuse_gelu.py b/test/tensorflow/quantization/ptq/test_graph_fuse_gelu.py
deleted file mode 100644
index f2fd054500e..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_fuse_gelu.py
+++ /dev/null
@@ -1,414 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import unittest
-
-import tensorflow as tf
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.fuse_gelu import FuseGeluOptimizer
-from neural_compressor.tensorflow.utils import disable_random, version1_lt_version2
-
-
-@unittest.skipIf(tf.version.VERSION.find("up") == -1, "Only supports tf 1.15.up2 and 1.15.up3 and SprBase")
-class TestGeluFusion(unittest.TestCase):
-    def gelu(self, input_tensor, mul_value=0.5, addv2_value=1.0, sqrt_value=2.0):
-        cdf = mul_value * (addv2_value + tf.math.erf(input_tensor / tf.sqrt(sqrt_value)))
-        return input_tensor * cdf
-
-    def gelu_enable_approximation(
-        self,
-        input_tensor,
-        another_mul_value=0.5,
-        mul1_value=0.044715,
-        addv2_value=1.0,
-        mul2_value=0.7978845608028654,
-        pow_value=3,
-    ):
-        coeff = tf.cast(mul1_value, input_tensor.dtype)
-        return (
-            another_mul_value
-            * input_tensor
-            * (addv2_value + tf.tanh(mul2_value * (input_tensor + coeff * tf.pow(input_tensor, pow_value))))
-        )
-
-    def gelu_enable_approximation_varaint(
-        self,
-        input_tensor,
-        another_mul_value=0.5,
-        mul1_value=0.044715,
-        addv2_value=1.0,
-        mul2_value=0.7978845608028654,
-        pow_value=3,
-    ):
-        coeff = tf.cast(mul1_value, input_tensor.dtype)
-        cdf = another_mul_value * (
-            addv2_value + tf.tanh(mul2_value * (input_tensor + coeff * tf.pow(input_tensor, pow_value)))
-        )
-
-        return input_tensor * cdf
-
-    def gelu_disable_approximation(
-        self,
-        input_tensor,
-        another_add_value=0.5,
-        mul1_value=0.044715,
-        addv2_value=1.0,
-        mul2_value=0.7978845608028654,
-        pow_value=3,
-    ):
-        coeff = tf.cast(mul1_value, input_tensor.dtype)
-        return (another_add_value + input_tensor) * (
-            addv2_value + tf.tanh(mul2_value * (input_tensor + coeff * tf.pow(input_tensor, pow_value)))
-        )
-
-    @disable_random()
-    def test_gelu_disable_approximation_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 224, 224, 3], name="input")
-
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv_bias = tf.compat.v1.get_variable("bias", [32], initializer=tf.compat.v1.random_normal_initializer())
-        conv1 = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME")
-        conv_bias = tf.math.add(conv1, conv_bias)
-
-        gelu = self.gelu_disable_approximation(conv_bias)
-        relu = tf.nn.relu(gelu)
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[relu.name.split(":")[0]]
-            )
-
-            output_graph_def = FuseGeluOptimizer(output_graph_def).do_transformation()
-
-            found_gelu = False
-            for i in output_graph_def.node:
-                if i.op == "Gelu":
-                    found_gelu = True
-                    break
-
-            self.assertEqual(found_gelu, False)
-
-    @disable_random()
-    def test_gelu_approximation_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 224, 224, 3], name="input")
-
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv_bias = tf.compat.v1.get_variable("bias", [32], initializer=tf.compat.v1.random_normal_initializer())
-        conv1 = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME")
-        conv_bias = tf.math.add(conv1, conv_bias)
-
-        gelu = self.gelu_enable_approximation(conv_bias)
-        relu = tf.nn.relu(gelu)
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[relu.name.split(":")[0]]
-            )
-
-            output_graph_def = FuseGeluOptimizer(output_graph_def).do_transformation()
-
-            found_gelu = False
-            for i in output_graph_def.node:
-                if i.op == "Gelu":
-                    found_gelu = True
-                    break
-
-            self.assertEqual(found_gelu, True)
-
-    @disable_random()
-    def test_gelu_approximation_fusion_varaint(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 224, 224, 3], name="input")
-
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv_bias = tf.compat.v1.get_variable("bias", [32], initializer=tf.compat.v1.random_normal_initializer())
-        conv1 = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME")
-        conv_bias = tf.math.add(conv1, conv_bias)
-
-        gelu = self.gelu_enable_approximation_varaint(conv_bias)
-        relu = tf.nn.relu(gelu)
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[relu.name.split(":")[0]]
-            )
-
-            output_graph_def = FuseGeluOptimizer(output_graph_def).do_transformation()
-
-            found_gelu = False
-            for i in output_graph_def.node:
-                if i.op == "Gelu":
-                    found_gelu = True
-                    break
-
-            self.assertEqual(found_gelu, True)
-
-    @disable_random()
-    def test_gelu_approximation_fusion_with_invalid_pow_value(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 224, 224, 3], name="input")
-
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv_bias = tf.compat.v1.get_variable("bias", [32], initializer=tf.compat.v1.random_normal_initializer())
-        conv1 = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME")
-        conv_bias = tf.math.add(conv1, conv_bias)
-
-        gelu = self.gelu_enable_approximation(conv_bias, pow_value=1.0)
-        relu = tf.nn.relu(gelu)
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[relu.name.split(":")[0]]
-            )
-
-            output_graph_def = FuseGeluOptimizer(output_graph_def).do_transformation()
-
-            found_gelu = False
-            for i in output_graph_def.node:
-                if i.op == "Gelu":
-                    found_gelu = True
-                    break
-
-            self.assertEqual(found_gelu, False)
-
-    @disable_random()
-    def test_gelu_approximation_fusion_with_invalid_mul2_value(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 224, 224, 3], name="input")
-
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv_bias = tf.compat.v1.get_variable("bias", [32], initializer=tf.compat.v1.random_normal_initializer())
-        conv1 = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME")
-        conv_bias = tf.math.add(conv1, conv_bias)
-
-        gelu = self.gelu_enable_approximation(conv_bias, mul2_value=1.0)
-        relu = tf.nn.relu(gelu)
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[relu.name.split(":")[0]]
-            )
-
-            output_graph_def = FuseGeluOptimizer(output_graph_def).do_transformation()
-
-            found_gelu = False
-            for i in output_graph_def.node:
-                if i.op == "Gelu":
-                    found_gelu = True
-                    break
-
-            self.assertEqual(found_gelu, False)
-
-    @disable_random()
-    def test_gelu_approximation_fusion_with_invalid_addv2_value(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 224, 224, 3], name="input")
-
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv_bias = tf.compat.v1.get_variable("bias", [32], initializer=tf.compat.v1.random_normal_initializer())
-        conv1 = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME")
-        conv_bias = tf.math.add(conv1, conv_bias)
-
-        gelu = self.gelu_enable_approximation(conv_bias, addv2_value=12.0)
-        relu = tf.nn.relu(gelu)
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[relu.name.split(":")[0]]
-            )
-
-            output_graph_def = FuseGeluOptimizer(output_graph_def).do_transformation()
-
-            found_gelu = False
-            for i in output_graph_def.node:
-                if i.op == "Gelu":
-                    found_gelu = True
-                    break
-
-            self.assertEqual(found_gelu, False)
-
-    @disable_random()
-    def test_gelu_approximation_fusion_with_invalid_mul1_value(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 224, 224, 3], name="input")
-
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv_bias = tf.compat.v1.get_variable("bias", [32], initializer=tf.compat.v1.random_normal_initializer())
-        conv1 = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME")
-        conv_bias = tf.math.add(conv1, conv_bias)
-
-        gelu = self.gelu_enable_approximation(conv_bias, mul1_value=1.0)
-        relu = tf.nn.relu(gelu)
-
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[relu.name.split(":")[0]]
-            )
-
-            output_graph_def = FuseGeluOptimizer(output_graph_def).do_transformation()
-
-            found_gelu = False
-            for i in output_graph_def.node:
-                if i.op == "Gelu":
-                    found_gelu = True
-                    break
-
-            self.assertEqual(found_gelu, False)
-
-    @disable_random()
-    def test_gelu_approximation_fusion_with_invalid_another_mul(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 224, 224, 3], name="input")
-
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv_bias = tf.compat.v1.get_variable("bias", [32], initializer=tf.compat.v1.random_normal_initializer())
-        conv1 = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME")
-        conv_bias = tf.math.add(conv1, conv_bias)
-
-        gelu = self.gelu_enable_approximation(conv_bias, another_mul_value=1.0)
-        relu = tf.nn.relu(gelu)
-
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[relu.name.split(":")[0]]
-            )
-
-            output_graph_def = FuseGeluOptimizer(output_graph_def).do_transformation()
-
-            found_gelu = False
-            for i in output_graph_def.node:
-                if i.op == "Gelu":
-                    found_gelu = True
-                    break
-
-            self.assertEqual(found_gelu, False)
-
-    @disable_random()
-    def test_gelu_fusion_with_invalid_sqrt(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 224, 224, 3], name="input")
-
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv_bias = tf.compat.v1.get_variable("bias", [32], initializer=tf.compat.v1.random_normal_initializer())
-        conv1 = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME")
-        conv_bias = tf.math.add(conv1, conv_bias)
-
-        gelu = self.gelu(conv_bias, sqrt_value=1.0)
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[gelu.name.split(":")[0]]
-            )
-
-            output_graph_def = FuseGeluOptimizer(output_graph_def).do_transformation()
-
-            found_gelu = False
-            for i in output_graph_def.node:
-                if i.op == "Gelu":
-                    found_gelu = True
-                    break
-
-            self.assertEqual(found_gelu, False)
-
-    @disable_random()
-    def test_gelu_fusion_with_invalid_addv2(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 224, 224, 3], name="input")
-
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv_bias = tf.compat.v1.get_variable("bias", [32], initializer=tf.compat.v1.random_normal_initializer())
-        conv1 = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME")
-        conv_bias = tf.math.add(conv1, conv_bias)
-
-        gelu = self.gelu(conv_bias, addv2_value=10.0)
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[gelu.name.split(":")[0]]
-            )
-
-            output_graph_def = FuseGeluOptimizer(output_graph_def).do_transformation()
-
-            found_gelu = False
-            for i in output_graph_def.node:
-                if i.op == "Gelu":
-                    found_gelu = True
-                    break
-
-            self.assertEqual(found_gelu, False)
-
-    @disable_random()
-    def test_gelu_fusion_with_invalid_mul(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 224, 224, 3], name="input")
-
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv_bias = tf.compat.v1.get_variable("bias", [32], initializer=tf.compat.v1.random_normal_initializer())
-        conv1 = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME")
-        conv_bias = tf.math.add(conv1, conv_bias)
-
-        gelu = self.gelu(conv_bias, mul_value=1.0)
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[gelu.name.split(":")[0]]
-            )
-
-            output_graph_def = FuseGeluOptimizer(output_graph_def).do_transformation()
-
-            found_gelu = False
-            for i in output_graph_def.node:
-                if i.op == "Gelu":
-                    found_gelu = True
-                    break
-
-            self.assertEqual(found_gelu, False)
-
-    @disable_random()
-    def test_gelu_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 224, 224, 3], name="input")
-
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 3, 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv_bias = tf.compat.v1.get_variable("bias", [32], initializer=tf.compat.v1.random_normal_initializer())
-        conv1 = tf.nn.conv2d(x, conv_weights, strides=[1, 1, 1, 1], padding="SAME")
-        conv_bias = tf.math.add(conv1, conv_bias)
-
-        gelu = self.gelu(conv_bias)
-        relu = tf.nn.relu(gelu)
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[relu.name.split(":")[0]]
-            )
-
-            output_graph_def = FuseGeluOptimizer(output_graph_def).do_transformation()
-
-            found_gelu = False
-            for i in output_graph_def.node:
-                if i.op == "Gelu":
-                    found_gelu = True
-                    break
-
-            self.assertEqual(found_gelu, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_input_output.py b/test/tensorflow/quantization/ptq/test_graph_input_output.py
deleted file mode 100644
index df26f9947eb..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_input_output.py
+++ /dev/null
@@ -1,192 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import os
-import platform
-import unittest
-
-import tensorflow as tf
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.utility import get_input_output_node_names, read_graph
-
-
-def build_fake_model_1():
-    with tf.compat.v1.Session(graph=tf.Graph()) as sess:
-        dataset = tf.data.Dataset.range(10)
-        ds_iterator = tf.compat.v1.data.make_one_shot_iterator(dataset)
-        iter_tensors = ds_iterator.get_next()
-        iter_tensors -= tf.compat.v1.constant([5], dtype=tf.int64)
-        final_node = tf.nn.relu(iter_tensors, name="op_to_store")
-        sess.run(tf.compat.v1.global_variables_initializer())
-        constant_graph = tf.compat.v1.graph_util.convert_variables_to_constants(
-            sess=sess, input_graph_def=sess.graph_def, output_node_names=[final_node.name.split(":")[0]]
-        )
-
-        with tf.io.gfile.GFile("model_1.pb", mode="wb") as f:
-            f.write(constant_graph.SerializeToString())
-
-
-def build_fake_model_2():
-    with tf.compat.v1.Session(graph=tf.Graph()) as sess:
-        final_node = tf.no_op()
-        sess.run(tf.compat.v1.global_variables_initializer())
-        constant_graph = tf.compat.v1.graph_util.convert_variables_to_constants(
-            sess=sess, input_graph_def=sess.graph_def, output_node_names=[final_node.name.split(":")[0]]
-        )
-
-        with tf.io.gfile.GFile("model_2.pb", mode="wb") as f:
-            f.write(constant_graph.SerializeToString())
-
-
-def build_fake_model_3():
-    with tf.compat.v1.Session(graph=tf.Graph()) as sess:
-        x = [1, 2, 3]
-        final_node = tf.Assert(tf.less_equal(tf.reduce_max(x), 3), x)
-        sess.run(tf.compat.v1.global_variables_initializer())
-        constant_graph = tf.compat.v1.graph_util.convert_variables_to_constants(
-            sess=sess, input_graph_def=sess.graph_def, output_node_names=[final_node.name.split(":")[0]]
-        )
-
-        with tf.io.gfile.GFile("model_3.pb", mode="wb") as f:
-            f.write(constant_graph.SerializeToString())
-
-
-class TestGraphInputOutputDetection(unittest.TestCase):
-    tf.compat.v1.disable_v2_behavior()
-    mb_fp32_pb_url = (
-        "https://storage.googleapis.com/intel-optimized-tensorflow/models/v1_6/mobilenet_v1_1.0_224_frozen.pb"
-    )
-    pb_path = "/tmp/.neural_compressor/mobilenet_fp32.pb"
-    platform = platform.system().lower()
-    if platform == "windows":
-        pb_path = "C:\\tmp\\.neural_compressor\\mobilenet_fp32.pb"
-    inputs = ["input"]
-    outputs = ["MobilenetV1/Predictions/Reshape_1"]
-
-    @classmethod
-    def setUpClass(self):
-        if not os.path.exists(self.pb_path):
-            if self.platform == "linux":
-                os.system(
-                    "mkdir -p /tmp/.neural_compressor && wget {} -O {} ".format(self.mb_fp32_pb_url, self.pb_path)
-                )
-            elif self.platform == "windows":
-                os.system("md C:\\tmp\.neural_compressor && cd C:\\tmp\.neural_compressor")
-                from urllib import request
-
-                if not self.mb_fp32_pb_url.startswith(("http://", "https://")):
-                    raise ValueError("Only http/https URLs are supported.")
-                request.urlretrieve(self.mb_fp32_pb_url)  # nosec B310
-        self.input_graph = tf.compat.v1.GraphDef()
-        with open(self.pb_path, "rb") as f:
-            self.input_graph.ParseFromString(f.read())
-
-        build_fake_model_1()
-        build_fake_model_2()
-        build_fake_model_3()
-
-    @classmethod
-    def tearDownClass(self):
-        os.remove("model_1.pb")
-        os.remove("model_2.pb")
-        os.remove("model_3.pb")
-
-    def test_identify_input_output(self):
-        g = GraphAnalyzer()
-        g.graph = self.input_graph
-        g.parse_graph()
-        inputs, outputs = g.get_graph_input_output()
-        self.assertEqual(inputs, self.inputs)
-        self.assertEqual(outputs, self.outputs)
-        inputs, outputs = get_input_output_node_names(self.input_graph)
-        self.assertEqual(inputs, self.inputs)
-        self.assertEqual(outputs, self.outputs)
-
-        input_graph = tf.compat.v1.GraphDef()
-        with open("model_1.pb", "rb") as f:
-            input_graph.ParseFromString(f.read())
-        g = GraphAnalyzer()
-        g.graph = input_graph
-        g.parse_graph()
-        inputs, outputs = g.get_graph_input_output()
-        self.assertEqual(inputs, ["sub"])
-        self.assertEqual(outputs, ["op_to_store"])
-        inputs, outputs = get_input_output_node_names(input_graph)
-        self.assertEqual(inputs, ["sub"])
-        self.assertEqual(outputs, ["op_to_store"])
-
-        input_graph = tf.compat.v1.GraphDef()
-        with open("model_2.pb", "rb") as f:
-            input_graph.ParseFromString(f.read())
-        g = GraphAnalyzer()
-        g.graph = input_graph
-        g.parse_graph()
-        inputs, outputs = g.get_graph_input_output()
-        self.assertEqual(inputs, [])
-        self.assertEqual(outputs, [])
-        inputs, outputs = get_input_output_node_names(input_graph)
-        self.assertEqual(inputs, [])
-        self.assertEqual(outputs, [])
-
-        input_graph = tf.compat.v1.GraphDef()
-        with open("model_3.pb", "rb") as f:
-            input_graph.ParseFromString(f.read())
-        g = GraphAnalyzer()
-        g.graph = input_graph
-        g.parse_graph()
-        inputs, outputs = g.get_graph_input_output()
-        self.assertEqual(inputs, [])
-        self.assertEqual(outputs, [])
-        inputs, outputs = get_input_output_node_names(input_graph)
-        self.assertEqual(inputs, [])
-        self.assertEqual(outputs, [])
-
-    def test_no_input_output_config(self):
-        from neural_compressor.tensorflow import quantize_model
-        from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-        g = GraphAnalyzer()
-        g.graph = self.input_graph
-        g.parse_graph()
-
-        float_graph_def = g.dump_graph()
-        fp32_graph_def = read_graph(self.pb_path)
-
-        dataset = DummyDataset(shape=(20, 224, 224, 3), label=True)
-        calib_dataloader = BaseDataLoader(dataset)
-        quant_config = {
-            "static_quant": {
-                "global": {
-                    "weight_dtype": "int8",
-                    "weight_sym": True,
-                    "weight_granularity": "per_tensor",
-                    "weight_algorithm": "minmax",
-                },
-            }
-        }
-        qmodel = quantize_model(float_graph_def, quant_config, calib_dataloader)
-
-        self.assertGreater(len(qmodel.graph_def.node), 0)
-
-    def test_invalid_input_output_config(self):
-        from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-        from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-        g = GraphAnalyzer()
-        g.graph = self.input_graph
-        g.parse_graph()
-        float_graph_def = g.dump_graph()
-
-        dataset = DummyDataset(shape=(20, 224, 224, 3), label=True)
-        calib_dataloader = BaseDataLoader(dataset)
-        quant_config = StaticQuantConfig()
-        qmodel = quantize_model(float_graph_def, quant_config, calib_dataloader)
-
-        # will detect the right inputs/outputs
-        self.assertNotEqual(qmodel.input_node_names, ["x"])
-        self.assertNotEqual(qmodel.output_node_names, ["op_to_store"])
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_insert_logging.py b/test/tensorflow/quantization/ptq/test_graph_insert_logging.py
deleted file mode 100644
index 425182ce988..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_insert_logging.py
+++ /dev/null
@@ -1,88 +0,0 @@
-import os
-import unittest
-
-import tensorflow as tf
-from tensorflow.compat.v1 import graph_util
-
-import neural_compressor
-from neural_compressor.tensorflow.algorithms.static_quant.tensorflow import TensorflowQuery
-from neural_compressor.tensorflow.quantization.utils.quantize_graph.quantize_graph_for_intel_cpu import (
-    QuantizeGraphForIntel,
-)
-from neural_compressor.tensorflow.utils import disable_random
-
-
-class TestTensorflowGraphInsertLogging(unittest.TestCase):
-    @disable_random()
-    def test_graph_insert_logging(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-
-        conv_weights = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(top_relu, conv_weights, strides=[1, 2, 2, 1], padding="SAME")
-        normed = tf.nn.bias_add(
-            conv, tf.constant([3.0, 1.2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 12, 2, 3, 4]), name="op_to_store"
-        )
-
-        out_name = normed.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            inputs = [x.name.split(":")[0]]
-            outputs = [out_name]
-            op_wise_config = {
-                "Conv2D": (False, "minmax", False, 7.0),
-            }
-            op_wise_sequences = TensorflowQuery(
-                local_config_file=neural_compressor.__path__[0] + "/tensorflow/algorithms/static_quant/tensorflow.yaml"
-            ).get_eightbit_patterns()
-
-            output_graph, _, _ = QuantizeGraphForIntel(
-                output_graph_def, inputs, outputs, op_wise_config, op_wise_sequences, "cpu"
-            ).do_transform()
-
-            offset_map = {
-                "QuantizedConv2DWithBiasSumAndRelu": 3,
-                "QuantizedConv2DWithBiasAndRelu": 2,
-                "QuantizedConv2DWithBias": 1,
-            }
-            target_conv_op = []
-            _print_node_mapping = {}
-            from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper
-
-            sorted_graph = QuantizeGraphHelper().get_sorted_graph(output_graph, inputs, outputs)
-
-            for node in output_graph.node:
-                if node.op in offset_map:
-                    target_conv_op.append(node.name.split("_eightbit_")[0])
-
-            node_name_mapping = {node.name: node for node in output_graph.node if node.op != "Const"}
-
-            output_node_names = []
-            for i in target_conv_op:
-                if node_name_mapping[i + "_eightbit_quantized_conv"].op == "QuantizedConv2DWithBias":
-                    output_node_names.append(node_name_mapping[i + "_eightbit_quantized_conv"].name)
-
-            from neural_compressor.tensorflow.quantization.utils.transform_graph.insert_logging import InsertLogging
-
-            graph_def = InsertLogging(
-                output_graph, node_name_list=output_node_names, message="__KL:", summarize=-1, dump_fp32=False
-            ).do_transformation()
-
-            found_conv_fusion = False
-
-            for i in output_graph.node:
-                if i.op.find("QuantizedConv2D") != -1:
-                    found_conv_fusion = True
-                    break
-
-            self.assertEqual(found_conv_fusion, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_library_detection.py b/test/tensorflow/quantization/ptq/test_graph_library_detection.py
deleted file mode 100644
index c3b41c45dee..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_library_detection.py
+++ /dev/null
@@ -1,54 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import os
-import platform
-import unittest
-
-import tensorflow as tf
-
-import neural_compressor
-from neural_compressor.tensorflow import Model
-from neural_compressor.tensorflow.algorithms.static_quant.tensorflow import TensorflowQuery
-from neural_compressor.tensorflow.quantization.utils.graph_converter import GraphConverter
-from neural_compressor.tensorflow.quantization.utils.utility import read_graph
-
-
-class TestGraphLibraryDetection(unittest.TestCase):
-    efficientnet_b0_model_url = "https://raw.githubusercontent.com/SkyAI/inference_benchmark/435c7ca2577830025ca5f6cbce8480db16f76a61/efficientnet-b0.pb"
-    pb_path = "/tmp/.neural_compressor/efficientnet-b0.pb"
-    if platform.system().lower() == "windows":
-        pb_path = "C:\\tmp\\.neural_compressor\\efficientnet-b0.pb"
-
-    @classmethod
-    def setUpClass(self):
-        if not os.path.exists(self.pb_path) and platform.system().lower() == "linux":
-            os.system(
-                "mkdir -p /tmp/.neural_compressor && wget {} -O {} ".format(
-                    self.efficientnet_b0_model_url, self.pb_path
-                )
-            )
-
-    def test_tensorflow_graph_library_detection(self):
-        tf.compat.v1.disable_eager_execution()
-
-        op_wise_sequences = TensorflowQuery(
-            local_config_file=neural_compressor.__path__[0] + "/tensorflow/algorithms/static_quant/tensorflow.yaml"
-        ).get_eightbit_patterns()
-
-        qt_config = {"calib_iteration": 1, "op_wise_config": {}}
-        original_graphdef = read_graph(self.pb_path)
-        model = Model(self.pb_path)
-        model.name = "test"
-        model.input_tensor_names = ["input_tensor"]
-        model.output_tensor_names = ["softmax_tensor"]
-        model.workspace_path = "/tmp/test.pb"
-
-        converter = GraphConverter(model, int8_sequences=op_wise_sequences, qt_config=qt_config)
-        converted_graph = converter.convert()
-
-        self.assertEqual(converted_graph.graph_def.library, original_graphdef.library)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_matmul_fusion.py b/test/tensorflow/quantization/ptq/test_graph_matmul_fusion.py
deleted file mode 100644
index 8926d2e1dc7..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_matmul_fusion.py
+++ /dev/null
@@ -1,450 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import os
-import unittest
-
-import numpy as np
-import tensorflow.compat.v1 as tf
-import yaml
-from tensorflow.python.framework import dtypes
-
-import neural_compressor
-from neural_compressor.tensorflow.algorithms.static_quant.tensorflow import TensorflowQuery
-from neural_compressor.tensorflow.utils import disable_random
-
-
-class TestGraphMatMulFusion(unittest.TestCase):
-    @classmethod
-    def setUpClass(self):
-        self.op_wise_sequences = TensorflowQuery(
-            local_config_file=neural_compressor.__path__[0] + "/tensorflow/algorithms/static_quant/tensorflow.yaml"
-        ).get_eightbit_patterns()
-
-    @disable_random()
-    def test_matmul_biasadd_relu_requantize_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            z = tf.nn.bias_add(z, [1, 2])
-            z = tf.nn.relu(z, name="op_to_store")
-            found_quantized_matmul = False
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                float_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = StaticQuantConfig()
-                qmodel = quantize_model(float_graph_def, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "QuantizedMatMulWithBiasAndReluAndRequantize":
-                        found_quantized_matmul = True
-                        break
-                self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_first_matmul_biasadd_relu_fusion(self):
-        x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-        y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-        x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-        y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-        z = tf.matmul(x, y)
-        z = tf.nn.bias_add(z, [1, 2])
-        z = tf.nn.relu(z, name="op_to_store")
-
-        with tf.Session() as sess:
-            sess.run(z, feed_dict={x: x_data, y: y_data})
-            float_graph_def = sess.graph.as_graph_def()
-
-            from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(2, 2), label=True)
-            calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-            quant_config = StaticQuantConfig()
-            qmodel = quantize_model(float_graph_def, quant_config, calib_dataloader)
-
-            found_quantized_matmul = False
-            for i in qmodel.graph_def.node:
-                if (
-                    i.op == "QuantizeV2"
-                    and i.name == "MatMul_eightbit_quantize_x"
-                    and i.attr["T"].type == dtypes.quint8
-                ):
-                    found_quantized_matmul = True
-                    break
-
-            self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_biasadd_requantize_dequantize_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            z = tf.nn.bias_add(z, [1, 2])
-            z = tf.identity(z, name="op_to_store")
-            found_quantized_matmul = False
-            if tf.version.VERSION < "2.2.0":
-                found_quantized_matmul = True
-            else:
-                with tf.Session() as sess:
-                    sess.run(z, feed_dict={x: x_data, y: y_data})
-                    float_graph_def = sess.graph.as_graph_def()
-
-                    from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-                    from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                    dataset = DummyDataset(shape=(2, 2), label=True)
-                    calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                    quant_config = StaticQuantConfig()
-                    qmodel = quantize_model(float_graph_def, quant_config, calib_dataloader)
-
-                    for i in qmodel.graph_def.node:
-                        if i.op == "QuantizedMatMulWithBiasAndDequantize":
-                            found_quantized_matmul = True
-                            break
-            self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_biasadd_requantize_dequantize_last_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            z = tf.nn.bias_add(z, [1, 2], name="op_to_store")
-            found_quantized_matmul = False
-            if tf.version.VERSION < "2.2.0":
-                found_quantized_matmul = True
-            else:
-                with tf.Session() as sess:
-                    sess.run(z, feed_dict={x: x_data, y: y_data})
-                    float_graph_def = sess.graph.as_graph_def()
-
-                    from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-                    from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                    dataset = DummyDataset(shape=(2, 2), label=True)
-                    calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                    quant_config = StaticQuantConfig()
-                    qmodel = quantize_model(float_graph_def, quant_config, calib_dataloader)
-
-                    for i in qmodel.graph_def.node:
-                        if i.op == "QuantizedMatMulWithBiasAndDequantize" and i.name == "op_to_store":
-                            found_quantized_matmul = True
-                            break
-
-            self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_disable_matmul_fusion(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y, name="no_quant_matmul")
-            z = tf.nn.relu6(z, name="op_to_store")
-            found_quantized_matmul = False
-
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                float_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = StaticQuantConfig()
-                qmodel = quantize_model(float_graph_def, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "QuantizedMatMulWithBiasAndDequantize" and i.name == "op_to_store":
-                        found_quantized_matmul = True
-                        break
-
-            self.assertEqual(found_quantized_matmul, False)
-
-    @disable_random()
-    def test_disable_matmul_fusion_with_transpose_b_true(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y, name="no_quant_matmul", transpose_b=True)
-            z = tf.nn.relu6(z, name="op_to_store")
-            found_quantized_matmul = False
-
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                float_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = StaticQuantConfig()
-                qmodel = quantize_model(float_graph_def, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "QuantizedMatMulWithBiasAndDequantize" and i.name == "op_to_store":
-                        found_quantized_matmul = True
-                        break
-            self.assertEqual(found_quantized_matmul, False)
-
-    @disable_random()
-    @unittest.skipIf(float(tf.__version__[:3]) > 2.7, "only tf lower than 2.8 enable dummy biasadd")
-    def test_matmul_with_dummy_biasadd(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y, name="no_quant_matmul")
-            z = tf.identity(z, name="op_to_store")
-            found_quantized_matmul = True
-
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                float_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = StaticQuantConfig()
-                qmodel = quantize_model(float_graph_def, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "MatMul":
-                        found_quantized_matmul = False
-                        break
-
-            self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    @unittest.skipIf(float(tf.__version__[:3]) > 2.7, "only tf lower than 2.8 enable dummy biasadd")
-    def test_matmul_with_nan(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            nan_array = np.empty((2, 2), dtype=np.float32)
-            nan_array[:] = np.NaN
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            z = tf.matmul(x, nan_array, name="no_quant_matmul")
-            z = tf.identity(z, name="op_to_store")
-            found_quantized_matmul = True
-
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data})
-                float_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = StaticQuantConfig()
-                qmodel = quantize_model(float_graph_def, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "MatMul":
-                        found_quantized_matmul = False
-                        break
-
-            self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_with_reshape_transpose(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            transpose = tf.transpose(y, perm=[1, 0])
-            reshape = tf.reshape(transpose, [2, 2])
-            z = tf.matmul(x, reshape, name="no_quant_matmul")
-            z = tf.nn.bias_add(z, [1, 2], name="op_to_store")
-            found_quantized_matmul = True
-
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                float_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = StaticQuantConfig()
-                qmodel = quantize_model(float_graph_def, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "MatMul":
-                        found_quantized_matmul = False
-                        break
-
-            self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_with_add(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            transpose = tf.transpose(y, perm=[1, 0])
-            reshape = tf.reshape(transpose, [2, 2])
-            z = tf.matmul(x, reshape, name="no_quant_matmul")
-            z = tf.math.add(z, [1, 2], name="op_to_store")
-            found_quantized_matmul = True
-
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                float_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = StaticQuantConfig()
-                qmodel = quantize_model(float_graph_def, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "MatMul":
-                        found_quantized_matmul = False
-                        break
-
-            self.assertEqual(found_quantized_matmul, True)
-
-    @disable_random()
-    def test_matmul_biasadd_requantize_dequantize_fusion_with_softmax(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.matmul(x, y)
-            biasadd = tf.nn.bias_add(z, [1, 2])
-            biasadd1 = tf.nn.bias_add(biasadd, [1, 1])
-
-            y1 = tf.constant(x_data, dtype=tf.float32, shape=[2, 2])
-            matmul1 = tf.matmul(biasadd1, y1)
-
-            biasadd2 = tf.nn.bias_add(matmul1, [1, 1])
-
-            z = tf.nn.softmax(biasadd2, name="op_to_store")
-            found_quantized_matmul = False
-            if tf.version.VERSION < "2.2.0":
-                found_quantized_matmul = False
-            else:
-                with tf.Session() as sess:
-                    sess.run(z, feed_dict={x: x_data, y: y_data})
-                    float_graph_def = sess.graph.as_graph_def()
-
-                    from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-                    from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                    dataset = DummyDataset(shape=(2, 2), label=True)
-                    calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                    quant_config = StaticQuantConfig()
-                    qmodel = quantize_model(float_graph_def, quant_config, calib_dataloader)
-
-                    count = 0
-                    for i in qmodel.model.as_graph_def().node:
-                        if i.op == "QuantizedMatMulWithBiasAndDequantize":
-                            count += 1
-                    found_quantized_matmul = bool(count > 1)
-
-            # TF2.6 has enabled matmul_biasadd_requantize_dequantize_fusion_with_softmax
-            if tf.__version__ < "2.6.0":
-                self.assertEqual(found_quantized_matmul, False)
-            else:
-                self.assertEqual(found_quantized_matmul, True)
-
-    def test_matmul_biasadd_relu_non_const_weight(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.matmul(x, x, name="no_quant_matmul")
-            biasadd = tf.nn.bias_add(y, [1, 2])
-            z = tf.nn.relu(biasadd)
-            found_quantized_matmul = True
-
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data})
-                float_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = StaticQuantConfig()
-                qmodel = quantize_model(float_graph_def, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "MatMul":
-                        found_quantized_matmul = False
-                        break
-
-            self.assertEqual(found_quantized_matmul, False)
-
-    def test_matmul_biasadd_non_const_weight(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.matmul(x, x, name="no_quant_matmul")
-            z = tf.nn.bias_add(y, [1, 2])
-            found_quantized_matmul = True
-
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data})
-                float_graph_def = sess.graph.as_graph_def()
-
-                from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-                from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-                dataset = DummyDataset(shape=(2, 2), label=True)
-                calib_dataloader = BaseDataLoader(dataset, batch_size=2)
-                quant_config = StaticQuantConfig()
-                qmodel = quantize_model(float_graph_def, quant_config, calib_dataloader)
-
-                for i in qmodel.graph_def.node:
-                    if i.op == "MatMul":
-                        found_quantized_matmul = False
-                        break
-
-            self.assertEqual(found_quantized_matmul, False)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_meta_pass.py b/test/tensorflow/quantization/ptq/test_graph_meta_pass.py
deleted file mode 100644
index 9df7305098c..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_meta_pass.py
+++ /dev/null
@@ -1,207 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import os
-import unittest
-
-import tensorflow as tf
-import yaml
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.tensorflow.utils import disable_random, version1_gte_version2
-
-
-class TestMetaPass(unittest.TestCase):
-    @disable_random()
-    def test_tensorflow_graph_meta_pass_with_different_mode(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(top_relu, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        relu = tf.nn.relu(normed)
-        sq = tf.squeeze(relu, [0])
-        reshape = tf.reshape(sq, [729, 16])
-        conv_weights2 = tf.compat.v1.get_variable(
-            "weight2", [16, 729], initializer=tf.compat.v1.random_normal_initializer()
-        )
-
-        matmul = tf.matmul(reshape, conv_weights2)
-        # normed2 = tf.compat.v1.layers.batch_normalization(matmul)
-        bias = tf.compat.v1.get_variable("bias", [729], initializer=tf.compat.v1.random_normal_initializer())
-        normed2 = tf.nn.bias_add(matmul, bias, name="bias_add")
-
-        relu6 = tf.nn.relu6(normed2)
-        reshape2 = tf.reshape(relu6, [1, 729, 729, 1], name="op_to_store")
-
-        out_name = reshape2.name.split(":")[0]
-
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_reshape = False
-            for i in qmodel.graph_def.node:
-                if i.op == "Reshape":
-                    found_reshape = True
-                    break
-
-            self.assertEqual(found_reshape, True)
-
-    @disable_random()
-    def test_tensorflow_graph_meta_pass_with_same_mode(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(top_relu, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        relu = tf.nn.relu(normed)
-        sq = tf.squeeze(relu, [0])
-        reshape = tf.reshape(sq, [1, 27, 27, 16])
-        conv_weights2 = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(reshape, conv_weights2, strides=[1, 2, 2, 1], padding="VALID")
-        normed2 = (
-            tf.keras.layers.BatchNormalization()(conv2)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv2)
-        )
-
-        relu6 = tf.nn.relu6(normed2, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            quantize_count = 0
-            dequantize_count = 0
-            for i in qmodel.graph_def.node:
-                if i.op == "QuantizeV2":
-                    quantize_count += 1
-                if i.op == "Dequantize":
-                    dequantize_count += 1
-
-            self.assertEqual(quantize_count, 1)
-            self.assertEqual(dequantize_count, 1)
-
-    @disable_random()
-    def test_tensorflow_graph_meta_with_reshape_only(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(top_relu, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        relu = tf.nn.relu(normed)
-        reshape = tf.reshape(relu, [1, 27, 27, 16])
-        conv_weights2 = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(reshape, conv_weights2, strides=[1, 2, 2, 1], padding="VALID")
-        normed2 = (
-            tf.keras.layers.BatchNormalization()(conv2)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv2)
-        )
-
-        relu6 = tf.nn.relu6(normed2, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            quantize_count = 0
-            dequantize_count = 0
-            for i in qmodel.graph_def.node:
-                if i.op == "QuantizeV2":
-                    quantize_count += 1
-                if i.op == "Dequantize":
-                    dequantize_count += 1
-
-            self.assertEqual(quantize_count, 1)
-            self.assertEqual(dequantize_count, 1)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_pad_conv.py b/test/tensorflow/quantization/ptq/test_graph_pad_conv.py
deleted file mode 100644
index 5a4fe4a702e..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_pad_conv.py
+++ /dev/null
@@ -1,183 +0,0 @@
-import os
-import unittest
-
-import tensorflow as tf
-import yaml
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.tensorflow.utils import disable_random, version1_gte_version2
-
-
-class TestFoldPadConv(unittest.TestCase):
-    @disable_random()
-    def test_fold_pad_conv(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-        relu = tf.nn.relu(normed, name="op_to_store")
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_pad = False
-            if tf.__version__ >= "2.0.0":
-                for i in qmodel.graph_def.node:
-                    if i.op == "Pad":
-                        found_pad = True
-                        break
-                self.assertEqual(found_pad, True)
-
-    @disable_random()
-    def test_fold_pad_conv2(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-        relu = tf.nn.relu(normed)
-
-        paddings2 = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad2 = tf.pad(x, paddings2, "CONSTANT")
-        conv_weights2 = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(x_pad2, conv_weights2, strides=[1, 2, 2, 1], padding="VALID")
-        normed2 = (
-            tf.keras.layers.BatchNormalization()(conv2)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv2)
-        )
-        relu2 = tf.nn.relu(normed2)
-        add = tf.math.add(relu, relu2, name="op_to_store")
-        out_name = add.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_pad = False
-            if tf.__version__ >= "2.0.0":
-                for i in qmodel.graph_def.node:
-                    if i.op == "Pad":
-                        found_pad = True
-                        break
-
-                self.assertEqual(found_pad, True)
-
-    @disable_random()
-    def test_fold_pad_conv3(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-        relu = tf.nn.relu(normed)
-
-        conv_weights2 = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(x, conv_weights2, strides=[1, 2, 2, 1], padding="SAME")
-        normed2 = (
-            tf.keras.layers.BatchNormalization()(conv2)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv2)
-        )
-        relu2 = tf.nn.relu(normed2)
-        add = tf.math.add(relu, relu2, name="op_to_store")
-        out_name = add.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_pad = False
-            if tf.__version__ >= "2.0.0":
-                for i in qmodel.graph_def.node:
-                    if i.op == "Pad":
-                        found_pad = True
-                        break
-
-                self.assertEqual(found_pad, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_post_cse_optimize.py b/test/tensorflow/quantization/ptq/test_graph_post_cse_optimize.py
deleted file mode 100644
index b0f55d30434..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_post_cse_optimize.py
+++ /dev/null
@@ -1,157 +0,0 @@
-import os
-import unittest
-
-import numpy as np
-import tensorflow as tf
-import yaml
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.tensorflow.utils import disable_random, version1_gte_version2
-
-
-class TestPostCSEOptimizer(unittest.TestCase):
-    @classmethod
-    def setUpClass(self):
-        self.enable_s8 = bool(tf.version.VERSION.find("1.15.0-up") != -1 or tf.version.VERSION >= "2.1.0")
-
-    @disable_random()
-    def test_post_cse(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        x = tf.nn.relu(x)
-        xw = tf.constant(np.random.random((2, 2, 16, 16)), dtype=tf.float32, name="y")
-        x = tf.nn.conv2d(input=x, filters=xw, strides=[1, 1, 1, 1], padding="VALID")
-
-        y = tf.constant(np.random.random((1, 55, 55, 16)), dtype=tf.float32, name="y")
-
-        z = tf.math.add(x, y, name="add")
-
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(z, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-        relu = tf.nn.relu(normed)
-
-        conv_weights2 = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(z, conv_weights2, strides=[1, 2, 2, 1], padding="VALID")
-        normed2 = (
-            tf.keras.layers.BatchNormalization()(conv2)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv2)
-        )
-        relu2 = tf.nn.relu(normed2)
-        add = tf.math.add(relu, relu2, name="op_to_store")
-        out_name = add.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            quantize_v2_count = 0
-            for i in qmodel.graph_def.node:
-                if i.op == "QuantizeV2":
-                    quantize_v2_count += 1
-
-            if self.enable_s8:
-                self.assertEqual(quantize_v2_count, 2)
-            else:
-                self.assertEqual(quantize_v2_count, 1)
-
-    @disable_random()
-    def test_post_cse2(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        x = tf.nn.relu(x)
-        xw = tf.constant(np.random.random((2, 2, 16, 16)), dtype=tf.float32, name="y")
-        x = tf.nn.conv2d(input=x, filters=xw, strides=[1, 1, 1, 1], padding="VALID")
-
-        y = tf.constant(np.random.random((1, 55, 55, 16)), dtype=tf.float32, name="y")
-
-        z = tf.math.add(x, y, name="add")
-
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(z, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-        relu = tf.nn.relu(normed)
-
-        conv_weights2 = tf.compat.v1.get_variable(
-            "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(z, conv_weights2, strides=[1, 2, 2, 1], padding="VALID")
-        normed2 = (
-            tf.keras.layers.BatchNormalization()(conv2)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv2)
-        )
-        relu2 = tf.nn.relu(normed2)
-        add = tf.math.add(relu, relu2)
-        ones_const = tf.constant(1, dtype=tf.float32)
-        ones_const2 = tf.constant(1, dtype=tf.float32)
-        mul1 = tf.math.multiply(add, ones_const)
-        mul2 = tf.math.multiply(mul1, ones_const)
-        mul3 = tf.math.multiply(mul2, ones_const2, name="op_to_store")
-        out_name = mul3.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            quantize_v2_count = 0
-            for i in qmodel.graph_def.node:
-                if i.op == "QuantizeV2":
-                    quantize_v2_count += 1
-
-            if self.enable_s8:
-                self.assertEqual(quantize_v2_count, 2)
-            else:
-                self.assertEqual(quantize_v2_count, 1)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_search_patterns.py b/test/tensorflow/quantization/ptq/test_graph_search_patterns.py
deleted file mode 100644
index f5ece257c06..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_search_patterns.py
+++ /dev/null
@@ -1,128 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import unittest
-
-import tensorflow as tf
-from tensorflow.core.framework import graph_pb2
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper
-
-
-class TestGraphSearchPatterns(unittest.TestCase):
-    def test_graph_search_partten_post_branch(self):
-        tf.compat.v1.disable_eager_execution()
-        tf.compat.v1.reset_default_graph()
-
-        input_constant_name = "input_constant"
-        relu_name = "relu"
-        float_graph_def = graph_pb2.GraphDef()
-        input_constant = QuantizeGraphHelper.create_constant_node(
-            input_constant_name, value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], dtype=dtypes.float32, shape=[1, 2, 6, 1]
-        )
-        float_graph_def.node.extend([input_constant])
-        relu_node = QuantizeGraphHelper.create_node("Relu", relu_name, [input_constant_name])
-        QuantizeGraphHelper.set_attr_dtype(relu_node, "T", dtypes.float32)
-        float_graph_def.node.extend([relu_node])
-
-        b_constant_name = "b_constant"
-        mat_mul_name = "mat_mul"
-        b_constant = QuantizeGraphHelper.create_constant_node(
-            b_constant_name, value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], dtype=dtypes.float32, shape=[2, 6]
-        )
-        float_graph_def.node.extend([b_constant])
-
-        mat_mul_node = QuantizeGraphHelper.create_node("MatMul", mat_mul_name, [relu_name, b_constant_name])
-        QuantizeGraphHelper.set_attr_dtype(mat_mul_node, "T", dtypes.float32)
-        QuantizeGraphHelper.set_attr_bool(mat_mul_node, "transpose_a", False)
-        QuantizeGraphHelper.set_attr_bool(mat_mul_node, "transpose_b", False)
-        float_graph_def.node.extend([mat_mul_node])
-
-        bias_add_name = "bias_add"
-        offset_constant_name = "offset_constant"
-
-        offset_constant = QuantizeGraphHelper.create_constant_node(
-            offset_constant_name, value=[1, 2, 3, 4, 5, 6], dtype=dtypes.float32, shape=[6]
-        )
-        float_graph_def.node.extend([offset_constant])
-        bias_add_node = QuantizeGraphHelper.create_node("BiasAdd", bias_add_name, [mat_mul_name, offset_constant_name])
-        QuantizeGraphHelper.set_attr_dtype(bias_add_node, "T", dtypes.float32)
-        float_graph_def.node.extend([bias_add_node])
-
-        post_relu_name = "post_relu"
-        post_relu_node = QuantizeGraphHelper.create_node("Relu", post_relu_name, [bias_add_name])
-        float_graph_def.node.extend([post_relu_node])
-
-        last_identity_node_name = "last_identity"
-        last_identity_node = QuantizeGraphHelper.create_node("Identity", last_identity_node_name, [post_relu_name])
-        float_graph_def.node.extend([last_identity_node])
-
-        last_identity_right_node_name = "last_identity_right"
-        last_identity_node_right = QuantizeGraphHelper.create_node(
-            "Identity", last_identity_right_node_name, [post_relu_name]
-        )
-        float_graph_def.node.extend([last_identity_node_right])
-        analyzer = GraphAnalyzer()
-        analyzer.graph = float_graph_def
-        analyzer.parse_graph()
-        res = analyzer.query_fusion_pattern_nodes([["BiasAdd"], ("Relu"), ("Identity")])
-        self.assertEqual(2, len(res))
-
-    def test_graph_search_pattern_straight(self):
-        tf.compat.v1.disable_eager_execution()
-        tf.compat.v1.reset_default_graph()
-
-        input_constant_name = "input_constant"
-        relu_name = "relu"
-        float_graph_def = graph_pb2.GraphDef()
-        input_constant = QuantizeGraphHelper.create_constant_node(
-            input_constant_name, value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], dtype=dtypes.float32, shape=[1, 2, 6, 1]
-        )
-        float_graph_def.node.extend([input_constant])
-        relu_node = QuantizeGraphHelper.create_node("Relu", relu_name, [input_constant_name])
-        QuantizeGraphHelper.set_attr_dtype(relu_node, "T", dtypes.float32)
-        float_graph_def.node.extend([relu_node])
-
-        b_constant_name = "b_constant"
-        mat_mul_name = "mat_mul"
-        b_constant = QuantizeGraphHelper.create_constant_node(
-            b_constant_name, value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], dtype=dtypes.float32, shape=[2, 6]
-        )
-        float_graph_def.node.extend([b_constant])
-
-        mat_mul_node = QuantizeGraphHelper.create_node("MatMul", mat_mul_name, [relu_name, b_constant_name])
-        QuantizeGraphHelper.set_attr_dtype(mat_mul_node, "T", dtypes.float32)
-        QuantizeGraphHelper.set_attr_bool(mat_mul_node, "transpose_a", False)
-        QuantizeGraphHelper.set_attr_bool(mat_mul_node, "transpose_b", False)
-        float_graph_def.node.extend([mat_mul_node])
-
-        bias_add_name = "bias_add"
-        offset_constant_name = "offset_constant"
-
-        offset_constant = QuantizeGraphHelper.create_constant_node(
-            offset_constant_name, value=[1, 2, 3, 4, 5, 6], dtype=dtypes.float32, shape=[6]
-        )
-        float_graph_def.node.extend([offset_constant])
-        bias_add_node = QuantizeGraphHelper.create_node("BiasAdd", bias_add_name, [mat_mul_name, offset_constant_name])
-        QuantizeGraphHelper.set_attr_dtype(bias_add_node, "T", dtypes.float32)
-        float_graph_def.node.extend([bias_add_node])
-
-        post_relu_name = "post_relu"
-        post_relu_node = QuantizeGraphHelper.create_node("Relu", post_relu_name, [bias_add_name])
-        float_graph_def.node.extend([post_relu_node])
-
-        last_identity_node_name = "last_identity"
-        last_identity_node = QuantizeGraphHelper.create_node("Identity", last_identity_node_name, [post_relu_name])
-        float_graph_def.node.extend([last_identity_node])
-
-        analyzer = GraphAnalyzer()
-        analyzer.graph = float_graph_def
-        analyzer.parse_graph()
-        res = analyzer.query_fusion_pattern_nodes([["MatMul"], ("BiasAdd"), ("Relu")])
-        self.assertEqual(3, len(res[0][-1]))
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_switch_optimizer.py b/test/tensorflow/quantization/ptq/test_graph_switch_optimizer.py
deleted file mode 100644
index 022b2bd0ba2..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_switch_optimizer.py
+++ /dev/null
@@ -1,126 +0,0 @@
-import imp
-import os
-import unittest
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.compat.v1 import graph_util
-from tensorflow.python.ops import control_flow_ops
-
-from neural_compressor.tensorflow.utils import disable_random, version1_gte_version2
-
-
-class TestSwitchOptimizer(unittest.TestCase):
-    @disable_random()
-    def test_switch_optimizer(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        y = tf.compat.v1.placeholder_with_default(True, [], name="place_true")
-
-        conv_weights = tf.constant(np.random.random((3, 3, 16, 16)).astype(np.float32), name="y")
-        _, switch_true = control_flow_ops.switch(conv_weights, y)
-        conv = tf.nn.conv2d(x_pad, switch_true, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-        relu = tf.nn.relu(normed, name="op_to_store")
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-        from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.switch_optimizer import (
-            SwitchOptimizer,
-        )
-
-        convert_graph = SwitchOptimizer(output_graph_def).do_transformation()
-        found_switch = False
-        for node in convert_graph.node:
-            if node.op == "Switch":
-                found_switch = True
-        self.assertEqual(found_switch, False)
-
-    @disable_random()
-    def test_switch_optimizer_with_const_boolean(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        place = tf.constant(True)
-        y = tf.compat.v1.placeholder_with_default(place, [], name="place_true")
-        conv_weights = tf.constant(np.random.random((3, 3, 16, 16)).astype(np.float32), name="y")
-        _, switch_true = control_flow_ops.switch(conv_weights, y)
-        conv = tf.nn.conv2d(x_pad, switch_true, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-        relu = tf.nn.relu(normed, name="op_to_store")
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-        from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.convert_placeholder_to_const import (
-            ConvertPlaceholderToConst,
-        )
-        from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.switch_optimizer import (
-            SwitchOptimizer,
-        )
-
-        convert_graph = ConvertPlaceholderToConst(output_graph_def).do_transformation()
-        convert_graph = SwitchOptimizer(convert_graph).do_transformation()
-
-        found_switch = False
-        for node in convert_graph.node:
-            if node.op == "Switch":
-                found_switch = True
-
-        self.assertEqual(found_switch, False)
-
-    @disable_random()
-    def test_switch_optimizer_invalid(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        y = tf.compat.v1.placeholder_with_default(True, [], name="place_true")
-
-        conv_weights = tf.constant(np.random.random((3, 3, 16, 16)).astype(np.float32), name="y")
-        switch_false, _ = control_flow_ops.switch(conv_weights, y)
-        conv = tf.nn.conv2d(x_pad, switch_false, strides=[1, 2, 2, 1], padding="VALID")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-        relu = tf.nn.relu(normed, name="op_to_store")
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-        from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.switch_optimizer import (
-            SwitchOptimizer,
-        )
-
-        convert_graph = SwitchOptimizer(output_graph_def).do_transformation()
-
-        found_switch = False
-        for node in convert_graph.node:
-            if node.op == "Switch":
-                found_switch = True
-
-        self.assertEqual(found_switch, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_graph_util.py b/test/tensorflow/quantization/ptq/test_graph_util.py
deleted file mode 100644
index a6d24f12338..00000000000
--- a/test/tensorflow/quantization/ptq/test_graph_util.py
+++ /dev/null
@@ -1,178 +0,0 @@
-import copy
-import re
-import unittest
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.core.framework import attr_value_pb2, graph_pb2, node_def_pb2
-from tensorflow.python.framework import tensor_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphAnalyzer, GraphRewriterHelper
-
-
-class TestGraph_util(unittest.TestCase):
-    x_node = node_def_pb2.NodeDef()
-    x_node.name = "placeholder"
-    x_node.op = "Placeholder"
-
-    input0_node = node_def_pb2.NodeDef()
-    input0_node.name = "input0"
-    input0_node.op = "Const"
-    input0_value = np.float32(np.abs(np.random.randn(4, 3, 2)))
-    input0_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(input0_value, input0_value.dtype.type, input0_value.shape)
-        )
-    )
-
-    input1_node = node_def_pb2.NodeDef()
-    input1_node.name = "input1"
-    input1_node.op = "Const"
-    input1_value = np.float32(np.abs(np.random.randn(4, 1, 1)))
-    input1_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(input1_value, input1_value.dtype.type, input1_value.shape)
-        )
-    )
-
-    add_node = node_def_pb2.NodeDef()
-    add_node.op = "Add"
-    add_node.name = "add"
-    add_node.input.extend([input0_node.name, input1_node.name])
-
-    input2_node = node_def_pb2.NodeDef()
-    input2_node.name = "input2"
-    input2_node.op = "Const"
-    input2_value = np.float32(np.abs(np.random.randn(1)))
-    input2_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(input2_value, input2_value.dtype.type, input2_value.shape)
-        )
-    )
-
-    input3_node = node_def_pb2.NodeDef()
-    input3_node.name = "input3"
-    input3_node.op = "Const"
-    input3_value = np.float32(np.abs(np.random.randn(1)))
-    input3_node.attr["value"].CopyFrom(
-        attr_value_pb2.AttrValue(
-            tensor=tensor_util.make_tensor_proto(input3_value, input3_value.dtype.type, input3_value.shape)
-        )
-    )
-
-    mul_node = node_def_pb2.NodeDef()
-    mul_node.op = "Mul"
-    mul_node.name = "mul"
-    mul_node.input.extend([add_node.name, input3_node.name])
-
-    sqrt_node = node_def_pb2.NodeDef()
-    sqrt_node.name = "rsqrt"
-    sqrt_node.op = "Rsqrt"
-    sqrt_node.input.extend([mul_node.name])
-
-    sqrt1_node = node_def_pb2.NodeDef()
-    sqrt1_node.op = "Relu"
-    sqrt1_node.name = "sqrt1"
-    sqrt1_node.input.extend([sqrt_node.name])
-
-    block_node = node_def_pb2.NodeDef()
-    block_node.name = "block_output"
-    block_node.op = "Add"
-    block_node.input.extend([x_node.name, sqrt1_node.name])
-
-    res_node = node_def_pb2.NodeDef()
-    res_node.name = "res_add"
-    res_node.op = "Add"
-    res_node.input.extend([sqrt_node.name, input2_node.name])
-
-    end_node = node_def_pb2.NodeDef()
-    end_node.name = "end"
-    end_node.op = "Add"
-    end_node.input.extend([block_node.name, res_node.name])
-
-    graph_def = graph_pb2.GraphDef()
-    graph_def.node.extend(
-        [
-            x_node,
-            input0_node,
-            input1_node,
-            input2_node,
-            input3_node,
-            add_node,
-            mul_node,
-            sqrt_node,
-            sqrt1_node,
-            block_node,
-            res_node,
-            end_node,
-        ]
-    )
-
-    def test_replace_constant_graph_with_constant_node(self):
-        graph_analyzer = GraphAnalyzer()
-        graph_analyzer.graph = copy.deepcopy(self.graph_def)
-
-        graph_analyzer.parse_graph()
-
-        new_constant_value = np.random.random([4, 1])
-        new_constant_type = tf.as_dtype(np.float32(new_constant_value).dtype)
-        new_constant_node = GraphRewriterHelper.create_constant_node(
-            self.add_node.name + "_const", new_constant_value, new_constant_type
-        )
-        assert graph_analyzer.replace_constant_graph_with_constant_node(new_constant_node, self.add_node.name)
-        result_graph = graph_analyzer.dump_graph()
-        assert len(list(result_graph.node)) == 10
-
-        new_constant_value = np.random.random([4, 1])
-        new_constant_type = tf.as_dtype(np.float32(new_constant_value).dtype)
-        new_constant_node = GraphRewriterHelper.create_constant_node(
-            self.mul_node.name + "_const", new_constant_value, new_constant_type
-        )
-        assert graph_analyzer.replace_constant_graph_with_constant_node(new_constant_node, self.mul_node.name)
-        result_graph = graph_analyzer.dump_graph()
-        assert len(list(result_graph.node)) == 8
-
-        new_constant_value = np.random.random([4, 1])
-        new_constant_type = tf.as_dtype(np.float32(new_constant_value).dtype)
-        new_constant_node = GraphRewriterHelper.create_constant_node(
-            self.sqrt_node.name + "_const", new_constant_value, new_constant_type
-        )
-        assert graph_analyzer.replace_constant_graph_with_constant_node(new_constant_node, self.sqrt_node.name)
-        result_graph = graph_analyzer.dump_graph()
-        assert len(list(result_graph.node)) == 7
-
-        new_constant_value = np.random.random([4, 1])
-        new_constant_type = tf.as_dtype(np.float32(new_constant_value).dtype)
-        new_constant_node = GraphRewriterHelper.create_constant_node(
-            self.block_node.name + "_const", new_constant_value, new_constant_type
-        )
-        assert not graph_analyzer.replace_constant_graph_with_constant_node(new_constant_node, self.block_node.name)
-
-    def test_replace_node(self):
-        graph_analyzer = GraphAnalyzer()
-        graph_analyzer.graph = copy.deepcopy(self.graph_def)
-
-        graph_analyzer.parse_graph()
-
-        new_add_node = node_def_pb2.NodeDef()
-        new_add_node.op = "Add"
-        new_add_node.name = "add1"
-        new_add_node.input.extend([self.input0_node.name, self.input1_node.name])
-        graph_analyzer.replace_node(new_add_node, self.add_node.name, [self.mul_node.name])
-        result_graph = graph_analyzer.dump_graph()
-        assert self.add_node not in list(result_graph.node)
-        assert new_add_node in list(result_graph.node)
-
-    def test_freeze_value_regrex(self):
-        sample_str_1 = ";efficientnet-b3/model/blocks_14/se/conv2d/Conv2D_eightbit_requant_range__print__;__requant_min_max:[-2.35420851e+09][2.59383834e+09]"
-        sample_str_2 = ";efficientnet-b3/model/blocks_15/se/conv2d/Conv2D_eightbit_requant_range__print__;__requant_min_max:[-1.254][2.59383834]"
-        print_suffix = "__print__"
-        postfix = "__requant_min_max"
-        res_1 = re.search(r"{};{}:\[\-?\d+\.?\d*e?\+?\d*\]".format(print_suffix, postfix), sample_str_1)
-        res_2 = re.search(r"{};{}:\[\-?\d+\.?\d*e?\+?\d*\]".format(print_suffix, postfix), sample_str_2)
-        self.assertNotEqual(res_1, None)
-        self.assertNotEqual(res_2, None)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_grappler_pass.py b/test/tensorflow/quantization/ptq/test_grappler_pass.py
deleted file mode 100644
index 1acc6237873..00000000000
--- a/test/tensorflow/quantization/ptq/test_grappler_pass.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import unittest
-
-import numpy as np
-import tensorflow.compat.v1 as tf
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.grappler_pass import GrapplerOptimizer
-from neural_compressor.tensorflow.utils import disable_random
-
-
-class TestGrapplerPass(unittest.TestCase):
-    @disable_random()
-    def test_grappler_pass(self):
-        g = tf.Graph()
-        with g.as_default():
-            x_data = np.array([[0.1, 0.2], [0.2, 0.3]])
-            y_data = np.array([[1, 2], [3, 4]], dtype=np.float32)
-            z_data = np.array([[2, 4], [6, 8]], dtype=np.float32)
-            x = tf.placeholder(tf.float32, shape=[2, 2], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[2, 2])
-            z = tf.constant(z_data, dtype=tf.float32, shape=[2, 2])
-            y1 = tf.math.add(y, z)
-            y2 = tf.math.add(y1, z)
-            z = tf.matmul(x, y2)
-            z = tf.nn.bias_add(z, [1, 2])
-            p = tf.identity(z)
-            z = tf.identity(p, name="op_to_store")
-            with tf.Session() as sess:
-                sess.run(z, feed_dict={x: x_data, y: y_data})
-                float_graph_def = sess.graph.as_graph_def()
-                opt_cfg = {
-                    "pruning": True,
-                    "shape": True,
-                    "dependency": True,
-                    "debug_stripper": True,
-                    "loop": True,
-                    "constfold": True,
-                    "arithmetic": True,
-                }
-                optimized_graph = GrapplerOptimizer(float_graph_def, ["op_to_store"], opt_cfg).do_transformation()
-                identity_count = 0
-                for i in optimized_graph.node:
-                    if i.op == "Identity":
-                        identity_count += 1
-
-                self.assertEqual(identity_count, 1)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_move_squeeze_after_relu.py b/test/tensorflow/quantization/ptq/test_move_squeeze_after_relu.py
deleted file mode 100644
index adba3027039..00000000000
--- a/test/tensorflow/quantization/ptq/test_move_squeeze_after_relu.py
+++ /dev/null
@@ -1,141 +0,0 @@
-import imp
-import os
-import unittest
-
-import numpy as np
-import tensorflow as tf
-from numpy.core.fromnumeric import squeeze
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.tensorflow.utils import disable_random
-
-
-class TestSwitchOptimizer(unittest.TestCase):
-    @disable_random()
-    def test_move_squeeze_after_relu(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-
-        conv_weights = tf.constant(np.random.random((3, 3, 16, 16)).astype(np.float32), name="y")
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        sque = tf.squeeze(conv)
-        bias_add = tf.nn.bias_add(sque, tf.constant(np.random.random((16)).astype(np.float32), name="bias_add"))
-        relu = tf.nn.relu(bias_add, name="op_to_store")
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-        from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.move_squeeze_after_relu import (
-            MoveSqueezeAfterReluOptimizer,
-        )
-
-        convert_graph = MoveSqueezeAfterReluOptimizer(output_graph_def).do_transformation()
-
-        move_relu = False
-        for node in convert_graph.node:
-            if node.op == "Squeeze" and node.input[0] == "op_to_store":
-                move_relu = True
-
-        self.assertEqual(move_relu, True)
-
-    @disable_random()
-    def test_move_squeeze_after_relu_with_outputs(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-
-        conv_weights = tf.constant(np.random.random((3, 3, 16, 16)).astype(np.float32), name="y")
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        sque = tf.squeeze(conv)
-        bias_add = tf.nn.bias_add(sque, tf.constant(np.random.random((16)).astype(np.float32), name="bias_add"))
-        relu = tf.nn.relu(bias_add, name="relu")
-        smax = tf.nn.softmax(relu, name="op_to_store")
-        out_name = smax.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-        from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.move_squeeze_after_relu import (
-            MoveSqueezeAfterReluOptimizer,
-        )
-
-        convert_graph = MoveSqueezeAfterReluOptimizer(output_graph_def).do_transformation()
-
-        move_relu = False
-        for node in convert_graph.node:
-            if node.op == "Squeeze" and node.input[0] == "op_to_store":
-                move_relu = True
-
-        self.assertEqual(move_relu, False)
-
-    @disable_random()
-    def test_move_squeeze_after_sigmoid(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-
-        conv_weights = tf.constant(np.random.random((3, 3, 16, 16)).astype(np.float32), name="y")
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        sque = tf.squeeze(conv)
-        bias_add = tf.nn.bias_add(sque, tf.constant(np.random.random((16)).astype(np.float32), name="bias_add"))
-        sigmoid = tf.nn.sigmoid(bias_add, name="op_to_store")
-        out_name = sigmoid.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-        from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.move_squeeze_after_relu import (
-            MoveSqueezeAfterReluOptimizer,
-        )
-
-        convert_graph = MoveSqueezeAfterReluOptimizer(output_graph_def).do_transformation()
-
-        move_sigmoid = False
-        for node in convert_graph.node:
-            if node.op == "Squeeze" and node.input[0] == "op_to_store":
-                move_sigmoid = True
-
-        self.assertEqual(move_sigmoid, True)
-
-    @disable_random()
-    def test_move_reshape_after_relu(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-
-        conv_weights = tf.constant(np.random.random((3, 3, 16, 16)).astype(np.float32), name="y")
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        bias_add = tf.nn.bias_add(conv, tf.constant(np.random.random((16)).astype(np.float32), name="bias_add"))
-        reshape = tf.reshape(bias_add, [1, 28, 28, 16])
-        relu = tf.nn.relu(reshape, name="op_to_store")
-        out_name = relu.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-        from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.move_squeeze_after_relu import (
-            MoveSqueezeAfterReluOptimizer,
-        )
-
-        convert_graph = MoveSqueezeAfterReluOptimizer(output_graph_def).do_transformation()
-
-        move_relu = False
-        for node in convert_graph.node:
-            if node.op == "Reshape" and node.input[0] == "op_to_store":
-                move_relu = True
-
-        self.assertEqual(move_relu, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_quantize_input.py b/test/tensorflow/quantization/ptq/test_quantize_input.py
deleted file mode 100644
index 3faef738723..00000000000
--- a/test/tensorflow/quantization/ptq/test_quantize_input.py
+++ /dev/null
@@ -1,78 +0,0 @@
-import os
-import shutil
-import unittest
-
-import tensorflow as tf
-import yaml
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.tensorflow.algorithms.static_quant.tensorflow import TensorFlowAdaptor
-from neural_compressor.tensorflow.utils import disable_random
-
-
-class TestQuantizeInput(unittest.TestCase):
-    @classmethod
-    def tearDownClass(self):
-        shutil.rmtree("./saved", ignore_errors=True)
-
-    @disable_random()
-    @unittest.skipIf(
-        tf.version.VERSION < "2.1.0",
-        "Quantize input needs tensorflow 2.1.0 and newer, so test_quantize_input is skipped",
-    )
-    def test_quantize_input(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-
-        conv_bias = tf.compat.v1.get_variable("bias", [16], initializer=tf.compat.v1.random_normal_initializer())
-
-        conv_bias = tf.math.add(conv, conv_bias)
-        relu6 = tf.nn.relu6(conv_bias, name="op_to_store")
-
-        out_name = relu6.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            constant_graph = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            for i in constant_graph.node:
-                if i.op.find("Add") != -1:
-                    i.op = "Add"
-
-            from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = StaticQuantConfig()
-            q_model = quantize_model(constant_graph, quant_config, calib_dataloader)
-
-            framework_specific_info = {
-                "device": "cpu",
-                "approach": "post_training_static_quant",
-                "random_seed": 1978,
-                "inputs": ["input"],
-                "outputs": ["op_to_store"],
-                "workspace_path": "saved",
-                "format": "default",
-                "backend": "default",
-            }
-
-            quantize_input_graph, _ = TensorFlowAdaptor(framework_specific_info).quantize_input(q_model.graph)
-            Not_found_QuantizedV2 = True
-            for i in quantize_input_graph.as_graph_def().node:
-                if i.op == "QuantizeV2":
-                    Not_found_QuantizedV2 = False
-                    break
-
-            self.assertEqual(Not_found_QuantizedV2, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_query_yaml.py b/test/tensorflow/quantization/ptq/test_query_yaml.py
deleted file mode 100644
index 192386a0b31..00000000000
--- a/test/tensorflow/quantization/ptq/test_query_yaml.py
+++ /dev/null
@@ -1,239 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import os
-import unittest
-
-import tensorflow as tf
-import yaml
-from tensorflow.compat.v1 import graph_util
-
-import neural_compressor
-from neural_compressor.tensorflow.algorithms.static_quant.tensorflow import TensorflowQuery
-from neural_compressor.tensorflow.utils import disable_random, version1_gte_version2
-
-
-def build_fake_framework_yaml():
-    fake_yaml = """
----
--
-  version:
-    name: ['2.1.0', '2.2.0', '2.3.0', '2.4.0', '2.5.0', '2.6.0', '2.7.0']
-
-  bf16: ['Conv2D', 'MatMul', 'ConcatV2', 'MaxPool', 'AvgPool', 'DepthwiseConv2dNative']
-
-  int8: {
-    'static': {
-        'Conv2D': {
-          'weight': {
-                      'dtype': ['int8'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_channel','per_tensor'],
-                      'algorithm': ['minmax']
-                      },
-          'activation': {
-                      'dtype': ['int8', 'uint8'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax', 'kl']
-                      }
-                  },
-        'MatMul': {
-          'weight': {
-                      'dtype': ['int8'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax']
-                      },
-          'activation': {
-                      'dtype': ['int8', 'uint8'],
-                      'scheme': ['asym', 'sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax']
-                      }
-                  }
-    },
-    'dynamic': {
-    }
-  }
-
--
-  version:
-    name: ['default']
-
-  bf16: ['Conv2D', 'MatMul', 'ConcatV2', 'MaxPool', 'AvgPool', 'DepthwiseConv2dNative']
-
-  int8: {
-    'static': {
-        'Conv2D': {
-          'weight': {
-                      'dtype': ['int8'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_channel','per_tensor'],
-                      'algorithm': ['minmax']
-                      },
-          'activation': {
-                      'dtype': ['int8', 'uint8'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax', 'kl']
-                      }
-                  },
-        'BatchMatMul': {
-          'weight': {
-                      'dtype': ['int8', 'fp32'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax']
-                      },
-          'activation': {
-                      'dtype': ['int8', 'fp32'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax']
-                      }
-                  },
-        'BatchMatMulV2': {
-          'weight': {
-                      'dtype': ['int8'],
-                      'scheme': ['sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax']
-                      },
-          'activation': {
-                      'dtype': ['int8', 'uint8'],
-                      'scheme': ['asym', 'sym'],
-                      'granularity': ['per_tensor'],
-                      'algorithm': ['minmax']
-                      }
-                  }
-    },
-    'dynamic': {
-    }
-  }
-        """
-    y = yaml.load(fake_yaml, Loader=yaml.SafeLoader)
-    with open("fake_framework.yaml", "w", encoding="utf-8") as f:
-        yaml.dump(y, f)
-    f.close()
-
-
-class TestTFQueryYaml(unittest.TestCase):
-    @classmethod
-    def setUpClass(self):
-        self.tf_yaml_path = neural_compressor.__path__[0] + "/tensorflow/algorithms/static_quant/tensorflow.yaml"
-
-        with open(self.tf_yaml_path) as f:
-            self.content = yaml.safe_load(f)
-        self.query_handler = TensorflowQuery(local_config_file=self.tf_yaml_path)
-
-    def test_unique_version(self):
-        versions = [i["version"]["name"] for i in self.content]
-        registered_version_name = []
-        for i in versions:
-            if isinstance(i, list):
-                registered_version_name.extend(i)
-            else:
-                registered_version_name.append(i)
-
-        self.assertEqual(len(registered_version_name), len(set(registered_version_name)))
-
-    def test_int8_sequences(self):
-        patterns = self.query_handler.get_eightbit_patterns()
-
-        has_conv2d = bool("Conv2D" in patterns)
-        has_matmul = bool("MatMul" in patterns)
-        self.assertEqual(has_conv2d, True)
-        self.assertEqual(has_matmul, True)
-        self.assertGreaterEqual(len(patterns["Conv2D"]), 13)
-        self.assertGreaterEqual(len(patterns["MatMul"]), 3)
-        self.assertEqual(len(patterns["ConcatV2"]), 1)
-        self.assertEqual(len(patterns["MaxPool"]), 1)
-        self.assertEqual(len(patterns["AvgPool"]), 1)
-
-    def test_convert_internal_patterns(self):
-        internal_patterns = self.query_handler.generate_internal_patterns()
-        self.assertEqual([["MaxPool"]] in internal_patterns, True)
-        self.assertEqual([["ConcatV2"]] in internal_patterns, True)
-        self.assertEqual([["AvgPool"]] in internal_patterns, True)
-        self.assertEqual([["MatMul"], ("BiasAdd",), ("Relu",)] in internal_patterns, True)
-
-    @disable_random()
-    def test_grappler_cfg(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 30, 30, 1], name="input")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [2, 2, 1, 1], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv_bias = tf.compat.v1.get_variable("bias", [1], initializer=tf.compat.v1.random_normal_initializer())
-
-        x = tf.nn.relu(x)
-        conv = tf.nn.conv2d(x, conv_weights, strides=[1, 2, 2, 1], padding="SAME", name="last")
-        normed = (
-            tf.keras.layers.BatchNormalization()(conv)
-            if version1_gte_version2(tf.__version__, "2.16.1")
-            else tf.compat.v1.layers.batch_normalization(conv)
-        )
-
-        relu = tf.nn.relu(normed)
-        relu2 = tf.nn.relu(relu)
-        pool = tf.nn.max_pool(relu2, ksize=1, strides=[1, 2, 2, 1], name="maxpool", padding="SAME")
-        conv1 = tf.nn.conv2d(pool, conv_weights, strides=[1, 2, 2, 1], padding="SAME", name="last")
-        conv_bias = tf.nn.bias_add(conv1, conv_bias)
-        x = tf.nn.relu(conv_bias)
-        final_node = tf.nn.relu(x, name="op_to_store")
-
-        out_name = final_node.name.split(":")[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 30, 30, 1), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            disable_arithmetic = False
-            for i in qmodel.graph_def.node:
-                if i.name == "maxpool_eightbit_quantize_Relu_2" and i.input[0] == "Relu_2":
-                    disable_arithmetic = True
-
-            self.assertEqual(True, disable_arithmetic)
-
-
-class TestFrameworkQueryYaml(unittest.TestCase):
-    @classmethod
-    def setUpClass(self):
-        build_fake_framework_yaml()
-        self.tf_yaml_path = os.path.join(os.getcwd() + "/fake_framework.yaml")
-
-        with open(self.tf_yaml_path) as f:
-            self.content = yaml.safe_load(f)
-        self.query_handler = TensorflowQuery(local_config_file=self.tf_yaml_path)
-
-    @classmethod
-    def tearDownClass(self):
-        os.remove("fake_framework.yaml")
-
-    def test_version_fallback(self):
-        if self.query_handler.version >= "2.1.0":
-            self.assertEqual(True, "Conv2D" in self.query_handler.get_op_types()["int8"])
-        else:
-            self.assertEqual(True, "BatchMatMul" in self.query_handler.get_op_types()["int8"])
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_remove_training_nodes.py b/test/tensorflow/quantization/ptq/test_remove_training_nodes.py
deleted file mode 100644
index 27370ca9644..00000000000
--- a/test/tensorflow/quantization/ptq/test_remove_training_nodes.py
+++ /dev/null
@@ -1,146 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import unittest
-
-import tensorflow as tf
-from tensorflow.core.framework import graph_pb2
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper
-
-
-class TestRemoveTrainingNodes(unittest.TestCase):
-    def test_remove_training_nodes(self):
-        tf.compat.v1.disable_eager_execution()
-
-        input_constant_name = "input_constant"
-        relu_name = "relu"
-        float_graph_def = graph_pb2.GraphDef()
-        input_constant = QuantizeGraphHelper.create_constant_node(
-            input_constant_name, value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], dtype=dtypes.float32, shape=[1, 2, 6, 1]
-        )
-        float_graph_def.node.extend([input_constant])
-        relu_node = QuantizeGraphHelper.create_node("Relu", relu_name, [input_constant_name])
-        QuantizeGraphHelper.set_attr_dtype(relu_node, "T", dtypes.float32)
-        float_graph_def.node.extend([relu_node])
-
-        b_constant_name = "b_constant"
-        mat_mul_name = "mat_mul"
-        identity_name = "identity"
-        b_constant = QuantizeGraphHelper.create_constant_node(
-            b_constant_name, value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], dtype=dtypes.float32, shape=[2, 6]
-        )
-        float_graph_def.node.extend([b_constant])
-
-        mat_mul_node = QuantizeGraphHelper.create_node("MatMul", mat_mul_name, [relu_name, b_constant_name])
-        QuantizeGraphHelper.set_attr_dtype(mat_mul_node, "T", dtypes.float32)
-        QuantizeGraphHelper.set_attr_bool(mat_mul_node, "transpose_a", False)
-        QuantizeGraphHelper.set_attr_bool(mat_mul_node, "transpose_b", False)
-        float_graph_def.node.extend([mat_mul_node])
-
-        identity_node = QuantizeGraphHelper.create_node("Identity", identity_name, [mat_mul_name])
-        float_graph_def.node.extend([identity_node])
-
-        bias_add_name = "bias_add"
-        offset_constant_name = "offset_constant"
-
-        offset_constant = QuantizeGraphHelper.create_constant_node(
-            offset_constant_name, value=[1, 2, 3, 4, 5, 6], dtype=dtypes.float32, shape=[6]
-        )
-        float_graph_def.node.extend([offset_constant])
-        bias_add_node = QuantizeGraphHelper.create_node("BiasAdd", bias_add_name, [identity_name, offset_constant_name])
-        QuantizeGraphHelper.set_attr_dtype(bias_add_node, "T", dtypes.float32)
-        float_graph_def.node.extend([bias_add_node])
-
-        post_relu_name = "post_relu"
-        post_relu_node = QuantizeGraphHelper.create_node("Relu", post_relu_name, [bias_add_name])
-        float_graph_def.node.extend([post_relu_node])
-
-        last_identity_node_name = "last_identity"
-        last_identity_node = QuantizeGraphHelper.create_node("Identity", last_identity_node_name, [post_relu_name])
-        float_graph_def.node.extend([last_identity_node])
-
-        left_relu_name = "final_relu"
-        left_relu_node = QuantizeGraphHelper.create_node("Relu", left_relu_name, [last_identity_node_name])
-        float_graph_def.node.extend([left_relu_node])
-        right_relu_name = "final_relu"
-        right_relu_node = QuantizeGraphHelper.create_node("Relu", right_relu_name, [last_identity_node_name])
-        float_graph_def.node.extend([right_relu_node])
-        post_graph = QuantizeGraphHelper().remove_training_nodes(
-            float_graph_def, protected_nodes=[right_relu_name, left_relu_name]
-        )
-
-        found_identity_node_name = []
-        for i in post_graph.node:
-            if i.op == "Identity":
-                found_identity_node_name.append(i.name)
-                break
-
-        self.assertEqual(found_identity_node_name, [])
-
-    def test_remove_training_nodes_save_last_identity(self):
-        tf.compat.v1.disable_eager_execution()
-
-        input_constant_name = "input_constant"
-        relu_name = "relu"
-        float_graph_def = graph_pb2.GraphDef()
-        input_constant = QuantizeGraphHelper.create_constant_node(
-            input_constant_name, value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], dtype=dtypes.float32, shape=[1, 2, 6, 1]
-        )
-        float_graph_def.node.extend([input_constant])
-        relu_node = QuantizeGraphHelper.create_node("Relu", relu_name, [input_constant_name])
-        QuantizeGraphHelper.set_attr_dtype(relu_node, "T", dtypes.float32)
-        float_graph_def.node.extend([relu_node])
-
-        b_constant_name = "b_constant"
-        mat_mul_name = "mat_mul"
-        identity_name = "identity"
-        b_constant = QuantizeGraphHelper.create_constant_node(
-            b_constant_name, value=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], dtype=dtypes.float32, shape=[2, 6]
-        )
-        float_graph_def.node.extend([b_constant])
-
-        mat_mul_node = QuantizeGraphHelper.create_node("MatMul", mat_mul_name, [relu_name, b_constant_name])
-        QuantizeGraphHelper.set_attr_dtype(mat_mul_node, "T", dtypes.float32)
-        QuantizeGraphHelper.set_attr_bool(mat_mul_node, "transpose_a", False)
-        QuantizeGraphHelper.set_attr_bool(mat_mul_node, "transpose_b", False)
-        float_graph_def.node.extend([mat_mul_node])
-
-        identity_node = QuantizeGraphHelper.create_node("Identity", identity_name, [mat_mul_name])
-        float_graph_def.node.extend([identity_node])
-
-        bias_add_name = "bias_add"
-        offset_constant_name = "offset_constant"
-
-        offset_constant = QuantizeGraphHelper.create_constant_node(
-            offset_constant_name, value=[1, 2, 3, 4, 5, 6], dtype=dtypes.float32, shape=[6]
-        )
-        float_graph_def.node.extend([offset_constant])
-        bias_add_node = QuantizeGraphHelper.create_node("BiasAdd", bias_add_name, [identity_name, offset_constant_name])
-        QuantizeGraphHelper.set_attr_dtype(bias_add_node, "T", dtypes.float32)
-        float_graph_def.node.extend([bias_add_node])
-
-        post_relu_name = "post_relu"
-        post_relu_node = QuantizeGraphHelper.create_node("Relu", post_relu_name, [bias_add_name])
-        float_graph_def.node.extend([post_relu_node])
-
-        last_identity_node_name = "last_identity"
-        last_identity_node = QuantizeGraphHelper.create_node("Identity", last_identity_node_name, [post_relu_name])
-        float_graph_def.node.extend([last_identity_node])
-
-        post_graph = QuantizeGraphHelper().remove_training_nodes(
-            float_graph_def, protected_nodes=[last_identity_node_name]
-        )
-
-        found_identity_node_name = []
-        for i in post_graph.node:
-            if i.op == "Identity":
-                found_identity_node_name.append(i.name)
-                break
-
-        self.assertEqual(found_identity_node_name[0], "last_identity")
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_rnn.py b/test/tensorflow/quantization/ptq/test_rnn.py
deleted file mode 100644
index aa812f12a4c..00000000000
--- a/test/tensorflow/quantization/ptq/test_rnn.py
+++ /dev/null
@@ -1,95 +0,0 @@
-import os
-import unittest
-
-import numpy as np
-import tensorflow as tf
-import yaml
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.utils import disable_random
-
-
-def quantize(model, q_data, e_data):
-    from neural_compressor.tensorflow import quantize_model
-    from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-    calib_dataloader = BaseDataLoader(dataset=list(zip(q_data[0], q_data[1])))
-    quant_config = {
-        "static_quant": {
-            "global": {
-                "weight_granularity": "per_tensor",
-                "act_algorithm": "minmax",
-            },
-        }
-    }
-    q_model = quantize_model(model, quant_config, calib_dataloader)
-
-    return q_model
-
-
-class TestTensorflowRnn(unittest.TestCase):
-    @unittest.skipUnless(bool(tf.version.VERSION.find("1.15.0-up2") != -1), "not supported the current tf version.")
-    @disable_random()
-    def test_tensorflow_dynamic_rnn(self):
-        X = np.random.randn(3, 6, 4)
-
-        X[1, 4:] = 0
-        X_lengths = [6, 4, 6]
-
-        rnn_hidden_size = 5
-        rnn_type = "ltsm1"
-        if rnn_type == "lstm":
-            cell = tf.contrib.rnn.BasicLSTMCell(num_units=rnn_hidden_size, state_is_tuple=True)
-        else:
-            cell = tf.contrib.rnn.GRUCell(num_units=rnn_hidden_size)
-
-        outputs, last_states = tf.nn.dynamic_rnn(cell=cell, dtype=tf.float64, sequence_length=X_lengths, inputs=X)
-
-        with tf.Session() as sess:
-            sess.run(tf.global_variables_initializer())
-            o1, s1 = sess.run([outputs, last_states])
-            rs = Helper.analysis_rnn_model(sess.graph.as_graph_def())
-            self.assertEqual(len(rs.keys()), 2)
-
-    @unittest.skipUnless(bool(tf.version.VERSION.find("1.15.0-up2") != -1), "not supported the current tf version.")
-    @disable_random()
-    def test_tensorflow_rnn(self):
-        inp = tf.keras.layers.Input(shape=(None, 4))
-        lstm_1 = tf.keras.layers.LSTM(units=10, return_sequences=True)(inp)
-        dropout_1 = tf.keras.layers.Dropout(0.2)(lstm_1)
-        lstm_2 = tf.keras.layers.LSTM(units=10, return_sequences=False)(dropout_1)
-        dropout_2 = tf.keras.layers.Dropout(0.2)(lstm_2)
-        out = tf.keras.layers.Dense(1)(dropout_2)
-        model = tf.keras.models.Model(inputs=inp, outputs=out)
-
-        model.compile(loss="mse", optimizer=tf.keras.optimizers.RMSprop())
-
-        input_names = [t.name.split(":")[0] for t in model.inputs]
-        output_names = [t.name.split(":")[0] for t in model.outputs]
-
-        q_data = np.random.randn(64, 10, 4)
-        label = np.random.randn(64, 1)
-        model.predict(q_data)
-
-        sess = tf.keras.backend.get_session()
-
-        graph = sess.graph
-        graph_def = graph_util.convert_variables_to_constants(
-            sess,
-            graph.as_graph_def(),
-            output_names,
-        )
-        with tf.Graph().as_default() as g:
-            tf.import_graph_def(graph_def, name="")
-            s = quantize(g, q_data=(q_data, label), e_data=(q_data, label))
-
-        convert_count = 0
-        for i in s.graph_def.node:
-            if i.op == "QuantizedMatMulWithBiasAndDequantize":
-                convert_count += 1
-        self.assertEqual(convert_count, 9)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_share_nodes_graph.py b/test/tensorflow/quantization/ptq/test_share_nodes_graph.py
deleted file mode 100644
index 1a6c1381d5a..00000000000
--- a/test/tensorflow/quantization/ptq/test_share_nodes_graph.py
+++ /dev/null
@@ -1,63 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-import copy
-import os
-import platform
-import tarfile
-import unittest
-
-from neural_compressor.tensorflow.quantization.utils.graph_rewriter.generic.split_shared_input import (
-    SplitSharedInputOptimizer,
-)
-from neural_compressor.tensorflow.quantization.utils.quantize_graph_common import QuantizeGraphHelper
-from neural_compressor.tensorflow.quantization.utils.utility import read_graph
-
-
-class TestTensorflowShareNodesGraphParsing(unittest.TestCase):
-    ssd_resnet50_model = "http://download.tensorflow.org/models/object_detection/ssd_resnet50_v1_fpn_shared_box_predictor_640x640_coco14_sync_2018_07_03.tar.gz"
-    dst_path = "/tmp/.neural_compressor/ssd_resnet50_v1.tgz"
-    platform = platform.system().lower()
-    if platform == "windows":
-        unzipped_folder_name = "C:\\tmp\\.neural_compressor\ssd_resnet50_v1\\ssd_resnet50_v1_fpn_shared_box_predictor_640x640_coco14_sync_2018_07_03"
-    else:
-        unzipped_folder_name = "ssd_resnet50_v1_fpn_shared_box_predictor_640x640_coco14_sync_2018_07_03"
-
-    @classmethod
-    def setUpClass(self):
-        if self.platform == "linux":
-            if not os.path.exists(self.dst_path):
-                os.system(
-                    "mkdir -p /tmp/.neural_compressor && wget {} -O {}".format(
-                        self.ssd_resnet50_model,
-                        self.dst_path,
-                    )
-                )
-            os.system("tar xvf {}".format(self.dst_path))
-        elif self.platform == "windows":
-            if not os.path.exists(self.unzipped_folder_name):
-                os.system("md C:\\tmp\.neural_compressor && cd C:\\tmp\.neural_compressor")
-                from urllib import request
-
-                if not self.ssd_resnet50_model.startswith(("http://", "https://")):
-                    raise ValueError("Only http/https URLs are supported.")
-                request.urlretrieve(self.ssd_resnet50_model, self.dst_path)  # nosec B310
-                tar = tarfile.open(self.dst_path)
-                tar.extractall(self.unzipped_folder_name)
-
-    @classmethod
-    def tearDownClass(self):
-        if self.platform == "linux":
-            os.system("rm -rf {}".format(self.unzipped_folder_name))
-
-    def test_parse_pb_contains_share_nodes(self):
-        original_graphdef = read_graph(os.path.join(self.unzipped_folder_name, "frozen_inference_graph.pb"))
-        copied_graphdef = copy.deepcopy(original_graphdef)
-        parsed_graphdef = SplitSharedInputOptimizer(original_graphdef).do_transformation()
-        legacy_graphdef = QuantizeGraphHelper.split_shared_inputs(copied_graphdef)
-        self.assertGreater(len(parsed_graphdef.node), len(original_graphdef.node))
-        self.assertEqual(len(legacy_graphdef.node), len(parsed_graphdef.node))
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_strip_equivalent_nodes.py b/test/tensorflow/quantization/ptq/test_strip_equivalent_nodes.py
deleted file mode 100644
index 62c2754c7f5..00000000000
--- a/test/tensorflow/quantization/ptq/test_strip_equivalent_nodes.py
+++ /dev/null
@@ -1,64 +0,0 @@
-#
-#  -*- coding: utf-8 -*-
-#
-
-import os
-import unittest
-
-import numpy as np
-import tensorflow as tf
-import yaml
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.tensorflow.utils import disable_random
-
-
-class TestConvBiasAddAddReluFusion(unittest.TestCase):
-    @disable_random()
-    def test_conv_relu_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(top_relu, paddings, "CONSTANT")
-        conv_weights = tf.compat.v1.get_variable(
-            "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv1 = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        conv2 = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        conv_add = tf.math.add(conv1, conv2)
-        relu6 = tf.nn.relu6(conv_add)
-        out_name = relu6.name.split(":")[0]
-
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            fp32_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-            from neural_compressor.tensorflow import quantize_model
-            from neural_compressor.tensorflow.utils import BaseDataLoader, DummyDataset
-
-            dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-            calib_dataloader = BaseDataLoader(dataset)
-            quant_config = {
-                "static_quant": {
-                    "global": {
-                        "weight_dtype": "int8",
-                        "weight_sym": True,
-                        "weight_granularity": "per_tensor",
-                        "weight_algorithm": "minmax",
-                    },
-                }
-            }
-            qmodel = quantize_model(fp32_graph_def, quant_config, calib_dataloader)
-
-            found_conv_num = 0
-            for i in qmodel.graph_def.node:
-                if "QuantizedConv2D" in i.op:
-                    found_conv_num += 1
-
-            self.assertEqual(found_conv_num, 1)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/ptq/test_utils.py b/test/tensorflow/quantization/ptq/test_utils.py
deleted file mode 100644
index c1231cf5c8a..00000000000
--- a/test/tensorflow/quantization/ptq/test_utils.py
+++ /dev/null
@@ -1,185 +0,0 @@
-import os
-import unittest
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.core.framework import graph_pb2
-from tensorflow.python.framework import dtypes
-
-from neural_compressor.tensorflow import Model
-from neural_compressor.tensorflow.quantization.utils.graph_util import GraphRewriterHelper as Helper
-from neural_compressor.tensorflow.quantization.utils.utility import (
-    collate_tf_preds,
-    fix_ref_type_of_graph_def,
-    generate_feed_dict,
-    get_graph_def,
-    get_model_input_shape,
-    get_tensor_by_name,
-    is_ckpt_format,
-)
-from neural_compressor.tensorflow.utils import disable_random
-
-
-def build_fake_graphdef():
-    graph_def = graph_pb2.GraphDef()
-    constant_1_name = "moving_1/switch_input_const"
-    constant_1 = Helper.create_constant_node(constant_1_name, value=0.0, dtype=dtypes.float32)
-
-    constant_3_name = "moving_1/switch_input_const/read"
-    constant_3 = Helper.create_constant_node(constant_3_name, value=[1], dtype=dtypes.float32)
-
-    constant_2_name = "switch_input_const2"
-    constant_2 = Helper.create_constant_node(constant_2_name, value=2.0, dtype=dtypes.float32)
-    equal_name = "equal"
-    equal = Helper.create_node("Equal", equal_name, [constant_1_name, constant_2_name])
-    Helper.set_attr_dtype(equal, "T", dtypes.float32)
-
-    refswitch_name = "refswitch"
-    refswitch_node = Helper.create_node("RefSwitch", refswitch_name, [constant_1_name, equal_name])
-    Helper.set_attr_dtype(refswitch_node, "T", dtypes.float32)
-
-    variable_name = "variable"
-    variable_node = Helper.create_node("VariableV2", variable_name, [])
-    Helper.set_attr_dtype(variable_node, "T", dtypes.float32)
-
-    assign_name = "assign"
-    assign_node = Helper.create_node("Assign", assign_name, [variable_name, refswitch_name])
-    Helper.set_attr_bool(assign_node, "use_locking", True)
-    Helper.set_attr_bool(assign_node, "validate_shape", True)
-    Helper.set_attr_dtype(assign_node, "T", dtypes.float32)
-
-    assignsub_name = "assignsub"
-    assignsub_node = Helper.create_node("AssignSub", assignsub_name, [assign_name, constant_1_name])
-    Helper.set_attr_bool(assignsub_node, "use_locking", True)
-    Helper.set_attr_dtype(assignsub_node, "T", dtypes.float32)
-
-    assignadd_name = "assignadd"
-    assignadd_node = Helper.create_node("AssignAdd", assignadd_name, [assignsub_name, constant_2_name])
-    Helper.set_attr_bool(assignadd_node, "use_locking", True)
-    Helper.set_attr_dtype(assignadd_node, "T", dtypes.float32)
-
-    graph_def.node.extend(
-        [
-            constant_1,
-            constant_2,
-            constant_3,
-            equal,
-            refswitch_node,
-            variable_node,
-            assign_node,
-            assignsub_node,
-            assignadd_node,
-        ]
-    )
-    return graph_def
-
-
-def build_fake_graphdef2():
-    input_placeholder = tf.compat.v1.placeholder(tf.float32, shape=(32, 224, 224, 3), name="input_placeholder")
-
-    conv_filter = tf.Variable(tf.random.normal([3, 3, 3, 32], stddev=0.1), name="conv_filter")
-    conv_bias = tf.Variable(tf.zeros([32]), name="conv_bias")
-    conv_output = tf.nn.conv2d(input_placeholder, conv_filter, strides=[1, 1, 1, 1], padding="SAME")
-    conv_output = tf.nn.bias_add(conv_output, conv_bias)
-    conv_output = tf.nn.relu(conv_output, name="conv_output")
-
-    pool_output = tf.nn.max_pool2d(
-        conv_output, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME", name="pool_output"
-    )
-
-    fc_weights = tf.Variable(
-        tf.random.normal(
-            [int(pool_output.shape[1]) * int(pool_output.shape[2]) * int(pool_output.shape[3]), 10], stddev=0.1
-        ),
-        name="fc_weights",
-    )
-    fc_bias = tf.Variable(tf.zeros([10]), name="fc_bias")
-    fc_input = tf.reshape(pool_output, [-1, int(fc_weights.shape[0])])
-    fc_output = tf.matmul(fc_input, fc_weights) + fc_bias
-
-    output = tf.reduce_sum(tf.nn.softmax(fc_output, name="output"), axis=-1)
-    graph_def = tf.compat.v1.get_default_graph().as_graph_def()
-
-    return graph_def
-
-
-class TestTFutil(unittest.TestCase):
-    @classmethod
-    def tearDownClass(self):
-        os.remove("test.pb")
-        os.removedirs("fake_ckpt")
-
-    @disable_random()
-    def test_fix_ref_type(self):
-        graph_def = build_fake_graphdef()
-        new_graph_def = fix_ref_type_of_graph_def(graph_def)
-        f = tf.io.gfile.GFile("./test.pb", "wb")
-        f.write(new_graph_def.SerializeToString())
-        find_Assign_prefix = False
-        for node in new_graph_def.node:
-            if "Assign" in node.op:
-                find_Assign_prefix = True
-
-        self.assertFalse(find_Assign_prefix, False)
-
-    @disable_random()
-    def test_collate_tf_preds(self):
-        results = [[1], [np.array([2])]]
-        data = collate_tf_preds(results)
-
-        self.assertEqual(data, [1, np.array([2])])
-
-        results = [[np.array([2])], [[1]]]
-        data = collate_tf_preds(results)
-
-        self.assertEqual(data[0].all(), np.array([2, 1]).all())
-
-    @disable_random()
-    def test_get_graph_def(self):
-        graph_def = get_graph_def("./test.pb", outputs="assignadd")
-
-        self.assertIsInstance(graph_def, tf.compat.v1.GraphDef)
-
-    @disable_random()
-    def test_judge_ckpt_format(self):
-        os.mkdir("fake_ckpt")
-        ckpt_format = is_ckpt_format("fake_ckpt")
-
-        self.assertEqual(ckpt_format, False)
-
-    @disable_random()
-    def test_get_model_input_shape(self):
-        graph_def = build_fake_graphdef2()
-        try:
-            tensor = get_tensor_by_name(graph_def, "fake:0")
-        except:
-            print("This code is for UT coverage of the exception handling")
-        model = Model(graph_def)
-        input_shape = get_model_input_shape(model)
-
-        self.assertEqual(input_shape, 32)
-
-    @disable_random()
-    def test_generate_feed_dict(self):
-        input_0 = [[1.0, 3.0], [3.0, 7.0]]
-        input_tensor_0 = tf.convert_to_tensor(input_0)
-        input_1 = [[1.0, 3.0]]
-        input_tensor_1 = tf.convert_to_tensor(input_1)
-
-        feed_dict = generate_feed_dict([input_tensor_0], input_0)
-        self.assertEqual(feed_dict, {input_tensor_0: input_0})
-
-        feed_dict = generate_feed_dict([input_tensor_0], {"Const": input_0})
-        self.assertEqual(feed_dict, {input_tensor_0: input_0})
-
-        feed_dict = generate_feed_dict([input_tensor_0, input_tensor_1], [input_0, input_1])
-        self.assertEqual(feed_dict[input_tensor_0], input_0)
-        self.assertEqual(feed_dict[input_tensor_1], input_1)
-
-        feed_dict = generate_feed_dict([input_tensor_0, input_tensor_1], {"Const": input_0, "Const_1": input_1})
-        self.assertEqual(feed_dict[input_tensor_0], input_0)
-        self.assertEqual(feed_dict[input_tensor_1], input_1)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/quantization/test_smooth_quant.py b/test/tensorflow/quantization/test_smooth_quant.py
deleted file mode 100644
index 9766a709bb7..00000000000
--- a/test/tensorflow/quantization/test_smooth_quant.py
+++ /dev/null
@@ -1,239 +0,0 @@
-import math
-import unittest
-
-import numpy as np
-import tensorflow as tf
-from tensorflow.compat.v1 import graph_util
-
-from neural_compressor.common import set_random_seed
-from neural_compressor.tensorflow import SmoothQuantConfig, StaticQuantConfig, get_default_sq_config, quantize_model
-from neural_compressor.tensorflow.utils import DummyDataset, disable_random, version1_gte_version2
-
-
-def build_conv_graph():
-    tf.compat.v1.disable_eager_execution()
-    x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-    top_relu = tf.nn.relu(x)
-    paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-    x_pad = tf.pad(top_relu, paddings, "CONSTANT")
-    conv_weights = tf.compat.v1.get_variable(
-        "weight", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-    )
-    conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-    normed = (
-        tf.keras.layers.BatchNormalization()(conv)
-        if version1_gte_version2(tf.__version__, "2.16.1")
-        else tf.compat.v1.layers.batch_normalization(conv)
-    )
-
-    conv_weights2 = tf.compat.v1.get_variable(
-        "weight2", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-    )
-    conv2 = tf.nn.conv2d(top_relu, conv_weights2, strides=[1, 2, 2, 1], padding="SAME")
-    normed2 = (
-        tf.keras.layers.BatchNormalization()(conv2)
-        if version1_gte_version2(tf.__version__, "2.16.1")
-        else tf.compat.v1.layers.batch_normalization(conv2)
-    )
-    add = tf.raw_ops.Add(x=normed, y=normed2, name="addv2")
-
-    relu = tf.nn.relu(add)
-    relu6 = tf.nn.relu6(relu, name="op_to_store")
-
-    out_name = relu6.name.split(":")[0]
-
-    with tf.compat.v1.Session() as sess:
-        sess.run(tf.compat.v1.global_variables_initializer())
-        output_graph_def = graph_util.convert_variables_to_constants(
-            sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-        )
-        return output_graph_def
-
-
-class MyDataLoader:
-    def __init__(self, dataset, batch_size=1):
-        self.dataset = dataset
-        self.batch_size = batch_size
-        self.length = math.ceil(len(dataset) / self.batch_size)
-
-    def __iter__(self):
-        images_list = []
-        labels_list = []
-        for _, (images, labels) in enumerate(self.dataset):
-            images = np.expand_dims(images, axis=0)
-            labels = np.expand_dims(labels, axis=0)
-            images_list.append(images[0])
-            labels_list.append(labels[0])
-            if self.batch_size == len(images_list):
-                yield (images_list, labels_list)
-                images_list = []
-                labels_list = []
-
-    def __len__(self):
-        return self.length
-
-
-class TestSmoothQuantTF3xNewApi(unittest.TestCase):
-    @classmethod
-    def setUpClass(self):
-        self.conv_graph = build_conv_graph()
-
-    @classmethod
-    def tearDownClass(self):
-        pass
-
-    def test_conv(self):
-        set_random_seed(9527)
-        quant_config = SmoothQuantConfig(alpha=0.5)
-        dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-        calib_dataloader = MyDataLoader(dataset=dataset, batch_size=1)
-        q_model = quantize_model(self.conv_graph, quant_config, calib_dataloader, calib_iteration=500)
-
-        mul_count = 0
-        for i in q_model.graph_def.node:
-            if i.op == "Mul":
-                mul_count += 1
-
-        self.assertEqual(mul_count, 2)
-
-    def test_sq_from_class_beginner(self):
-        set_random_seed(9527)
-        quant_config = get_default_sq_config()
-        dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-        calib_dataloader = MyDataLoader(dataset=dataset, batch_size=1)
-        q_model = quantize_model(self.conv_graph, quant_config, calib_dataloader, calib_iteration=500)
-
-        mul_count = 0
-        for i in q_model.graph_def.node:
-            if i.op == "Mul":
-                mul_count += 1
-
-        self.assertEqual(mul_count, 2)
-
-    def test_sq_from_dict_beginner(self):
-        quant_config = {
-            "smooth_quant": {
-                "global": {
-                    "alpha": 0.5,
-                },
-            }
-        }
-        dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-        calib_dataloader = MyDataLoader(dataset=dataset, batch_size=1)
-        q_model = quantize_model(self.conv_graph, quant_config, calib_dataloader, calib_iteration=500)
-
-        mul_count = 0
-        for i in q_model.graph_def.node:
-            if i.op == "Mul":
-                mul_count += 1
-
-        self.assertEqual(mul_count, 2)
-
-    def test_sq_completed_workflow(self):
-        x_data = np.random.rand(1024, 1024).astype(np.float32)
-        y_data = np.random.rand(1024, 1024).astype(np.float32)
-        import tensorflow.compat.v1 as tf
-
-        with tf.Session(graph=tf.Graph()) as sess:
-            x = tf.placeholder(tf.float32, shape=[1024, 1024], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[1024, 1024])
-            z = tf.matmul(x, y)
-            bias = np.random.rand(1024).astype(np.float32)
-            z = tf.nn.bias_add(z, bias)
-            z = tf.nn.relu(z, name="op_to_store")
-            sess.run(z, feed_dict={x: x_data, y: y_data})
-            output_graph_def = sess.graph.as_graph_def()
-
-        set_random_seed(9527)
-        sq_config = SmoothQuantConfig(alpha=0.5)
-        static_config = StaticQuantConfig()
-        dataset = DummyDataset(shape=(1024, 1024), label=True)
-        calib_dataloader = MyDataLoader(dataset=dataset, batch_size=1024)
-        q_model = quantize_model(output_graph_def, [sq_config, static_config], calib_dataloader, calib_iteration=500)
-
-        mul_count = 0
-        quantized = False
-        for i in q_model.graph_def.node:
-            if i.op == "Mul":
-                mul_count += 1
-            if "quantize" in i.op:
-                quantized = True
-
-        self.assertEqual(mul_count, 1)
-        self.assertEqual(quantized, True)
-
-    @disable_random()
-    def test_matmul(self):
-        x_data = np.random.rand(1024, 1024).astype(np.float32)
-        y_data = np.random.rand(1024, 1024).astype(np.float32)
-        import tensorflow.compat.v1 as tf
-
-        with tf.Session(graph=tf.Graph()) as sess:
-            x = tf.placeholder(tf.float32, shape=[1024, 1024], name="x")
-            y = tf.constant(y_data, dtype=tf.float32, shape=[1024, 1024])
-            z = tf.matmul(x, y)
-            bias = np.random.rand(1024).astype(np.float32)
-            z = tf.nn.bias_add(z, bias)
-            z = tf.nn.relu(z, name="op_to_store")
-            sess.run(z, feed_dict={x: x_data, y: y_data})
-            output_graph_def = sess.graph.as_graph_def()
-
-        set_random_seed(9527)
-        quant_config = SmoothQuantConfig(alpha=0.5)
-        dataset = DummyDataset(shape=(1024, 1024), label=True)
-        calib_dataloader = MyDataLoader(dataset=dataset, batch_size=1024)
-        q_model = quantize_model(output_graph_def, quant_config, calib_dataloader, calib_iteration=1)
-
-        mul_count = 0
-        for i in q_model.graph_def.node:
-            if i.op == "Mul":
-                mul_count += 1
-
-        self.assertEqual(mul_count, 1)
-
-    @disable_random()
-    def test_conv_matmul(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(top_relu, paddings, "CONSTANT")
-        conv1_weights = tf.compat.v1.get_variable(
-            "weight_conv1", [3, 3, 16, 16], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv1 = tf.nn.conv2d(x_pad, conv1_weights, strides=[1, 2, 2, 1], padding="VALID")
-        matmul_weights = tf.compat.v1.get_variable(
-            "weight_matmul", [28 * 28 * 16, 7 * 7 * 32], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv1_reshaped = tf.reshape(conv1, shape=[-1, 28 * 28 * 16])
-        matmul = tf.matmul(conv1_reshaped, matmul_weights)
-        reshape = tf.reshape(matmul, (1, 7, 7, 32))
-        conv2_weights = tf.compat.v1.get_variable(
-            "weight_conv2", [7, 7, 32, 1], initializer=tf.compat.v1.random_normal_initializer()
-        )
-        conv2 = tf.nn.conv2d(reshape, conv2_weights, strides=[1, 2, 2, 1], padding="VALID")
-        leaky_relu = tf.nn.leaky_relu(conv2, name="op_to_store")
-
-        out_name = leaky_relu.name.split(":")[0]
-
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-            )
-
-        set_random_seed(9527)
-        quant_config = SmoothQuantConfig(alpha=0.6)
-        dataset = DummyDataset(shape=(100, 56, 56, 16), label=True)
-        calib_dataloader = MyDataLoader(dataset=dataset, batch_size=1)
-        q_model = quantize_model(output_graph_def, quant_config, calib_dataloader, calib_iteration=500)
-
-        mul_count = 0
-        for i in q_model.graph_def.node:
-            if i.op == "Mul":
-                mul_count += 1
-
-        self.assertEqual(mul_count, 3)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/requirements.txt b/test/tensorflow/requirements.txt
deleted file mode 100644
index e079f8a6038..00000000000
--- a/test/tensorflow/requirements.txt
+++ /dev/null
@@ -1 +0,0 @@
-pytest
diff --git a/test/tensorflow/test_autotune.py b/test/tensorflow/test_autotune.py
deleted file mode 100644
index 646a86a1549..00000000000
--- a/test/tensorflow/test_autotune.py
+++ /dev/null
@@ -1,194 +0,0 @@
-import math
-import shutil
-import unittest
-from functools import wraps
-from typing import Callable, Dict, List, Optional, Union
-from unittest.mock import patch
-
-import numpy as np
-import tensorflow as tf
-from tensorflow import keras
-
-from neural_compressor.common import logger
-from neural_compressor.common.base_tuning import Evaluator, TuningConfig
-from neural_compressor.tensorflow.quantization import SmoothQuantConfig, StaticQuantConfig, autotune
-from neural_compressor.tensorflow.utils import version1_gte_version2
-
-
-def _create_evaluator_for_eval_fns(eval_fns: Optional[Union[Callable, Dict, List[Dict]]] = None) -> Evaluator:
-    evaluator = Evaluator()
-    evaluator.set_eval_fn_registry(eval_fns)
-    return evaluator
-
-
-def build_model():
-    # Load MNIST dataset
-    mnist = keras.datasets.mnist
-
-    # 60000 images in train and 10000 images in test, but we don't need so much for ut
-    (train_images, train_labels), (test_images, test_labels) = mnist.load_data()
-    train_images, train_labels = train_images[:1000], train_labels[:1000]
-    test_images, test_labels = test_images[:200], test_labels[:200]
-
-    # Normalize the input image so that each pixel value is between 0 to 1.
-    train_images = train_images / 255.0
-    test_images = test_images / 255.0
-
-    # Define the model architecture.
-    model = keras.Sequential(
-        [
-            keras.layers.InputLayer(input_shape=(28, 28)),
-            keras.layers.Reshape(target_shape=(28, 28, 1)),
-            keras.layers.Conv2D(filters=12, kernel_size=(3, 3), activation="relu"),
-            keras.layers.MaxPooling2D(pool_size=(2, 2)),
-            keras.layers.Flatten(),
-            keras.layers.Dense(10),
-        ]
-    )
-    # Train the digit classification model
-    model.compile(
-        optimizer="adam", loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=["accuracy"]
-    )
-
-    model.fit(
-        train_images,
-        train_labels,
-        epochs=1,
-        validation_split=0.1,
-    )
-
-    _, baseline_model_accuracy = model.evaluate(test_images, test_labels, verbose=0)
-
-    print("Baseline test accuracy:", baseline_model_accuracy)
-    if version1_gte_version2(tf.__version__, "2.16.1"):
-        tf.saved_model.save(model, "baseline_model")
-    else:
-        model.save("baseline_model")
-
-
-class Dataset(object):
-    def __init__(self, batch_size=1):
-        self.batch_size = batch_size
-        mnist = keras.datasets.mnist
-        (train_images, train_labels), (test_images, test_labels) = mnist.load_data()
-        train_images, train_labels = train_images[:1000], train_labels[:1000]
-        test_images, test_labels = test_images[:200], test_labels[:200]
-        # Normalize the input image so that each pixel value is between 0 to 1.
-        self.train_images = train_images / 255.0
-        self.test_images = test_images / 255.0
-        self.train_labels = train_labels
-        self.test_labels = test_labels
-
-    def __len__(self):
-        return len(self.test_images)
-
-    def __getitem__(self, idx):
-        return self.test_images[idx], self.test_labels[idx]
-
-
-class MyDataloader:
-    def __init__(self, dataset, batch_size=1):
-        self.dataset = dataset
-        self.batch_size = batch_size
-        self.length = math.ceil(len(dataset) / self.batch_size)
-
-    def __iter__(self):
-        for _, (images, labels) in enumerate(self.dataset):
-            images = np.expand_dims(images, axis=0)
-            labels = np.expand_dims(labels, axis=0)
-            yield (images, labels)
-
-    def __len__(self):
-        return self.length
-
-
-class TestAutoTune(unittest.TestCase):
-    @classmethod
-    def setUpClass(self):
-        build_model()
-
-    @classmethod
-    def tearDownClass(self):
-        shutil.rmtree("baseline_model", ignore_errors=True)
-
-    def setUp(self):
-        # print the test name
-        logger.info(f"Running TestAutoTune test: {self.id()}")
-
-    def test_static_quant_auto_tune(self):
-        acc_data = iter([1.0, 0.8, 0.99, 1.0, 0.99, 0.99])
-
-        def eval_acc_fn(model) -> float:
-            return next(acc_data)
-
-        perf_data = iter([1.0, 0.9, 0.99])
-
-        def eval_perf_fn(model) -> float:
-            return next(perf_data)
-
-        calib_dataloader = MyDataloader(dataset=Dataset())
-        custom_tune_config = TuningConfig(
-            config_set=[
-                StaticQuantConfig(weight_sym=True, act_sym=True),
-                StaticQuantConfig(weight_sym=False, act_sym=False),
-            ]
-        )
-        best_model = autotune(
-            model="baseline_model",
-            tune_config=custom_tune_config,
-            eval_fn=eval_acc_fn,
-            calib_dataloader=calib_dataloader,
-        )
-        self.assertIsNotNone(best_model)
-
-    def test_sq_auto_tune(self):
-        acc_data = iter([1.0, 0.8, 0.6, 1.0, 0.99, 0.9])
-
-        def eval_acc_fn(model) -> float:
-            return next(acc_data)
-
-        perf_data = iter([1.0, 0.99, 0.99])
-
-        def eval_perf_fn(model) -> float:
-            return next(perf_data)
-
-        eval_fns = [
-            {"eval_fn": eval_acc_fn, "weight": 0.5, "name": "accuracy"},
-            {
-                "eval_fn": eval_perf_fn,
-                "weight": 0.5,
-            },
-        ]
-
-        evaluator = _create_evaluator_for_eval_fns(eval_fns)
-
-        def eval_fn_wrapper(model):
-            result = evaluator.evaluate(model)
-            return result
-
-        calib_dataloader = MyDataloader(dataset=Dataset())
-        custom_tune_config = TuningConfig(config_set=[SmoothQuantConfig(alpha=0.5), SmoothQuantConfig(alpha=0.6)])
-        best_model = autotune(
-            model="baseline_model",
-            tune_config=custom_tune_config,
-            eval_fn=eval_acc_fn,
-            calib_dataloader=calib_dataloader,
-        )
-        self.assertIsNone(best_model)
-
-        custom_tune_config = TuningConfig(config_set=[SmoothQuantConfig(alpha=[0.5, 0.6])])
-        best_model = autotune(
-            model="baseline_model",
-            tune_config=custom_tune_config,
-            eval_fn=eval_fn_wrapper,
-            calib_dataloader=calib_dataloader,
-        )
-        self.assertEqual(len(evaluator.eval_fn_registry), 2)
-        self.assertIsNotNone(best_model)
-
-        op_names = [i.name for i in best_model.graph_def.node if i.op == "MatMul" and "_mul" in i.input[0]]
-        self.assertTrue(len(op_names) > 0)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/test_config.py b/test/tensorflow/test_config.py
deleted file mode 100644
index 4a48387af55..00000000000
--- a/test/tensorflow/test_config.py
+++ /dev/null
@@ -1,344 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import math
-import os
-import shutil
-import time
-import unittest
-
-import numpy as np
-
-from neural_compressor.common import logger
-
-
-def build_model():
-    import tensorflow as tf
-    from tensorflow.compat.v1 import graph_util
-
-    tf.compat.v1.disable_eager_execution()
-    tf.compat.v1.reset_default_graph()
-    tf.compat.v1.set_random_seed(1)
-
-    graph = tf.Graph()
-    graph_def = tf.compat.v1.GraphDef()
-
-    x = tf.compat.v1.placeholder(tf.float32, [1, 32, 32, 3], name="x")
-    top_relu = tf.nn.relu(x)
-    paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-    x_pad = tf.pad(top_relu, paddings, "CONSTANT")
-    conv_weights = tf.compat.v1.get_variable(
-        "weight", [3, 3, 3, 3], initializer=tf.compat.v1.random_normal_initializer()
-    )
-    conv = tf.nn.conv2d(x_pad, conv_weights, strides=[1, 2, 2, 1], padding="VALID", name="conv1")
-    relu = tf.nn.relu(conv)
-    relu6 = tf.nn.relu6(relu, name="op_to_store")
-    out_name = relu6.name.split(":")[0]
-    with tf.compat.v1.Session() as sess:
-        sess.run(tf.compat.v1.global_variables_initializer())
-        output_graph_def = graph_util.convert_variables_to_constants(
-            sess=sess, input_graph_def=sess.graph_def, output_node_names=[out_name]
-        )
-
-    graph_def.ParseFromString(output_graph_def.SerializeToString())
-    with graph.as_default():
-        tf.import_graph_def(graph_def, name="")
-    return graph
-
-
-class MyDataLoader:
-    def __init__(self, dataset, batch_size=1):
-        self.dataset = dataset
-        self.batch_size = batch_size
-        self.length = math.ceil(len(dataset) / self.batch_size)
-
-    def __iter__(self):
-        for _, (images, labels) in enumerate(self.dataset):
-            images = np.expand_dims(images, axis=0)
-            labels = np.expand_dims(labels, axis=0)
-            yield (images, labels)
-
-    def __len__(self):
-        return self.length
-
-
-class TestTF3xNewApi(unittest.TestCase):
-    @classmethod
-    def setUpClass(self):
-        self.graph = build_model()
-
-    @classmethod
-    def tearDownClass(self):
-        shutil.rmtree("baseline_model", ignore_errors=True)
-
-    def test_static_quant_from_dict_default(self):
-        logger.info("test_static_quant_from_dict_default")
-        from neural_compressor.tensorflow import get_default_static_quant_config, quantize_model
-        from neural_compressor.tensorflow.utils import DummyDataset
-
-        dataset = DummyDataset(shape=(100, 32, 32, 3), label=True)
-        calib_dataloader = MyDataLoader(dataset=dataset)
-        fp32_model = self.graph
-        qmodel = quantize_model(fp32_model, get_default_static_quant_config(), calib_dataloader)
-        self.assertIsNotNone(qmodel)
-
-        conv2d_quantized = False
-        for node in qmodel.graph_def.node:
-            if "Quantized" in node.op:
-                conv2d_quantized = True
-                break
-
-        self.assertEqual(conv2d_quantized, True)
-
-    def test_static_quant_from_dict_beginner(self):
-        logger.info("test_static_quant_from_dict_beginner")
-        from neural_compressor.tensorflow import quantize_model
-
-        quant_config = {
-            "static_quant": {
-                "global": {
-                    "weight_dtype": "fp32",
-                    "act_dtype": "fp32",
-                },
-            }
-        }
-        from neural_compressor.tensorflow.utils import DummyDataset
-
-        dataset = DummyDataset(shape=(100, 32, 32, 3), label=True)
-        calib_dataloader = MyDataLoader(dataset=dataset)
-        fp32_model = self.graph
-
-        qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-        self.assertIsNotNone(qmodel)
-
-        quantized = False
-        for node in qmodel.graph_def.node:
-            if "Quantize" in node.op:
-                quantized = True
-                break
-
-        self.assertEqual(quantized, False)
-
-    def test_static_quant_from_class_default(self):
-        logger.info("test_static_quant_from_class_default")
-        from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-        from neural_compressor.tensorflow.utils import DummyDataset
-
-        dataset = DummyDataset(shape=(100, 32, 32, 3), label=True)
-        calib_dataloader = MyDataLoader(dataset=dataset)
-        fp32_model = self.graph
-        quant_config = StaticQuantConfig()
-        qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-        self.assertIsNotNone(qmodel)
-
-        conv2d_quantized = False
-        for node in qmodel.graph_def.node:
-            if "Quantized" in node.op:
-                conv2d_quantized = True
-                break
-
-        self.assertEqual(conv2d_quantized, True)
-
-    def test_static_quant_from_class_beginner(self):
-        logger.info("test_static_quant_from_class_beginner")
-        from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-        from neural_compressor.tensorflow.utils import DummyDataset
-
-        dataset = DummyDataset(shape=(100, 32, 32, 3), label=True)
-        calib_dataloader = MyDataLoader(dataset=dataset)
-        fp32_model = self.graph
-        quant_config = StaticQuantConfig(
-            weight_dtype="fp32",
-            act_dtype="fp32",
-        )
-        qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-        self.assertIsNotNone(qmodel)
-
-        quantized = False
-        for node in qmodel.graph_def.node:
-            if "Quantize" in node.op:
-                quantized = True
-                break
-
-        self.assertEqual(quantized, False)
-
-    def test_static_quant_from_dict_advance(self):
-        logger.info("test_static_quant_from_dict_advance")
-        from neural_compressor.tensorflow import quantize_model
-        from neural_compressor.tensorflow.utils import DummyDataset
-
-        dataset = DummyDataset(shape=(100, 32, 32, 3), label=True)
-        calib_dataloader = MyDataLoader(dataset=dataset)
-        fp32_model = self.graph
-        quant_config = {
-            "static_quant": {
-                "global": {
-                    "weight_dtype": "int8",
-                    "weight_sym": True,
-                    "weight_granularity": "per_channel",
-                    "act_dtype": "int8",
-                    "act_sym": True,
-                    "act_granularity": "per_channel",
-                },
-                "local": {
-                    "conv1": {
-                        "weight_dtype": "fp32",
-                        "act_dtype": "fp32",
-                    }
-                },
-            }
-        }
-        qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-        self.assertIsNotNone(qmodel)
-
-        conv2d_quantized = True
-        for node in qmodel.graph_def.node:
-            if node.name == "conv1" and "Quantize" not in node.op:
-                conv2d_quantized = False
-                break
-
-        self.assertEqual(conv2d_quantized, False)
-
-    def test_static_quant_from_dict_advance2(self):
-        logger.info("test_static_quant_from_dict_advance2")
-        from neural_compressor.tensorflow import quantize_model
-        from neural_compressor.tensorflow.utils import DummyDataset
-
-        dataset = DummyDataset(shape=(100, 32, 32, 3), label=True)
-        calib_dataloader = MyDataLoader(dataset=dataset)
-        fp32_model = self.graph
-        quant_config = {
-            "static_quant": {
-                "global": {
-                    "weight_dtype": "int8",
-                    "weight_sym": True,
-                    "weight_granularity": "per_channel",
-                    "act_dtype": "int8",
-                    "act_sym": True,
-                    "act_granularity": "per_channel",
-                },
-                "local": {
-                    "conv1": {
-                        "weight_algorithm": "kl",
-                        "act_algorithm": "kl",
-                    }
-                },
-            }
-        }
-        qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-        self.assertIsNotNone(qmodel)
-
-    def test_static_quant_from_class_advance(self):
-        logger.info("test_static_quant_from_class_advance")
-        from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-        from neural_compressor.tensorflow.utils import DummyDataset
-
-        dataset = DummyDataset(shape=(100, 32, 32, 3), label=True)
-        calib_dataloader = MyDataLoader(dataset=dataset)
-        fp32_model = self.graph
-        quant_config = StaticQuantConfig(
-            weight_dtype="int8",
-            weight_sym=True,
-            weight_granularity="per_channel",
-            act_dtype="int8",
-            act_sym=True,
-            act_granularity="per_channel",
-        )
-        conv2d_config = StaticQuantConfig(
-            weight_dtype="fp32",
-            act_dtype="fp32",
-        )
-        quant_config.set_local("conv1", conv2d_config)
-        qmodel = quantize_model(fp32_model, quant_config, calib_dataloader)
-        self.assertIsNotNone(qmodel)
-
-        conv2d_quantized = True
-        for node in qmodel.graph_def.node:
-            if node.name == "conv1" and "Quantize" not in node.op:
-                conv2d_quantized = False
-                break
-
-        self.assertEqual(conv2d_quantized, False)
-
-    def test_config_from_dict(self):
-        logger.info("test_config_from_dict")
-        from neural_compressor.tensorflow import StaticQuantConfig
-
-        quant_config = {
-            "static_quant": {
-                "global": {
-                    "weight_dtype": "int8",
-                    "weight_sym": True,
-                    "weight_granularity": "per_tensor",
-                    "act_dtype": "int8",
-                    "act_sym": True,
-                    "act_granularity": "per_tensor",
-                },
-                "local": {
-                    "conv1": {
-                        "weight_dtype": "fp32",
-                        "act_dtype": "fp32",
-                    }
-                },
-            }
-        }
-        config = StaticQuantConfig.from_dict(quant_config["static_quant"])
-        self.assertIsNotNone(config.local_config)
-
-    def test_config_to_dict(self):
-        logger.info("test_config_to_dict")
-        from neural_compressor.tensorflow import StaticQuantConfig
-
-        quant_config = StaticQuantConfig(
-            weight_dtype="int8",
-            weight_sym=True,
-            weight_granularity="per_channel",
-            act_dtype="int8",
-            act_sym=True,
-            act_granularity="per_channel",
-        )
-        conv2d_config = StaticQuantConfig(
-            weight_dtype="fp32",
-            act_dtype="fp32",
-        )
-        quant_config.set_local("conv1", conv2d_config)
-        config_dict = quant_config.to_dict()
-        self.assertIn("global", config_dict)
-        self.assertIn("local", config_dict)
-
-
-class TestQuantConfigForAutotune(unittest.TestCase):
-    def test_expand_config(self):
-        # test the expand functionalities, the user is not aware it
-        from neural_compressor.tensorflow import StaticQuantConfig
-
-        quant_configs = StaticQuantConfig(
-            weight_dtype="int8",
-            weight_sym=True,
-            weight_granularity=["per_channel", "per_tensor"],
-            act_dtype="int8",
-            act_sym=True,
-            act_granularity="per_channel",
-        )
-
-        expand_config_list = StaticQuantConfig.expand(quant_configs)
-        self.assertEqual(expand_config_list[0].weight_granularity, "per_channel")
-        self.assertEqual(expand_config_list[1].weight_granularity, "per_tensor")
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/test_model_wrappers.py b/test/tensorflow/test_model_wrappers.py
deleted file mode 100644
index 63eb1689de5..00000000000
--- a/test/tensorflow/test_model_wrappers.py
+++ /dev/null
@@ -1,365 +0,0 @@
-"""Tests for model."""
-
-import os
-import platform
-import shutil
-import tempfile
-import unittest
-
-import numpy as np
-import tensorflow as tf
-from pkg_resources import parse_version
-
-from neural_compressor.tensorflow.utils.model import Model
-
-
-def build_graph():
-    try:
-        graph = tf.Graph()
-        graph_def = tf.GraphDef()
-        with tf.Session(graph=graph) as sess:
-            x = tf.placeholder(tf.float64, shape=(1, 256, 256, 1), name="x")
-            y = tf.constant(np.random.random((2, 2, 1, 1)), name="y")
-            op = tf.nn.conv2d(input=x, filter=y, strides=[1, 1, 1, 1], padding="VALID", name="op_to_store")
-
-            sess.run(tf.global_variables_initializer())
-            constant_graph = tf.graph_util.convert_variables_to_constants(sess, sess.graph_def, ["op_to_store"])
-
-        graph_def.ParseFromString(constant_graph.SerializeToString())
-        with graph.as_default():
-            tf.import_graph_def(graph_def, name="")
-    except:
-        graph = tf.Graph()
-        graph_def = tf.compat.v1.GraphDef()
-        with tf.compat.v1.Session(graph=graph) as sess:
-            x = tf.compat.v1.placeholder(tf.float64, shape=(1, 256, 256, 1), name="x")
-            y = tf.compat.v1.constant(np.random.random((3, 3, 1, 1)), name="y")
-            op = tf.nn.conv2d(input=x, filters=y, strides=[1, 1, 1, 1], padding="VALID", name="op_to_store")
-            sess.run(tf.compat.v1.global_variables_initializer())
-            constant_graph = tf.compat.v1.graph_util.convert_variables_to_constants(
-                sess, sess.graph_def, ["op_to_store"]
-            )
-
-        graph_def.ParseFromString(constant_graph.SerializeToString())
-        with graph.as_default():
-            tf.import_graph_def(graph_def, name="")
-    return graph
-
-
-def build_estimator():
-    def model_fn(features, labels, mode):
-        logits = tf.keras.layers.Dense(12)(features)
-        logits = tf.keras.layers.Dense(56)(logits)
-        logits = tf.keras.layers.Dense(4)(logits)
-
-        output_spec = tf.estimator.EstimatorSpec(mode=tf.estimator.ModeKeys.PREDICT, predictions=logits)
-        return output_spec
-
-    return model_fn
-
-
-def build_input_fn():
-    def input_fun():
-        tf.compat.v1.disable_eager_execution()
-        raw_dataset = np.ones([100, 224, 224, 3], dtype=np.float32)
-        tf_dataset = tf.compat.v1.data.Dataset.from_tensor_slices(raw_dataset)
-        tf_dataset = tf_dataset.batch(1)
-        ds_iterator = tf_dataset.make_initializable_iterator()
-        iter_tensors = ds_iterator.get_next()
-        return iter_tensors
-
-    return input_fun
-
-
-def build_keras():
-    from tensorflow import keras
-
-    (train_images, train_labels), (test_images, test_labels) = keras.datasets.fashion_mnist.load_data()
-
-    train_images = train_images.astype(np.float32) / 255.0
-
-    # Create Keras model
-    model = keras.Sequential(
-        [
-            keras.layers.InputLayer(input_shape=(28, 28), name="input"),
-            keras.layers.Reshape(target_shape=(28, 28, 1)),
-            keras.layers.Conv2D(filters=12, kernel_size=(3, 3), activation="relu"),
-            keras.layers.Conv2D(filters=12, kernel_size=(3, 3), activation="relu"),
-            keras.layers.Conv2D(filters=12, kernel_size=(3, 3), activation="relu"),
-            keras.layers.Conv2D(filters=12, kernel_size=(3, 3), activation="relu"),
-            keras.layers.Conv2D(filters=12, kernel_size=(3, 3), activation="relu"),
-            keras.layers.MaxPooling2D(pool_size=(2, 2)),
-            keras.layers.Flatten(),
-            keras.layers.Dense(10, activation="softmax", name="output"),
-        ]
-    )
-
-    # Compile model with optimizer
-    opt = keras.optimizers.Adam(learning_rate=0.01)
-    model.compile(optimizer=opt, loss="sparse_categorical_crossentropy", metrics=["accuracy"])
-
-    # # Train model
-    model.fit(x={"input": train_images[0:100]}, y={"output": train_labels[0:100]}, epochs=1)
-    return model
-
-
-class TestModelWrappers(unittest.TestCase):
-    @classmethod
-    def tearDownClass(self):
-        os.remove("model_test.pb")
-
-    def test_graph(self):
-        graph = build_graph()
-        model = Model(graph)
-        model.input_tensor_names = ["x"]
-        model.output_tensor_names = ["op_to_store"]
-
-        self.assertEqual(True, isinstance(model.graph_def, tf.compat.v1.GraphDef))
-        self.assertEqual(model.input_node_names[0], "x")
-        self.assertEqual(model.output_node_names[0], "op_to_store")
-        model.save("model_test.pb")
-
-        model = Model("model_test.pb")
-        self.assertEqual(model.input_tensor_names[0], "x")
-        self.assertEqual(model.output_tensor_names[0], "op_to_store")
-        self.assertEqual(model.input_tensor[0].name, "x:0")
-        self.assertEqual(model.output_tensor[0].name, "op_to_store:0")
-
-        # test wrong input tensor names can't set
-        with self.assertRaises(AssertionError):
-            model.input_tensor_names = ["wrong_input"]
-        with self.assertRaises(AssertionError):
-            model.output_tensor_names = ["wrong_output"]
-
-        # test right tensor
-        model.input_tensor_names = ["x_1"]
-        model.output_tensor_names = ["op_to_store_1"]
-        self.assertEqual(True, isinstance(model.graph_def, tf.compat.v1.GraphDef))
-
-    def test_validate_graph_node(self):
-        from neural_compressor.tensorflow.utils.model_wrappers import validate_graph_node
-
-        graph = build_graph()
-        self.assertEqual(False, validate_graph_node(graph.as_graph_def(), []))
-        self.assertEqual(False, validate_graph_node(graph.as_graph_def(), ["test"]))
-        self.assertEqual(True, validate_graph_node(graph.as_graph_def(), ["x"]))
-
-    @unittest.skipIf(
-        parse_version(tf.version.VERSION) >= parse_version("2.16.1"),
-        "Only supports tf previous to the version 2.16.1",
-    )
-    def test_estimator(self):
-        model_fn = build_estimator()
-        input_fn = build_input_fn()
-        estimator = tf.estimator.Estimator(model_fn, model_dir=None, config=None, params=None, warm_start_from=None)
-        with self.assertRaises(AssertionError):
-            graph_def = Model(estimator).graph_def
-        model = Model(estimator, input_fn=input_fn)
-
-        self.assertEqual(model.output_tensor_names[0], "dense_2/BiasAdd:0")
-
-    def test_ckpt(self):
-        mobilenet_ckpt_url = "http://download.tensorflow.org/models/mobilenet_v1_2018_02_22/mobilenet_v1_1.0_224.tgz"
-        dst_path = "/tmp/.neural_compressor/mobilenet_v1_1.0_224.tgz"
-        if platform.system().lower() == "windows":
-            model_path = "C:\\tmp\.neural_compressor\\mobilenet_v1_1.0_224"
-        else:
-            model_path = "./ckpt"
-            if not os.path.exists(dst_path):
-                os.system("mkdir -p /tmp/.neural_compressor && wget {} -O {}".format(mobilenet_ckpt_url, dst_path))
-            if not os.path.getsize(dst_path):
-                os.system("rm -fr {0} && wget {1} -O {0}".format(dst_path, mobilenet_ckpt_url))
-            os.system("mkdir -p ckpt && tar xvf {0} -C {1}".format(dst_path, model_path))
-        model = Model(model_path)
-        model.output_tensor_names = ["MobilenetV1/Predictions/Reshape_1"]
-
-        self.assertEqual(model_path, model.model_path)
-        self.assertGreaterEqual(len(model.input_tensor_names), 1)
-        self.assertEqual(len(model.output_tensor_names), 1)
-        graph_def = model.graph_def
-        self.assertEqual(True, isinstance(graph_def, tf.compat.v1.GraphDef))
-
-        model.graph_def = graph_def
-        os.system("rm -rf ckpt")
-
-    def test_slim(self):
-        tf.compat.v1.reset_default_graph()
-        inception_ckpt_url = "http://download.tensorflow.org/models/inception_v1_2016_08_28.tar.gz"
-        if platform.system().lower() == "windows":
-            dst_path = "C:\\tmp\\.neural_compressor\\inception_v1_2016_08_28.tar.g"
-        elif platform.system().lower() == "linux":
-            dst_path = "/tmp/.neural_compressor/slim/inception_v1_2016_08_28.tar.gz"
-        if platform.system().lower() == "linux":
-            if not os.path.exists(dst_path):
-                os.system("mkdir -p /tmp/.neural_compressor/slim")
-                os.system("wget {} -O {}".format(inception_ckpt_url, dst_path))
-            if not os.path.getsize(dst_path):
-                os.system("rm -fr {0} && wget {1} -O {0}".format(dst_path, inception_ckpt_url))
-            os.system("mkdir -p slim_ckpt && tar xvf {} -C slim_ckpt".format(dst_path))
-        if parse_version(tf.version.VERSION) > parse_version("2.0.0"):
-            return
-        model = Model("./slim_ckpt/inception_v1.ckpt")
-        model.name = "inception_v1"
-        graph_def = model.graph_def
-        self.assertGreaterEqual(len(model.output_node_names), 1)
-        self.assertGreaterEqual(len(model.input_node_names), 1)
-        self.assertEqual(model.model_path, "./slim_ckpt/inception_v1.ckpt")
-        # test net factory
-        from neural_compressor.tensorflow.utils.utility import TFSlimNetsFactory
-
-        factory = TFSlimNetsFactory()
-        from tf_slim.nets import inception
-
-        input_shape = [None, 224, 224, 3]
-        model_func = inception.inception_v1
-        arg_scope = inception.inception_v1_arg_scope
-        num_classes = 1001
-        factory.register("inceptionv1", model_func, input_shape, arg_scope, num_classes=num_classes)
-        os.system("rm -rf slim_ckpt")
-
-    @unittest.skipIf(
-        parse_version(tf.version.VERSION) < parse_version("2.4.0") or platform.system().lower() == "windows",
-        "Only supports tf 2.4.0 or above",
-    )
-    def test_saved_model(self):
-        ssd_resnet50_ckpt_url = "http://download.tensorflow.org/models/object_detection/ssd_resnet50_v1_fpn_shared_box_predictor_640x640_coco14_sync_2018_07_03.tar.gz"
-        center_resnet50_saved_model_url = (
-            "https://tfhub.dev/tensorflow/centernet/resnet50v1_fpn_512x512/1?tf-hub-format=compressed"
-        )
-        dst_path = "/tmp/.neural_compressor/saved_model.tar.gz"
-        center_dst_path = "/tmp/.neural_compressor/center_saved_model.tar.gz"
-
-        if not os.path.exists(dst_path):
-            os.system("mkdir -p /tmp/.neural_compressor && wget {} -O {}".format(ssd_resnet50_ckpt_url, dst_path))
-        if not os.path.getsize(dst_path):
-            os.system("rm -fr {0} && wget {1} -O {0}".format(dst_path, ssd_resnet50_ckpt_url))
-        if not os.path.exists(center_dst_path):
-            os.system(
-                "mkdir -p /tmp/.neural_compressor && wget {} -O {}".format(
-                    center_resnet50_saved_model_url, center_dst_path
-                )
-            )
-        if not os.path.getsize(center_dst_path):
-            os.system("rm -fr {0} && wget {1} -O {0}".format(center_dst_path, center_resnet50_saved_model_url))
-
-        os.system("tar -xvf {}".format(dst_path))
-        unzip_center_model = "unzip_center_model"
-        os.system("mkdir -p {} ".format(unzip_center_model))
-        os.system("tar -xvf {} -C {}".format(center_dst_path, unzip_center_model))
-
-        model = Model("ssd_resnet50_v1_fpn_shared_box_predictor_640x640_coco14_sync_2018_07_03/saved_model")
-        center_model = Model("unzip_center_model")
-
-        from tensorflow.python.trackable.autotrackable import AutoTrackable
-
-        assert isinstance(
-            model.model, AutoTrackable
-        ), "The model getter of TensorflowSavedModelModel is not correctly run."
-
-        from tensorflow.compat.v1 import graph_util
-
-        graph_def = graph_util.convert_variables_to_constants(
-            sess=model.sess, input_graph_def=model.graph_def, output_node_names=model.output_node_names
-        )
-
-        model.graph_def = graph_def
-        tmp_saved_model_path = "./tmp_saved_model"
-
-        if os.path.exists(tmp_saved_model_path):
-            os.system("rm -rf {}".format(tmp_saved_model_path))
-        os.system("mkdir -p {}".format(tmp_saved_model_path))
-
-        self.assertTrue(isinstance(model.graph_def, tf.compat.v1.GraphDef))
-        self.assertTrue(isinstance(model.graph, tf.compat.v1.Graph))
-        model.save(tmp_saved_model_path)
-        # load again to make sure model can be loaded
-        model = Model(tmp_saved_model_path)
-        os.system("rm -rf ssd_resnet50_v1_fpn_shared_box_predictor_640x640_coco14_sync_2018_07_03")
-        os.system("rm -rf temp_saved_model")
-        os.system("rm -rf {}".format(tmp_saved_model_path))
-
-        center_graph_def = graph_util.convert_variables_to_constants(
-            sess=center_model.sess,
-            input_graph_def=center_model.graph_def,
-            output_node_names=center_model.output_node_names,
-        )
-
-        center_model.graph_def = center_graph_def
-
-        self.assertTrue(isinstance(center_model.graph_def, tf.compat.v1.GraphDef))
-        self.assertTrue(isinstance(center_model.graph, tf.compat.v1.Graph))
-
-        from neural_compressor.tensorflow.utils.model_wrappers import _get_graph_from_saved_model_v1
-
-        graph_def, input_names, output_names = _get_graph_from_saved_model_v1(unzip_center_model)
-        assert graph_def is not None, "Can not parse the saved model..."
-
-        from tensorflow.python.saved_model.loader_impl import parse_saved_model_with_debug_info
-
-        from neural_compressor.tensorflow.utils.model_wrappers import _contains_function_with_implements_attr
-
-        saved_model_proto, _ = parse_saved_model_with_debug_info(unzip_center_model)
-        self.assertEqual(False, _contains_function_with_implements_attr(saved_model_proto))
-
-        os.system("rm -rf unzip_center_model")
-
-
-class TestKerasModelSafety(unittest.TestCase):
-    """Test that keras model files containing arbitrary python code are refused."""
-
-    @classmethod
-    def setUpClass(self):
-        self.workspace = tempfile.mkdtemp()
-
-    @classmethod
-    def tearDownClass(self):
-        shutil.rmtree(self.workspace, ignore_errors=True)
-
-    def _build_malicious_model(self):
-        inputs = tf.keras.Input(shape=(4,), name="in")
-        outputs = tf.keras.layers.Lambda(lambda x: x * 2, name="evil")(inputs)
-        return tf.keras.Model(inputs, outputs, name="innocent")
-
-    def test_contains_arbitrary_python(self):
-        from neural_compressor.tensorflow.utils.model_wrappers import _contains_arbitrary_python
-
-        self.assertTrue(
-            _contains_arbitrary_python(
-                {"class_name": "Lambda", "config": {"function": ["bytecode", None, None], "function_type": "lambda"}}
-            )
-        )
-        self.assertTrue(
-            _contains_arbitrary_python(
-                {"class_name": "Lambda", "config": {"function": {"class_name": "__lambda__", "config": {}}}}
-            )
-        )
-        self.assertFalse(
-            _contains_arbitrary_python(
-                {"class_name": "Lambda", "config": {"function": "relu", "function_type": "function"}}
-            )
-        )
-        self.assertFalse(_contains_arbitrary_python({"class_name": "Dense", "config": {"units": 4}}))
-
-    def test_load_malicious_keras_model_is_refused(self):
-        from neural_compressor.tensorflow.utils.model_wrappers import UnsafeKerasModelError, load_keras_model
-
-        for suffix in (".keras", ".h5"):
-            model_path = os.path.join(self.workspace, "malicious" + suffix)
-            self._build_malicious_model().save(model_path)
-            with self.assertRaises(UnsafeKerasModelError):
-                load_keras_model(model_path)
-            with self.assertRaises(UnsafeKerasModelError):
-                Model(model_path)
-
-    def test_load_normal_keras_model(self):
-        from neural_compressor.tensorflow.utils.model_wrappers import load_keras_model
-
-        inputs = tf.keras.Input(shape=(4,), name="in")
-        outputs = tf.keras.layers.Dense(2, name="dense")(inputs)
-        model_path = os.path.join(self.workspace, "normal.keras")
-        tf.keras.Model(inputs, outputs).save(model_path)
-        self.assertTrue(isinstance(load_keras_model(model_path), tf.keras.Model))
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/tensorflow/test_quantize_model.py b/test/tensorflow/test_quantize_model.py
deleted file mode 100644
index 383bb80c0ab..00000000000
--- a/test/tensorflow/test_quantize_model.py
+++ /dev/null
@@ -1,160 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2024 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import math
-import shutil
-import time
-import unittest
-
-import numpy as np
-import tensorflow as tf
-from tensorflow import keras
-
-from neural_compressor.common import logger
-from neural_compressor.tensorflow.utils import version1_gte_version2
-
-
-def build_model():
-    # Load MNIST dataset
-    mnist = keras.datasets.mnist
-
-    # 60000 images in train and 10000 images in test, but we don't need so much for ut
-    (train_images, train_labels), (test_images, test_labels) = mnist.load_data()
-    train_images, train_labels = train_images[:1000], train_labels[:1000]
-    test_images, test_labels = test_images[:200], test_labels[:200]
-
-    # Normalize the input image so that each pixel value is between 0 to 1.
-    train_images = train_images / 255.0
-    test_images = test_images / 255.0
-
-    # Define the model architecture.
-    model = keras.Sequential(
-        [
-            keras.layers.InputLayer(input_shape=(28, 28)),
-            keras.layers.Reshape(target_shape=(28, 28, 1)),
-            keras.layers.Conv2D(filters=12, kernel_size=(3, 3), activation="relu", name="conv2d"),
-            keras.layers.MaxPooling2D(pool_size=(2, 2)),
-            keras.layers.Flatten(),
-            keras.layers.Dense(10, name="dense"),
-        ]
-    )
-    # Train the digit classification model
-    model.compile(
-        optimizer="adam", loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=["accuracy"]
-    )
-
-    model.fit(
-        train_images,
-        train_labels,
-        epochs=1,
-        validation_split=0.1,
-    )
-
-    _, baseline_model_accuracy = model.evaluate(test_images, test_labels, verbose=0)
-
-    print("Baseline test accuracy:", baseline_model_accuracy)
-    if version1_gte_version2(tf.__version__, "2.16.1"):
-        model.export("baseline_model")
-    else:
-        model.save("baseline_model")
-
-
-class Dataset(object):
-    def __init__(self, batch_size=1):
-        self.batch_size = batch_size
-        mnist = keras.datasets.mnist
-        (train_images, train_labels), (test_images, test_labels) = mnist.load_data()
-        train_images, train_labels = train_images[:1000], train_labels[:1000]
-        test_images, test_labels = test_images[:200], test_labels[:200]
-        # Normalize the input image so that each pixel value is between 0 to 1.
-        self.train_images = train_images / 255.0
-        self.test_images = test_images / 255.0
-        self.train_labels = train_labels
-        self.test_labels = test_labels
-
-    def __len__(self):
-        return len(self.test_images)
-
-    def __getitem__(self, idx):
-        return self.test_images[idx], self.test_labels[idx]
-
-
-class MyDataloader:
-    def __init__(self, dataset, batch_size=1):
-        self.dataset = dataset
-        self.batch_size = batch_size
-        self.length = math.ceil(len(dataset) / self.batch_size)
-
-    def __iter__(self):
-        for _, (images, labels) in enumerate(self.dataset):
-            images = np.expand_dims(images, axis=0)
-            labels = np.expand_dims(labels, axis=0)
-            yield (images, labels)
-
-    def __len__(self):
-        return self.length
-
-
-def evaluate(model):
-    input_tensor = model.input_tensor
-    output_tensor = model.output_tensor if len(model.output_tensor) > 1 else model.output_tensor[0]
-
-    iteration = -1
-    calib_dataloader = MyDataloader(dataset=Dataset())
-    for idx, (inputs, labels) in enumerate(calib_dataloader):
-        # dataloader should keep the order and len of inputs same with input_tensor
-        inputs = np.array([inputs])
-        feed_dict = dict(zip(input_tensor, inputs))
-
-        start = time.time()
-        predictions = model.sess.run(output_tensor, feed_dict)
-        end = time.time()
-
-        if idx + 1 == iteration:
-            break
-
-
-class TestQuantizeModel(unittest.TestCase):
-    @classmethod
-    def setUpClass(self):
-        build_model()
-        self.fp32_model_path = "baseline_model"
-
-    @classmethod
-    def tearDownClass(self):
-        shutil.rmtree(self.fp32_model_path, ignore_errors=True)
-
-    def test_calib_func(self):
-        logger.info("Run test_calib_func case...")
-
-        from neural_compressor.common import set_random_seed
-        from neural_compressor.tensorflow import StaticQuantConfig, quantize_model
-
-        set_random_seed(9527)
-        quant_config = StaticQuantConfig()
-        q_model = quantize_model(self.fp32_model_path, quant_config, calib_func=evaluate)
-        quantized = False
-        for node in q_model.graph_def.node:
-            if "Quantized" in node.op:
-                quantized = True
-                break
-
-        self.assertEqual(quantized, True)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/third-party-programs.txt b/third-party-programs.txt
index af70cb32047..450d1c1a127 100644
--- a/third-party-programs.txt
+++ b/third-party-programs.txt
@@ -12,18 +12,11 @@ govern your use of the third party programs as set forth in in the
 Third party programs and their corresponding required notices and/or license
 terms are listed below.
 -------------------------------------------------------------
-1. example-tensorflow-models
-   Copyright 2016, The Authors.
-
-   IntelAI Models
-
-   mlperf-inference
+1. mlperf-inference
 
    mlperf-training
    Copyright 2018 The MLPerf Authors
 
-   tensor2tensor
-
    Transformer
 
    nnUnet

From fc1c73afac874853d050afe444baff4c2771d624 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 13 Oct 2026 06:15:40 +0000
Subject: [PATCH 2/3] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 .azure-pipelines/scripts/models/collect_log_model.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.azure-pipelines/scripts/models/collect_log_model.py b/.azure-pipelines/scripts/models/collect_log_model.py
index 63c59f27bf3..0373f5e7006 100644
--- a/.azure-pipelines/scripts/models/collect_log_model.py
+++ b/.azure-pipelines/scripts/models/collect_log_model.py
@@ -21,6 +21,8 @@
     + args.build_id
     + "&view=artifacts&pathAsName=false&type=publishedArtifacts"
 )
+
+
 def get_model_tuning_dict_results():
     tuning_result_dict = {}
 

From dd2bc6f3048266b2413fcfeeb79234c99fba3c2c Mon Sep 17 00:00:00 2001
From: chensuyue <suyue.chen@intel.com>
Date: Mon, 19 Oct 2026 21:27:19 -0700
Subject: [PATCH 3/3] url update

Signed-off-by: chensuyue <suyue.chen@intel.com>
---
 docs/source/quantization.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/source/quantization.md b/docs/source/quantization.md
index 4b59b7cb968..f8b793d0551 100644
--- a/docs/source/quantization.md
+++ b/docs/source/quantization.md
@@ -21,7 +21,7 @@ Quantization
 
 ## Introduction
 
-Quantization is a very popular deep learning model optimization technique invented for improving the speed of inference. It minimizes the number of bits required by converting a set of real-valued numbers into the lower bit data representation, such as int8 and int4, mainly on inference phase with minimal to no loss in accuracy. This way reduces the memory requirement, cache miss rate, and computational cost of using neural networks and finally achieve the goal of higher inference performance. On Intel 3rd Gen Intel Xeon Scalable Processors, user could expect up to 4x theoretical performance speedup. We expect further performance improvement with [Intel Advanced Matrix Extensions](https://www.intel.com/content/www/us/en/products/docs/accelerator-engines/advanced-matrix-extensions/overview.html) on 4th Gen Intel Xeon Scalable Processors.
+Quantization is a very popular deep learning model optimization technique invented for improving the speed of inference. It minimizes the number of bits required by converting a set of real-valued numbers into the lower bit data representation, such as int8 and int4, mainly on inference phase with minimal to no loss in accuracy. This way reduces the memory requirement, cache miss rate, and computational cost of using neural networks and finally achieve the goal of higher inference performance. On Intel 3rd Gen Intel Xeon Scalable Processors, user could expect up to 4x theoretical performance speedup. We expect further performance improvement with [Intel Advanced Matrix Extensions](https://www.intel.com/content/www/us/en/products/details/processors/xeon/features/advanced-matrix-extensions.html) on 4th Gen Intel Xeon Scalable Processors.
 
 ## Quantization Fundamentals