Method export

ppq/parser/caffe_exporter.py:249–400

(self, file_path: str, graph: BaseGraph, config_path: str = None,
               input_shapes: List[List[int]] = [[1, 3, 224, 224]], write_weight=False)

class PPLDSPCaffeExporter(CaffeExporter):
    def export(self, file_path: str, graph: BaseGraph, config_path: str = None,
               input_shapes: List[List[int]] = [[1, 3, 224, 224]], write_weight=False):
        # PPL3 DSP do not need a json config file, all quantization configuration will be merged into protobuf
        caffe_model, caffe_proto = self.prepare_model(graph, input_shapes)
        for idx in range(len(caffe_proto.layer)):
            layer = caffe_proto.layer[idx]
            layer_name = layer.name

            assert isinstance(layer, ppl_caffe_pb2.LayerParameter)
            assert isinstance(layer_name, str)
            # layer is a caffe data structure, corresponding to operation in ppq.
            # following code write ppq quantization configuration to caffe layer.

            # step - 1, find corresponding op
            if layer_name not in graph.operations:
                # PATCH FOR Slice
                if layer.type == 'Slice':
                    # slice0 --> (ppq parse, export, combine) --> slice0_0_0, everything else
                    # is the same with original model
                    # layer_name is slice0_0_0, obtain original_name slice0
                    original_name = ''.join(layer_name.split('_')[:-2])
                    for bottom in layer.bottom:
                        var = graph.variables.get(bottom, None)
                        if var is not None and isinstance(var, QuantableVariable) and not var.is_parameter:
                            cfg = None
                            for dest_op, dest_cfg in zip(var.dest_ops, var.dest_op_configs):
                                # dest_op.name is slice0_0
                                if ''.join(dest_op.name.split('_')[:-1]) == original_name:
                                    cfg = dest_cfg
                                    break
                            assert cfg is not None
                            qt_min = convert_value(cfg.scale * (cfg.quant_min - cfg.offset), True, DataType.FP32)
                            qt_max = convert_value(cfg.scale * (cfg.quant_max - cfg.offset), True, DataType.FP32)
                            layer.quantize_param.add(type='bottom', range_min=qt_min, range_max=qt_max)

                    for top in layer.top:
                        var = graph.variables.get(top, None)
                        if var is not None and isinstance(var, QuantableVariable) and not var.is_parameter:
                            cfg = var.source_op_config
                            assert cfg is not None
                            qt_min = convert_value(cfg.scale * (cfg.quant_min - cfg.offset), True, DataType.FP32)
                            qt_max = convert_value(cfg.scale * (cfg.quant_max - cfg.offset), True, DataType.FP32)
                            layer.quantize_param.add(type='top', range_min=qt_min, range_max=qt_max)
                    continue
                else:
                    raise KeyError(f'Can not find operation {layer_name} with current graph.')

            op = graph.operations[layer_name]
            if not isinstance(op, QuantableOperation): continue

            # step - 2, dump parameter quantization config
            if layer.type in {'Convolution', 'Deconvolution'}:
                for cfg, var in op.config_with_variable:
                    if not var.is_parameter: continue
                    if cfg.num_of_bits > 8: continue # skip bias

                    if cfg.policy.has_property(QuantizationProperty.PER_CHANNEL):
                        qt_min = convert_value(cfg.scale * (cfg.quant_min - cfg.offset), False, DataType.FP32)