Class GraphDecomposer

ppq/IR/morph.py:1078–1158

Since PPQ 0.6.4, GraphDecomposer is introduced to split some complex operations For example, Gemm can be split with MatMul with Bias add. Gemm General Matrix multiplication: https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms#Level_3 A' = transpose(A) if transA else A

class GraphDecomposer(GraphCommandProcessor):
    """Since PPQ 0.6.4, GraphDecomposer is introduced to split some complex
    operations For example, Gemm can be split with MatMul with Bias add.

    Gemm
    General Matrix multiplication: https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms#Level_3

    A' = transpose(A) if transA else A

    B' = transpose(B) if transB else B

    Compute Y = alpha * A' * B' + beta * C, where input tensor A has shape (M, K) or (K, M), 
        input tensor B has shape (K, N) or (N, K), input tensor C is broadcastable to shape (M, N), 
        and output tensor Y has shape (M, N). A will be transposed before doing the computation if attribute transA is non-zero, 
        same for B and transB. 
    
    This operator supports unidirectional broadcasting (tensor C should be unidirectional broadcastable to tensor A * B); 
        for more details please check the doc. This operator has optional inputs/outputs. 
        
    See the doc for more details about the representation of optional arguments. 
    An empty string may be used in the place of an actual argument's name to indicate a missing argument. 
    Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.

    Attributes
        alpha : float (default is 1.0)
        Scalar multiplier for the product of input tensors A * B.
    
        beta : float (default is 1.0)
        Scalar multiplier for input tensor C.
    
        transA : int (default is 0)
        Whether A should be transposed
    
        transB : int (default is 0)
        Whether B should be transposed
    """

    def process(self, command: GraphCommand) -> Any:
        return super().process(command)

    def _acceptable_command_types(self) -> List[GraphCommandType]:
        return super()._acceptable_command_types

    def decompose_gemm(self):
        graph = self.graph
        interested_ops = []
        for operation in graph.operations.values():
            if operation.type == 'Gemm':
                interested_ops.append(operation)

        for op in interested_ops:
            assert isinstance(op, Operation)
            output_var = op.outputs[0]

            if op.num_of_input == 3:
                bias_add  = graph.create_operation(op_type='Add', platform=op.platform)
                bias_var  = op.inputs[-1]