o "j@sddlmZddlZddlZddlZddlZddlZddlmZddl m m Z ddl mZmZddlm Z mZddlmZddlmZmZmZddlmZmZdd lmZmZdd lm Z dd l!m"Z"dd l#m$Z$m%Z%d dl&m'Z'm(Z(d dl)m*Z*d dl+m,Z,m-Z-m.Z.m/Z/d dl0m1Z1m2Z2m3Z3d dl4m5Z5d dl6m5Z7d dl8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDerddlEmFZFgZGdZHdZIddZJGdddZKeLZMeKZNddZOGdddZPdd ZQGd!d"d"ZRd#d$ZSGd%d&d&eRZTGd'd(d(eRZUd)d*ZVGd+d,d,ZWGd-d.d.ZXd/d0ZYGd1d2d2ZZGd3d4d4Z[Gd5d6d6Z\Gd7d8d8e7Z]Gd9d:d:Z^Gd;d<dd>Z`d?d@ZaeebebdAdAfdBdCZcdS)D) annotationsN) TYPE_CHECKING) decomposition get_flags)core framework) check_type)_to_static_mode_guard_ param_guardswitch_to_static_graph)UniqueNameGeneratorguard)in_dynamic_mode use_pir_api)layers)OpResult)flattengast)error logging_utils)DygraphToStaticAst) FunctionSpec_hash_spec_names get_buffersget_parameters)attach_origin_info!create_and_update_origin_info_map$update_op_callstack_with_origin_info)PartialProgramLayerHook) ALREADY_D2SNO_SHAPE_VAR_TYPE ast_to_func backend_guardfunc_to_source_codeinput_specs_compatibleis_paddle_func make_hashableprim_is_enabledprim_or_cinn_is_enabled type_nameunwrap) AmpOptions Z__jst_not_to_staticcst_fdd}|S)Ncs8j|i|WdS1swYdSN)__lock__)argskwargsfunch/var/www/html/Deteccion_Ine/venv/lib/python3.10/site-packages/paddle/jit/dy2static/program_translator.py lock_funcYs $zsynchronized..lock_func) threadingLockr/)r3r6r4r2r5 synchronizedVs  r9c@s0eZdZdZddZddZddZdd Zd S) FunctionCachez_ Caches the transformed functions to avoid redundant conversions of the same function. cCst|_i|_t|_dSr.)weakrefWeakKeyDictionary_converted_static_func_caches_code_to_ast_cachesr_dygraph_to_staticselfr4r4r5__init__es  zFunctionCache.__init__cCs.|j|d}|dur||}||j|<|S)zg Returns the cached static function or converts it when first encounters the function. N)r=get_convert)rAr3 static_funcr4r4r5convert_with_cachels   z FunctionCache.convert_with_cachecCslt|}t|}||jvr|j|}nt|}t||}|j|}||j|<t||\}}t |||S)a! Converts dygraph function into static function. For two functions with same dedent code, the second function will reuse the transformed ast node of previous one. For example: # A.py def foo(x, y): z = x + y return z # B.py def foo(x, y): z = x + y return z If the conversion of A.foo happens after B.foo, it will reuse the transformed ast node of B.foo to speed up the conversion. ) r+r$r>rparserr?Zget_static_astr"r)rAr3 source_coderootrE file_namer4r4r5rDys       zFunctionCache._convertcCs ||jvSr.)r=)rAr3r4r4r5exist zFunctionCache.existN)__name__ __module__ __qualname____doc__rBrFrDrKr4r4r4r5r:`s  *r:cCst|tdr|St|td}|dur|jpt|}|r%t|r#|jS|Stt |}t |td|WdS1s?wYdS)a Transforms function of dygraph into static function using the cache mechanism. Note(dev): It will return function.__func__ if encountering class method. Args: function(callable): The function with dygraph layers that will be converted into static layers. NT) getattrr CONVERSION_OPTIONSZ not_convertr&inspectismethod__func__ _CACHE_LOCK_FUNCTION_CACHErFsetattr)functionoptionsZ need_skiprEr4r4r5convert_to_statics    $r[c@sLeZdZdZgdZddZeddZddZd d Z d d Z d dZ dS)CacheKeyz& Cached key for ProgramCache. ) function_specinput_args_with_specinput_kwargs_with_specclass_instancer1_spec_names_id _pir_flagscKsH||_||_||_||_||_t|||_tddp tdd|_dS)a Initializes a cache key. Args: functions_spec(FunctionSpec): a FunctionSpec instance of decorated function. input_args_with_spec(list[InputSpec]): actual input args with some arguments replaced by InputSpec. input_kwargs_with_spec(list[{string:InputSpec}]): actual input kwargs with some arguments replaced by InputSpec. class_instance(object): a instance of class `Layer`. **kwargs(dict): manage other arguments used for better scalability ZFLAGS_enable_pir_in_executorZ!FLAGS_enable_pir_with_pt_in_dy2stN) r]r^r_r`r1rrarrb)rAr]r^r_r`r1r4r4r5rBszCacheKey.__init__c CsN|rt|dtjr|dd}|||\}}|||\}}t||||S)ag Generated a CacheKey instance by given inputs. Args: functions_spec(FunctionSpec): a FunctionSpec instance of decorated function. args(tuple): tuple of actual inputs arguments. kwargs(dict): dict of actual inputs keyword arguments. class_instance(object): a instance of class `Layer`. rrN) isinstancerLayerunified_args_and_kwargsargs_to_input_specr\) clsr]r0r1r`_args_kwargsr^r_r4r4r5from_func_and_argss  zCacheKey.from_func_and_argsc CsTd}|jdd}|jdd}tt|jt|j|t|j||j|j |||j fS)NzoArguments to a `@paddle.jit.to_static` must be a hashable Python objects (or nested structures of these types). with_hookFis_train) r1rChashidr]r'r^r_rar`rb)rA error_msgrkrlr4r4r5__hash__s  zCacheKey.__hash__cCs t|t|uot|t|kSr.)typermrAotherr4r4r5__eq__'s zCacheKey.__eq__cCs ||k Sr.r4rrr4r4r5__neq__*rLzCacheKey.__neq__cCsdt|j|j|j|jS)Nz_id(function_spec): {}, input_args_with_spec: {}, input_kwargs_with_spec: {}, class_instance: {})formatrnr]r^r_r`r@r4r4r5__repr__-s zCacheKey.__repr__N) rMrNrOrP __slots__rB classmethodrjrprtrurwr4r4r4r5r\s $  r\cCsNg}|} t|tr!|||j}|dur|j|}n |j}n ||fSq)zW Unwraps a decorated function and returns the decorator list and inner target. TN)rcStaticFunctionappend_class_instancedygraph_function__get__)r3Z decoratorscurinstancer4r4r5unwrap_decorators6s  rc@seZdZd5ddZddZeddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZeddZed d!Zed"d#Z $d6d%d&Zd'd(Zd)d*Zed+d,Zed-d.Zed/d0Zed1d2Zed3d4ZdS)7rzNcKst|r |j|_|j|_t|jdstd|j|jj|j <n||_d|_|durMt rMddl m }t |D]}t||rLd|jvrLd}tdnq7||_t|||_t|_t|_t|_||_d|_d |_d|_| d d |_!|"dS) az Initializes a `StaticFunction`. Args: function(callable): A function or method that will be converted into static program. input_spec(list[InputSpec]): list of InputSpec to specify the `shape/dtype/name` information for each input argument, default None. **kwargs(dict): other arguments like `build_strategy` et.al. _original_funcscWhen using 'to_static' to convert method of a class, please ensure the class inherits from nn.LayerNr) InputSpecz\Now prim and cinn do not support -1 shape, but input_spec has -1 shape so we set it to None.TpropertyF)#rSrTrU_dygraph_function__self__r|hasattr TypeErrorrrMr(Z paddle.staticrrrcshapewarningswarn _input_specr_function_spec ProgramCache_program_cacher;r<_descriptor_cacheProgramTranslator_program_transri _training_cuda_graph_capture_mode_cuda_graph_pool_idrC _property_get_debug_name)rArY input_specr1rspecr4r4r5rBKsD       zStaticFunction.__init__cCsDz|jr |jjj|_WdS|jj|_WdSty!d|_YdSw)NZstatic_function)r| __class__rM _debug_namer Exceptionr@r4r4r5r~s  zStaticFunction._get_debug_namecC|jSr.)rr@r4r4r5 is_propertyszStaticFunction.is_propertycC4t|jtjr|jjdurtd|jd|_dS)NFzcFailed to switch train mode. {} is a Layer's method, please use Layer.train() to switch train mode.T rcr|rrdtraining RuntimeErrorrvr}rr@r4r4r5train   zStaticFunction.traincCr)NTz`Failed to switch eval mode. {} is a Layer's method, please use Layer.eval() to switch eval mode.Frr@r4r4r5evalrzStaticFunction.evalcCsf||jvr.|dur |S|}t|tjr&|jj|jvr&|j|j|jj<||_ ||j|<|j|S)a Overrides this method to parse the class instance and call bound method correctly. For example: ''' class Net(Layer): def __init__(self): pass @paddle.jit.to_static def forward(self, x, y): return x + y net = Net() out = net(x, y) ''' In above case, `net(x, y)` will call `net.forward(x, y)` firstly that is a bound method of `Net` instance. After decorated by `@paddle.jit.to_static`, it will firstly to call `__get__` to parse the class instance correctly instead of the `StaticFunction` instance. N) r_clonercrrdrrMrkeysr|)rArownerZnew_static_layerr4r4r5r~s    zStaticFunction.__get__cCs|j|j|jfi|jSr.)rr}rrir@r4r4r5rs zStaticFunction._clonecOs`|jr |j|i|S|jjstd|j|i|Sts(td|jd|j |i|S)ag Supports to call the returned instance with input `args` and `kwargs` directly. Args: *args(tuple): tuple of all input arguments from original decorated function. **kwargs(dict): dict of all input keyward arguments from original decorated function. Return: Outputs of decorated function. zThe decorator '@paddle.jit.to_static' does NOT work when setting 'paddle.jit.enable_to_static' to False. We will just return dygraph output. If you would like to get static graph output, please call API paddle.jit.enable_to_static(True)z"Failed to run the callable object z decorated by '@paddle.jit.to_static', because it is NOT in dynamic mode. Please disable the static graph mode to enter dynamic mode with the following API: paddle.disable_static().) r_call_dygraph_functionrenable_to_staticrrrrr} _perform_callrAr0r1r4r4r5__call__s  zStaticFunction.__call__cCs,|jdurt|jdstd|jjS|jS)Nrr)r|rrrrr@r4r4r5_is_train_modes  zStaticFunction._is_train_modecOs|j|i|S)aN Calls dygraph function directly and returns the outputs. Args: *args(tuple): tuple of all input arguments from original decorated function. **kwargs(dict): dict of all input keyward arguments from original decorated function. Return: Outputs of dygraph function. )r}rr4r4r5rs z%StaticFunction._call_dygraph_functioncCs|jrtddS)zraise RuntimeError when property=True Raises: RuntimeError: can not call this func when property=True z)Can not call the func when property=True.N)rrr@r4r4r5_raise_when_propertysz#StaticFunction._raise_when_propertycOtdNzNot implemented yet.NotImplementedErrorrr4r4r5get_concrete_programz#StaticFunction.get_concrete_programcCrrr)rA cached_keyr4r4r5#get_concrete_program_with_cache_keyrz2StaticFunction.get_concrete_program_with_cache_keycCrrrr@r4r4r5get_traced_count rzStaticFunction.get_traced_countcCrrrr@r4r4r5code#zStaticFunction.codecCs|jdur |j|jS|jS)z: Returns the original decorated function. N)r|rr~r@r4r4r5r}'s zStaticFunction.dygraph_functioncCrrrr@r4r4r5concrete_program1rzStaticFunction.concrete_programFcCrrr)rArrk is_prim_inferr4r4r5#concrete_program_specify_input_spec5sz2StaticFunction.concrete_program_specify_input_speccsfdd|jdur|jS|jj}||jjvs"Jd||jj|jj|}t|j|||j|jjddD]}|q:t |j|S)a Rollback into original dygraph functions for current class instance. Returns: Function or Method Example:: .. code-block:: python >>> # doctest: +SKIP('`paddle.jit.to_static` can not run in xdoctest') >>> import paddle >>> class Net(paddle.nn.Layer): ... def __init__(self): ... super().__init__() ... ... def forward(self, x, flag=True): ... if flag: ... out = x + 1 ... else: ... out = x - 1 ... return out ... >>> x = paddle.randn([10, 1], 'float32') >>> net = paddle.jit.to_static(Net()) # convert into static graph mode >>> out = net(x) >>> net.forward.rollback() # rollback into dygraph mode >>> out = net(x) csD|jD] \}}t||||q|jddD]}|qdS)NFZ include_self)ritemsrXr~ sublayers)r`namer3sublayer rollback_implr4r5rZs  z.StaticFunction.rollback..rollback_implNz&Not Found function '{}' in class '{}'.Fr) r|rrMrrvrrXr~rrQ)rA func_namer3rr4rr5rollback:s    zStaticFunction.rollbackcCsP|jdur%t|jj}tjdd||d||j|t |jS|jS)a Customized behavior for copy.deepcopy, return original decorated function instead of a new StaticFunction Object. StaticFunction itself is not copyable becuase it's associated with class_instance. We add __deepcopy__ here only for the following usage: Example:: .. code-block:: python >>> import copy >>> import paddle >>> class Net(paddle.nn.Layer): ... def __init__(self): ... super().__init__() ... ... def forward(self, x, flag=True): ... if flag: ... out = x + 1 ... else: ... out = x - 1 ... return out ... >>> x = paddle.randn([10, 1], 'float32') >>> net = paddle.jit.to_static(Net()) # convert into static graph mode >>> copy_net = copy.deepcopy(net) # deepcopy a new net without @to_static Please attention that original 'net' will unwrap @to_static and rollback into simple Layer. NrzNot recommend to deepcopy '{}' decorated with @to_static, it has side effect that will rollback into original state before @to_static. Please deepcopy '{}' before applying @to_static.)levelmsg) r|rqrMrlogrvrrr~rn)rAmemoZnet_namer4r4r5 __deepcopy__us  zStaticFunction.__deepcopy__cCrrrr@r4r4r5inputsrzStaticFunction.inputscCrrrr@r4r4r5outputsrzStaticFunction.outputscCrrrr@r4r4r5 main_programrzStaticFunction.main_programcCrrrr@r4r4r5 program_cacherzStaticFunction.program_cachecCrrrr@r4r4r5r]rzStaticFunction.function_specr.NFF)rMrNrOrBrrrrrr~rrrrrrrrrr}rrrrrrrrr]r4r4r4r5rzJsH 3   *$       ;0    rzcsfdd}|S)Ncsd}t|jd)Nz[Can't call {func} when full_graph=False. Use paddle.jit.to_static(full_graph=True) instead.r2)rrv)r0r1Zerror_templatefunc_strr4r5 _raise_errorsz*raise_error_template.._raise_errorr4)rrr4rr5raise_error_templates rcseZdZdfdd ZddZeddZedd Zed Z ed Z ed Z ed Z eddZ eddZeddZeddZeddZZS)SymbolicStaticFunctionNc s2|dur tdtj||fi|d|_dS)Nzfull_graph=False don't support input_spec arguments. It will not produce any effect. You can set full_graph=True, then you can assign input spec. )rrsuperrBlast_call_input_specrArYrr1rr4r5rBs  zSymbolicStaticFunction.__init__c Osddlm}|j||\}}|j||\}}||_|jdd}|jdd}||j|| |d}|j dur?|j f|}||i|S)N)symbolic_translatebuild_strategybackend)rrr) ZsotrrrerfrrirCrrr|) rAr0r1rr^r_rrZ traced_funr4r4r5rs$    z$SymbolicStaticFunction._perform_callcCtddS)Nrrr@r4r4r5rzSymbolicStaticFunction.codecCr)Nrrr@r4r4r5rrz'SymbolicStaticFunction.concrete_programrrrrcCr)Nrrr@r4r4r5rrzSymbolicStaticFunction.inputscCr)Nrrr@r4r4r5rrzSymbolicStaticFunction.outputscCr)Nrrr@r4r4r5rrz#SymbolicStaticFunction.main_programcCr)Nrrr@r4r4r5rrz$SymbolicStaticFunction.program_cachecCr)Nzfunction_spec rr@r4r4r5r]rz$SymbolicStaticFunction.function_specr.)rMrNrOrBrrrrrrrrrrrrrr] __classcell__r4r4rr5rs2       rcseZdZdZdfdd ZddZddZd d Zd d Ze d dZ e ddZ dddZ e ddZ e ddZe ddZe ddZe ddZZS) ASTStaticFunctionzL Wrapper class to Manage program conversion of decorated function. Nc stj||fi|dSr.)rrBrrr4r5rBszASTStaticFunction.__init__c Os|j||\}}zR|j|i|d|i\}}t|jtjr'|jj|_n|j |_|j |_ |j |_ z||WWSt y[}zt |tjsOtj|ddWYd}~WdSd}~wwt y}z"t|tjd}|rq|n tdt|d|WYd}~dSd}~ww)NrlT)Z in_runtimezaPlease file an issue at 'https://github.com/PaddlePaddle/Paddle/issues' if you can't handle this z yourself.)rrerrrcr|rrdrrrrrrr ERROR_DATAattach_error_datarQraise_new_exceptionrrrq)rAr0r1_partial_program_layere error_datar4r4r5rsJ     zASTStaticFunction._perform_callc Os||dd}|dd}|dd}d|vr|dd|vr(|dd|vr1|dt|t|jjkrD|j||\}}|j||\}}t|j|||j fi|j ||d}|rk|j |\} } n|j |\} } |j | _ | | fS)a* Returns traced concrete program and inner executable partial layer. Args: *args(tuple): input arguments values or InputSpec **kwargs(dict) : input kwargs values. Returns: Traced ConcreteProgram and executable translated Layer. rkFrlTr)rkrl)rrCpoplenrZ args_namererfr\r|rirget_program_without_cacher) rAr0r1rkrlrr^r_ cache_keyrrr4r4r5r:sN         z&ASTStaticFunction.get_concrete_programcCs ||j|\}}||fS)a Returns traced concrete program and inner executable partial layer by cached key. Args: cached_key(CacheKey): The cached key use to get concrete program. Returns: Traced ConcreteProgram and executable translated Layer. )rrr)rArrrr4r4r5rqs  z5ASTStaticFunction.get_concrete_program_with_cache_keycC t|jS)zS Returns the number of traced programs for the decorated function. )rrr@r4r4r5rs z"ASTStaticFunction.get_traced_countcCst|j}t|}|S)zW Returns the source code of transformed static function for debugging. )r[r}r$)rArErHr4r4r5rs zASTStaticFunction.codecCs |jddS)a Returns recent ConcreteProgram instance of decorated function. Examples: .. code-block:: python >>> # doctest: +SKIP('`paddle.jit.to_static` can not run in xdoctest') >>> import paddle >>> from paddle.jit import to_static >>> from paddle.static import InputSpec >>> paddle.disable_static() >>> def foo(x, y): ... z = x + y ... return z ... >>> # usage 1: >>> decorated_foo = to_static(foo, input_spec=[InputSpec([10], name='x'), InputSpec([10], name='y')]) >>> print(decorated_foo.concrete_program) >>> # usage 2: >>> decorated_foo = to_static(foo) >>> out_foo = decorated_foo(paddle.rand([10]), paddle.rand([10])) >>> print(decorated_foo.concrete_program) N)r)rr@r4r4r5rs z"ASTStaticFunction.concrete_programFc Cs|t|j}|}|jjdur;|dur*tt|t|jjs*td||jj|jj}|dur;t d|||du}|rQ|j ||| |d\}}|S|dkrt d|dkrht d|j||jj } |rsd | jd <|r~|| \}}|S|j| \}}|Std |j) a Returns recent ConcreteProgram instance of decorated function while specifying input_spec. If the self._function_spec already has input_spec, it will check the compatibility of input input_spec and the self._function_spec.input_spec. If input input_spec=None, then this method uses self._function_spec.input_spec args: input_spec (list[InputSpec], optional): Describes the input of the translate function. NzxThe `input_spec`: {} used to construct concrete_program is conflict with the `input_spec`: {} in `@paddle.jit.to_static`z You have specified `input_spec` both in function definition (higher priority) and `paddle.jit.save` (will be ignored.) Using: {} Ignore: {} )rkrlrrz3No input_spec is found, save cached program insteadrzcCurrent {} has more than one cached programs: {}, the last traced progam will be return by default.TrkzNo valid transformed program for {}. Please specific `input_spec` in `@paddle.jit.to_static` or feed input tensor to call the decorated function at once. )rrrrrr%r ValueErrorrvrrrr_recent_cache_keyr1r) rArrkrZcached_program_lenZdesired_input_specZhas_input_specrrrr4r4r5rsl     z5ASTStaticFunction.concrete_program_specify_input_speccC&||j}ddt|jD}|S)zK Returns input tensors of recent converted static program. cS g|] }t|tjtfr|qSr4rcrVariabler.0varr4r4r5  z,ASTStaticFunction.inputs..)rrrr)rArrr4r4r5rs zASTStaticFunction.inputscCr)zL Returns output tensors of recent converted static program. cSrr4rrr4r4r5rrz-ASTStaticFunction.outputs..)rrrr)rArrr4r4r5rs zASTStaticFunction.outputscCs||j}|j}|S)z? Returns recent converted static main program. )rrr)rArrr4r4r5r szASTStaticFunction.main_programcCrr.)rr@r4r4r5r*zASTStaticFunction.program_cachecCrr.)rr@r4r4r5r].rzASTStaticFunction.function_specr.r)rMrNrOrPrBrrrrrrrrrrrrr]rr4r4rr5r s.&7   T    rcCs(t|tjr|jstd|dSdS)z? Verifies the instance is initialized in dynamic mode. z `paddle.jit.to_static` is only available in dynamic mode. Please call `paddle.disable_static()` before initializing your Layer class `{}` . Because parameters of Layer class should be initialized firstly in dynamic mode while applying transformation.N)rcrrdZ_init_in_dynamic_moderrv)r`r4r4r5_verify_init_in_dynamic_mode3s rc@s*eZdZdZd ddZddZddZd S) HookHelperz Only For converting pre/post hooks operation in outermost layer while jit.save. Because hooks in sublayer have been processed automatically. FcCs4||_||_||_|ot|jtjo|jdk|_dS)Nforward)r3r`rkrcrrdrMneed_apply_hook)rAr3r`rkr4r4r5rBHs zHookHelper.__init__cCs`|js|S|dd}|jjD]}||j|}|dur't|ts%|f}|}q|jgt|S)z? Apply _forward_pre_hooks from outermost layer rN)rr`Z_forward_pre_hooksvaluesrctuplelist)rArZforward_pre_hook hook_resultr4r4r5apply_pre_hooksRs   zHookHelper.apply_pre_hookscCsT|js|S|dd}|jjD]}||j||}|dur |}q|d|j|S)z@ Apply _forward_post_hooks from outermost layer rNr)rr`Z_forward_post_hooksrinsert)rArrZforward_post_hookrr4r4r5apply_post_hookscs  zHookHelper.apply_post_hooksN)F)rMrNrOrPrBrrr4r4r4r5rBs   rc@s@eZdZgdZ d ddZeeddZeeddZdS) ConcreteProgramrrrstartup_program parametersrYname_generatorr1Nc Ks4||_||_||_||_||_||_||_||_dSr.r ) rArrr rYr rr r1r4r4r5rBs  zConcreteProgram.__init__cKst||j}t|}t|||dd}tt}} t|| tdd| ||} | ||} |rBt |gt | } t t |dZt t|dCz|| } | rb|| i| } n|| } || | } Wnty}zt|t|tjd}|r|d}~wwWdn1swYWdn1swYddlm}||}| durt| t t f pt| dk}|r| g} Wdn1swYWdn1swYt}td | | ||||| d |S)  Builds the main_program with specialized inputs and returns outputs of program as fetch_list. Args: func_spec(FunctionSpec): A FunctionSpec instance for decorated function. input_spec(list[InputSpec]): rkFTZ is_to_staticNr)_global_parameter_recorderr)rrr r rYrr r4)rr}r[rrC ir_staticProgram program_guardr Zpir_to_static_inputs_with_specrrr rrrr BaseExceptionrrrQrrZ pir_dy2static.parameter_recorderrrrcrr r ) func_specrinput_kwargs_specr`r1r}rE hook_helperrr  static_inputsrirrrrrall_parameters_and_buffersneed_wrap_into_listnew_name_generatorr4r4r5pir_from_func_specs       5z"ConcreteProgram.pir_from_func_speccKsLt||j}t|}t|||dd}tt}} tj|_t j| _t } t j t|| tddt| |||} |||} |r]t|gt| } tt|dZtt|dCz|| } | r}|| i| }n|| }|| |}Wnty}zt|t|tjd}|r|d}~wwWdn1swYWdn1swYt j !|}|durt"|ttf pt#|dk}|r|g}Wdn1swYWdn1swYWdn 1swYt$|}t%d| |||| || d|S) rrkFTrNr)rrr rYr rr r4)&rr}r[rrCrrZdefault_main_programZ random_seedZdefault_startup_programr r get_instance _amp_recordsclearrr UniqueNameGuardZto_static_inputs_with_specrrr rrrrrrrrQrr_params_recorderrrcrrr )rrrr`r1r}rErrr rrrirrrrrrr4r4r5from_func_specs       3zConcreteProgram.from_func_specr.) rMrNrOrxrB staticmethodr rr"r4r4r4r5r xs  cr cCst|S)zh because program is not deleted while calling from_func_spec. so it's ok to use id(program) )rn)programr4r4r5 _program_hashbsr%c@s(eZdZddZeddZddZdS)ParametersRecordercC i|_dSr. params_dictr@r4r4r5rBkrLzParametersRecorder.__init__cCs6t|}||jvrt|j|<|j|}||dSz@use the default_program as key, append param the parameter list.N)r%r)setadd)rAr$paramkeyparamsr4r4r5r,ns    zParametersRecorder.addcCs0|jt|}|durgS|jt|=t|Sr.)r)rCr%r)rAr$r/r4r4r5rws  zParametersRecorder.popN)rMrNrOrBr9r,rr4r4r4r5r&js   r&c@s8eZdZddZeddZddZddZd d Zd S) InplaceMapcCr'r.r(r@r4r4r5rBrLzInplaceMap.__init__cCs2t|}||jvri|j|<|j|}|||<dSr*)r%r))rAr$rnr-r.r/r4r4r5r,s     zInplaceMap.addcCs|jt|}|durdS||vrdS||}g}|j|vr8||||j}|j|vs#|D] }|||j<q:|Sr.)r)rCr%descrnrr{)rAr$rnr/Zroot_varsavedrr4r4r5rCs zInplaceMap.getcCs ||_dSr.r()rA checkpointr4r4r5restore_checkpoints zInplaceMap.restore_checkpointcCst|jSr.)dictr)rr@r4r4r5save_checkpointzInplaceMap.save_checkpointN) rMrNrOrBr9r,rCr4r6r4r4r4r5r0s   r0cs@eZdZgdZddZddZfddZfdd ZZS) FallbackProgramLayer) _instance_dy_funcrrrrcCs||_||_dSr.)r9r:)rArZdy_funcr4r4r5rBs zFallbackProgramLayer.__init__cCs |j|Sr.)r:)rArr4r4r5rrLzFallbackProgramLayer.__call__cs@||jvr td|dvr|jdurt|j|SdSt|SNzThere raises a exception after applying `@paddle.jit.to_static()` and already switch into fallback mode. You can't get attribute for a fallback program layer. Please check `to_static.error` file for detail.)r)rxrr9rQr __getattr__)rAr.rr4r5r<s    z FallbackProgramLayer.__getattr__csD||jvr td|dvr|jdurt|j||SdSt||Sr;)rxrr9rXr __setattr__)rAr.valuerr4r5r=s  z FallbackProgramLayer.__setattr__) rMrNrOrxrBrr<r=rr4r4rr5r8s    r8c@,eZdZddZddZddZddZd S) PirPrimHookercCsl||_t|_t|j tr$dd|jD|_WddSWddS1s/wYdS)NcSsh|] }t|r|qSr4)rZhas_custom_vjprropr4r4r5 s z)PirPrimHooker.__init__..)rr+ custom_vjpsr#r_is_all_prim_enabled global_blockopsrAZoriginal_programrr4r4r5rBs  "zPirPrimHooker.__init__cCsft|j$trtj|||jd}||fWdS||fWdS1s,wYdSN) blacklist)r#rr_is_fwd_prim_enabledr decomposerD)rAforward_programsrc_varsdst_varsr4r4r5before_append_backwards $z$PirPrimHooker.before_append_backwardcCst|j?tr8t|jdkr8t|j|}tj |||jd}t|j|}|||fWdS|||fWdS1sGwYdS)Nr) whitelist) r#rrrKrrDrFrGrrL)rA whole_programrNZforward_end_idxbackward_lengthrOnew_start_indexr4r4r5after_append_backwards  $z#PirPrimHooker.after_append_backwardcCsft|j$tr t|j|j}||_dt|j j f|_ WddS1s,wYdSNr) r#rrrKrrLr$Z out_valuesrrFrGZ forward_range)rA infer_programtargetsr4r4r5 after_infers $zPirPrimHooker.after_inferNrMrNrOrBrPrUrYr4r4r4r5r@s   r@c@s\eZdZdZdZddZddZddZd d Zd d Z d dZ ddZ ddZ ddZ dS)rzN Wrapper class for the program functions defined by dygraph function. zto_static.errorcCst|_d|_d|_dSr.) collections OrderedDict_caches _recent_keyrr@r4r4r5rBs  zProgramCache.__init__c Cs|jdj}|}z*trtjd |j|j|j|jd|j}ntj d |j|j|j|jd|j}WnCt yu}z7|rpt dt |jd}|t|Wdn1sYwYt|j|jj}||fWYd}~Sd}~ww|jd}t|jd|rts|jD]} | jtvrd| jvrt d| j| jqtrdd lm} | ||jdu} ndd lm} | ||jdu} t|9t rtr| !t"|j|n| !t#|j|Wd|| fSWd|| fSWd|| fS1swY|| fS) Nr)rrrr`aGException is thrown while applying @paddle.jit.to_static. It will fallback into dygraph mode for training. 1. You can check `to_static.error` file in current workspace directory for detail. 2. In fallback mode, you can only do training, can't call paddle.jit.save(). Please modify model code according `to_static.error` firstlywrrzHNow prim and cinn do not support -1 shape, but the shape of var {} is {}r)partial_program_fromr4)$r1Zbuild_cinn_passrr rr]r^r_r`r"rrropendy2static_error_filewritestrr8r}r)rZ list_varsrqr!rrvrpir_partial_programr`partial_programr#rrKZ set_hookerr@ PrimHooker) rArZ enable_primZenable_fallbackrrfpZfallback_layerrrr`rfr4r4r5 _build_onces                zProgramCache._build_oncecCsvt|ts tdt|t|}||_||_||jvr6|||j|<t |j}|t kr6t d |t |j|S)Nz.type(item) should be CacheKey, but received %szCurrent traced program number: {} > `max_tracing_count`:{}. Too much cached programs will bring expensive overhead. The reason may be: (1) passing tensors with different shapes, (2) passing python objects instead of tensors.)rcr\rr*rmrr^r]rirMAX_TRACED_PROGRAM_COUNTrrrv)rAitemitem_idZcurrent_tracing_countr4r4r5 __getitem__fs(    zProgramCache.__getitem__cCs |j|dS)N)r)ri)rArr4r4r5r}s z&ProgramCache.get_program_without_cachecCs>t|ts tdt|t|}||jvrtd|j|S)Nz9Input item's type should be FunctionSpec, but received %szaFailed to find program for input item, please decorate input function by `@paddle.jit.to_static`.)rcr\rr*rmr]r)rArkrlr4r4r5 get_programs   zProgramCache.get_programcCs6t|jdks Jd|jdusJ|j|j|jfS)Nrz(No valid cached program in ProgramCache.)rr]r^r@r4r4r5lasts zProgramCache.lastcCrr.)rr]r@r4r4r5__len__rLzProgramCache.__len__cCsdd|jDS)NcSsg|]\}\}}|qSr4r4)rr.cprr4r4r5rsz2ProgramCache.concrete_programs..)r]rr@r4r4r5concrete_programsszProgramCache.concrete_programscCst|_dSr.)r[r\r]r@r4r4r5rr7zProgramCache.clearN)rMrNrOrPrbrBrirmrrnrorprrrr4r4r4r5r sO  rc@r?) rgcCst|jdkr td||_t|_t|j!tr0dd| dj D|_WddSWddS1s;wYdS)Nrz4The primitive mode only support one block currently.cSsh|] }t|jr|jqSr4)rZhas_comp_grad_op_makerrqrAr4r4r5rCs  z&PrimHooker.__init__..r) rblocksrrr+rDr#rrEblockrGrHr4r4r5rBs   "zPrimHooker.__init__cCsJt|jtrt|j|jd|WdS1swYdSrI)r#rrrK_to_primrsrD)rArMr4r4r5rPs $z!PrimHooker.before_append_backwardcCst|j=t|dj|}tr"t|jdkr"t|j |dt|dj|}|dkr7t|j |d||fWdS1sEwYdS)Nr)rS) start_idx) r#rrrtrGrrKrDrurs)rArRZbackward_start_idxrSrTr4r4r5rUs $z PrimHooker.after_append_backwardcCsHt|jtrt|d|WdS1swYdSrV)r#rrrKrurt)rArWr4r4r5rYs $zPrimHooker.after_inferNrZr4r4r4r5rgs  rgc@sPeZdZdZeZdZeddZ e ddZ e ddZ d d Z d d ZdS) ra Class to translate dygraph function into static graph function. The object of this class is a singleton. Args: None. Returns: ProgramTranslator: the singleton object. Examples: .. code-block:: python >>> import paddle >>> # Two methods get same object because ProgramTranslator is a singleton >>> paddle.jit.dy2static.program_translator.ProgramTranslator() >>> paddle.jit.dy2static.program_translator.ProgramTranslator.get_instance() NcOs2|jdurtj|g|Ri||_d|j_|jSNF)r9object__new__ _initialized)rgr0r1r4r4r5rys zProgramTranslator.__new__cCsB|jdur|j||_Wd|jS1swY|jSr.)r9_singleton_lockrgr4r4r5rs   zProgramTranslator.get_instancecCs$|jdurd|j_|jdSdSrw)r9rzrBr|r4r4r5resets zProgramTranslator.resetcCs8|jrdSd|_t|_t|_t|_i|_d|_dS)NT) rzrrr&r!r0Z _inplace_maprrr@r4r4r5rBs zProgramTranslator.__init__cCst|dtd||_dS)NrProgramTranslator.enable)rboolr)rArr4r4r5enables r~)rMrNrOrPr7r8r{r9r9ryryrr}rBrr4r4r4r5rs    rcCs"t|dtdt}||dS)aw Enable or disable the converting from imperative to static graph by ProgramTranslator globally. Args: enable_to_static_bool (bool): True or False to enable or disable converting to static. Returns: None. Examples: .. code-block:: python >>> import paddle >>> @paddle.jit.to_static >>> def func(x): ... if paddle.mean(x) > 0: ... x_v = x - 1 ... else: ... x_v = x + 1 ... return x_v ... >>> paddle.jit.enable_to_static(False) >>> x = paddle.ones([1, 2]) >>> # ProgramTranslator is disabled so the func is run in dygraph >>> print(func(x)) Tensor(shape=[1, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[0., 0.]]) enable_to_static_boolzpaddle.jit.enable_to_staticN)rrrr)rrr4r4r5r s rrcCs$ddlm}|j|||||ddS)z'Swith to static graph and call to_prim.r)primapi)rJrQrvrSN)Zpaddle.incubate.autogradrZto_prim)rsrJrQrvrSrr4r4r5ru5s  ru)d __future__rr[rSr7rr;typingrZpaddle.pir.coreZpirrrZpaddlerrZ paddle.baserZpaddle.base.data_feederrZpaddle.base.dygraph.baser r r Zpaddle.base.unique_namer r r Zpaddle.frameworkrrZpaddle.nn.layerrZ paddle.pirrZ paddle.utilsrrrrrZast_transformerrr]rrrrZ origin_inforrrrfrreZPirPartialProgramLayerHookutilsr r!r"r#r$r%r&r'r(r)r*r+Zpaddle.static.amp.fp16_utilsr,__all__rjrRr9r:r8rVrWr[r\rrzrrrrrr r%r&r0r8r@rrgrr frozensetrur4r4r4r5s        8  Gpr F*6k,,2+B*