o Ne3 @sddlmZddlZddlZddlZddlZddlmZddlZddl Z ddl m Z m Z m Z mZddlZddlZddlmZmZddlmZmZmZddlmZddlmZmZdd lmZmZdd l m!Z!dd l"m#Z#m$Z$dd l%m&Z&m'Z'dd l(m)Z)m*Z*m+Z+ddl,m-Z-m.Z.m/Z/m0Z0m1Z1ddl2m3Z3ddl4m5Z5m6Z6ddl7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@ddl7mAZAmBZBddlCmDZDgdZEddZFdKddZGdKddZHddZIeDeIZJdd ZK    !dLd"d#ZLdMd$d%ZMGd&d'd'eNZOd(d)ZPd*d+ZQd,d-ZRdNd.d/ZSd0d1ZTe UaVgaWGd2d3d3eNZXd4d5ZYd6d7ZZd8d9Z[eDd:d;Z\dd?Z]e\edMd@dAZ^eAdBdCZ_eA D E FdOdGdHZ`GdIdJdJeNZadS)P)print_functionN) OrderedDict)TextTupleAnyList)coredygraph) BuildStrategyCompiledProgramExecutionStrategy) check_type)flattenpack_sequence_as)program_desc_tracing_guardswitch_to_static_graph) logging_utils)ConversionOptionsCONVERSION_OPTIONS)set_code_level set_verbosity)ProgramTranslatorStaticFunctionunwrap_decorators)TranslatedLayerINFER_MODEL_SUFFIXINFER_PARAMS_SUFFIXINFER_PARAMS_INFO_SUFFIXINFER_PROPERTY_SUFFIX)Layer)Executor scope_guard)Block ParamBaseProgramVariable ParameterEagerParamBase)_current_expected_place_dygraph_guard_dygraph_tracer) dygraph_only_non_static_mode)wrap_decorator) TracedLayer declarativedygraph_to_static_funcrrsaveload not_to_staticcCs&t}||_t|dg|_||SNr)r$descr"blocksZ_sync_with_cpp) program_descprogramr9HD:\Projects\ConvertPro\env\Lib\site-packages\paddle/fluid/dygraph/jit.pycreate_program_from_desc4s r;inputscCsTt|tr ||dSt|ttfr |D]}t|||qdStd|t|)NzpThe type of 'each element of {}' in fluid.dygraph.jit.TracedLayer.trace must be fluid.Variable, but received {}.) isinstancer%appendlisttuple _extract_vars TypeErrorformattype)r< result_listerr_tagvarr9r9r:rA<s  rAcCsg}t||||SN)rA)r<rFrEr9r9r: extract_varsHs rIcsfdd}|S)aj 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 import paddle.fluid as fluid import numpy as np from paddle.fluid.dygraph.jit 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 x = fluid.layers.fill_constant(shape=[3, 3], value=0, dtype='float64') x_v = func(x) exe = fluid.Executor(fluid.CPUPlace()) out = exe.run(fetch_list=[x_v]) print(out[0]) # [[1. 1. 1.] # [1. 1. 1.] # [1. 1. 1.]] csBt}ts |jstd|i|S|}||i|S)NzThe decorator 'dygraph_to_static_func' doesn't work in dygraph mode or set ProgramTranslator.enable to False. We will just return dygraph output.)rr,enable_to_staticrwarnZget_func)argskwargsZprogram_translator static_func dygraph_funcr9r:__impl__s  z*_dygraph_to_static_func_..__impl__r9)rPrQr9rOr:_dygraph_to_static_func_Ns 1 rRcCs6d}|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. r/ __module__)__name__Z_decorator_name __wrapped____doc__hasattrrS) original_func decorated_objZdecorator_namer9r9r:copy_decorator_attrss rZFcsfdd}p tttstdtj|durCt|tr?t|jtr7|j j}t d|||j|_|S||S|S)a Converts imperative dygraph APIs into declarative function APIs. Decorator @declarative handles the Program and Executor of static mode and returns the result as dygraph Tensor(s). Users could use the returned dygraph Tensor(s) to do imperative training, inference, or other operations. If the decorated function calls other imperative function, the called one will be converted into declarative function as well. Args: function (callable): callable imperative function. 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. property(bool, Optional): whether the fucntion is python property. The default is False. Returns: Tensor(s): containing the numerical result. Examples: .. code-block:: python 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) # [[2. 2.]] cs(t|\}}t|t|dd}|S)zK Decorates a python function into a StaticFunction object. )function input_specbuild_strategyproperty)rXrY)rrZr)Z python_func_Z static_layerr]r\r^r9r: decorateds zdeclarative..decoratedzURequired type(build_strategy) shall be `paddle.static.BuildStrategy`, but received {}Nzb`{}.forward` has already been decorated somewhere. It will be redecorated to replace previous one.) r r=rBrCrDrTrforwardr __class__rrK)r[r\r]r^ra class_namer9r`r:r/s&/      r/cCs&|durtStdd}t|t||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 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) # [[2. 2.]] NT)Z not_convert)r3rsetattrr)funcoptionsr9r9r:r3s    r3c@s|eZdZddZeddZejddZeddZejddZed d Zejd d Zed d Z e jdd Z dS)_SaveLoadConfigcCs:d|_d|_d|_d|_d|_d|_d|_d|_d|_dS)NFT) _output_spec_model_filename_params_filenameZ_separate_params_keep_name_table_export_for_deployment _program_only with_hookcombine_paramsselfr9r9r:__init__%s z_SaveLoadConfig.__init__cC|jSrH)rirqr9r9r: output_spec<z_SaveLoadConfig.output_speccCs0|durdSt|tstdtt||_dS)NzIThe config `output_spec` should be 'list', but received input type is %s.)r=r?rBrDinputrVarBaseri)rrspecrGr9r9r:ru@s  cCrtrH)rjrqr9r9r:model_filenameOrvz_SaveLoadConfig.model_filenamecCF|durdSt|tjstdt|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=six string_typesrBrDlen ValueErrorrjrrfilenamer9r9r:rzS   cCrtrH)rkrqr9r9r:params_filename_rvz_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=r|r}rBrDr~rrkrr9r9r:rcrcCrtrH)rlrqr9r9r:keep_name_tableorvz_SaveLoadConfig.keep_name_tablecCs0|durdSt|tstdt|||_dS)NzSThe config `keep_name_table` should be bool value, but received input's type is %s.)r=boolrBrDrl)rrvaluer9r9r:rss  N) rTrS __qualname__rsr^rusetterrzrrr9r9r9r:rh#s$       rhcCsvgd}|D] }||vrtd|qt}|dd|_|dd|_|dd|_|dd|_|d d|_|S) N)rurorp clip_extra skip_forwardzAThe additional config (%s) of `paddle.jit.save` is not supported.ruroFrprTr)rrhgetrurorprrconfigsZsupported_configskeyZ inner_configr9r9r:_parse_save_configs~s rcCsLddg}|D] }||vrtd|qt}|dd|_|dd|_|S)NrzrzAThe additional config (%s) of `paddle.jit.load` is not supported.)rrhrrzrrr9r9r:_parse_load_configsrcCsd}d}g}ddt|D}|dur|Sdd|D}t|t|krI|}|D]}|jdur7t||q(|j|vrEt||jq( q(|S|D]}|jdurXt|||j|vrdt||j||jqK|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.cSsg|] }t|tr|jqSr9)r=r%name).0rGr9r9r: s  z(_get_input_var_names..cSsg|] }t|tjjr|qSr9)r=paddlestatic InputSpec)rryr9r9r:rs  )rr~rwarningsrKrr>)r<r\Zname_none_errorname_no_exists_errorrEinput_var_namesryr9r9r:_get_input_var_namess6      rcCsd}|r |r tdg}t}t|D] }t|tr|||j<q|dur,t|}|S|durRt|t|krRt|}|D]}|j|vrOt ||jq@|S|D]}|j|vrbt ||j| ||jqT|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.) RuntimeErrorrrr=r%rr?valuesr~rrKrr>)outputsrurorrEZoutput_vars_dictrGr9r9r:_get_output_varss4        rcCs|t}tj|}tj|}|r|rtd||f|s&|s&td||rVtj|}tj|}|jdur>t d|t|_|j durMt d|t |_ ||fS|}||fS)NzThe %s.pdmodel and %s 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.) rospathexistsisdirrbasenamedirnamerzrrKrr)rconfigZprefix_format_pathZprefix_format_existZdirectory_format_exist file_prefix model_pathr9r9r:_build_load_path_and_configs:        rc@s eZdZdZddZddZdS)HookRemoveHelperz5 A HookRemoveHelper that can be used to remove hook. cCs ||_dSrH)_hook)rrhookr9r9r:rs1s zHookRemoveHelper.__init__cCst|jdSrH)_remove_save_pre_hookrrqr9r9r:remove4szHookRemoveHelper.removeN)rTrSrrVrsrr9r9r9r:r.s 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 import numpy as np import paddle IMAGE_SIZE = 256 CLASS_NUM = 10 class LinearNet(paddle.nn.Layer): def __init__(self): super(LinearNet, self).__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.register_save_pre_hook(save_pre_hook) layer = LinearNet() paddle.jit.save(layer, "/tmp", [paddle.static.InputSpec(shape=[-1, IMAGE_SIZE])]) # saving_count == 1 remove_handler.remove() paddle.jit.save(layer, "/tmp", [paddle.static.InputSpec(shape=[-1, IMAGE_SIZE])]) # saving_count == 1 )_save_pre_hooks_lockacquire_save_pre_hooksr>releaserrr9r9r:_register_save_pre_hook8s 2 rcCstttdSrH)rrrclearrr9r9r9r:_clear_save_pre_hooksqs rcCs&t|tvr t|tdSrH)rrrrrrr9r9r:rys  rcsdfdd }|S)Ncs.tD]}||||q|||fi|dSrH)r)layerrr\rrrfr9r:wrappersz$_run_save_pre_hooks..wrapperrHr9)rfrr9rr:_run_save_pre_hookssrr property_valscCszdd}t|d*}tjj}|D]}|d|d}}||||q||WddS1s6wYdS)zclass property serialization. Args: filename (Text): *.meta property_vals (List[Tuple): class property. cSst|tr |||dSt|tr|||dSt|tr'|||dSt|ttfr[t|dtr=| ||dSt|dtrL| ||dSt|dtrY| ||dSt dt |)NrzNote support val type: )r=floatZ set_floatintZset_intstrZ set_stringr@r?Z set_floatsZset_intsZ set_stringsrrD)metarvalr9r9r: set_propertys(        z$_save_property..set_propertywbrN)openrZ frameworkrPropertywriteZserialize_to_string)rrrfritemrrr9r9r:_save_propertys  "rc/Kst}|js tdt|ts!t|s!t|ts!tdt |t|s+t|tr0t dt|t j r:|j}n|}tj|}|dkrJtdtj|}|r]tj|s]t|d}|durt|trt|D]} t|| d} t| trd| krtdt |qlt|ttfstd t |g}t|D]*} t| t jjr|| qt| tjtj j!t"fr|t jj#| q|| qt$|}|j%} |j&} | rd |_'t(}t)}t|trt|}|j*s|j+rd } n|g}i}g}d}|D]} t|trNt|| d} t| tr+| j,r#| }|||j-j.d | fq| j/|| d }n]d| krM|j0r5q|r=t1||}t2|j3|d }|j/| d }d}n;qt| tri| j,rc| }||| fq| /|}n|rqt1||}t2| |d }|j4}|j5durt d6|d}t|tr|7}nt| tr| j5r| j57}|rt)}t)}t89|D]\}} ||| j:<| || j:<qt;<m|j=D]a}|j tj>j?j@kr|AB}|C|j:}|D|n|C|j:E}||j:AE}|F||j:|vr*t)} |j:|vr||j:| d<|jG| d<t|tHtIfr%|jJ| d<| ||j:<qWdn 1s7wYtK|jL|}!tM|jN|jO| }"ddlPmQ}#|}$d| ks]t|tsf|tR}%|tS}&n|d | tR}%|d | tS}&tT||#|$|!|"tUtV|jWX|%|&|jY|j'|jZd Wdn 1swY| r|jWX}'|'[|!|"}'|'j\D] }(|]|(j^qq| rt_|`ddd}g})|D] \}*} |)| q|tS}&tT|t jjatUtV|$ttbt jcjdje|)|&dWdn 1swYtjftjg|$|th}+ti|+|d},|dur1|jWjD] } |,t| tkO},q&t|ts:|,r|rtT|3|tl}-tm|-d}.tnjo||.ddWdn1s_wYWddSWddS1sxwYdSdSdS)a2 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 # 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(LinearNet, self).__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() zPThe paddle.jit.save doesn't work when setting ProgramTranslator.enable 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.NrbzIf 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.T.)ro)r\z`jit.save` will only save the `Program`, not the parameters. If you have to save the parameters, please make sure that {} is a member function of `paddle.nn.Layer` and the saved parameters are in `state_dict`structured_name stop_gradient trainablersave_inference_model) rfeeded_var_names target_varsexecutor main_programrzrZexport_for_deploymentZ program_onlyrcSs|dSr4r9)rr9r9r:7szsave..)r)rvarsrFr)protocol)prrJrr=rinspect isfunctionrrBrDrrKrZ DataParallelZ_layersrrrrrrmakedirsdirgetattrr?r@rrrr>rrxeagerZTensorr%Z from_tensorrrorprnScopedictZ_forward_pre_hooksZ_forward_post_hooksZ is_propertyrcrTZ#concrete_program_specify_input_specrrr/rbconcrete_programZ_class_instancerCZto_static_state_dictr| iteritemsrr guard parametersZVarDescZVarTypeZVOCABrZget_map_tensorrGZ set_vocab get_tensor_share_data_withrr#r'rrr<rrrupaddle.fluid.iorrrr!r r(rclonermrZ_prune_with_inputr6updatersorteditemsZ save_varsfilterZfluidioZis_persistablejoinnormpathrrZ list_varsr&rrpickledump)/rrr\rZprog_translatorZ inner_layerrrZinner_input_specZ attr_funcrNrGrorpscopeZextra_var_infoZ functionsZ combine_varsrrZ immediate_valZstatic_forwardZstatic_functionZdygraph_state_dictZstate_names_dictZstate_var_dictrZparam_or_bufferZ scr_tensorZtgt_varZparam_or_buffer_tensor src_tensorZextra_info_dictrZ output_varsrrrzrZclone_main_programblockZ ordered_varsrZproperty_save_pathZcontain_parameterZextra_var_info_pathrr9r9r:r1s                                    #              $r1cKs"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.fluid.io.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 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(LinearNet, self).__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.fluid.io.save_inference_model`` then performing and fine-tune training. .. code-block:: python 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.fluid.io.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()))) )rrrZ _construct)rrrrr9r9r:r2fs` r2feed_fetch_t_cCst|tsJt|ttfs|g}t}t|}td0||}t|ttfs.|g}n|}t|dd} |||| ||\} } } } | Wdn1sQwYt d t | }Wdn1siwY||| | | fS)NTr)rF) r=rr?r@r*Z_get_program_desc_tracerrIrZcreate_program_descresetr)r;)rr<Z feed_prefixZ fetch_prefixZ tmp_prefixZtracerZvar_listZoriginal_outputsrZout_varsr7 feed_names fetch_namesrr8r9r9r:_traceKs(      rc@s~eZdZdZddZeddZdddZee d d Z dd d Z e ddZ ddZe ddZddZe dddZd S)r.a :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|_dSrH)_program _feed_names _fetch_names_paramsr(_placerr_scoperrrGrrr _exe_compiled_program_build_strategy_exec_strategy)rrr8rrrprZ dst_tensorr9r9r:rss     zTracedLayer.__init__cCrtrH)rrqr9r9r:r8rvzTracedLayer.programTcCsDt|jjD]}|j|}|jD] }|dr|d|qqdS)Nis_test)rangerZ num_blocksropsZhas_attrZ _set_attr)rrrZblock_idropr9r9r:_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(ExampleLayer, self).__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.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(dirname='./saved_infer_model') zhThe type of 'layer' in fluid.dygraph.jit.TracedLayer.trace must be fluid.dygraph.Layer, but received {}.)r=rrCrDrr.)rr<ZoutsprogfeedfetchrZtracedr9r9r:traces.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(ExampleLayer, self).__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.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 runzxThe type of 'build_strategy' in fluid.dygraph.jit.TracedLayer.set_strategy must be fluid.BuildStrategy, but received {}.z{The type of 'exec_strategy' in fluid.dygraph.jit.TracedLayer.set_strategy must be fluid.ExecutionStrategy, but received {}.)rr=rDr rCr rr)rrr] exec_strategyr9r9r: set_strategys")   zTracedLayer.set_strategycCs"t|jj|j|j|jd|_dS)N)r]rZplaces)r rZwith_data_parallelrrrrrqr9r9r:_compile s 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@r~rr,ziprr)rrr<Z feed_dictxrr9r9r: _build_feeds zTracedLayer._build_feedcCs|jj|j||jdS)N)r Z fetch_list)rrunrr)rrr r9r9r:_run!s zTracedLayer._runcCsPt|j|jdur||||WdS1s!wYdSrH)r!rrrrr)rrr<r9r9r:__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 lm} dd} t|jN| |j|} | |j|} g} | D]}|jj|d}|dusJd|| |q|t}|t}| || | |j|j|||dWddS1swYdS)aW 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'.set to True if you want to clip extra information for every operator. Returns: None Examples: .. code-block:: python: import numpy as np import paddle class ExampleLayer(paddle.nn.Layer): def __init__(self): super(ExampleLayer, self).__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.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) rz2fluid.dygraph.jit.TracedLayer.save_inference_modelr Nzeach element of feedrzeach element of fetchrTrrrrcs|durSfdd|DS)Ncsg|]}|qSr9r9)ridxall_varsr9r:rszLTracedLayer.save_inference_model..get_feed_fetch..r9)rZ partial_varsr9rr:get_feed_fetchsz8TracedLayer.save_inference_model..get_feed_fetchz{} cannot be found)rrrrrrzrr)r rrDr?r=rrrrrrrrrrrr!rrrrZ global_blockrrCr>rrrr)rrrr rrMrrrrrrrZtarget_var_namesrrZ target_varrzrr9r9r:r.sh7           "z TracedLayer.save_inference_model)T)NN)rTrSrrVrsr^r8r  staticmethodr+rrrrrrrrr9r9r9r:r.ls$    45  r.)r<)NNNFrH)F)rrr)b __future__rrrr functools collectionsrr threadingtypingrrrrr|rZ paddle.fluidrr Zpaddle.fluid.compilerr r r Zpaddle.fluid.data_feederr Zpaddle.fluid.layers.utilsrrZpaddle.fluid.dygraph.baserrZ&paddle.fluid.dygraph.dygraph_to_staticrZ8paddle.fluid.dygraph.dygraph_to_static.convert_call_funcrrZ4paddle.fluid.dygraph.dygraph_to_static.logging_utilsrrZ9paddle.fluid.dygraph.dygraph_to_static.program_translatorrrrZpaddle.fluid.dygraph.iorrrrrZpaddle.fluid.dygraph.layersrZpaddle.fluid.executorr r!Zpaddle.fluid.frameworkr"r#r$r%r&r'r(r)r*r+r,Zpaddle.fluid.wrapped_decoratorr-__all__r;rArIrRr0rZr/r3objectrhrrrrrLockrrrrrrrrr1r2rr.r9r9r9r:s         ? W([ 2)' 9  "7 e