paddlepaddle / paddleslim Goto Github PK

from paddle.fluid.contrib.slim.quantization import PostTrainingQuantization
ImportError: cannot import name 'PostTrainingQuantization'

def flops_sensitivity(program,
                      place,
                      param_names,
                      eval_func,
                      sensitivities_file=None,
                      pruned_flops_rate=0.1):

    assert (1.0 / len(param_names) > pruned_flops_rate)

    scope = fluid.global_scope()
    graph = GraphWrapper(program)
    sensitivities = load_sensitivities(sensitivities_file)

    for name in param_names:
        if name not in sensitivities:
            sensitivities[name] = {}
    base_flops = flops(program)
    target_pruned_flops = base_flops * pruned_flops_rate

    pruner = Pruner()
    baseline = None
    for name in sensitivities:

        pruned_program, _, _ = pruner.prune(
            program=graph.program,
            scope=None,
            params=[name],
            ratios=[0.5],
            place=None,
            lazy=False,
            only_graph=True)
       ################################################
        param_flops = (base_flops - flops(pruned_program)) * 2
        channel_size = graph.var(name).shape()[0]
        pruned_ratio = target_pruned_flops / float(param_flops)
       ################################################
        pruned_ratio = round(pruned_ratio, 3)
        pruned_size = round(pruned_ratio * channel_size)
        pruned_ratio = 1 if pruned_size >= channel_size else pruned_ratio

        if len(sensitivities[name].keys()) > 0:
            _logger.debug(
                '{} exist; pruned ratio: {}; excepted ratio: {}'.format(
                    name, sensitivities[name].keys(), pruned_ratio))
            continue
        if baseline is None:
            baseline = eval_func(graph.program)
        param_backup = {}
        pruner = Pruner()
        _logger.info("sensitive - param: {}; ratios: {}".format(name,
                                                                pruned_ratio))
        loss = 1
        if pruned_ratio < 1:
            pruned_program = pruner.prune(
                program=graph.program,
                scope=scope,
                params=[name],
                ratios=[pruned_ratio],
                place=place,
                lazy=True,
                only_graph=False,
                param_backup=param_backup)
            pruned_metric = eval_func(pruned_program)
            loss = (baseline - pruned_metric) / baseline
        _logger.info("pruned param: {}; {}; loss={}".format(name, pruned_ratio,
                                                            loss))
        sensitivities[name][pruned_ratio] = loss
        _save_sensitivities(sensitivities, sensitivities_file)

        # restore pruned parameters
        for param_name in param_backup.keys():
            param_t = scope.find_var(param_name).get_tensor()
            param_t.set(param_backup[param_name], place)
    return sensitivities

def get_ratios_by_sensitive(self, sensitivities, pruned_flops,
                                eval_program):
        """
        Search a group of ratios for pruning target flops.
        Args:
          sensitivities(dict): The sensitivities used to generate a group of pruning ratios. The key of dict
                               is name of parameters to be pruned. The value of dict is a list of tuple with
                               format `(pruned_ratio, accuracy_loss)`.
          pruned_flops(float): The percent of FLOPS to be pruned.
          eval_program(Program): The program whose FLOPS is considered.
        Returns:
          dict: A group of ratios. The key of dict is name of parameters while the value is the ratio to be pruned.
        """

        min_loss = 0.
        max_loss = 0.
        # step 2: Find a group of ratios by binary searching.
        base_flops = flops(eval_program)
        ratios = None
        max_times = 20
        while min_loss < max_loss and max_times > 0:
            loss = (max_loss + min_loss) / 2
            _logger.info(
                '-----------Try pruned ratios while acc loss={}-----------'.
                format(loss))
            ratios = self.get_ratios_by_loss(sensitivities, loss)
            _logger.info('Pruned ratios={}'.format(
                [round(ratio, 3) for ratio in ratios.values()]))
            pruned_program = self._pruner.prune(
                eval_program,
                None,  # scope
                ratios.keys(),
                ratios.values(),
                None,  # place
                only_graph=True)
            pruned_ratio = 1 - (float(flops(pruned_program)) / base_flops)
            _logger.info('Pruned flops: {:.4f}'.format(pruned_ratio))

            # Check whether current ratios is enough
            if abs(pruned_ratio - pruned_flops) < 0.015:
                break
            if pruned_ratio > pruned_flops:
                max_loss = loss
            else:
                min_loss = loss
            max_times -= 1
        return ratios

input_size=(3, 512, 512)
sys.path[0] = os.path.join(
    os.path.dirname("__file__"), os.path.pardir, os.path.pardir)


        

def quantize():
    val_reader = mjreader.custom_reader(images_lists, data_dir, input_size,mode)
    place = fluid.CUDAPlace(0) 
    exe = fluid.Executor(place)
    quant_post(
        executor=exe,
        model_dir='../work/PaddleDetection/yolov3_dark_freeze/mj_yolov3_darknet',
        quantize_model_path='./yolov3_darknet_quant/',
        sample_generator=val_reader,
        model_filename='__model__',
        params_filename='__params__',
        batch_size=16,
        batch_nums=20) 

Error: Param and Velocity of MomentumOp should have the same dimension.
  [Hint: Expected param_dim == ctx->GetInputDim("Velocity"), but received param_dim:256 != ctx->GetInputDim("Velocity"):128.] at (/paddle/paddle/fluid/operators/optimizers/momentum_op.h:79)
  [operator < momentum > error]

