refine dtype convert code (#1092)

Author: mengniwang95

neural_compressor/adaptor/ox_utils/quantizer.py

@@ -271,7 +271,7 @@ def dfs(match_nodes, node, pattern):
                         if all([i.op_type in ['QuantizeLinear', 'DequantizeLinear'] \
                             for i in self.model.get_children(match_nodes[0])]):
                             self.remove_nodes.append(match_nodes[0])
-                else:
+                else: # pragma: no cover
                     parent = self.model.get_parents(match_nodes[0])[0]
                     children = self.model.get_children(match_nodes[1])
                     input_dtype = '1' # float32
@@ -326,9 +326,12 @@ def dtype_cast(self, node, cfg, keep_io_types=True): # pragma: no cover
             if initializer is not None:
                 if initializer.data_type != onnx_proto.TensorProto.FLOAT: 
                     continue
-                cast_tensor(initializer, cfg, min_positive_val, max_finite_val)
-                self.new_value_info[tensor_name] = ValueInfo(tensor_name,
-                                                         TensorProto.FLOAT, dtype_mapping[cfg])
+                new_tensor = cast_tensor(initializer, cfg)
+                if new_tensor:
+                    self.model.remove_initializer(initializer)
+                    self.model.add_initializer(new_tensor)
+                    self.new_value_info[tensor_name] = ValueInfo(tensor_name,
+                                                             TensorProto.FLOAT, dtype_mapping[cfg])
             else:
                 if tensor_name in self.value_infos and \
                     self.value_infos[tensor_name].type.HasField('tensor_type') and \
@@ -681,7 +684,7 @@ def quantize_weights_per_channel(self, node, indices, weight_qType, scheme, axis
                 qlinear_node = make_quant_node(weight_name + "_QuantizeLinear",
                         [weight_name, scale_name, zp_name], [weight_name + "_quantized"])
                 dequant_node = make_dquant_node(weight_name + "_DequantizeLinear",
-                            [weight_name + "_QuantizeLinear", scale_name, zp_name], 
+                            [weight_name + "_quantized", scale_name, zp_name], 
                             [weight_name + "_dequantized"])
                 self.replace_input.append([node, weight_name, dequant_node.output[0]])
                 self.new_nodes.extend([qlinear_node, dequant_node])

neural_compressor/adaptor/ox_utils/util.py

@@ -18,7 +18,7 @@
 
 import os
 import numpy as np
-from onnx import helper
+from onnx import helper, numpy_helper
 from onnx import onnx_pb as onnx_proto  
 from enum import Enum
 from pathlib import Path
@@ -103,58 +103,24 @@ def split_shared_bias(model):
                     node.input[2] = new_input_name
     return model    
 
-def convert_np_to_float16(np_array, min_positive_val=1e-7, max_finite_val=1e4): # pragma: no cover
+def cast_tensor(tensor, dtype): # pragma: no cover
     '''
-    Convert float32 numpy array to float16 without changing sign or finiteness.
-    Positive values less than min_positive_val are mapped to min_positive_val.
-    Positive finite values greater than max_finite_val are mapped to max_finite_val.
-    Similar for negative values. NaN, 0, inf, and -inf are unchanged.
-    '''
-    def between(a, b, c):
-        return np.logical_and(a < b, b < c)
-    np_array = np.where(between(0, np_array, min_positive_val), min_positive_val, np_array)
-    np_array = np.where(between(-min_positive_val, np_array, 0), -min_positive_val, np_array)
-    np_array = np.where(between(max_finite_val, np_array, float('inf')), max_finite_val, np_array)
-    np_array = np.where(between(float('-inf'), np_array, -max_finite_val), -max_finite_val, np_array)
-    return np.float16(np_array)
-
-def _npfloat16_to_int(np_list):
-    '''
-    Convert numpy float16 to python int.
-        param np_list: numpy float16 list
-        return int_list: python int list
-    '''
-    return [int(bin(_.view('H'))[2:].zfill(16), 2) for _ in np_list]
-
-def cast_tensor(tensor, dtype, min_positive_val=1e-7, max_finite_val=1e4): # pragma: no cover
-    '''
-    Convert tensor float to float16.
+    Convert tensor float to target dtype.
         param tensor: TensorProto object
-        return tensor_float16: converted TensorProto object
-    Example:
-        from onnxmltools.utils.float16_converter import convert_tensor_float_to_float16
-        new_tensor = convert_tensor_float_to_float16(tensor)
+        return tensor_target_dtype: converted TensorProto object
     '''
     if not isinstance(tensor, onnx_proto.TensorProto):
         raise ValueError('Expected input type is an ONNX TensorProto but got %s' % type(tensor))
 
     if tensor.data_type == onnx_proto.TensorProto.FLOAT:
-        tensor.data_type = onnx_proto.TensorProto.FLOAT16
-        # convert float_data (float type) to float16 and write to int32_data
-        if tensor.float_data:
-            float16_data = convert_np_to_float16(np.array(tensor.float_data), min_positive_val, max_finite_val)
-            int_list = _npfloat16_to_int(float16_data)
-            tensor.int32_data[:] = int_list
-            tensor.float_data[:] = []
-        # convert raw_data (bytes type)
-        if tensor.raw_data:
-            # convert n.raw_data to float
-            float32_list = np.fromstring(tensor.raw_data, dtype='float32')
-            # convert float to float16
-            float16_list = convert_np_to_float16(float32_list, min_positive_val, max_finite_val)
-            # convert float16 to bytes and write back to raw_data
-            tensor.raw_data = float16_list.tostring()
-    return tensor
+        new_tensor = helper.make_tensor(
+            name=tensor.name,
+            data_type=dtype_mapping[dtype],
+            dims=numpy_helper.to_array(tensor).shape,
+            vals=numpy_helper.to_array(tensor)
+        )
+        return new_tensor
+    return None
 
 def remove_init_from_model_input(model):
     inputs = model.model.graph.input

test/adaptor/onnxrt_adaptor/test_adaptor_onnxrt.py

@@ -830,6 +830,13 @@ def test_adaptor(self):
             from neural_compressor.utils.utility import recover
             model = recover(self.ir3_model, './nc_workspace/recover/history.snapshot', 0)
             self.assertTrue(model.model == q_model.model)
+
+        quantizer = Quantization("qdq.yaml")
+        quantizer.calib_dataloader = self.matmul_dataloader
+        quantizer.eval_dataloader = self.matmul_dataloader
+        quantizer.model = self.matmul_model
+        q_model = quantizer.fit()
+        self.assertNotEqual(q_model, None)
         options.onnxrt.qdq_setting.AddQDQPairToWeight = False
 
         options.onnxrt.qdq_setting.DedicatedQDQPair = True