o OeW@sddlmZddlZddlmZddlmZddlmZm Z ddl m Z ddl m Z mZdd lmZmZmZmZdd lmZmZmZmZdd lmZmZmZmZdd d ZddZGddde Z!Gddde Z"ddZ#ej$dddZ%ej$dddZ&dS)) OrderedDictN)compat) framework)Operatordefault_main_program) as_tensors)add fill_const)lookup_orig2primlookup_prim2origop_position_inputsop_position_output)_jvp _orig2prim _prim2orig _transpose)flattenflatten_and_remove_noneget_input_var_listget_output_var_listc s8|dur tn|}g}g}tt|D]}|dus&|j|ks&Jd|t|<qfdd}|jD]}||rP||tt|D]}|t|<qGq6tfdd|Dfdd} t |D]}| |r||tt |D]}|t|<qwqffdd |D} fd d |D} t t || | fS) aReturns the list of ops on the path from `xs` to `ys` in topological order. TODO(Tongxin): supporting control flow and nested blocks. Args: xs: a list|tuple of vars as source ys: a list|tuple of vars as sink block: the program block containing the path, optional Returns: (path, unused_xs, unreached_ys): a tuple comprised of the resulting op path, the unused variables in `xs`, and the unreached variables in `ys` Nz"x is not None and x.block != blockctfddtt|DS)Nc3|] }t|vVqdSNid.0v reached_varsND:\Projects\ConvertPro\env\Lib\site-packages\paddle/incubate/autograd/primx.py D  .topo_path....)anyrroprr!r"D ztopo_path..c3s(|]}t|vrt||fVqdSrrryrr!r"r#Rs&ztopo_path..cr)Nc3rrr)rout used_varsr!r"r#Sr$r%)r&rrr'r.r!r"r)Sr*cg|] }t|vr|qSr!rrxr.r!r" _ztopo_path..cr0r!rr+rr!r"r3`r4) r current_blockrblockropsappendrrreversedrlist) xsysr6pathZbackpathr2Zreachingr(varZ back_reaching unused_xsZ unreached_ysr!)r r/r" topo_path's8      r@cCs2t}|D]}tt|D]}||t|<q q|S)zReturns the output variables of all the ops on the path from `xs` to `ys`. Args: path: a list of ops on which to find the output variables Returns: vars: the output vars )rrrr)r=varsr(r-r!r!r"output_vars_on_pathes  rBc@s`eZdZdZgdZddZddZddZd d Zd d Z d dZ ddZ ddZ ddZ dS)VarMapz~A general map data structure for linking variables to variables. An example is linking variables to their gradients. )namevarsettabcCs||_||_t|_dSr)rDrErrF)selfrDrEr!r!r"__init__s zVarMap.__init__cCst||jt|<dSrrrF)rGkey_var value_varr!r!r"r sz VarMap.addcCs|durdSt|tjjjr*t|tjjjstdt|t||jt|<dSt |t |ksAJdt |dt |dt ||D] \}}| ||qFdS)Nz%value_vars must be Variable, but got zDlen(key_vars) shoule be equal to len(value_vars), but len(key_vars)=z and len(value_vars)=.) isinstancepaddlefluidrVariable TypeErrortyperrFlenzipadd_rec)rGkey_vars value_varsrJrKr!r!r"rUs$ zVarMap.add_reccCs(|jt|}|dur|j|SdSr)rFgetrrE)rGrJZvalue_idr!r!r"lookups z VarMap.lookupcCs&t|}||jvr|jt|=dSdSrrI)rGrJvaridr!r!r"deletes z VarMap.deletecCs(|D]}t|}||jvr|j|=qdSrrI)rGrVr>rZr!r!r"delete_keyvarss  zVarMap.delete_keyvarscs<dd|Dfdd|jD}|D]}|j|=qdS)NcSsg|]}t|qSr!rrr!r!r"r3sz+VarMap.delete_valuevars..csg|] \}}|vr|qSr!r!)rkrZidsr!r"r3r4)rFitems)rGrWkeysr]r!r^r"delete_valuevarss  zVarMap.delete_valuevarscCs|jt|Sr)rF __contains__r)rGrJr!r!r" contain_varszVarMap.contain_varcCst||jvSr)rrFvalues)rGrKr!r!r" contain_valueszVarMap.contain_valueN)__name__ __module__ __qualname____doc__ __slots__rHr rUrYr[r\rarcrer!r!r!r"rCws rCc@sdeZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ dddZ dddZ dS) TransformzXAn object that maintains the state of transformations applied to a primitve program.cCsH|tks Jd||_|||_td|j|_td|j|_dS)Nz8only support transform on current block of main program.var2dotZdot2var)rr5r6 init_varsrArCrldot2bar)rGr6r!r!r"rHs zTransform.__init__cCs*t}|jD] \}}||t|<q|Sr)rrAr_r)rGr6rA_r>r!r!r"rmszTransform.init_varscCs|jdd|DdS)NcSsi|] }|durt||qSrrrr!r!r" z&Transform.add_vars..)rAupdate)rGnew_varsr!r!r"add_varsszTransform.add_varscCsh|durdSt|tjjjr|jt||idSt|ts(t dt ||D]}| |q*dS)Nznew_vars must be list, but got ) rMrNrOrrPrArrrr:rQrR add_vars_rec)rGrsr>r!r!r"rus  zTransform.add_vars_reccCsH|j}t|D] }|j||dqt|D]}|j|=q|dS)Nr)r6r9desc _remove_opr7_sync_with_cpp)rGZordered_indexesr6Zop_indexr!r!r" erase_opss     zTransform.erase_opscCsx|D]}t||jvr|jt|=q|j||j||j}|D]}|j}|j t ||j|=q#| dSr) rrArnr\rlrar6rDrv _remove_varcptto_bytesrx)rGZ vars_to_eraser>r6rDr!r!r" erase_dotss     zTransform.erase_dotscs6t|tjjjrj|}|Sfdd|D}|S)zLookup var2dot recursively.cg|]}|qSr!) var2dot_recrr>rGr!r"r3z)Transform.var2dot_rec..)rMrNrOrrPrlrY)rGrAdotdotsr!rr"rs  zTransform.var2dot_reccsFt|tjjjrj|}|dusJd|Sfdd|D}|S)Nzbar must be not Nonecr~r!) dot2bar_rec)rrrr!r"r3rz)Transform.dot2bar_rec..)rMrNrOrrPrnrY)rGrbarZbarsr!rr"rs  zTransform.dot2bar_recNcsH|durdd|D}|nt|t|ks'Jdt|dt|t||D]/\}}|j|jksBJd|jd|j|j|jksTJd|jd |jj||q,t||j\}}}|D]}j |qh|D]#} t | } | } t | g| R} | t| } j| | qsfd d|D}||fS) aPerforms the linearization transform, a.k.a, forward mode AD transform, on a primitive lowered program. Args: xs: a list of input variables ys: a list of output variables xs_dot: optional, a list of gradient input variables. The list size must be equal to `len(xs)`. The shape and dtype of each element must be the same as in `xs` Returns: (xs_dot, ys_dot): a tuple of two lists. `xs_dot` is the list of gradient inputs of the resulting linearized program. `ys_dot` is the list gradient outputs of the resulting linearized program NcSsg|] }td|j|jdqS)?shapedtype)r rrr1r!r!r"r3rqz'Transform.linearize..z4len(xs) should be equal to len(xs_dot), but len(xs)=z and len(xs_dot)=z2x.dtype should be equal to dot.dtype, but x.dtype=z and dot.dtype=z2x.shape should be equal to dot.shape, but x.shape=z and dot.shape=cg|]}j|qSr!)rlrYr+rr!r"r3<)rtrSrTrrrlr r@r6r[r rrrurrU)rGr;r<xs_dotr2rr=r?ror(insZjvp_insZouts_dotZoutsys_dotr!rr" linearizesL   zTransform.linearizeFcstdd|Ds Jdtdd|DsJd|dur7g}|D]}|td|j|jdq"|nDt|t|ksMJd t|d t|t||D](\}}|j|jkshJd |jd |j|j|jkszJd |jd|jqRt||D] \}} j || qt ||j \} } } | D]}j |qt | dd|Dfdd} t| D]y}t|}|}t|| |}t|trt|}n|g}|t|}tt|}t|t|ksJdt|dt|t||D]0\}} | dur0j|}|durj || qt || }|gj ||qqfdd|D}|st| dkrt}| D] }|tt|qKg}j }t|jD]\}}|| vr~||| dt| dkr~nqb |!|||fS)aPerforms the transpose transform, a.k.a, reverse mode AD transform, on a linearized primitive program. Note, `transpose` is supposed to be used in couple with `linearize`. Args: ys_dot: a list of outputs of the linearized program. xs_dot: a list of inputs of the linearized program. ys_bar: optional, a list of inputs of the resulting transposed program. The list size must be equal to `len(ys_dot)`. The shape and dtype of each element must be the same as in `ys_dot` Returns: (ys_bar, xs_bar): a tuple of two lists. `ys_bar` is the list of inputs of the resulting transposed program. `xs_bar` is the list outputs of the resulting transposed program cs|]}|duVqdSrr!rr!r!r"r#Rz&Transform.transpose..z`xs_dot` includes None.csrrr!rr!r!r"r#Srz`ys_dot` includes None.Nrrz.z7len(ins) should be equal to len(ins_bar), but len(ins)=z and len(ins_bar)=crr!)rnrYr1rr!r"r3rz'Transform.transpose..r)"allr8r rrrtrSrTrnr r@r6r[rBrrr9rrrrMtupler:rurr rYsetrr enumerater7popryr})rGrrZys_barZ retain_fwdr,Zy_dotZy_barrrr=Z unused_xs_dotroZis_dotr(r-Z out_bar_recZ ins_bar_recZins_barrZgradZxs_barvars_to_removeZ op_indexesr6ir!)rrGr" transpose?s                     zTransform.transposer)NF)rfrgrhrirHrmrtruryr}rrrrr!r!r!r"rks     ;rkc sZfddfddfdd|rtnt}|rtnt}i}i}i}|jD] }||||<q)g} t} t t |j D]} |j | } | | || j dur| j |vrt| } | ||tt| t|| g| RD]'\}}|du|duArJd| |j|||j<|j||j<|j||j<qxqCi}t t | jD]}| | j|||| j|<qi}t t | jD]}| | j||| j|<qi}t| jD] }| |||<qdd lm}|j}||(||t||| j |||d } Wdn 1swYWdn 1s"wY|j | qCt| D]} |j| | d |j | =q2| t t |j D]0} |j | } | j!D]}||vrg| "|||qX| j#D]}||vr{| $|||qlqNt| D]#}||vsJd %||||kr|j&t'(||j)|=q| dS) Ncsftt|D]*}t||tr||||q||dur0||j|vr0||||j||<qdSr)rangerSrMr:rD)argsto_bind value_tabler)bindr!r"rsz_lower..bindcsHg}|D]}t|tr|||q|||vr||n|q|SrrMr:r8)namesr return_listrD) bind_namer!r"rs  z_lower..bind_namecs4g}|D]}t|tr||}q||q|Srr)r;rr2)expand_nested_listr!r"rs   z"_lower..expand_nested_listz"orig_out and new_out should match.r) param_guard)r6rvrRinputsoutputsattrsrz$var_name "{}" is not in to_bind_rev.)*rrr r rvZall_varsr>rDrrrSr7r8rRrrTrrr Z input_namesinputZ output_namesoutputsortedZ attr_namesattrZpaddle.fluid.dygraph.baserZ append_oprr9rwrxZinput_arg_namesZ _rename_inputZoutput_arg_namesZ_rename_outputformatrzr{r|rA)r6reverse blacklistZlower_fnZ lookup_fnrrZ to_bind_revr>Z ops_to_removerZop_idxr(Z input_argsZorig_outZnew_outrrrrrDrZ new_op_descZin_nameZout_namevar_namer!)rrrr"_lowers                        rcCs>|dur tn|}|tksJdt|dgddS)a' Note: **This API is ONLY available in the static mode.** **Args block must be None or current block of main program.** All operators in the target block are processed as follows. If it is an original operator, it will be transformed into one or a series of automatic differential basic operators with equivalent function. Args: block(paddle.static.Block|None, optional): The target block to process on. Default None, and will process on the current block of main program. N7block is neither None nor current block of main programFrrrr5r)r6r!r!r" orig2prim#s rcCsN|dur tn|}|tksJd|durgn|}t|d|ddS)a Note: **ONLY available in the static mode.** **Args block must be None or current block of main program.** All operators in the target block are processed as follows. If it is an automatic differential basic operator, it will be transformed into one or a series of original operators with equivalent function to support execution. Args: block(paddle.static.Block|None, optional): The target block to process on. Default None, and will process on the current block of main program. blacklist(list[string]|None, optional): The names of automatic differential basic operator that will not be transformed into original operators. Default None, and the blacklist is treated as empty list. Examples: .. code-block:: python import paddle from paddle.incubate.autograd import enable_prim, prim_enabled, prim2orig paddle.enable_static() enable_prim() x = paddle.ones(shape=[2, 2], dtype='float32') x.stop_gradients = False y = x * x dy_dx = paddle.static.gradients(y, x) if prim_enabled(): prim2orig() NrTrr)r6rr!r!r" prim2orig<s 'rr)NN)' collectionsrrNrr{Z paddle.fluidrZpaddle.fluid.frameworkrrZpaddle.incubate.autograd.utilsrZprimopsr r Zprimregr r r rZ primrulesrrrrutilsrrrrr@rBobjectrCrkrZ static_onlyrrr!r!r!r"s(     >A{q