def train():

    logger.info("start train YOLOv3, train params:%s", str(train_parameters))

    logger.info("create place, use gpu:" + str(train_parameters['use_gpu']))

    logger.info("build network and program")

    place = fluid.CUDAPlace(0) if train_parameters['use_gpu'] else fluid.CPUPlace()
    exe = fluid.Executor(place)

    scope = fluid.Scope()
    train_program = fluid.Program()
    start_program = fluid.Program()
    test_program = fluid.Program()
    
    feeder, reader, loss = build_program_with_feeder(train_program, start_program, place)

    pred = build_program_with_feeder(test_program, start_program, istrain=False)
    
    test_program = test_program.clone(for_test=True)
    
    train_fetch_list = [loss.name]
    
    exe.run(start_program, scope=scope)
    
    load_pretrained_params(exe, train_program)
    
    if train_parameters['print_params']:
        param_delimit_str = '-' * 20 + "All parameters in current graph" + '-' * 20
        print(param_delimit_str)
        for block in train_program.blocks:
            for param in block.all_parameters():
                print("parameter name: {}\tshape: {}".format(param.name,
                                                             param.shape))
        print('-' * len(param_delimit_str))
    
    pruned_params = train_parameters['pruned_params'].strip().split(",")
    logger.info("pruned params: {}".format(pruned_params))
    pruned_ratios = [float(n) for n in train_parameters['pruned_ratios'].strip().split(",")]
    logger.info("pruned ratios: {}".format(pruned_ratios))
    
    logger.info("build executor and init params")
    
    pruner = Pruner()
    train_program = pruner.prune(
        train_program,
        scope,
        params=pruned_params,
        ratios=pruned_ratios,
        place=place,
        only_graph=False)[0]
    
    base_flops = flops(test_program)
    test_program = pruner.prune(
        test_program,
        scope,
        params=pruned_params,
        ratios=pruned_ratios,
        place=place,
        only_graph=True)[0]
    pruned_flops = flops(test_program)

    stop_strategy = train_parameters['early_stop']
    rise_limit = stop_strategy['rise_limit']

    min_loss = stop_strategy['min_loss']
    # stop_train = False
    rise_count = 0
    total_batch_count = 0
    current_best_f1 = 0.0
    train_temp_loss = 0
    current_best_pass = 0
    current_best_box_pass = 0
    current_best_recall = 0
    current_best_precision = 0
    current_best_box_recall = 0
    current_best_box_precision = 0
    current_best_box_f1 = 0
    for pass_id in range(train_parameters["num_epochs"]):
        logger.info("current pass: {}, start read image".format(pass_id))
        batch_id = 0
        total_loss = 0.0
        for batch_id, data in enumerate(reader()):
            t1 = time.time()
            loss = exe.run(train_program, feed=feeder.feed(data), fetch_list=train_fetch_list)
            period = time.time() - t1
            loss = np.mean(np.array(loss))
            total_loss += loss
            batch_id += 1
            total_batch_count += 1
            
            if batch_id % 200 == 0:
                logger.info("pass {}, trainbatch {}, loss {} time {}".format(pass_id,
                                                                             batch_id, loss, "%2.2f sec" % period))
        pass_mean_loss = total_loss / batch_id
        logger.info("pass {0} train result, current pass mean loss: {1}".format(pass_id, pass_mean_loss))

    logger.info("end training")`

Python Call Stacks (More useful to users):
------------------------------------------
  File "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/framework.py", line 2594, in _prepend_op
    attrs=kwargs.get("attrs", None))
  File "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/layers/nn.py", line 5472, in autoincreased_step_counter
    attrs={'step': float(step)})
  File "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/layers/learning_rate_scheduler.py", line 48, in _decay_step_counter
    counter_name='@LR_DECAY_COUNTER@', begin=begin, step=1)
  File "/opt/conda/envs/python35-paddle120-env/lib/python3.7/site-packages/paddle/fluid/layers/learning_rate_scheduler.py", line 387, in piecewise_decay
    global_step = _decay_step_counter()
  File "train.py", line 265, in optimizer_momentum_setting
    learning_rate=fluid.layers.piecewise_decay(boundaries=boundaries, values=values),
  File "train.py", line 371, in get_loss
    optimizer = optimizer_momentum_setting()
  File "train.py", line 306, in build_program_with_feeder
    loss = get_loss(model, outputs, gt_box, gt_label, main_prog)
  File "train.py", line 403, in train
    feeder, reader, loss = build_program_with_feeder(train_program, start_program, place)
  File "train.py", line 544, in <module>
    train()

----------------------
Error Message Summary:
----------------------
InvalidArgumentError: The Tensor in the increment Op's Input Variable X(@LR_DECAY_COUNTER@) is not initialized.
  [Hint: Expected t->IsInitialized() == true, but received t->IsInitialized():0 != true:1.] at (/paddle/paddle/fluid/framework/operator.cc:1264)
  [operator < increment > error]

@PRUNE_WORKER.register
class sgd(PruneWorker):
    def __init__(self, op, pruned_params, visited={}):
        super(sgd, self).__init__(op, pruned_params, visited)

    def _prune(self, var, pruned_axis, pruned_idx):
        pass

from paddleslim.quant import quant_aware, convert
quantized_graph = convert(infer_prog, place, config=config)
quantized_program = quantized_graph.to_program()
for var in quantized_program.list_vars():
    print(var.name)

with fluid.program_guard(quantized_program):
    out = quantized_program.global_block().var("your_var_name")
    out = fluid.layers.some_op(out)

fluid.io.save_inference_model(main_program=quantized_program, ...)