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] 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"SCALED") helper.set_attr_string(quantize_input_node, "round_mode", b"HALF_TO_EVEN") # if FLAGS.model_name in ["wide_deep_large_ds"]: # set_attr_string(quantize_input_node, "mode", b"MIN_FIRST") # else: # set_attr_string(quantize_input_node, "mode", # b"SCALED" if self.intel_cpu_eightbitize else b"MIN_FIRST") # set_attr_string(quantize_input_node, "round_mode", # b"HALF_TO_EVEN" if self.intel_cpu_eightbitize # else b"HALF_AWAY_FROM_ZERO") 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 apply_matmul_biasadd_fusion(self, match_node_name): 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] 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]: logging.debug("matched node {} with input {}".format( node.name, node.input)) logging.debug("apply_conv_biasadd_fusion") quantized_node_name = node.name + "_eightbit_quantized_mat_mul" bias_node_name = self.node_name_mapping[ match_node_name[1]].node.input[1] all_input_names = self._add_eightbit_prologue_nodes( matched_node.node.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) 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[1], requantize_type) else: new_node = node_def_pb2.NodeDef() new_node.CopyFrom(node) self.add_output_graph_node(new_node)
def _add_quantize_down_nodes(self, original_node, quantized_output_name, requantize_type=dtypes.quint8, is_relu6=False): quantized_outputs = [ quantized_output_name, quantized_output_name + ":1", quantized_output_name + ":2" ] # Add a RequantizationRange node for finding the min and max values. requant_range_node = helper.create_node( "RequantizationRangePerChannel" if self.per_channel else "RequantizationRange", original_node.name + "_eightbit_requant_range", quantized_outputs) if self.per_channel: 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" ] requantize_node = helper.create_node( "RequantizePerChannel" if self.per_channel else "Requantize", original_node.name + "_eightbit_requantize", quantized_outputs + min_max_inputs) if self.per_channel: 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_single_input_tensor_node(self, original_node, add_op_function): quantized_op_name = original_node.name + "_eightbit_quantized" 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) self._intel_cpu_add_dequantize_result_node(quantized_op_name, original_node.name)
def add_dequantize_result_node(self, quantized_output_name, original_node_name, min_tensor_index=1): 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", dtypes.quint8) helper.set_attr_string( dequantize_node, "mode", b"SCALED" if self.intel_cpu_eightbitize else b"MIN_FIRST") self.add_output_graph_node(dequantize_node)
def _apply_concatv2_transform(self, original_node): 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: 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=dtypes.quint8)) 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", dtypes.quint8) self.add_output_graph_node(quantized_concat_node) if self.intel_cpu_eightbitize: self._intel_cpu_add_dequantize_result_node(quantized_concat_name, original_node.name) else: self._add_dequantize_result_node(quantized_concat_name, original_node.name)
def apply_conv_single_fusion(self, match_node_name): 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 s8 feature. if self.enable_s8 and matched_node.node.op == "DepthwiseConv2dNative" and not self._find_relu_node( matched_node.node): self.output_graph = self.input_graph return 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) skip_node_name.append(weight_name) for _, node in enumerate(self.input_graph.node): if node.name in skip_node_name: logging.debug("skip node {}".format(node.name)) elif node.name == match_node_name[0]: postfix = "_eightbit_quantized_conv" if node.op == "Conv2D" else "_eightbit_quantized_depthwise_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 node.op != 'DepthwiseConv2dNative' and "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_addn_relu_fusion(self, match_node_name): 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] 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) skip_node_name.append(weight_name) for _, node in enumerate(self.input_graph.node): if node.name in skip_node_name: logging.debug("skip node {}".format(node.name)) elif node.name == match_node_name[0]: logging.debug("matched node {} with input {}".format( node.name, node.input)) logging.debug("apply_conv_biasadd_addn_relu_fusion") quantized_node_name = node.name + "_eightbit_quantized_conv" bias_node_name = self.node_name_mapping[ match_node_name[1]].node.input[1] 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] == self.node_name_mapping[ match_node_name[2]].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]].node.input[sum_index] ] + control_inputs quantized_conv_node = helper.create_node( "QuantizedConv2DWithBiasSumAndRelu", 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) 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: 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. Arguments: match_node_name {[type]} -- [description] """ 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] 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) skip_node_name.append(weight_name) for _, node in enumerate(self.input_graph.node): if node.name in skip_node_name: logging.debug("skip node {}".format(node.name)) elif node.name == match_node_name[0]: logging.debug("apply_conv_biasadd_relu_fusion") postfix = "_eightbit_quantized_conv" if node.op == "Conv2D" else "_eightbit_quantized_depthwise_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 quantized_conv_node = helper.create_node( "QuantizedConv2DWithBiasAndRelu" if node.op == "Conv2D" else "QuantizedDepthwiseConv2DWithBiasAndRelu", 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 node.op != 'DepthwiseConv2dNative' and "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.quint8, is_relu6) 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)
def _intel_cpu_quantize_weight_eightbit(self, parent, input_node, per_channel, quantization_mode=b"SCALED"): 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 if parent in ("Conv2D", "MatMul"): if per_channel: ranges = np.abs(float_tensor).max(axis=(0, 1, 2)) 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 = (float_tensor * 127.0 / ranges).astype(np.int8) else: min_value = np.min(float_tensor.flatten()) max_value = np.max(float_tensor.flatten()) # Same processing of min-max as in quantize_weight_eightbit # function. if min_value > 0.0: 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 sess = session.Session() with sess.as_default(): quantize_op = array_ops.quantize_v2( float_tensor, min_value, max_value, dtypes.qint8, mode=quantization_mode, round_mode="HALF_TO_EVEN") qint8_tensor = quantize_op[0].eval() # Updated min-max values should be passed to the next feeding node. min_value = quantize_op[1].eval() max_value = quantize_op[2].eval() elif parent == "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 = (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 = helper.create_constant_node(qint8_const_name, qint8_tensor, dtypes.qint8, shape=shape) min_node = helper.create_constant_node(min_name, min_value, dtypes.float32) max_node = helper.create_constant_node(max_name, max_value, dtypes.float32) dequantize_node = helper.create_node( "Dequantize", input_node.name, [qint8_const_name, min_name, max_name]) helper.set_attr_dtype(dequantize_node, "T", dtypes.qint8) helper.set_attr_string(dequantize_node, "mode", b"SCALED") self.add_output_graph_node(qint8_const_node) self.add_output_graph_node(min_node) self.add_output_graph_node(max_node) self.add_output_graph_node(dequantize_node)