Method optimize

ppq/quantization/optim/equalization.py:334–376

(
        self, graph: BaseGraph, dataloader: Iterable,
        executor: BaseGraphExecutor, collate_fn: Callable, **kwargs
    )

    @ empty_ppq_cache
    def optimize(
        self, graph: BaseGraph, dataloader: Iterable,
        executor: BaseGraphExecutor, collate_fn: Callable, **kwargs
    ) -> None:
        interested_operations = []

        if self.interested_layers is None:

            for operation in graph.operations.values():
                if operation.type in EQUALIZATION_OPERATION_TYPE:
                    interested_operations.append(operation)
        else:

            for name in self.interested_layers:
                if name in graph.operations:
                    interested_operations.append(graph.operations[name])

        pairs = self.find_equalization_pair(
            graph=graph, interested_operations=interested_operations)

        if self.including_act:
            activations = self.collect_activations(
                graph=graph, executor=executor, dataloader=dataloader, collate_fn=collate_fn,
                operations=interested_operations)

            for name, act in activations.items():
                graph.variables[name].value = act # 将激活值写回网络

        print(f'{len(pairs)} equalization pair(s) was found, ready to run optimization.')
        for iter_times in tqdm(range(self.iterations), desc='Layerwise Equalization', total=self.iterations):
            for equalization_pair in pairs:
                equalization_pair.equalize(
                    value_threshold=self.value_threshold,
                    including_bias=self.including_bias,
                    including_act=self.including_act,
                    bias_multiplier=self.bias_multiplier,
                    act_multiplier=self.act_multiplier)

        # equalization progress directly changes fp32 value of weight,
        # store it for following procedure.
        for op in graph.operations.values():
            if isinstance(op, QuantableOperation):
                op.store_parameter_value()


class ChannelwiseSplitPass(LayerwiseEqualizationPass):