Method optimize

ppq/quantization/optim/morph.py:158–199

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

        return r_value, s_value, processed_values
        
    def optimize(self, graph: BaseGraph, 
                 dataloader: Iterable, executor: BaseGraphExecutor, 
                 **kwargs) -> None:
        with torch.no_grad():
            for name in self.interested_layers:
                # op check
                if name not in graph.operations:
                    raise KeyError(f'Operation {name} is not in current graph.')
                op1 = graph.operations[name]
                if op1.type not in {'Gemm', 'MatMul', 'Conv', 'ConvTranspose'}:
                    raise TypeError(f'Operation {op1.name} can not be splited, op type is invalid({op1.type})')
                if not op1.inputs[1].is_parameter:
                    raise ValueError(f'Operation {op1.name} can not be splited, input 1 is not parameter.')
                if isinstance(op1, QuantableOperation):
                    raise TypeError(f'Can not split a quantized operation, '
                                    'Layer Split Pass should only be invoked as a pre-quant optimziation.')

                r_value, s_value, processed_values = self.h_split(op1)

                if processed_values > 0:
                    # clone current operation
                    op2 = graph.create_operation(
                        op_type=op1.type, attributes=op1.attributes.copy(), 
                        platform=op1.platform)
                    input_var, output_var = op1.inputs[0], op1.outputs[0]
                    graph.create_link_with_op(
                        variable=op1.inputs[0], A=input_var.source_op, 
                        B=op2)
                    
                    # create weight for cloned operation.
                    graph.create_variable(value=op1.inputs[1].value.clone(), is_parameter=True, dest_ops=[op2])

                    # set splited value
                    op1.inputs[1].value.copy_(r_value)
                    op2.inputs[1].value.copy_(s_value)

                    op1.outputs.clear()
                    adder = graph.create_operation(op_type='Add', platform=op1.platform, outputs=[output_var])
                    output_var.source_op = adder
                    
                    graph.create_link_with_op(A=op1, B=adder)
                    graph.create_link_with_op(A=op2, B=adder)


class MetaxGemmSplitPass(QuantizationOptimizationPass):