\;jeddlZddlZddlZddlmZddlmZddlmZm Z m Z ddl m Z m Z mZddlmZddlmZd Zd Zd Zd Z dd ZeefdZdZdZdZde dejdedefdZde dejdejdedef dZ de dejdejdedededefdZ!y)N)pir) ir_backward) call_decomp decomp_ops_contain_unused_output has_decomp)Block OperationProgram)core)registerct|tjr|fSt|tjr t |St dt|dS)NzType z is not supported.) isinstancerOpResulttypingSequencetuple TypeErrortype)xss dG:\00. PROJECTS\API\Inventory\templateJSON\kerjaOCR\Lib\site-packages\paddle/decomposition/decomp.py_build_tensor_tupler sH"cll#u B (Ry uT"XJ&89 ::ct|t|k(sJg}t|D]\}}t||tjr|j t jvr |t |j vr|d/Jt|dk(rt|dtjsJ|j|d|j||S)Nrr ) len enumeraterrrnamerkeysappend) orig_outs decomp_outsopresidxvalues r_analyse_decomp_resultsr&(s y>S- -- - C , U incll 3 =BBDD;BGGIFFQx'''5zQ:eAh +MMM JJuQx JJu - Jrc4d}g}|jD]}|j}|r|jrp|j}t |t r>|j |k(r+|jDcgc]}|j}}|j||jd|j |k(r|fS||jDcgc]}|j|c}z}t|Scc}wcc}w)z For standard api of operator, its inputs should keep consistent with organization of its inputs and attrs. Args: op (Operator): The target operator. builtin.combineN) operandssource initializedget_defining_oprr rrget_attr_namesattrsr)r"combine_op_nameinputsxinputprev_opitem api_argumentss r_prepare_python_api_argumentsr6:s(O F [[]  U&&(++-G7I.LLNo53:3C3C3EF3E43EF MM% MM$ " wwyO#yR5F5F5HI5Hbhhjm5HIIM  GJs ?D&Dc dd}g}|jD]}|j}|s|js(|j}t |t r|j |k(ry|jD]e}|jj}d|vs"tjd|jjd|j dy|j}d|vstjd|jd|j dyy)Nr(z;Decomp op does not support dynamic shape -1, but got shape z in inputs of op  Tz in op ) r)r*r+r,rr rshapewarningswarn)r"r/r0r1r2r3r4r:s r_check_prim_dynamicr=[s,'O F [[]  U&&(++-G7I.LLNo5#,,.D KKM//EU{ YZ^ZeZeZgZmZmYnnACAHAHAJ@KKLM $ / ;MMUV[VaVaUbbijljqjqjsittuv +rc ,t|t|k(s"Jd|dt|dt|t||D]\}}||&|tjvrt d|d|d||3|||||j vr||||<|j }|j }|j} |j} ||k(sJd|d|d |d | vs Jd|d | | k(sJd|d | d | |du|duz rJdyy)az Check whether the replaced outputs are consistent with origin outputs. Args: op_name (str): The name of operator. orig_outs (tuple): The outputs of original operator. new_outs (tuple): The outputs of replaced operator. orig_vars (dict): Origin variables of original block. dst_vars (list): Corresponding replaced variables of Origin variables. zwhen replace origin op z[ with composite rule, num of origin outs should be equal to new outs, but len(orig_outs) = z and len(new_outs) = Nzop z2 should not contain any None value. original outs=z and its composite rule outs=z\ with composite rule, origin out dtype should be equal to new out dtype, but orig_out dtype=z and new_out dtype=r8z1 with composite rule, composite out shape has -1.z\ with composite rule, origin out shape should be equal to new out shape, but orig_out shape=z and new_out shape=z"orig_out and new_out should match.)rzipr ops_contain_none ValueErrorrdtyper:) op_namer new_outs orig_varsdst_varsorig_outnew_out orig_dtype new_dtype orig_shape new_shapes r_check_op_resultsrMvs y>S] * !'+ #I//DS]O U * !'   400 0gYPQZP[[xzByCD      $)=y~~//4;HYx01!J I!J I* )'3&&0\1DYKQ * )# d( 1bc d#* )'3&&0\1DYKQ *!D(4 43 4 Grctjs|St|tst dt |d|j }tttfst dt dtttfst dt dtjdztjdtdkDrtdkDrfd}nGtdkDrtdk(rfd }n%tdk(rtdkDrfd }nd }d gt|z}i}t|D]?\}} t| tjst d t | d|d||| <Atjj!|5t#||||d d d t|D]E\}} t| tjr!| ||||<,t d t | d|dtjdj%tjd|S#1swYxYw)a Search nonbasic ops which have be registered composite rules and replace them with primitive ops. The operators in blacklist will be excluded from program when decomposed into primitives, and only the operators in whitelist will be decomposed. The priority of blacklist is higher than whitelist, it means an operator both in blacklist and whitelist will not be decomposed. The finally set that will be decomposed is: (block.ops & ops have decomposite rule & whitelist) - blacklist Note: All variables must be contained inside the given program. Args: program (Program): The program to be processed. src_vars (list[OpResult]): In program, once some operator is decomposed, its vars will be replaced by new ones. This argument means some vars will be used later and corresponding vars will be returned for later usage. blacklist (frozenset): The Operators that will be exclude when decomposed into primitives. whitelist (frozenset): Only the operators in whitelist will be decomposed into primitives. Returns: dst_vars (list): A list contains all vars which replace origin ones in src_vars. z"Expect type Program, but got type .z6Expected type of blacklisst is set|frozenset, but got z6Expected type of whiltelist is set|frozenset, but got forward_blacklistz(Decompose composite forward ops begin...rcP|jvxr|jvSNr)r1 blacklist whitelists rzdecompose..s#affh)+I 0IIrc(|jvSrRrS)r1rTs rrVzdecompose..saffhi7rc(|jvSrRrS)r1rUs rrVzdecompose..saffh)3rcy)NT)r1s rrVzdecompose..sdrNzLEach var in dst_vars should map corresponding var in src_vars, but got type z in z*Decompose composite forward ops finish: {}composite_ops_record)r _is_fwd_prim_enabledrr rr global_blockset frozenset prim_configloggingdebugrrrr program_guard_decompose_subgraphformat) programsrc_varsrTrUblock op_filterrF dst_vars_dctr$r4s `` r decomposerks]6  $ $ & gw ' 7#7JYr]E335'+wwy--  !78< JJL '"-b/K6!; H 3:z3JKH"Y)X779 @ E E GG$S^4#CBGGI#NO&cN@@#O 5wwy$D$I$I$KK!! ::8A;G00:#& $I ' 1++-(-I!!2!0"G{+|  E6?? +D i9 E  ?U }M rct|tstdt|t|ts tdg}g}i}|j D]@}g}|j D]$}|js|j|&|||<B|D]}|jD]}|||vs ||vrR|j||j|j j||j|gga||j|j|j j||j|gt|t|fS)aP This API checks which op contributes to the outputs of the entire computation graph, as well as determining the corresponding output index. Args: block (Block): the block of program to be processed. global_outputs (tuple(Value)): the outputs of the entire computation graph. Returns: related_ops (tuple(pir.Operation)): a tuple of op that contributes to the outputs of the entire graph. related_ops_output_indexes (tuple(tuple())) : a tuple records the mapping of tuple(the output index of the op, the output index of the entire graph) z$block should be Block, but got type z)The type of global_outputs should be list) rrrrlistrmrrr+rrindexr) rhglobal_outputs related_opsrelated_ops_output_indexesop_to_op_valid_resultr"op_valid_resultr1 global_outputs r get_leaf_opsr\sq eU #>tE{mLMM nd +CDDK!#iiA}}&&q)%4b! ( ',,.B 5b 99[(&&r*.55!# 2 2= A . 4 4] C/{/@/@/DELLJJL..}=*00?/(*  u%?@ @@rc4||D]}||d||d<y)z This API replace the outputs of the entire computation graph with the new outputs of the op, when the op contributes to the outputs of the entire computation graph. rr NrZ)r op_outputsop_indexrrs rreplace_graph_outputsrs*,H5#-eAh#7uQx 6rrhfwd_opgrad_var_to_var_mapreturnctjs tdtjj |j 5|j }|j}tj|}t|}|xs|}|rt|}tj||rt|} t|| |} nt||} t!||| |j#D]!\} } | |vs | |j%| || <#|j'| |j)|| dfcdddSt+|dfcdddS#1swYyxYw)a Decompose the fwd_op into a list of primitive ops. Args: block (Block): the block to which the fwd_op belongs. fwd_op (pir.Operation): the forward op to be decomposed. grad_var_to_var_map (dict): a dict obtained from distributed processing, which maps the backward grad variable to its corresponding forward variable. Returns: new_outputs (tuple(Value)): the new outputs after decomposing. has_decomposed: whether the forward op has been successfully decomposed. zRTo decompose forward op, please set `core._set_prim_forward_enabled(True)` firstlyTNF)r r\ RuntimeErrorrrcrfrrrr rnrr6rqrr&rrMitemsrrtrur) rhrrrCr ryrzr{r|r!rDgrad_varvars rdecompose_fwd_oprsN  $ $ & `      .++-NN$ --g6 )&122 6v>J  # #F +#)&1 2{F/z:/FG gy( ;"5!:!:!< #)#4<!,5'1"=  ( ( 2 OOF #T>; / .>#U*? / . .s B9E!>E! E!!E*bwd_opc tjs td|jDcgc]}|j }}|j }|jDcgc]}|j }}|j }g} g} |D]} | |vr| |vr | j | g |D cgc]} | g} } td|jDcgc]}|j|g}}g}|D]7}|jr|j dg&|j dg9|jj|}t|j}tj||| | |}t|j}||z }|dk(rM|jdj|jk(r|j!|jdy|D]R}|d(|djr| j |d0| j t#j$Tt'|D]/\}}||j)vs|j+||| |<1|}t||D]&}|j-|j|||dz }(|j/| |j!|t1| dfScc}wcc}wcc} wcc}w)ac Decompose the bwd_op into a list of primitive ops. If fwd_op has composite vjp rules (including custom vjp), call call_vjp() to get a list of primitive operators in backward graph, then replace bwd_op. Args: block (Block): the block to which the bwd_op belongs. fwd_op (pir.Operation): the forward op. bwd_op (pir.Operation): the backward op to be decomposed. grad_var_to_var_map (dict): a dict obtained from distributed processing, which maps the backward grad variable to its corresponding forward variable. Return: new_input_grads (tuple(Value)): new results of backward op after decomposing. has_decomposed: whether the backward op has been successfully decomposed. If a fwd op does not have composite vjp rules and can not be decomposed directly, this function will return False. TTo decompose backward op, please set `core._set_prim_backward_enabled(True)` firstlyrFTr r8)NF)r _is_bwd_prim_enabledrr)r*rrrrs num_operandsoperand_sourcer+rmrrcall_vjprrurfake_op_resultrrpopmove_oprtr)rhrrrr1 fwd_inputs fwd_outputs bwd_inputs grad_inputsr# grad_outputs bwd_input fwd_output fwd_outputs_i fwd_inputs_stop_gradients grad_input bwd_op_idxbefore_num_opsnew_grad_inputs after_num_opsnum_appended_opsr$ insert_idxs rdecompose_bwd_op_directlyrs*  $ $ & b  '-oo&78&7!((*&7J8.."K&,oo&78&7!((*&7J8.."K CL Z'9 +C    , 4??;ZZL;L?,1!V5H5H5J,K,Kq  q !",KN!  ! ! #  ! !5' *  ! !4& ) "(J^Nmm \<O NM$~512!3!3!5!F  " &*J!}(Z]-F-F-H :a=) 3--/0 * )5OC055770C0G0G1#CH- 6 ~}5A MM%))A, 3 !OJ6 $$S) Sz4}98@sK1-K6 K;)Lrfwd_outputs_after_decomposectjs td td|jDcgc]}|j }}|j }g} t fd|D} t fd| D} t fd|D} |jj|} t|j}tj| | | }t|j}d}t|D]R\}}|jr| j|||dz }0| jtj Tt|D]/\}}|j#vsj%|| |<1| }t'||D]&}|j)|j|||dz }(|j+| |j-|t | Scc}w)a Decompose the bwd_op into a list of primitive ops. If fwd_op has no composite vjp rules, and fwd_op has been decomposed to a list of primitive operators in forward graph previously, call grad() for the decomposed forward subgraph to get a list of primitive operators in backward graph, then replace bwd_op. Args: block (Block): the block to which the bwd_op belongs. fwd_op (pir.Operation): the forward op. bwd_op (pir.Operation): the backward op to be decomposed. grad_var_to_var_map (dict): a dict obtained from distributed processing, which maps the backward grad variable to its corresponding forward variable. fwd_inputs: (tuple(Value)): the original input of the forward op, fwd_outputs_after_decompose (tuple(Value)): the output of the decomposed forward op, if forward op has no vjp rules, forward op shoule be decomposed firstly, fwd_outputs_after_decompose means the new output of the decomposed forward op. If forward op has vjp rules, fwd_outputs_after_decompose is None. Return: new_input_grads (tuple(Value)): results of backward op after decomposing. rz=To decompose backward op, please decompose forward op firstlyc32K|]}|vs|vs|ywrRrZ).0rrrs r z0decompose_bwd_op_after_fwd_op..[s)#I  #y4O'O #sc3(K|] }| ywrRrZ)r grad_outputrs rrz0decompose_bwd_op_after_fwd_op..bs.es*%J  ! ! # J'%s"rr )r rrr)r*rrrrmrrrgradrr+rrrrrrsrrtru)rhrrrrrr1rrr#rrrrrrrinput_grads_idxr$rrrs ``` rdecompose_bwd_op_after_fwd_opr2s4  $ $ & b  #* K  '-oo&78&7!((*&7J8.."K C#L= 1 eiilJ/a 2    % OOF :i9sH )NN)"rarr;paddlerpaddle.autogradrpaddle.base.corerrrpaddle.base.libpaddle.pirrr r paddle.frameworkr r rr&r6r=rMr_rkrdrrdictrrrrrZrrrs9 ' @?!;$ B 8<@5vkk TnTn2Aj 84+ 4+--4+>B4+ 4+nY Y MMY  MMY  Y  Y xX X MMX MMX X  X "' X Xr