o "j%@sddlmZddlZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z ddl mZddlZddlmZmZddlmZmZmZddlmZdd lmZmZdd lmZmZdd lm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(dd l)m*Z*dd l+m,Z,ddl-m.Z.ddl/m0Z0ddl1m2Z2m3Z3ddl4m5Z5ddl6m7Z7m8Z8ddl9m:Z:m;Z;mZ>m?Z?ddl@mAZAmBZBmCZCmDZDmEZEe2ddZFe d[ddZGddZHd\dd ZId\d!d"ZJd#d$ZKe*eKZLd%d&ZMd]d)d*ZNd+d,ZO    d^d-d.ZPd_d/d0ZQGd1d2d2ZRd3d4ZSd5d6ZTd7d8ZUd`d:d;ZVdd?d?Z[d@dAZ\dBdCZ]dDdEZ^e*dFdGZ_dadLdMZ`e_ed_dNdOZae(dPdQZbe( TdbdUdVZcGdWdXdXZddYdZZedS)c) annotationsN) OrderedDict)contextmanager)Any)coredygraph) BuildStrategyCompiledProgramExecutionStrategy) check_type)program_desc_tracing_guardswitch_to_static_graph)Executor scope_guard) BlockEagerParamBase ParameterProgramVariable_current_expected_place_dygraph_guard_dygraph_tracer dygraph_only)wrap_decorator)in_dynamic_mode)Layer)save_inference_model)BooleanEnvironmentVariableEnvironmentVariableGuard) logging_utils)ConversionOptionsadd_ignore_module)ASTStaticFunctionProgramTranslatorStaticFunctionSymbolicStaticFunctionconvert_to_staticunwrap_decorators)INFER_MODEL_SUFFIXINFER_PARAMS_INFO_SUFFIXINFER_PARAMS_SUFFIXINFER_PROPERTY_SUFFIXTranslatedLayerZENABLE_FALL_BACKTvalueboolccs8tt| dVWddS1swYdSN)rENV_ENABLE_SOT)r.r2O/var/www/html/Deteccion_Ine/venv/lib/python3.10/site-packages/paddle/jit/api.pysot_mode_guardSs "r4cCs&t}||_t|dg|_||SNr)rdescrblocksZ_sync_with_cpp) program_descprogramr2r2r3create_program_from_descYs r:inputscCsTt|tr ||dSt|ttfr |D]}t|||qdStd|t|)NzlThe type of 'each element of {}' in paddle.jit.api.TracedLayer.trace must be base.Variable, but received {}.) isinstancerappendlisttuple _extract_vars TypeErrorformattype)r; result_listerr_tagvarr2r2r3r@as r@cCsg}t||||Sr0)r@)r;rErDr2r2r3 extract_varsos rGcsfdd}|S)a+ Converts imperative dygraph APIs into declarative function APIs. Decorator @dygraph_to_static_func only converts imperative dygraph APIs into declarative net-building APIs, which means it doesn't return immediate digital result as imperative mode. Users should handle Program and Executor by themselves. Note: This decorator is NOT our recommended way to transform imperative function to declarative function. We will remove this decorator after we finalize cleaning up code. Args: dygraph_func (callable): callable imperative function. Returns: Callable: converting imperative dygraph APIs into declarative net-building APIs. Examples: .. code-block:: python >>> # doctest: +SKIP('`paddle.jit.dygraph_to_static_func` can not run in xdoctest') >>> import paddle >>> from paddle.jit.api import dygraph_to_static_func >>> @dygraph_to_static_func ... def func(x): ... if paddle.mean(x) < 0: ... x_v = x - 1 ... else: ... x_v = x + 1 ... ... return x_v ... >>> paddle.enable_static() >>> x = paddle.full(shape=[3, 3], fill_value=0, dtype='float64') >>> x_v = func(x) >>> exe = paddle.static.Executor(paddle.CPUPlace()) >>> out = exe.run(fetch_list=[x_v]) >>> print(out[0]) [[1. 1. 1.] [1. 1. 1.] [1. 1. 1.]] cs@t}ts |jstd|i|St}||i|S)NzThe decorator 'dygraph_to_static_func' doesn't work in dygraph mode or set 'paddle.jit.enable_to_static' to False. We will just return dygraph output.)r$renable_to_staticr warnr')argskwargsZprogram_translator static_func dygraph_funcr2r3__impl__s z*_dygraph_to_static_func_..__impl__r2)rNrOr2rMr3_dygraph_to_static_func_us 2 rPcCs6d}|j|_||_||_|j|_t|dr|j|_|S)z Copies some necessary attributes from original function into decorated function. Args: original_func(callable): the original decorated function. decorated_obj(StaticFunction): the target decorated StaticFunction object. to_static __module__)__name__Z_decorator_name __wrapped____doc__hasattrrR) original_func decorated_objZdecorator_namer2r2r3copy_decorator_attrss rYmodules list[Any]cCs t|dS)a/ Adds modules that ignore transcription. Builtin modules that have been ignored are collections, pdb, copy, inspect, re, numpy, logging, six Args: modules (List[Any]): Ignored modules that you want to add Examples: .. code-block:: python >>> import scipy >>> import astor >>> import paddle >>> from paddle.jit import ignore_module >>> modules = [ ... scipy, ... astor, ... ] >>> ignore_module(modules) N)r")rZr2r2r3 ignore_modules r\cCs.|dvr td|d|dkrd|_dSdS)N)CINNNz@The backend of to_static should be 'CINN' or None, but received .r]T) ValueErrorZbuild_cinn_pass)backendbuild_strategyr2r2r3_check_and_set_backends  rbc s|dd|ddfdd}pttts*tdtjt|durVt|trRt|j t rJ|j j}t d|||j |_ |S||S|S) a Converts dynamic graph APIs into static graph function APIs. Decorator @to_static handles the Program and Executor of static graph mode and returns the result as dynamic graph Tensor(s). Users could use the returned dynamic graph Tensor(s) to do dynamic graph training, inference, or other operations. If the decorated function calls other dynamic graph function, the called one will be converted into static graph function as well. Args: function (callable): Callable dynamic graph function. If it used as a decorator, the decorated function will be parsed as this parameter. input_spec (list[InputSpec]|tuple[InputSpec]): list/tuple of InputSpec to specific the shape/dtype/name information of each input Tensor. build_strategy (BuildStrategy|None): This argument is used to compile the converted program with the specified options, such as operators' fusion in the computational graph and memory optimization during the execution of the computational graph. For more information about build_strategy, please refer to :code:`paddle.static.BuildStrategy`. The default is None. backend(str, Optional): Specifies compilation backend, which can be `CINN` or None. When backend is `CINN`, CINN compiler will be used to speed up training and inference. kwargs: Support keys including `property`, set `property` to True if the function is python property. Returns: Tensor(s): containing the numerical result. Examples: .. code-block:: python >>> # doctest: +SKIP('`paddle.jit.to_static` can not run in xdoctest') >>> import paddle >>> from paddle.jit import to_static >>> @to_static >>> def func(x): ... if paddle.mean(x) < 0: ... x_v = x - 1 ... else: ... x_v = x + 1 ... return x_v ... >>> x = paddle.ones([1, 2], dtype='float32') >>> x_v = func(x) >>> print(x_v) Tensor(shape=[1, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[2., 2.]]) propertyF full_graphNc sjdur t}| tjdkrstddttd}t|\}}t |||dd}|S)zN Decorates a python function into a ASTStaticFunction object. N) zTfull_graph=False is not supported in Python 3.12+. Set full_graph=True automaticallyT)FT)function input_specrarcr`)rWrX) r1getsys version_infowarningsrIr&r#r(rY)Z python_funcflagZ StaticClass_Z static_layerr`rardrhrcr2r3 decorated+s2  zto_static..decoratedzURequired type(build_strategy) shall be `paddle.static.BuildStrategy`, but received {}zb`{}.forward` has already been decorated somewhere. It will be redecorated to replace previous one.)rirr<rArBrCrSrbrforwardr% __class__r rI)rgrhrar`rKrp class_namer2ror3rQs0 8  &     rQcCs$|durtStdd}|||S)a A Decorator to suppresses the convertion of a function. Args: func(callable): The function to decorate. Returns: callable: A function which won't be converted in Dynamic-to-Static. Examples: .. code-block:: python >>> # doctest: +SKIP('`paddle.jit.to_static` can not run in xdoctest') >>> import paddle >>> @paddle.jit.not_to_static ... def func_not_to_static(x): ... res = x - 1 ... return res >>> @paddle.jit.to_static ... def func(x): ... if paddle.mean(x) < 0: ... out = func_not_to_static(x) ... else: ... out = x + 1 ... return out ... >>> x = paddle.ones([1, 2], dtype='float32') >>> out = func(x) >>> print(out) Tensor(shape=[1, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[2., 2.]]) NT)Z not_convert) not_to_staticr!attach)funcoptionsr2r2r3rtms #  rtc@s|eZdZddZeddZejddZeddZejddZed d Zejd d Zed d Z e jdd Z dS)_SaveLoadConfigcCsFd|_d|_d|_d|_d|_d|_d|_d|_d|_d|_ d|_ dS)NFT) _output_spec_model_filename_params_filenameZ_separate_params_keep_name_tableZ_export_for_deployment _program_only with_hookcombine_paramsinput_names_after_pruneskip_prune_programselfr2r2r3__init__s z_SaveLoadConfig.__init__cC|jSr0)ryrr2r2r3 output_specz_SaveLoadConfig.output_speccCs0|durdSt|tstdtt||_dS)NzIThe config `output_spec` should be 'list', but received input type is %s.) r<r>rArCinputreagerTensorry)rspecrFr2r2r3rs  cCrr0)rzrr2r2r3model_filenamerz_SaveLoadConfig.model_filenamecCD|durdSt|tstdt|t|dkrtd||_dS)NzKThe config `model_filename` should be str, but received input's type is %s.rz,The config `model_filename` is empty string.)r<strrArClenr_rzrfilenamer2r2r3r   cCrr0)r{rr2r2r3params_filenamerz_SaveLoadConfig.params_filenamecCr)NzLThe config `params_filename` should be str, but received input's type is %s.rz-The config `params_filename` is empty string.)r<rrArCrr_r{rr2r2r3rrcCrr0)r|rr2r2r3keep_name_tablerz_SaveLoadConfig.keep_name_tablecCs0|durdSt|tstdt|||_dS)NzSThe config `keep_name_table` should be bool value, but received input's type is %s.)r<r/rArCr|)rr.r2r2r3rs  N) rSrR __qualname__rrcrsetterrrrr2r2r2r3rxs$       rxcCsgd}|D] }||vrtd|qt}|dd|_|dd|_|dd|_|dd|_|d d|_|d d|_|d d|_ |S) N)rr~r clip_extra skip_forwardrrzAThe additional config (%s) of `paddle.jit.save` is not supported.rr~FrrTrrr) r_rxrirr~rrrrrconfigsZsupported_configskeyZ inner_configr2r2r3_parse_save_configss( rcCsLddg}|D] }||vrtd|qt}|dd|_|dd|_|S)NrrzAThe additional config (%s) of `paddle.jit.load` is not supported.)r_rxrirrrr2r2r3_parse_load_configsrcsd}d}durfdd|D}g}ddtj|D}|dur$|Sdd|D}t|t|krX|}|D]}|jdurFt||q7|j|vrTt||jq7 q7|S|D]}|jdurgt|||j|vrst||j||jqZ|S)NzThe %s's name is None. When using jit.save, please set InputSepc's name in to_static(input_spec=[]) and jit.save(input_spec=[]) and make sure they are consistent.zThe tensor `%s` does not exists. Please make sure the name of InputSpec or example Tensor in input_spec is the same as the name of InputSpec in `to_static` decorated on the Layer.forward method.cs(g|]}t|tjjr|jvr|qSr2)r<paddlestatic InputSpecname).0xrr2r3 @s  z(_get_input_var_names..cSsg|] }t|tr|jqSr2)r<rr)rrFr2r2r3rHs cSsg|] }t|tjjr|qSr2)r<rrr)rrr2r2r3rRs  ) rutilsflattenrrrlrIr_r=)r;rhrZname_none_errorname_no_exists_errorrDinput_var_namesrr2rr3_get_input_var_names2sB        rFcCsd}|r |r tdg}t}tj|D] }t|tr!|||j<q|dur.t| }|S|durTt |t |krTt| }|D]}|j|vrQt ||jqB|S|D]}|j|vrdt ||j|||jqV|S)NzThe tensor `%s` does not exists. Please make sure the name of example Tensor in configs.output_spec is the output tensor of Layer.forward method.z`Currently not support specify output_spec while founding pre/post hooks in your outermost layer.) RuntimeErrorrrrrr<rrr>valuesrrlrIr_r=)outputsrr~rrDZoutput_vars_dictrFr2r2r3_get_output_varsss6       rcCs|t}tj|}tj|}|r|rtd|d|d|s)|s)td||rYtj|}tj|}|jdurAt d|t|_|j durPt d|t |_ ||fS|}||fS)NzThe z .pdmodel and z directory exist at the same time, don't know which one to load, please make sure that the specified target of ``path`` is unique.zThe ``path`` (%s) to load model not exists. Please make sure that *.pdmodel exists or don't using ``skip_forward=True`` to jit.save.zqWhen loading the result saved with the specified file prefix, the ``model_filename`` config does not take effect.zrWhen loading the result saved with the specified file prefix, the ``params_filename`` config does not take effect.) r)ospathexistsisdirr_basenamedirnamerrlrIrr+)rconfigZprefix_format_pathZprefix_format_existZdirectory_format_exist file_prefix model_pathr2r2r3_build_load_path_and_configs:        rc@s eZdZdZddZddZdS)HookRemoveHelperz3A HookRemoveHelper that can be used to remove hook.cCs ||_dSr0)_hook)rhookr2r2r3rs zHookRemoveHelper.__init__cCst|jdSr0)_remove_save_pre_hookrrr2r2r3removeszHookRemoveHelper.removeN)rSrRrrUrrr2r2r2r3rs rcCs*t|tvr t|tt|S)a Register a save pre-hook for `paddle.jit.save`. This hook will be executed before `save` function has been invoked. hook(layer, input_spec, configs) -> None - layer (Layer|function): This argument is corresponding to `layer` in `paddle.jit.save`. - input_spec (list or tuple[InputSpec|Tensor|Python built-in variable]): This argument is corresponding to `input_spec` in `paddle.jit.save`. - configs (dict): This argument is corresponding to `configs` in `paddle.jit.save`. Args: hook(function): a function registered as a save pre-hook Returns: HookRemoveHelper: a HookRemoveHelper object that can be used to remove the added hook by calling `hook_remove_helper.remove()`. Examples: .. code-block:: python >>> # doctest: +SKIP('`paddle.jit.api.to_static` can not run in xdoctest') >>> import numpy as np >>> import paddle >>> IMAGE_SIZE = 256 >>> CLASS_NUM = 10 >>> class LinearNet(paddle.nn.Layer): ... def __init__(self): ... super().__init__() ... self._linear = paddle.nn.Linear(IMAGE_SIZE, CLASS_NUM) ... ... def forward(self, x): ... return self._linear(x) ... >>> saving_count = 0 >>> def save_pre_hook(layer, input_spec, configs): ... global saving_count ... saving_count += 1 ... >>> remove_handler = paddle.jit.api._register_save_pre_hook(save_pre_hook) >>> layer = LinearNet() >>> paddle.jit.save(layer, "/tmp", [paddle.static.InputSpec(shape=[-1, IMAGE_SIZE])]) >>> print(saving_count) 1 >>> remove_handler.remove() >>> paddle.jit.save(layer, "/tmp", [paddle.static.InputSpec(shape=[-1, IMAGE_SIZE])]) >>> print(saving_count) 1 )_save_pre_hooks_lockacquire_save_pre_hooksr=releaserrr2r2r3_register_save_pre_hooks 5 rcCstttdSr0)rrrclearrr2r2r2r3_clear_save_pre_hookss rcCs&t|tvr t|tdSr0)rrrrrrr2r2r3rs  rcsdfdd }|S)Ncs.tD]}||||q|||fi|dSr0)r)layerrrhrrrvr2r3wrapper%sz$_run_save_pre_hooks..wrapperr0r2)rvrr2rr3_run_save_pre_hooks#srrr property_valslist[tuple[Any, str]]cCszdd}t|d*}tjj}|D]}|d|d}}||||q||WddS1s6wYdS)zclass property serialization. Args: filename (str): *.meta property_vals (list[tuple[Any, str]]): class property. cSst|tr |||dSt|tr|||dSt|tr'|||dSt|ttfr]t|dtr=| ||dSt|dtrL| ||dSt|dtr[| ||dSdSt dt |)NrzNote support val type: )r<floatZ set_floatintZset_intrZ set_stringr?r>Z set_floatsZset_intsZ set_stringsr_rC)metarvalr2r2r3 set_property6s   z$_save_property..set_propertywbrrN)openr frameworkrPropertywriteZserialize_to_string)rrrfritemrrr2r2r3_save_property.s  "rc0 sft}to t}|jstdt|ttfs&t |s&t dt |t |s0t|tr5t dt|tjr?|j}n|}tj|}|dkrOtdtj|}|rbtj|sbt|d} |durt|trt|D]} t|| d} t| trd| krtdt |qqt|ttfst d t |g} tj|D](} t| tjj r| !| qt| tj"j#t$fr| !tjj %| q| !| qt&|}|j'} |j(}|rd |_)t*}i}t|trtt+t|}t,|}|j-s|j.rd } n|g}i}g}d|D]} t|trdt/t|| d} t| tr;| j0r2| }|!||j1j2d | fq| j3| | |d nrd| krb|j4rFq| rPtj5|| } t6|j7| d d }|j3| |d d} nKqt| trt/| } | j0r~| }|!|| fq| j3| |dn't/| } | rtj5|| } t6| | d d }|j8|j9durt d|dd}t|tr|:}nt| tr| j9r| j9:}|ri}i}|;D]\}} ||| j<<| || j<<qt=>jj?D]^}|j tj@jAjBkr |CD}|E|j<}|F|n|E|j<G}||j<CG}|H||j<|vrIi} |j<|vr4||j<| d<|jI| d<t|tJrD|jK| d<| ||j<<qWdn 1sVwYtLjM| |jN}!tOjP|jQ| }"|}#d| ksxt|ts|tR}$|tS}%|}&n|d | tR}$|d | tS}%|d | }tjT|#|}tU|$fdd|!D}'tV||'|"tWtXjYZ|j[|j\dWdn 1swY|rjYZ}(|(]|!|"}(|(j^D] })|_|)j`qq|rJt,|;ddd}g}*|D] \}+} |*!| q|tS}%tU|tjjatWtX|#ttbtjcjdje|*|%dWdn 1s3wYtjTtjf|#|tg},th|,|d}-durajYiD] } |-t| tjO}-qVt|tsj|-r|rtU|3|tk}.tl|.d}/tmjn||/ddWdn1swYWddSWddS1swYdSdSdS)a Saves input Layer or function as ``paddle.jit.TranslatedLayer`` format model, which can be used for inference or fine-tuning after loading. It will save the translated program and all related persistable variables of input Layer to given ``path`` . ``path`` is the prefix of saved objects, and the saved translated program file suffix is ``.pdmodel`` , the saved persistable variables file suffix is ``.pdiparams`` , and here also saved some additional variable description information to a file, its suffix is ``.pdiparams.info``, these additional information is used in fine-tuning. The saved model can be loaded by follow APIs: - ``paddle.jit.load`` - ``paddle.static.load_inference_model`` - Other C++ inference APIs .. note:: When using ``paddle.jit.save`` to save a function, parameters will not be saved. If you have to save the parameter, please pass the Layer containing function and parameter to ``paddle.jit.save``. Args: layer (Layer|function): The Layer or function to be saved. path (str): The path prefix to save model. The format is ``dirname/file_prefix`` or ``file_prefix``. input_spec (list or tuple[InputSpec|Tensor|Python built-in variable], optional): Describes the input of the saved model's forward method, which can be described by InputSpec or example Tensor. Moreover, we support to specify non-tensor type argument, such as int, float, string, or list/dict of them.If None, all input variables of the original Layer's forward method would be the inputs of the saved model. Default None. **configs (dict, optional): Other save configuration options for compatibility. We do not recommend using these configurations, they may be removed in the future. If not necessary, DO NOT use them. Default None. The following options are currently supported: (1) output_spec (list[Tensor]): Selects the output targets of the saved model. By default, all return variables of original Layer's forward method are kept as the output of the saved model. If the provided ``output_spec`` list is not all output variables, the saved model will be pruned according to the given ``output_spec`` list. Returns: None Examples: .. code-block:: python >>> # doctest: +SKIP('`paddle.jit.to_static` can not run in xdoctest') >>> # example 1: save layer >>> import numpy as np >>> import paddle >>> import paddle.nn as nn >>> import paddle.optimizer as opt >>> BATCH_SIZE = 16 >>> BATCH_NUM = 4 >>> EPOCH_NUM = 4 >>> IMAGE_SIZE = 784 >>> CLASS_NUM = 10 >>> # define a random dataset >>> class RandomDataset(paddle.io.Dataset): ... def __init__(self, num_samples): ... self.num_samples = num_samples ... ... def __getitem__(self, idx): ... image = np.random.random([IMAGE_SIZE]).astype('float32') ... label = np.random.randint(0, CLASS_NUM - 1, (1, )).astype('int64') ... return image, label ... ... def __len__(self): ... return self.num_samples >>> class LinearNet(nn.Layer): ... def __init__(self): ... super().__init__() ... self._linear = nn.Linear(IMAGE_SIZE, CLASS_NUM) ... ... @paddle.jit.to_static ... def forward(self, x): ... return self._linear(x) >>> def train(layer, loader, loss_fn, opt): ... for epoch_id in range(EPOCH_NUM): ... for batch_id, (image, label) in enumerate(loader()): ... out = layer(image) ... loss = loss_fn(out, label) ... loss.backward() ... opt.step() ... opt.clear_grad() ... print("Epoch {} batch {}: loss = {}".format( ... epoch_id, batch_id, np.mean(loss.numpy()))) >>> # 1. train & save model. >>> # create network >>> layer = LinearNet() >>> loss_fn = nn.CrossEntropyLoss() >>> adam = opt.Adam(learning_rate=0.001, parameters=layer.parameters()) >>> # create data loader >>> dataset = RandomDataset(BATCH_NUM * BATCH_SIZE) >>> loader = paddle.io.DataLoader(dataset, ... batch_size=BATCH_SIZE, ... shuffle=True, ... drop_last=True, ... num_workers=2 ... ) >>> # train >>> train(layer, loader, loss_fn, adam) >>> # save >>> path = "example_model/linear" >>> paddle.jit.save(layer, path) >>> # example 2: save function >>> import paddle >>> from paddle.static import InputSpec >>> def save_function(): ... @paddle.jit.to_static ... def fun(inputs): ... return paddle.tanh(inputs) ... ... path = 'test_jit_save_load_function_1/func' ... inps = paddle.rand([3, 6]) ... origin = fun(inps) ... ... paddle.jit.save(fun, path) ... load_func = paddle.jit.load(path) ... ... load_result = load_func(inps) ... print((load_result - origin).abs().max() < 1e-10) >>> save_function() zUThe paddle.jit.save doesn't work when setting 'paddle.jit.enable_to_static' to False.z\The input of paddle.jit.save should be 'Layer' or 'Function', but received input type is %s.aWhat you save is a function, and `jit.save` will generate the name of the model file according to `path` you specify. When loading these files with `jit.load`, you get a `TranslatedLayer` whose inference result is the same as the inference result of the function you saved.The input path MUST be format of dirname/file_prefix [dirname\file_prefix in Windows system], but received file_prefix is empty string.NrqzIf there are static functions other than 'forward' that need to be saved, the input 'input_spec' should be None, but received the type of 'input_spec' is %s.zLThe input input_spec should be 'list', but received input_spec's type is %s.Tr^)r~ is_prim_infer)rhrd)rzw`jit.save` will only save the `Program`, not the parameters. If you have to save the parameters, please make sure that zW is a member function of `paddle.nn.Layer` and the saved parameters are in `state_dict`structured_name stop_gradient trainablecsg|] }j|qSr2) main_program global_blockrF)rrconcrete_programr2r3rszsave..) path_prefix feed_vars fetch_varsexecutorr9rrcSs|dSr5r2)rr2r2r3 szsave..)r)rvarsrFr)protocol)or$rZ_is_fwd_prim_enabledZ_is_bwd_prim_enabledrHrr<rr%inspect isfunctionrArCrlrIrZ DataParallelZ_layersrrrr_rrmakedirsdirgetattrr>r?rrrrr=rrrZ from_tensorrr~rr}ScopesetsortedZ_forward_pre_hooksZ_forward_post_hooksget_ast_static_functionZ is_propertyrrrSZ#concrete_program_specify_input_specrZpack_sequence_asrQrqr_class_instanceZto_static_state_dictitemsrrguard parametersZVarDescZVarTypeZVOCABr.Zget_map_tensorrFZ set_vocab get_tensor_share_data_withrrrrr;rrrrr)r+joinrrrrrclonerrZ_prune_with_inputr7updaterZ save_varsfilterrZio_utilsZis_persistablenormpathr,rZ list_varsrr*rpickledump)0rrrhrZprog_translatorrZ inner_layerrrZinner_input_specZ attr_funcrLrFr~rscopeZextra_var_infoZ functionsZ combine_varsrZ immediate_valZstatic_forwardZstatic_functionZdygraph_state_dictZstate_names_dictZstate_var_dictrZparam_or_bufferZ scr_tensorZtgt_varZparam_or_buffer_tensor src_tensorZextra_info_dictrZ output_varsrrrrZ input_varsZclone_main_programblockZ ordered_varsrZproperty_save_pathZcontain_parameterZextra_var_info_pathrr2rr3saveOs                                      )               $rcKs"t|}t||\}}t||S)a& :api_attr: imperative Load model saved by ``paddle.jit.save`` or ``paddle.static.save_inference_model`` or paddle 1.x API ``paddle.static.save_inference_model`` as ``paddle.jit.TranslatedLayer``, then performing inference or fine-tune training. .. note:: If you load model saved by ``paddle.static.save_inference_model`` , there will be the following limitations when using it in fine-tuning: 1. Imperative mode do not support LoDTensor. All original model's feed targets or parametars that depend on LoD are temporarily unavailable. 2. All saved model's feed targets need to be passed into TranslatedLayer's forward function. 3. The variable's ``stop_gradient`` information is lost and can not be recovered. 4. The parameter's ``trainable`` information is lost and can not be recovered. Args: path (str): The path prefix to load model. The format is ``dirname/file_prefix`` or ``file_prefix`` . **configs (dict, optional): Other load configuration options for compatibility. We do not recommend using these configurations, they may be removed in the future. If not necessary, DO NOT use them. Default None. The following options are currently supported: (1) model_filename (str): The inference model file name of the paddle 1.x ``save_inference_model`` save format. Default file name is :code:`__model__` . (2) params_filename (str): The persistable variables file name of the paddle 1.x ``save_inference_model`` save format. No default file name, save variables separately by default. Returns: TranslatedLayer: A Layer object can run saved translated model. Examples: 1. Load model saved by ``paddle.jit.save`` then performing inference and fine-tune training. .. code-block:: python :name: code-example1 >>> # doctest: +SKIP('`paddle.jit.to_static` can not run in xdoctest') >>> import numpy as np >>> import paddle >>> import paddle.nn as nn >>> import paddle.optimizer as opt >>> BATCH_SIZE = 16 >>> BATCH_NUM = 4 >>> EPOCH_NUM = 4 >>> IMAGE_SIZE = 784 >>> CLASS_NUM = 10 >>> # define a random dataset >>> class RandomDataset(paddle.io.Dataset): ... def __init__(self, num_samples): ... self.num_samples = num_samples ... ... def __getitem__(self, idx): ... image = np.random.random([IMAGE_SIZE]).astype('float32') ... label = np.random.randint(0, CLASS_NUM - 1, (1, )).astype('int64') ... return image, label ... ... def __len__(self): ... return self.num_samples >>> class LinearNet(nn.Layer): ... def __init__(self): ... super().__init__() ... self._linear = nn.Linear(IMAGE_SIZE, CLASS_NUM) ... ... @paddle.jit.to_static ... def forward(self, x): ... return self._linear(x) ... >>> def train(layer, loader, loss_fn, opt): ... for epoch_id in range(EPOCH_NUM): ... for batch_id, (image, label) in enumerate(loader()): ... out = layer(image) ... loss = loss_fn(out, label) ... loss.backward() ... opt.step() ... opt.clear_grad() ... print("Epoch {} batch {}: loss = {}".format( ... epoch_id, batch_id, np.mean(loss.numpy()))) >>> # 1. train & save model. >>> # create network >>> layer = LinearNet() >>> loss_fn = nn.CrossEntropyLoss() >>> adam = opt.Adam(learning_rate=0.001, parameters=layer.parameters()) >>> # create data loader >>> dataset = RandomDataset(BATCH_NUM * BATCH_SIZE) >>> loader = paddle.io.DataLoader( ... dataset, ... batch_size=BATCH_SIZE, ... shuffle=True, ... drop_last=True, ... num_workers=2 ... ) >>> # train >>> train(layer, loader, loss_fn, adam) >>> # save >>> path = "example_model/linear" >>> paddle.jit.save(layer, path) >>> # 2. load model >>> # load >>> loaded_layer = paddle.jit.load(path) >>> # inference >>> loaded_layer.eval() >>> x = paddle.randn([1, IMAGE_SIZE], 'float32') >>> pred = loaded_layer(x) >>> # fine-tune >>> loaded_layer.train() >>> adam = opt.Adam(learning_rate=0.001, parameters=loaded_layer.parameters()) >>> train(loaded_layer, loader, loss_fn, adam) 2. Load model saved by ``paddle.static.save_inference_model`` then performing and fine-tune training. .. code-block:: python :name: code-example2 >>> # doctest: +SOLO('can not use multiprocessing testing `DataLoader`') >>> import numpy as np >>> import paddle >>> import paddle.static as static >>> import paddle.nn as nn >>> import paddle.optimizer as opt >>> import paddle.nn.functional as F >>> BATCH_SIZE = 16 >>> BATCH_NUM = 4 >>> EPOCH_NUM = 4 >>> IMAGE_SIZE = 784 >>> CLASS_NUM = 10 >>> # define a random dataset >>> class RandomDataset(paddle.io.Dataset): ... def __init__(self, num_samples): ... self.num_samples = num_samples ... ... def __getitem__(self, idx): ... image = np.random.random([IMAGE_SIZE]).astype('float32') ... label = np.random.randint(0, CLASS_NUM - 1, (1, )).astype('int64') ... return image, label ... ... def __len__(self): ... return self.num_samples >>> paddle.enable_static() >>> image = static.data(name='image', shape=[None, 784], dtype='float32') >>> label = static.data(name='label', shape=[None, 1], dtype='int64') >>> pred = static.nn.fc(x=image, size=10, activation='softmax') >>> loss = F.cross_entropy(input=pred, label=label) >>> avg_loss = paddle.mean(loss) >>> optimizer = paddle.optimizer.SGD(learning_rate=0.001) >>> optimizer.minimize(avg_loss) >>> place = paddle.CPUPlace() >>> exe = static.Executor(place) >>> exe.run(static.default_startup_program()) >>> # create data loader >>> dataset = RandomDataset(BATCH_NUM * BATCH_SIZE) >>> loader = paddle.io.DataLoader(dataset, ... feed_list=[image, label], ... places=place, ... batch_size=BATCH_SIZE, ... shuffle=True, ... drop_last=True, ... return_list=False, ... num_workers=2 ... ) >>> # 1. train and save inference model >>> for data in loader(): ... exe.run( ... static.default_main_program(), ... feed=data, ... fetch_list=[avg_loss] ... ) >>> model_path = "fc.example.model" >>> paddle.static.save_inference_model( ... model_path, ... [image], ... [pred], ... exe ... ) >>> # 2. load model >>> # enable dygraph mode >>> paddle.disable_static(place) >>> # load >>> fc = paddle.jit.load(model_path) >>> # inference >>> fc.eval() >>> x = paddle.randn([1, IMAGE_SIZE], 'float32') >>> pred = fc(x) >>> # fine-tune >>> fc.train() >>> loss_fn = nn.CrossEntropyLoss() >>> adam = opt.Adam(learning_rate=0.001, parameters=fc.parameters()) >>> loader = paddle.io.DataLoader(dataset, ... places=place, ... batch_size=BATCH_SIZE, ... shuffle=True, ... drop_last=True, ... num_workers=2 ... ) >>> for epoch_id in range(EPOCH_NUM): ... for batch_id, (image, label) in enumerate(loader()): ... out = fc(image) ... loss = loss_fn(out, label) ... loss.backward() ... adam.step() ... adam.clear_grad() ... print("Epoch {} batch {}: loss = {}".format( ... epoch_id, batch_id, np.mean(loss.numpy()))) )rrr-Z _construct)rrrrr2r2r3loadAsm rfeed_fetch_t_cCst|tsJt|ttfs|g}t}t|}td0||}t|ttfs.|g}n|}t|dd} |||| ||\} } } } | Wdn1sQwYt d t | }Wdn1siwY||| | | fS)NTr)rE) r<rr>r?rZ_get_program_desc_tracerrGr Zcreate_program_descresetrr:)rr;Z feed_prefixZ fetch_prefixZ tmp_prefixZtracerZvar_listZoriginal_outputsrZout_varsr8 feed_names fetch_namesrr9r2r2r3_trace3s2       r c@s~eZdZdZddZeddZdddZee d d Z dd d Z e ddZ ddZe ddZddZe dddZd S) TracedLayera :api_attr: imperative TracedLayer is used to convert a forward dygraph model to a static graph model. This is mainly used to save the dygraph model for online inference using C++. Besides, users can also do inference in Python using the converted static graph model, which usually has better performance than the original dygraph model. TracedLayer would run the static graph model using :code:`Executor` and :code:`CompiledProgram` . The static graph model would share parameters with the dygraph model. All TracedLayer objects should not be created by constructor and should be created by static method :code:`TracedLayer.trace(layer, inputs)` . The TracedLayer can only be used to convert the data-independent dygraph model into the static graph model, which means the dygraph model should be independent with the tensor data and shape. cCs~||_||_||_||_t|_t|_|D]}| }|j |j  }| |qt|j|_d|_d|_d|_dSr0)_program _feed_names _fetch_names_paramsrZ_placerr_scoper.rrFrrr_exe_compiled_program_build_strategy_exec_strategy)rr9rr r prZ dst_tensorr2r2r3rns     zTracedLayer.__init__cCrr0)rrr2r2r3r9rzTracedLayer.programTcCsDt|jjD]}|j|}|jD] }|dr|d|qqdS)Nis_test)rangerZ num_blocksropsZhas_attrZ _set_attr)rrZblock_idropr2r2r3_switchs    zTracedLayer._switchcCsFt|tsJdt|t||\}}}}}t||||}||fS)a{ This method is the only allowed method to create TracedLayer object. It would call the :code:`layer(*inputs)` method to run the dygraph model and convert it into a static graph model. Args: layer (paddle.nn.Layer): the layer object to be traced. inputs (list(Tensor)|tuple(Tensor)|Tensor): the input tensors of the layer object. Returns: tuple: A tuple of 2 items, whose the first item is the output of :code:`layer(*inputs)` , and the second item is the created TracedLayer object. Examples: .. code-block:: python >>> import paddle >>> class ExampleLayer(paddle.nn.Layer): ... def __init__(self): ... super().__init__() ... self._fc = paddle.nn.Linear(3, 10) ... ... def forward(self, input): ... return self._fc(input) >>> layer = ExampleLayer() >>> in_var = paddle.uniform(shape=[2, 3], dtype='float32') >>> out_dygraph, static_layer = paddle.jit.api.TracedLayer.trace(layer, inputs=[in_var]) >>> # run the static graph model using Executor inside >>> out_static_graph = static_layer([in_var]) >>> print(len(out_static_graph)) # 1 >>> print(out_static_graph[0].shape) # (2, 10) >>> # save the static graph model for inference >>> static_layer.save_inference_model('./saved_infer_model') zaThe type of 'layer' in paddle.jit.api.TracedLayer.trace must be paddle.nn.Layer, but received {}.)r<rrBrCr r )rr;ZoutsprogfeedfetchrZtracedr2r2r3traces.zTracedLayer.traceNcCsj|jdus Jdt|tdtfsJdt|t|tdtfs-Jdt|||_||_dS)a Set the strategies when running static graph model. Args: build_strategy (BuildStrategy, optional): build strategy of :code:`CompiledProgram` inside TracedLayer. Default None. exec_strategy (ExecutionStrategy, optional): execution strategy of :code:`CompiledProgram` inside TracedLayer. Default None. Returns: None Examples: .. code-block:: python >>> import paddle >>> class ExampleLayer(paddle.nn.Layer): ... def __init__(self): ... super().__init__() ... self._fc = paddle.nn.Linear(3, 10) ... ... def forward(self, input): ... return self._fc(input) >>> layer = ExampleLayer() >>> in_var = paddle.uniform(shape=[2, 3], dtype='float32') >>> out_dygraph, static_layer = paddle.jit.api.TracedLayer.trace(layer, inputs=[in_var]) >>> build_strategy = paddle.static.BuildStrategy() >>> build_strategy.enable_inplace = True >>> exec_strategy = paddle.static.ExecutionStrategy() >>> exec_strategy.num_threads = 2 >>> static_layer.set_strategy(build_strategy=build_strategy, exec_strategy=exec_strategy) >>> out_static_graph = static_layer([in_var]) NzCannot set strategy after runztThe type of 'build_strategy' in paddle.jit.api.TracedLayer.set_strategy must be base.BuildStrategy, but received {}.zwThe type of 'exec_strategy' in paddle.jit.api.TracedLayer.set_strategy must be base.ExecutionStrategy, but received {}.)rr<rCrrBr rr)rraZ exec_strategyr2r2r3 set_strategys")   zTracedLayer.set_strategycCst|j|jd|_dS)N)ra)r rrrrr2r2r3_compiles zTracedLayer._compilecCst|ttfs Jdt|t|jksJi}tr0t||jD] \}}|||<q!|St||jD]\}}|||<q6|S)Nz-Inputs should be a list or tuple of variables) r<r>r?rrrzipr.r)rr;Z feed_dictrrr2r2r3 _build_feeds zTracedLayer._build_feedcCs|jj|j||jdS)N)rZ fetch_list)rrunrr)rrr2r2r3_runs zTracedLayer._runcCsPt|j|jdur||||WdS1s!wYdSr0)rrrr"r&r$)rr;r2r2r3__call__s  $zTracedLayer.__call__c Kst|dtdt|dtdtfdt|tr#|D] }t|dtdqt|dtdtfdt|tr?|D] }t|dtdq5|dd }tj |}|d krSt d tj |}|rftj |sft |d d } t|js| |j|} | |j|} g} | D]} |jj| d}|dusJ| d| |qg}| D]} |jj| d}|dusJ| d||q|dd}tj||}t|| ||j|j||dWddS1swYdS)aG Save the TracedLayer to a model for inference. The saved inference model can be loaded by C++ inference APIs. ``path`` is the prefix of saved objects, and the saved translated program file suffix is ``.pdmodel`` , the saved persistable variables file suffix is ``.pdiparams`` . Args: path(str): The path prefix to save model. The format is ``dirname/file_prefix`` or ``file_prefix``. feed (list[int], optional): the input variable indices of the saved inference model. If None, all input variables of the TracedLayer object would be the inputs of the saved inference model. Default None. fetch (list[int], optional): the output variable indices of the saved inference model. If None, all output variables of the TracedLayer object would be the outputs of the saved inference model. Default None. kwargs: Supported keys including - clip_extra(bool): whether to clip extra information for every operator. Defaults to True. - legacy_format(bool): whether to save program in legacy format. Default to False. Returns: None Examples: .. code-block:: python >>> import numpy as np >>> import paddle >>> class ExampleLayer(paddle.nn.Layer): ... def __init__(self): ... super().__init__() ... self._fc = paddle.nn.Linear(3, 10) ... ... def forward(self, input): ... return self._fc(input) >>> save_dirname = './saved_infer_model' >>> in_np = np.random.random([2, 3]).astype('float32') >>> in_var = paddle.to_tensor(in_np) >>> layer = ExampleLayer() >>> out_dygraph, static_layer = paddle.jit.api.TracedLayer.trace(layer, inputs=[in_var]) >>> static_layer.save_inference_model(save_dirname, feed=[0], fetch=[0]) >>> paddle.enable_static() >>> place = paddle.CPUPlace() >>> exe = paddle.static.Executor(place) >>> program, feed_vars, fetch_vars = paddle.static.load_inference_model( ... save_dirname, ... exe ... ) >>> fetch, = exe.run(program, feed={feed_vars[0]: in_np}, fetch_list=fetch_vars) >>> print(fetch.shape) [2, 10] rz/paddle.jit.api.TracedLayer.save_inference_modelrNzeach element of feedrzeach element of fetchrTrrcs|durSfdd|DS)Ncsg|]}|qSr2r2)ridxall_varsr2r3rszLTracedLayer.save_inference_model..get_feed_fetch..r2)r*Z partial_varsr2r)r3get_feed_fetchsz8TracedLayer.save_inference_model..get_feed_fetchz cannot be found legacy_formatF)rrrrr9rr,)r rrCr>r<rrirrrr_rrrrrrrrrrr=rrrr)rrrrrKrrrrr+Zfeeded_var_namesZtarget_var_namesrrZfeed_varZ target_varsZ target_varr,r2r2r3rs<              "z TracedLayer.save_inference_model)T)NN)rSrRrrUrrcr9r staticmethodrr r!r r"r$r&r'rr2r2r2r3r Xs$    57  r cCsnt|tr5|jrt|j|j}n|j}|jjdur't||j fi|j }|St||jjfi|j }|S|Sr0) r<r&rtypes MethodTypeZ_dygraph_functionZ_function_specZ _input_specr#Zlast_call_input_spec_kwargs)rgZdygraph_functionZast_static_functionr2r2r3rs,  r)r.r/)r;)rZr[)NNNNr0)F)rrrr)rrr)f __future__rrrrrj threadingr.rl collectionsr contextlibrtypingrrZ paddle.baserrZpaddle.base.compilerrr r Zpaddle.base.data_feederr Zpaddle.base.dygraph.baser r Zpaddle.base.executorrrZpaddle.base.frameworkrrrrrrrrrZpaddle.base.wrapped_decoratorrZpaddle.frameworkrZ paddle.nnrZpaddle.static.iorZpaddle.utils.environmentsrrZ dy2staticr Zdy2static.convert_call_funcr!r"Zdy2static.program_translatorr#r$r%r&r'r(Ztranslated_layerr)r*r+r,r-r1r4r:r@rGrPZdygraph_to_static_funcrYr\rbrQrtrxrrrrrLockrrrrrrrrrrr r rr2r2r2r3s     ,         A   }+e" A*+ <  !s r $ S