o Ne@sddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z ddl m Z ddlmZmZmZddlmZddlmZmZmZddlmZmZmZmZmZmZmZmZdd l m!Z!dd l"m#Z#m$Z$dd l"m%Z%m&Z&m'Z'zdd l(m)Z)Wn dd lm)Z)YgZ*d dZ+ddZ,ddZ-ddZ.ddZ/ddZ0ddZ1ddZ2ddZ3dd Z4d!d"Z5d#d$Z6d%d&Z7d'd(Z8d)d*Z9d+d,Z:d-d.Z;d/d0Zd5d6Z?d7d8Z@dCd:d;ZAdDd=d>Zd?d@ZBdAdBZCdS)E)print_functionN)fluid)core)_unpack_saved_dict_pack_loaded_dict_pickle_loads_mac) _legacy_save)_open_file_buffer _is_file_path_is_memory_buffer)Variable_varbase_creator_dygraph_tracer_non_static_mode ParamBaseEagerParamBase_current_expected_placeProgram)_SaveLoadConfig)_construct_program_holders_construct_params_and_buffers)INFER_MODEL_SUFFIXINFER_PARAMS_SUFFIXINFER_PARAMS_INFO_SUFFIX)IterablecCsi}i}|D]<\}}t|ttjtjjfr@|jtjj j kr(| ||<n| s4td|||<|j||<q|||<q||d<|S)NzdThe saved tensor is not initialized. If you used group sharded, please use save_group_sharded_model.StructuredToParameterName@@)items isinstancer rVarBaseeagerTensortypeZVarDescZVarTypeZVOCABvalueZget_map_tensor get_tensor_is_initialized ValueErrornumpyname)Z state_dict save_dictZ name_tablekeyr"r*CD:\Projects\ConvertPro\env\Lib\site-packages\paddle/framework/io.py_build_saved_state_dictBs   r,c Cst||j}tjzt|||jdd}t}|D] }||||<qt |jd}t j ||}t j |r}t|d }t|} Wdn1sNwYt} |D]}| |dd} | duslJd|||| | <qX| }Wd|SWd|S1swY|S)NF)Z append_suffixz.inforbstructured_namezACannot find saved variable (%s)'s structured name in saved model.)rmodel_filenamerdygraphguardrparams_filenamedictr&strospathjoinexistsopenpickleloadget) model_pathconfigZprogramsZpersistable_var_dictload_param_dictvar_nameZvar_info_filenameZ var_info_pathfZextra_var_infoZstructured_para_dictr.r*r*r+*_load_state_dict_from_save_inference_modelWsF          rBc Csg}g}t|D]#\}}}|D]}tj||}tj||}|dd} || qq tj +|D] } t | dd} t j did| idtj|| id|| q5Wdn1s`wYt } |D] } | | | j<qj| S) N\/T)r'Z persistabler;ZOut file_path)r!ZinputsZoutputsattrs)r5walkr6r7relpathreplaceappendrr0r1r rZtrace_opr3r&r')r=Z load_var_listZ var_name_listroot_filesfilenamerEZ tmp_var_namer@r'Znew_varr?varr*r*r+!_load_state_dict_from_save_params}s2      rPc Cs|t}tj|}tj|}|r|rtd||f|s@|s@d}|d}|d}tj|s6tj|r:|d7}t|||rptj|}tj|} |jdurXt d|t|_|j durgt 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.z+The ``path`` (%s) to load model not exists.z .pdparamsz.pdoptz If you want to load the results saved by `fluid.save_dygraph`, please specify the full file name, not just the file name prefix. For example, it should be written as `paddle.load('model.pdparams')` instead of `paddle.load('model')`.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.) rr5r6r8isdirr%basenamedirnamer/warningswarnr2r) r6r>Zprefix_format_pathZprefix_format_existZdirectory_format_exist error_msgZparams_file_pathZopti_file_pathZ file_prefixr=r*r*r+_build_load_path_and_configsD         rWcCshgd}|D] }||vrtd|qt}|dd|_|dd|_|dd|_|dd|_|S)N)r/r2keep_name_table return_numpyz=The additional config (%s) of `paddle.load` is not supported.r/r2rXrYF)r%rr<r/r2rXrYconfigsZsupported_configsr)Z inner_configr*r*r+_parse_load_configsr\cCsLddg}|D] }||vrtd|qt}|dd|_|dd|_|S)Nuse_binary_formatpickle_protocolz=The additional config (%s) of `paddle.save` is not supported.F)r%rr<r]r^rZr*r*r+_parse_save_configsr_c s^t|tstdt||dks|dkrtd|ddddd d tfd d }t|d d|fdd}fdd}tjdkrytj j dkry|t |}|d}t dt||D] }|||||qidSt ||} tj| _| jtj<| jtj<| jt<| jtjj<| jt<| j| |dS)N-The 'protocol' MUST be `int`, but received {}1Expected 1<'protocol'<5, but received protocol={}cSs|}|j}t||fffSN)r&r'tuple)selfdatar'r*r*r+reduce_varbasesz$_pickle_save..reduce_varbasecSst|}tdd|iffS)Nrg)nparrayeval)rfrgr*r*r+reduce_LoDTensor#s z&_pickle_save..reduce_LoDTensorcSstd)Nz6paddle do not support saving `paddle.nn.Layer` object.)r%)rfr*r*r+ reduce_Layer(sz"_pickle_save..reduce_Layercs|j<|Srd) __class__)layer)dispatch_table_layerrmr*r+create_layer_dispatch_table/s z1_pickle_save..create_layer_dispatch_tablecS t|tjSrdrrLayer)vr*r*r+4s z_pickle_save..csJtjtj<tjt<tjtjj<tjt<tjtj<tj dSrd) r:dispatch_tablerrrrr r LoDTensorupdater*)rprlrhr*r+add_dispatch_table7s    z(_pickle_save..add_dispatch_tablecs^tjtjtjtjtjttjtjjtjt D]}tj|q$dSrd) r:rwpoprrrxrrr r)k)rpr*r+pop_dispatch_table@s  z(_pickle_save..pop_dispatch_tabledarwin@r)rintr%formatr!r3_parse_every_objectsysplatform version_infomajorr:dumpsrangelenwritePicklercopyregrwcopyrrrxrrr rrydump) objrAprotocolrqrzr} pickle_bytes max_bytesiZpicklerr*)rprmrlrhr+ _pickle_savesJ            rcCst|tjr td||rdSt|ttjtt fvrHt|ttjfvr+t| }nt t |}d}|D]}|t |||O}|rEdSq5|SdS)Nz3`paddle.save` do not support saving 'SelectedRows'.TF)rr SelectedRowsNotImplementedErrorr!r3 collections OrderedDictlistrekeysrr _contain_x)rcondition_funcrflagr)r*r*r+r_s$  rcCszt|tr;dd}|D]+\}}t|tr)|D] \}}t||r'dSqq t|tjtjjtjfs8dSq dSdS)NcSs"t|tjttjtjjtjtj fSrd) rrrtrrrrr rxrrr*r*r+ conditionysz!_is_state_dict..conditionFT) rr3rrrrrr rx)rrr)r"r|rur*r*r+_is_state_dictvs   rcCs@t|trt|dkrt}t|d|rt|dtjrdSdS)NrarTF)rrerr4rindarray)rZ name_typesr*r*r+_transformed_from_varbases rcCst|tjrdSdS)NTF)rrirrr*r*r+_transformed_from_lodtensors rcCs<t|tjstdt|t}t}| |||S)Nz;Type of `ndarray` should be numpy.ndarray, but received {}.) rrir TypeErrorrr!rrxrset)rtZplacer*r*r+ _to_LodTensors  rcCs:|r|dStrt|d}|d|_|St|dS)Nrr)rpaddle to_tensorr'r)rrYrr*r*r+_tuple_to_tensors  rcCs |r|Str t|St|Srd)rrrr)rrYr*r*r+_ndarray_to_tensors  rcCs t}||t|Srd)r r"r#rr)tensorZ return_varr*r*r+_lod_tensor2varbasesrcCs||r||St|ttjtfvrEt|tkrtt|}nt|}|D]}|||r8|||||<q't||||||<q'|St|t krUt tt|||St|t kret tt|||St |t rt |t tjtjtjjtjfstdt||S)Nz]The iteratable objects supported are tuple, list, dict, OrderedDict, string. But received {}.)r!r3rrrrrrrrerrrr4rirrrrr rxrr)rrZ convert_funcrr)r*r*r+rs:        rcsndd}dd}t||rtstdt|||fdd}fdd }t|tr1t|t|St|t|S) NcSrrrdrsrr*r*r+is_layer z$_parse_load_result..is_layercSst|jd}|j||S)NF)_parse_load_result__dict__ry)rZ temp_dictr*r*r+ parse_layers  z'_parse_load_result..parse_layerzMLayer can only be loaded in dynamic graph mode, but now in static graph mode.c t|dSNrY)rrrr*r+tuple_to_tensorrz+_parse_load_result..tuple_to_tensorcrr)rrrr*r+ndarray_to_tensor rz-_parse_load_result..ndarray_to_tensor)rrr%rrr)rrYrrrrr*rr+rs"     rcCs|stdt|rt||}|St|r>t|}t|d}||| }Wd|S1s7wY|St d t |)NzlThe saved tensor is not initialized. If you used group sharded, please use save_group_sharded_model firstly.wb@Only supports saving objects to file or BytesIO, but received {}) r$r%r rZsave_lod_tensorr Zsave_lod_tensor_to_memoryr rtellrrr!)r file_name_seek tensor_bytesrAr*r*r+_save_lod_tensors*        rcCstjj}t|rtjj||}||fSt|rFt|d}|}tjj ||| }Wd||fS1s=wY||fSt d t |Nr-z@Only supports load objects from file or BytesIO, but received {})rrrrxr Zload_lod_tensorr r readZload_lod_tensor_from_memoryrrrr!)rZtemp_trrArr*r*r+_load_lod_tensor3s$      rcCs|s tdt|rt||}|St|r@t|}t|d}| || }Wd|S1s9wY|St d t |)Nz$The saved tensor is not initialized.rr)r#r$r%r rZsave_selected_rowsr Zsave_selected_rows_to_memoryr rrrrr!)Z selected_rowsrrselected_rows_bytesrAr*r*r+_save_selected_rowsIs&          rcCst}t|rt||}||fSt|r?t|d}|}tjj ||Wdn1s2wY| }||fSt d t |r)rrr Zload_selected_rowsr r rrrZload_selected_rows_from_memoryrrrr!)rZtemp_srrrArr*r*r+_load_selected_rows^s$   rcCspt|tjr t||dSt|tjrt||dSt|tjtjjfr/t| |dSt d t |)NzOWhen use_binary_format = True, `paddle.save` expected Tensor, but received {}.)rrrxrrrrrr r"r#rrr!)rr6r*r*r+_save_binary_varvs  rrbcKszt|r&tj|}|dkrtdtj|}|r%tj|s%t|n t|s3td t |t |}t |j tsGtd t |j |j rQt||dS|jdur^|j}tdt |tr|jt|d}||jWddS1swYdSt|rtrt|||dSt|||dSt|d}t|||WddS1swYdS)a Save an object to the specified path. Note: Now supports saving ``state_dict`` of Layer/Optimizer, Tensor and nested structure containing Tensor, Program. Note: Different from ``paddle.jit.save``, since the save result of ``paddle.save`` is a single file, there is no need to distinguish multiple saved files by adding a suffix. The argument ``path`` of ``paddle.save`` will be directly used as the saved file name instead of a prefix. In order to unify the saved file name format, we recommend using the paddle standard suffix: 1. for ``Layer.state_dict`` , recommend to use ``.pdparams`` ; 2. for ``Optimizer.state_dict`` , recommend to use ``.pdopt`` . For specific examples, please refer to API code examples. Args: obj(Object) : The object to be saved. path(str|BytesIO) : The path/buffer of the object to be saved. If saved in the current directory, the input path string will be used as the file name. protocol(int, optional): The protocol version of pickle module must be greater than 1 and less than 5. Default: 4 **configs(dict, optional): optional keyword arguments. The following options are currently supported: use_binary_format(bool): When the saved object is static graph variable, you can specify ``use_binary_for_var``. If True, save the file in the c++ binary format when saving a single static graph variable; otherwise, save it in pickle format. Default: False Returns: None Examples: .. code-block:: python # example 1: dynamic graph import paddle emb = paddle.nn.Embedding(10, 10) layer_state_dict = emb.state_dict() # save state_dict of emb paddle.save(layer_state_dict, "emb.pdparams") scheduler = paddle.optimizer.lr.NoamDecay( d_model=0.01, warmup_steps=100, verbose=True) adam = paddle.optimizer.Adam( learning_rate=scheduler, parameters=emb.parameters()) opt_state_dict = adam.state_dict() # save state_dict of optimizer paddle.save(opt_state_dict, "adam.pdopt") # save weight of emb paddle.save(emb.weight, "emb.weight.pdtensor") # example 2: Save multiple state_dict at the same time from paddle import nn from paddle.optimizer import Adam layer = paddle.nn.Linear(3, 4) adam = Adam(learning_rate=0.001, parameters=layer.parameters()) obj = {'model': layer.state_dict(), 'opt': adam.state_dict(), 'epoch': 100} path = 'example/model.pdparams' paddle.save(obj, path) # example 3: static graph import paddle import paddle.static as static paddle.enable_static() # create network x = paddle.static.data(name="x", shape=[None, 224], dtype='float32') z = paddle.static.nn.fc(x, 10) place = paddle.CPUPlace() exe = paddle.static.Executor(place) exe.run(paddle.static.default_startup_program()) prog = paddle.static.default_main_program() for var in prog.list_vars(): if list(var.shape) == [224, 10]: tensor = var.get_value() break # save/load tensor path_tensor = 'temp/tensor.pdtensor' paddle.save(tensor, path_tensor) # save/load state_dict path_state_dict = 'temp/model.pdparams' paddle.save(prog.state_dict("param"), path_tensor) # example 4: save program import paddle paddle.enable_static() data = paddle.static.data( name='x_static_save', shape=(None, 224), dtype='float32') y_static = z = paddle.static.nn.fc(data, 10) main_program = paddle.static.default_main_program() path = "example/main_program.pdmodel" paddle.save(main_program, path) # example 5: save object to memory from io import BytesIO import paddle from paddle.nn import Linear paddle.disable_static() linear = Linear(5, 10) state_dict = linear.state_dict() byio = BytesIO() paddle.save(state_dict, byio) tensor = paddle.randn([2, 3], dtype='float32') paddle.save(tensor, byio) ~The input path MUST be format of dirname/filename [dirname\filename in Windows system], but received filename is empty string.z>only supports saving objects to file and `BytesIO`, but got {}zrAr*r*r+savesTv        " "rrac Cst|ts tdt|t|dkrtdt|ts&td t||dks.|dkr5td |t |rZt j |}|dkrGtd t j |}|rZt j |sZt |t|trct|}t||}t |rtjd krtjjd krtj||d }t|d !}d}tdt||D] } ||| | |qWddS1swYdSt|d }tj|||d WddS1swYdS)NzVNow only supports save state_dict of Layer or Optimizer, expect dict, but received %s.rz/The input state dict is empty, no need to save.r`rarbrcrrr~r)rrr)rr3rr!rrTrUrr%rr r5r6rRrSr8rr,rrrrrr:rr9rrr r) rr6rrNrSZ saved_objrrArrr*r*r+r3sX            " "rc KsTt|s tj|r t|}tj}zut|db}t|r.t j dkr.t j j dkr.t ||}ntj|dd}t|trmt|}d|vrf|dD]}t||tjrZt|||j||<qF|jsed|vre|d=n t||j}nt||j}Wdn 1s}wYW|SW|S|y}zzt|\}} |WWYd}~Sz2t|\}} |jrt|WYWYd}~Strt|WYWYd}~S|WYWYd}~Sz.t|d}|} t| } | WdWYYWYd}~S1swYWn t d!|YYWYd}~|Sd}~wwt"|fi|}|S) a" Load an object can be used in paddle from specified path. Note: Now supports loading ``state_dict`` of Layer/Optimizer, Tensor and nested structure containing Tensor, Program. Note: In order to use the model parameters saved by paddle more efficiently, ``paddle.load`` supports loading ``state_dict`` of Layer from the result of other save APIs except ``paddle.save`` , but the argument ``path`` format is different: 1. loading from ``paddle.static.save`` or ``paddle.Model().save(training=True)`` , ``path`` needs to be a complete file name, such as ``model.pdparams`` or ``model.pdopt`` ; 2. loading from ``paddle.jit.save`` or ``paddle.static.save_inference_model`` or ``paddle.Model().save(training=False)`` , ``path`` need to be a file prefix, such as ``model/mnist``, and ``paddle.load`` will get information from ``mnist.pdmodel`` and ``mnist.pdiparams`` ; 3. loading from paddle 1.x APIs ``paddle.fluid.io.save_inference_model`` or ``paddle.fluid.io.save_params/save_persistables`` , ``path`` need to be a directory, such as ``model`` and model is a directory. Note: If you load ``state_dict`` from the saved result of static mode API such as ``paddle.static.save`` or ``paddle.static.save_inference_model`` , the structured variable name in dynamic mode will cannot be restored. You need to set the argument ``use_structured_name=False`` when using ``Layer.set_state_dict`` later. Args: path(str|BytesIO) : The path/buffer to load the target object. Generally, the path is the target file path. When loading state_dict from the saved result of the API used to save the inference model, the path may be a file prefix or directory. **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. (3) return_numpy(bool): If specified as True, return tensor as numpy.ndarray, otherwise return tensor as paddle.Tensor. Default False. Returns: Object(Object): a target object can be used in paddle Examples: .. code-block:: python # example 1: dynamic graph import paddle emb = paddle.nn.Embedding(10, 10) layer_state_dict = emb.state_dict() # save state_dict of emb paddle.save(layer_state_dict, "emb.pdparams") scheduler = paddle.optimizer.lr.NoamDecay( d_model=0.01, warmup_steps=100, verbose=True) adam = paddle.optimizer.Adam( learning_rate=scheduler, parameters=emb.parameters()) opt_state_dict = adam.state_dict() # save state_dict of optimizer paddle.save(opt_state_dict, "adam.pdopt") # save weight of emb paddle.save(emb.weight, "emb.weight.pdtensor") # load state_dict of emb load_layer_state_dict = paddle.load("emb.pdparams") # load state_dict of optimizer load_opt_state_dict = paddle.load("adam.pdopt") # load weight of emb load_weight = paddle.load("emb.weight.pdtensor") # example 2: Load multiple state_dict at the same time from paddle import nn from paddle.optimizer import Adam layer = paddle.nn.Linear(3, 4) adam = Adam(learning_rate=0.001, parameters=layer.parameters()) obj = {'model': layer.state_dict(), 'opt': adam.state_dict(), 'epoch': 100} path = 'example/model.pdparams' paddle.save(obj, path) obj_load = paddle.load(path) # example 3: static graph import paddle import paddle.static as static paddle.enable_static() # create network x = paddle.static.data(name="x", shape=[None, 224], dtype='float32') z = paddle.static.nn.fc(x, 10) place = paddle.CPUPlace() exe = paddle.static.Executor(place) exe.run(paddle.static.default_startup_program()) prog = paddle.static.default_main_program() for var in prog.list_vars(): if list(var.shape) == [224, 10]: tensor = var.get_value() break # save/load tensor path_tensor = 'temp/tensor.pdtensor' paddle.save(tensor, path_tensor) load_tensor = paddle.load(path_tensor) # save/load state_dict path_state_dict = 'temp/model.pdparams' paddle.save(prog.state_dict("param"), path_tensor) load_state_dict = paddle.load(path_tensor) # example 4: load program import paddle paddle.enable_static() data = paddle.static.data( name='x_static_save', shape=(None, 224), dtype='float32') y_static = z = paddle.static.nn.fc(data, 10) main_program = paddle.static.default_main_program() path = "example/main_program.pdmodel" paddle.save(main_program, path) load_main = paddle.load(path) print(load_main) # example 5: save object to memory from io import BytesIO import paddle from paddle.nn import Linear paddle.disable_static() linear = Linear(5, 10) state_dict = linear.state_dict() byio = BytesIO() paddle.save(state_dict, byio) tensor = paddle.randn([2, 3], dtype='float32') paddle.save(tensor, byio) byio.seek(0) # load state_dict dict_load = paddle.load(byio) r-r~rlatin1encodingrNz(`paddle.load` can not parse the file:{}.)#r r5r6isfiler\r:UnpicklingErrorr r rrrrrr;rr3rrirrrYrXrrrrjrrrrZparse_from_stringr%r _legacy_load) r6r[r>Zexception_typerA load_resultr)Z msg_picklerrLZprogram_desc_strprogramr*r*r+r;ls       FF   <r;cKsd}t|}tj|st|rrAr=r/Zmodel_file_pathr*r*r+rTs0    r)rb)ra)D __future__rr5rr:rTrr&rirrrZ paddle.fluidrZpaddle.fluid.iorrrrrr r r Zpaddle.fluid.frameworkr r rrrrrrZpaddle.fluid.dygraph.jitrZpaddle.fluid.dygraph.iorrrrrcollections.abcr__all__r,rBrPrWr\r_rrrrrrrrrrrrrrrrrr;rr*r*r*r+sf    ( &14P!    #%  .9 i