o "jJc@s2ddlZddlZddlZddlmZddlmZddlmZm Z m Z ddl m Z m Z mZddlmZddlmZd d Zd d Zd dZddZ d(ddZeefddZddZddZddZde dej dedefdd Zde dej d!ej dedef d"d#Z de dej d!ej ded$ed%edefd&d'Z!dS))N)pir) ir_backward) call_decomp decomp_ops_contain_unused_output has_decomp)Block OperationProgram)core)registercCs:t|tjr |fSt|tjrt|Stdt|dS)NzType z is not supported.) isinstancerOpResulttypingSequencetuple TypeErrortype)Zxsr\/var/www/html/Deteccion_Ine/venv/lib/python3.10/site-packages/paddle/decomposition/decomp.py_build_tensor_tuple s  rcCst|t|ks Jg}t|D]B\}}t||tjrM|tvr5|t|vr5|ddus4Jnt|dkrCt|dtjsEJ||dq||q|S)Nrr ) len enumerater rrnamerkeysappend) orig_outs decomp_outsopresidxvaluerrr_analyse_decomp_results(s  r"csd}g}D]/}|}|r2|r2|}t|tr,||kr,dd|D}||q|dq|krA|fS|fddD}t |S)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.combinecSg|]}|qSrsource).0itemrrr Kz1_prepare_python_api_arguments..Ncsg|]}|qSr)attrsr'xrrrr)W) operandsr& initializedget_defining_opr rrrZget_attr_namesr)rcombine_op_nameinputsr-inputprev_opZ api_argumentsrr.r_prepare_python_api_arguments:s       r7c Csd}g}|D]Z}|}|rb|rb|}t|trI||krI|D] }|j}d|vrGt d|jd|ddSq'q|j}d|vrbt d|jd|ddSqdS)Nr#z;Decomp op does not support dynamic shape -1, but got shape z in inputs of op  Tz in op ) r0r&r1r2r rrshapewarningswarn)rr3r4r-r5r6r(r:rrr_check_prim_dynamic[s4     r=c CsHt|t|ksJd|dt|dt|t||D]\}}|dus*|dur<|tjvrr/zdecompose..cs |vSrFrGrH)rJrrrL cs |vSrFrGrH)rKrrrLrMcSsdS)NTrrHrrrrLsNzLEach 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_enabledr r rrZ global_blockset frozenset prim_configloggingdebugrrrr program_guard_decompose_subgraphformat) programZsrc_varsrJrKblock op_filterrCZ dst_vars_dctr r(rrIr decomposesj      r[cCst|tr|j}d}t|D]\}}|}t|} t|} | s#| o&||} | r3t r3t |r3d} |dkr;|}| rtj d ||durY||ddkrYt |nt |t|} |} | rst|}t| ||}nt| | }t|| ||||tvrtt| D]}|t|vr| |||qn|tvr| d|dn|||||durd}|D] }|rd}nq|r||d}qdSt|tjr|D] }t||||qdStdt |) a The operators in block wich satisfy the filter conditon will be decomposed into primitives. Args: block (Block|Sequence[Block]): The blocks of program to be processed. op_filter (function): The filter to specify which ops to be processed. orig_vars (dict): Origin variables of original block. dst_vars (list): Corresponding replaced variables of Origin variables. NFr#rNr rTz5Expect type Block or Sequence of Block, but got type )!r ropsrrr get_decomp_rulerr Z_enable_prim_dynamic_shaper=rRaddrset_insertion_pointr7resultsrr"rrDrrrangerreplace_all_uses_with remove_opZ has_one_userrrVrr)rYrBrCrZZops_listZtemp_opr rr@ decom_rulehas_sink_decomp_rulelower input_argsrrrArcr(rrrrVs              rVc Cst|tstdt|t|tstdg}g}i}|jD]}g}|D] }|r3||q(|||<q |D]=}| D]6}|||vrw||vrc|||| || |ggqA|| || || |gqAq;t |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) r rrrlistr\r`r1rrindexr) rYglobal_outputsZ related_opsrelated_ops_output_indexesZop_to_op_valid_resultrZop_valid_resultr-Z global_outputrrr get_leaf_ops\sB           rlcCs&||D] }||d||d<qdS)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 Nr)rjZ op_outputsZop_indexrkrirrrreplace_graph_outputss rmrYfwd_opgrad_var_to_var_mapreturnc Cststdtj|jr|}|}t |}t |}|p$|}|rtt |}t ||r=t |} t|| |} nt||} t||| |D]\} } | |vr^| || || <qM|| ||| dfWdSt|dfWdS1swYdS)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 rO RuntimeErrorrrUrXrr`r r]rr7r_rr"rrDitemsrirbrcr) rYrnror@rrdrerfrgrrAZgrad_varvarrrrdecompose_fwd_ops@       $rtbwd_opcststdddD}}dd|D}|}g}g} |D]} | |vs8| |vs8| | gq(dd|D} fddtdD} g} |D]}|r_| dgqR| d gqR|j |}t |j }t | | | | }t |j }||}|d kr|j d  | kr||j d d S|D]}|dd ur|dr||dq|tqt|D]\}}||vr|||||<q|}t||D]}||j |||d 7}q||||t|d fS)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)` firstlycSr$rr%r,rrrr)r*z-decompose_bwd_op_directly..cSr$rr%r,rrrr)r*cSsg|]}|gqSrr)r'Z fwd_outputrrrr)scsg|]}|gqSr)Zoperand_source)r'irnrrr)s rFTr r8)NFN)r _is_bwd_prim_enabledrqr0r`rraZ num_operandsr1r\rirZcall_vjprrcrfake_op_resultrrpopmove_oprbr)rYrnruro fwd_inputsZ fwd_outputs bwd_inputs grad_inputsr grad_outputs bwd_input fwd_outputs_ fwd_inputs_Zstop_gradients grad_input bwd_op_idxbefore_num_opsnew_grad_inputs after_num_opsZnum_appended_opsr insert_idxrwrrxrdecompose_bwd_op_directlysd             rr}fwd_outputs_after_decomposecsntstddurtddd|D}|}g}tfdd|D} tfdd| D} tfd d|D} |j|} t|j} t | | | }t|j}d }t |D]\}}| rr| |||d 7}q^| tq^t |D]\}}|vr|||<q~| }t| |D]}||j|||d 7}q||||t|S) 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. rvNz=To decompose backward op, please decompose forward op firstlycSr$rr%r,rrrr)Vr*z1decompose_bwd_op_after_fwd_op..c3s$|] }|vs|vs|VqdSrFr)r'r)r}rrr [sz0decompose_bwd_op_after_fwd_op..c3s|]}|VqdSrFr)r'Z grad_outputrorrrbs c3s |] }|r|VqdSrF)r1)r'rrrrres rr )r ryrqr0r`rr\rirrZgradrr1rrrzrr{rar|rbrc)rYrnruror}rr~rrrrrrrrrZinput_grads_idxr rrrwr)r}rrordecompose_bwd_op_after_fwd_op2sR          r)NN)"rSrr;ZpaddlerZpaddle.autogradrZpaddle.base.corerrrZpaddle.base.libpaddle.pirrrr Zpaddle.frameworkr r rr"r7r=rDrQr[rVrlrmdictrrtrrrrrrsp    ! ; WW5 7 \