Αi"^SSKrSSKrSSKJrJr SSKJrJr S Sjr\S Sj5r Sr Sr \S Sj5r \S S j5r g) N)Program static_only)coredygraph_not_supportcSnSn[U[5(d [S5eUR(d [ S5eUR (d [ S5eUR RUR 5nU"XU5 g)a customized load_persistables for distributed training. it should be used on parameter server, Args: executor(Executor): The executor to run for saving parameters. dirname(str): The load directory path. main_program(Program): The program whose parameters will be loaded. the main_program must be the pserver_program get after transpiler. Returns: None Examples: .. code-block:: python >>> # doctest: +REQUIRES(env: DISTRIBUTED) >>> import paddle >>> import paddle.base as base >>> paddle.enable_static() >>> exe = base.Executor(base.CPUPlace()) >>> param_path = "./my_paddle_model" >>> t = paddle.distributed.transpiler.DistributeTranspiler() >>> t.transpile(...) >>> pserver_prog = t.get_pserver_program(...) >>> _load_distributed_persistables(executor=exe, dirname=param_path, main_program=pserver_prog) c\URS5nURS5nU=(d U$)Nz .trainer_z.block)find)varname trainer_idx block_idxs U/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/paddle/distributed/io.py__is_distributed_part_varA_load_distributed_persistables..__is_distributed_part_var5s)ll;/ LL* 'i'c [5nUR5n/nUGH<nURnURnURn UR n U (aUR URURURURSS9n URS0SU /0[RRXR5U U RS.S9 MUR URURURURSS9n URS0SU /0S[RRXR50S9 GM? URU5 g)NT)nametypeshapedtype persistableloadOut) file_pathseekrrinputsoutputsattrsr)r global_blockoriginsliceis_sliceoffset create_varrrrr append_opospathjoinrun) executordirnameneed_load_vars load_prog load_blockneed_delete_varsparam origin_var slice_varr"r#r!r s r __load_persistable_vars?_load_distributed_persistables..__load_persistable_vars:sUI ++- #EJ I~~H\\F"--""#//#// $ .$$"UG,%'WW\\'??%K &!& % $..&OO,#$**$** $ /$$"VH-& Woo(NO %C$P  Yr0'main_program' should be an instance of Program.zK'_load_distributed_persistables' just be designed for distributed training.z\'_load_distributed_persistables' need current_endpoint set in DistributeTranspiler.transpileN) isinstancer TypeError_is_distributed ValueError _ps_endpoint_parameters_on_pserversget_distributed_vars_by_ep)r*r+ main_programrr3r,s r _load_distributed_persistablesr>s>( - ^ lG , ,JKK  ' ' Y    $ $ j  ,,GG  % %  H~>rcU(aUR(a [XUS9 g[RRR UUU[ US9 g)a :api_attr: Static Graph This API filters out all variables with ``persistable==True`` from the given ``main_program`` and then tries to load these variables from the directory ``dirname`` or the file ``filename``. Use the ``dirname`` to specify the directory where persistable variables (refer to :ref:`api_guide_model_save_reader_en`) were saved. If variables were saved in separate files, set ``filename`` as None; if all variables were saved in a single file, use ``filename`` to specify the file name. Args: executor(Executor): The executor used for loading persistable variables. See :ref:`api_guide_executor_en` for more details about it. dirname(str): The directory path. main_program(Program, optional): The program whose persistable variables will be loaded. If it is None, the ``default_main_program`` will be used automatically. See :ref:`api_guide_Program_en` for more about ``Program``. Default: None. filename(str, optional): The file which saved all persistable variables. If variables were saved in separated files, set it to None. Default: None. Returns: None Examples: .. code-block:: python >>> import paddle >>> import paddle.base as base >>> paddle.enable_static() >>> exe = base.Executor(base.CPUPlace()) >>> param_path = "./my_paddle_model" >>> prog = base.default_main_program() >>> paddle.distributed.io.load_persistables(executor=exe, dirname=param_path, ... main_program=None) r+r=)r+r= predicatefilenameN)r8r>paddlestaticio load_varsis_persistabler*r+r=rBs r load_persistablesrI~sKX 44& L   "" %$ # rcSnSn/4Sjn[U[5(d [S5eUR(d [ S5eUR R SS/SS 9n/nU(aURUR55 UR(aV[UR[5(aURUR5 OURUR5 [[U"U5UR555n[RR!XXS 9 UR"(aBU(a U"XU5 UR(a U"UUURUR$5 g g g ) a save_persistables for distributed training. the method will do things listed below: 1.save part of persistable variables on trainer. 2.receive "remote prefetch variables" from parameter servers and merge them. 3.save "distributed lookup table" on parameter servers. 4.receive "optimizer variables" from parameter servers and merge them. Args: executor(Executor): The executor to run for saving parameters. dirname(str): The saving directory path. main_program(Program): The program whose parameters will be saved. the main_program must be the trainer_program get after transpiler. Returns: None Examples: .. code-block:: python >>> # doctest: +REQUIRES(env: DISTRIBUTED) >>> import paddle >>> import paddle >>> paddle.enable_static() >>> exe = paddle.static.Executor(paddle.CPUPlace()) >>> param_path = "./my_paddle_model" >>> t = paddle.distributed.transpiler.DistributeTranspiler() >>> t.transpile(...) >>> train_program = t.get_trainer_program() >>> _save_distributed_persistables(executor=exe, dirname=param_path, main_program=train_program) cU(dg[RR5nUR5nUR 5GHiupVUSR nUSR nS/[U5-n S/[U5-n S/[U5-n S/[U5-n [U5HaupURnURnURnU(aUOU nUU U'URSU 3U U'URU U'UU U'Mc /nU HHnURVs/sHn[U5PM nnURSR!U55 MJ UR#SSURUU U U [$R&R!XR5S.S9 GMl UR)U5 gs snf)zl receive params on pserver through rpc. if the params are be sliced, will concat them to one, then save it. Nrz.slice., recv_save) trainer_idr slice_shapesslice_varnamesremote_varnames endpointsr)rr)rCrDrritemsr r"len enumerateblock_idr!endpointrrstrappendr(r%r&r'r))r*r+remote_params_mapprogblockr remote_paramsr r"slicesrPrQrRidx optimizerrVr!rWindexrOdimtmps r __save_remote_params<_save_distributed_persistables..__save_remote_paramss ! }}$$&!!#$5#:#:#< D"1%,,F$Q'00HVc-00F"Vc-&88N#fs='99O]!33I"+M":$--!$--$,# %u +0::,gcU(Cu%).&#+ % #;L+0;;7;Cs3x;7##CHHSM2  OO "##\\$0&4'6!*!#g{{!C  3$=L  T!8s,Gc[RR5nUR5n[R R US5n0nX7S'XgS'X'S'URS00US9 URU5 g)z because the distributed lookup table may too huge to merge and save at one place, it will be saved at parameter server independent respectively. the save directory is dirname/"__lookup_table__". __lookup_table__epmapdir lookup_tablecheckpoint_notifyrN) rCrDrrr&r'r(r%r))r*r+distributed_lookup_tablerRr[r\lookup_table_filenamers r __save_distributed_lookup_tablesH_save_distributed_persistables..__save_distributed_lookup_tabless}}$$&!!#!# W6H I"g,e 8n $R5    Trc^U4SjnU$)Nc>URT;agURR5[RR R :XdURR5[RR R:Xd@URR5[RR R:XagUR$)NF) rdescrrVarDescVarTypeFEED_MINIBATCH FETCH_LISTREADERr)varexclude_var_namess r is_validH_save_distributed_persistables..__exclude_vars..is_valid(sxx,, 4<<#7#7#F#FF88==?dll&:&:&E&EE88==?dll&:&:&A&AA?? "r)ryrzs` r __exclude_vars6_save_distributed_persistables..__exclude_vars's #rr5zK'_save_distributed_persistables' just be designed for distributed training. OptimizerRemotePrefetchT)groupby)r=r+varsN)r6rr7r8r9r;get_distributed_vars_by_vtypesextendkeys_distributed_lookup_tablelistrYfilter list_varsrCrD save_vars _is_chief _endpoints) r*r+r=rdrnr}rZry local_varss r _save_distributed_persistablesrslF2h0*,  lG , ,JKK  ' ' Y  ,,KK * +T L    !2!7!7!9:-- l<>> import paddle >>> paddle.enable_static() >>> image = paddle.static.data( ... name='image', shape=[None, 28], dtype='float32') >>> bias_attr = paddle.ParamAttr('fc.b') >>> fc = paddle.static.nn.fc(image, size=10, bias_attr=bias_attr) >>> param = paddle.static.default_main_program().global_block().var('fc.b') >>> res = paddle.distributed.io.is_persistable(param) F) rrrrrsrtrurvrwr)rxs r rGrG`sw4  4<<//>>> 88==?dll22== = 88==?dll2299 9 ??rc U(aUR(a [XUS9$[RR UUUS[ US9$)a Save all persistable variables from :code:`main_program` to the folder :code:`dirname` or file :code:`filename`. You can refer to :ref:`api_guide_model_save_reader_en` for more details. And then saves these persistables variables to the folder :code:`dirname` or file :code:`filename`. The :code:`dirname` is used to specify the folder where persistable variables are going to be saved. If you would like to save variables in separate files, set :code:`filename` None; if you would like to save all variables in a single file, use :code:`filename` to specify the file name. Args: executor(Executor): The executor to run for saving persistable variables. You can refer to :ref:`api_guide_executor_en` for more details. dirname(str, optional): The saving directory path. When you need to save the parameter to the memory, set it to None. main_program(Program, optional): The program whose persistable variables will be saved. You can refer to :ref:`api_guide_Program_en` for more details. If it is None, the default main program will be used. Default: None. filename(str, optional): The file to save all variables. If you prefer to save variables in different files, set it to None. Default: None. Returns: str: When saving parameters to a file, returns None. When saving parameters to memory, returns a binary string containing parameters. Examples: .. code-block:: python >>> import paddle >>> paddle.enable_static() >>> dir_path = "./my_paddle_model" >>> file_name = "persistables" >>> image = paddle.static.data(name='img', shape=[None, 28, 28], dtype='float32') >>> label = paddle.static.data(name='label', shape=[None, 1], dtype='int64') >>> feeder = paddle.base.DataFeeder(feed_list=[image, label], place=paddle.CPUPlace()) >>> predict = paddle.static.nn.fc(x=image, size=10, activation='softmax') >>> loss = paddle.nn.functional.cross_entropy(input=predict, label=label) >>> avg_loss = paddle.mean(loss) >>> exe = paddle.static.Executor(paddle.CPUPlace()) >>> exe.run(paddle.static.default_startup_program()) >>> paddle.distributed.io.save_persistables(executor=exe, dirname=dir_path, filename=file_name) >>> # The persistables variables weights and bias in the fc layer of the network >>> # are going to be saved in the same file named "persistables" in the path >>> # "./my_paddle_model" r@N)r+r=rrArB)r8rrCrDrrGrHs r save_persistablesrsRr 44- L  }}&& %$ '  rcSnUb[RRU5n[RRU5(d[ SUS35eUcSn[RR U[RR U55nUb[RR U5n[US5nUR5nSSS5 OSnUc [ S5eUnUnUn[R"W5n [R"U R55(d[ S U R5S 35e[XX5 U RR!5n U RR#5n U V s/sH!oR%5R'U 5PM# n n XU /$!,(df  N=fs sn f) a Load the inference model from a given directory. By this API, you can get the model structure(Inference Program) and model parameters. You can refer to :ref:`api_guide_model_save_reader_en` for more details. Args: dirname(str): One of the following: - The given directory path. - Set to None when reading the model from memory. executor(Executor): The executor to run for loading inference model. See :ref:`api_guide_executor_en` for more details about it. model_filename(str, optional): One of the following: - The name of file to load the inference program. - If it is None, the default filename ``__model__`` will be used. - When ``dirname`` is ``None``, it must be set to a string containing model. Default: ``None``. params_filename(str, optional): It is only used for the case that all parameters were saved in a single binary file. One of the following: - The name of file to load all parameters. - When ``dirname`` is ``None``, it must be set to a string containing all the parameters. - If parameters were saved in separate files, set it as ``None``. Default: ``None``. pserver_endpoints(list, optional): It is only needed by the distributed inference. If using a distributed look up table during the training, this table is also needed by the inference process. Its value is a list of pserver endpoints. Returns: list: The return of this API is a list with three elements: (program, feed_target_names, fetch_targets). The `program` is a ``Program`` (refer to :ref:`api_guide_Program_en`), which is used for inference. The `feed_target_names` is a list of ``str``, which contains names of variables that need to feed data in the inference program. The `fetch_targets` is a list of ``Variable`` (refer to :ref:`api_guide_Program_en`). It contains variables from which we can get inference results. Examples: .. code-block:: python >>> import paddle >>> import paddle.base as base >>> import numpy as np >>> paddle.enable_static() >>> # Build the model >>> main_prog = paddle.static.Program() >>> startup_prog = paddle.static.Program() >>> with paddle.static.program_guard(main_prog, startup_prog): ... data = paddle.static.data(name="img", shape=[64, 784], append_batch_size=False) ... w = paddle.create_parameter(shape=[784, 200], dtype='float32') ... b = paddle.create_parameter(shape=[200], dtype='float32') ... hidden_w = paddle.matmul(x=data, y=w) ... hidden_b = base.layers.elementwise_add(hidden_w, b) >>> place = base.CPUPlace() >>> exe = base.Executor(place) >>> exe.run(startup_prog) >>> # Save the inference model >>> path = "./infer_model" >>> base.io.save_inference_model(dirname=path, feeded_var_names=['img'], ... target_vars=[hidden_b], executor=exe, main_program=main_prog) ... >>> # Demo one. Not need to set the distributed look up table, because the >>> # training doesn't use a distributed look up table. >>> [inference_program, feed_target_names, fetch_targets] = ( ... paddle.distributed.io.load_inference_model_distributed(dirname=path, executor=exe)) >>> tensor_img = np.array(np.random.random((1, 64, 784)), dtype=np.float32) >>> results = exe.run(inference_program, ... feed={feed_target_names[0]: tensor_img}, ... fetch_list=fetch_targets) ... >>> # Demo two. If the training uses a distributed look up table, the pserver >>> # endpoints list should be supported when loading the inference model. >>> # The below is just an example. >>> endpoints = ["127.0.0.1:2023","127.0.0.1:2024"] >>> [dist_inference_program, dist_feed_target_names, dist_fetch_targets] = ( ... paddle.distributed.io.load_inference_model_distributed(dirname=path, ... executor=exe, ... pserver_endpoints=endpoints)) ... >>> # In this example, the inference program was saved in the file >>> # "./infer_model/__model__" and parameters were saved in >>> # separate files under the directory "./infer_model". >>> # By the inference program, feed_target_names and >>> # fetch_targets, we can use an executor to run the inference >>> # program for getting the inference result. FNzThere is no directory named '' __model__rbTzBThe path of params cannot be None when the directory path is None.zUnsupported program version:  )r&r'normpathisdirr9r(basenameopenreadrparse_from_stringr_is_program_version_supported_versionrIrrget_feed_target_namesget_fetch_target_namesrrx)r+r*model_filenameparams_filenamepserver_endpointsload_from_memory load_dirnamefprogram_desc_strprogramfeed_target_namesfetch_target_namesr fetch_targetss r load_inference_model_distributedrsBww''0 ww}}\**:   & gg..?O .$ '1 vvx ( '   "T  ))''(89G  - -g.>.>.@ A A89I9I9K8LBOPPhgG ::< <<>5G5GT""4(5G  661( '(sG(G G)N)NN)NNN)r&rCpaddle.base.frameworkrrpaddle.frameworkrrr>rIrrGrrr|rr rst 66e?P6 6 rePDD D N  H7 H7r