o Me|@sddlmZddlZddlZddlZddlZddlZddlZddl m Z ddl Z ddl m Z ddlmZmZmZmZddlmZmZddlmZdd lmZdd lmZd d lmZdd lmZddlmZddlZddlmZddlm Z!ddlm"Z"ddl#m$Z$gdZ%e&a'ej(Z)ej*Z+ddZ,ddZ-e ddZ.dGddZ/ddZ0dd Z1dHd!d"Z2d#d$Z3 %dId&d'Z4 dGd(d)Z5d*d+Z6dJd-d.Z7d/d0Z8d1d2Z9d3d4Z:d5d6Z;d7d8ZdKd=d>Z?Gd?d@d@e@ZAGdAdBdBe@ZBGdCdDdDe@ZCGdEdFdFe@ZDdS)L)print_functionN)signature_safe_contextmanager) convert_dtype)Programdefault_main_programVariableOperator)convert_np_dtype_to_dtype_ _apply_pass)core) unique_name)compiler)compat)TrainerFactory)FetchHandlerMonitor) framework)auto_checkpoint)_prune_feed_ops) lru_cache)Executor global_scope scope_guardcCstS)a :api_attr: Static Graph Get the global/default scope instance. There are a lot of APIs use :code:`global_scope` as its default value, e.g., :code:`Executor.run` Returns: Scope: The global/default scope instance. Examples: .. code-block:: python import paddle import numpy paddle.static.global_scope().var("data").get_tensor().set(numpy.ones((2, 2)), paddle.CPUPlace()) numpy.array(paddle.static.global_scope().find_var("data").get_tensor()) g_scoperrED:\Projects\ConvertPro\env\Lib\site-packages\paddle/fluid/executor.pyr1srcCs t}|a|SNrscopeexrrr _switch_scopeGsr"ccs*t|}z dVWt|dSt|w)a This function switches scope through python `with` statement. Scope records the mapping between variable names and variables ( :ref:`api_guide_Variable` ), similar to brackets in programming languages. If this function is not invoked, all variables and variable names are recorded in the default global scope. When users need to create variables with the same name, they need to switch scopes through this function if they do not want the mapping of variables with the same name to be overwritten. After switching through the `with` statement, all variables created in the `with` block will be assigned to a new scope. Parameters: scope: The new scope. Returns: None Examples: .. code-block:: python import paddle import numpy paddle.enable_static() new_scope = paddle.static.Scope() with paddle.static.scope_guard(new_scope): paddle.static.global_scope().var("data").get_tensor().set(numpy.ones((2, 2)), paddle.CPUPlace()) numpy.array(new_scope.find_var("data").get_tensor()) N)r"rrrrrNs "rFcst|tjrfdd|DSt|trfdd|DSt|tjs%J|}t|dkr3td|rCr>t |St |SdS)a Convert a Tensor to a numpy.ndarray, its only support Tensor without LoD information. For higher dimensional sequence data, please use LoDTensor directly. Examples: .. code-block:: python import paddle.fluid as fluid import numpy new_scope = fluid.Scope() with fluid.scope_guard(new_scope): fluid.global_scope().var("data").get_tensor().set(numpy.ones((2, 2)), fluid.CPUPlace()) tensor = new_scope.find_var("data").get_tensor() fluid.executor.as_numpy(tensor) # or numpy.array(new_scope.find_var("data").get_tensor()) Args: tensor(Variable): a instance of Tensor copy(bool, optional): Whether to use deep copy. Returns: numpy.ndarray cg|]}t|qSras_numpy.0tcopyrr zas_numpy..cr#rr$r&r)rrr+r,rzSome of your fetched tensors hold LoD information. They can not be completely cast to Python ndarray. Please set the parameter 'return_numpy' as 'False' to return LoDTensor itself directly.N) isinstancer ZLoDTensorArraylist LoDTensorlodlen RuntimeErrorZ_is_initializednparrayZasarray)tensorr*r0rr)rr%ws     r%cCs4t|tjjs t|}t|tjjst|}||kS)a Returns True if the first dtype can be compatible the second one. Currently, we require the two dtype's have to be same. Args: dtype (np.dtype|VarType|str): The type of data: float32, int64, etc. Returns: True if the two types are same. )r-r VarDescVarTyper )firstsecondrrrdtype_is_compatible_withs  r:cCstt|}|t|kr dSt|D]'}||dus||dkrq||dus+||dkr,q||||kr7dSqdS)aw Returns True if the two dimensions are compatible. A dimension is compatible with the other if: 1. The length of the dimensions are same. 2. Each non-negative number of the two dimensions are same. 3. For negative number or 'None' in a dimension, it means unknown so it is compatible with any number. Args: first (list/tuple): integers representing shape. "None" or negative number means unknown. second (list/tuple): integers representing shape. "None" or negative number means unknown. Returns: True if the two dimensions are compatible. FNrT)r1range)r8r9Zdim_lenirrrdimension_is_compatible_withs  r=cCs|jrUt||j|}|dur td|jt|j|j|ft| |j sUt |j tj j r5t|j n|j }t | tj j rGt| n| }td|j||fdS)a Returns True if the variable doesn't require feed check or it is compatible with the shape and have same dtype as the fed value. A dimension is compatible with the other if: 1. The length of the dimensions are same. 2. Each non-negative number of the two dimensions are same. 3. For negative number or 'None' in a dimension, it means unknown so it is compatible with any number. Args: var (Variable): the Variable object feed (LoDTensor): the fed value, which must be a LoDTensor num_places: an integer value indicating the number of places. ParallelExecutor will divide data into devices (CPU/GPU) evenly. Returns: True if the shape and dtype of variable is compatible with the feed value Raises: ValueError: if the shape or dtype of the variable is not compatible with the feed value NzeThe fed Variable %r should have dimensions = %d, shape = %r, but received fed shape %r on each devicez. Returns: A boolean value that indicates whether a block has feed operators that match the info contained in feed_targets and feed_holder_name. rrErXOutz('feed_targets' does not have {} variablez:Feed operators in program desc do not match 'feed_targets')opsr>typeinputoutput Exceptionformatr1)blockZ feed_targetsZfeed_holder_nameZ feed_countopfeed_target_namerrrhas_feed_operatorss& rRfetchcCsd}|jD]B}|j|krG|d7}|jdd|ksJ|jdd}|dd|Dvr6td||jd}|||jksGJq|dkrV|t |krVtd |dkS) a Check whether the block already has fetch operators. Return false if the block does not have any fetch operators. If some fetch operators have been appended to the block, check that the info contained in these fetch operators matches the fetch_targets and fetch_holder_name. Raise exception when any mismatch is found. Return true when the block has fetch operators with matching info. Args: block: a block instance (typically global block of a program) fetch_targets: a dictionary of {fetch_target_name: fetch_target_data} fetch_holder_name: the name of the variable that holds the data of all fetch targets. The type of this fetch_holder variable is FETCH_LIST, which is essentially vector. fetch_op: the operator name of fetch Return: A boolean value that indicates whether a block has fetch operators that match the info contained in fetch_targets and fetch_holder_name. rrrHrGcSsg|]}|jqSr)r>rA)r'rDrrrr+Fs z'has_fetch_operators..z)'fetch_targets' does not have {} variablecolzrJrLrKrMrNattrrAr1)rOZ fetch_targetsZfetch_holder_namefetch_opZ fetch_countrPZfetch_target_nameidxrrrhas_fetch_operators's,  rXcCsJ|}|}||jvr||}n |j|tjjjdd}||jvr)||} n |j|tjjj dd} t |||sft |D]'\} } | | r^|| } |j dd|gid| gid| idq>td| q>|rkd } nd } t|||| st |D]*\} }t|tst|tjsJd | t|f|j| d|gid| gid| idqx|S) NTrArJ persistablerErGrHrTrJZinputsZoutputsattrsIThe variable %s is not found in program. It is not declared or is pruned.fetch_v2rS!Wrong type for fetch_list[%s]: %s)clone global_blockvarsrD create_varr r6r7FEED_MINIBATCH FETCH_LISTrR enumeratehas_var _prepend_opwarningswarnrXr-rsix string_typesrJ append_op)programrE fetch_list feed_var_namefetch_var_name use_fetch_v2 tmp_programrafeed_var fetch_varr<rAoutrVrDrrr_add_feed_fetch_opsTsd         rwc Csjtrdnd}||d}ddd}t}|r!d}t||||||r1|r3d}t|||||dSdSdS)NTF)use_cudaZmem_opt_skip_varsboolz list[str]Zbuffer_shared_inplace_passZinplace_addto_op_pass)r Zis_compiled_with_cudarr ) rnenable_inplace enable_addtoskip_var_namesrxr\Z attr_typesZempty_startup_programZ pass_namerrr_apply_inplace_addto_passs    r}TcCspt|tjsJ|durt}t|tjsJ|t|}|dus*Jd|d|}|r6t |dd}|S)aR Fetch the value of the variable with the given name from the given scope. Args: name(str): name of the variable. Typically, only persistable variables can be found in the scope used for running the program. scope(core.Scope|None): scope object. It should be the scope where you pass to Executor.run() when running your program. If None, global_scope() will be used. Default None. return_numpy(bool): whether convert the tensor to numpy.ndarray. Default True. Returns: LodTensor|numpy.ndarray Nz Cannot find zm in scope. Perhaps you need to make the variable persistable by using var.persistable = True in your program.Tr)) r-rkrlrr Z_Scopefind_var _to_name_strZ get_tensorr%)rAr return_numpyrDr5rrr _fetch_vars   rcsHddt|tr |d}t|tr fdd|D}d|S|S)NcSs\t|tr |jSt|tr|St|tjrt|St|tr&tt|St t|d)Nz$ should be Variable, Operator or str) r-rr>rAstrrkrlr id TypeErrorrDrrr_to_strs      z_to_name_str.._to_strrcsg|]}|qSrr)r'itemrrrr+z _to_name_str..,)r-tupler.join)rDsrrrrs   rcCstjdup tjdvSNr1TTruetrue)rZ_enable_standalone_executor_rrrr_is_enable_standalone_executorsrcCs tjdvSr)rZ"_dy2st_enable_standalone_executor_rrrr$_is_dy2st_enable_standalone_executor rc Csddlm}tdd}|d}|}ttdd}||_t|}t |D]\}}| }||_ ||_ |j |q(t|} | S)Nr)fleet_executor_desc_pb2PADDLE_TRAINER_ENDPOINTSrPADDLE_TRAINER_IDr)Zdistributed.fleet.protorosgetenvsplitZFleetExecutorDescintcur_rankr1rfZRankInforankZip_portZ cluster_infoappendr Z FleetExecutorZSerializeToString) rZtrainer_endpoints_strtrainer_endpointsZfleet_exe_descrnrankrZendpointZ rank_infoZ fleet_exerrr_prepare_fleet_executors   rcCs|jt||Sr)r>Zcached_hash_str_get_program_cache_key)rnrErorrr)_get_strong_program_cache_key_for_new_exes rcCsBdd}t|tjr |jn|}||jdtt|t||S)NcSs,g}t|jD]}||q d|S)N )r.rbkeysrr)rOZ block_strvar_namerrr_get_varname_from_blocks  z>_get_strong_program_cache_key.._get_varname_from_blockr)r-rCompiledProgram_programblocksrrr)rnrEror inner_programrrr_get_strong_program_cache_keys rcCslg}t|trt|}nt|tst|tr)t|D] \}}|t|7}qttt|}t||Sr) r-dictr.rrrfmaprr)rEroZfeed_var_namesr<eachfetch_var_namesrrrr s  rcCst|tjsO|dusJdt|tjjrt|n|}t|r*t|g |}n%t|t t frFt|}|j tj kr@td| |}n tdt|t}||||S)a Convert numpy.ndarray to Tensor, its only support Tensor without LoD information. For higher dimensional sequence data, please use LoDTensor directly. Examples: >>> import paddle.fluid as fluid >>> place = fluid.CPUPlace() >>> exe = fluid.executor(place) >>> data = np.array(size=(100, 200, 300)) >>> np_outs = map(lambda x: fluid.executor._as_lodtensor(x, place), data) >>> ... Args: data(numpy.ndarray|list|tuple|scalar): a instance of array, scalar, list or tuple data(core.Place): the place of created tensor dtype(core.VarDesc.VarType|str): the expected data type of created tensor Returns: LoDTensor Nz:The dtype should be given when feed data is not np.ndarrayz Faild to convert input data to a regular ndarray : * Usually this means the input data contains nested lists with different lengths. Please consider using 'fluid.create_lod_tensor' to convert it to a LoD-Tensor.z2Convert data of type {} to Tensor is not supported)r-r3ndarrayr r6r7rZisscalarr4astyper.rrCZobject_rrNrJr/set)dataplacerCr5rrr _as_lodtensors0       rc@s*eZdZd ddZddZeddZdS) FetchHandlerN<cCs|dksJ||_||_dSr)var_dict period_secs)selfrrrrr__init__Is  zFetchHandler.__init__cCsH|D]}t||tjurtjd|||dqtjddS)Nz {}[0]: {} rr)rJr3rsysstdoutwriterN)rres_dictkeyrrrhandlerNs zFetchHandler.handlercCs tddS)Na class FetchHandlerExample(FetchHandler): def handler(self, res_dict): print(res_dict["auc"]) print("auc: {}, {}".format(res_dict["auc"], time.ctime())) auc = Variable() var_dict = {"auc": auc} handler = FetchHandlerExample(var_dict=var_dict) )printrrrrhelpTs zFetchHandler.help)Nr)__name__ __module__ __qualname__rr staticmethodrrrrrrGs  rc@s6eZdZddZd ddZddZdd Zd d Zd S)_StandaloneExecutorcCs0t|_|j|||_||_||_dSr)r Place_place set_place _main_programZ_scope_create_new_executor_new_exe)rrZ main_programr rrrrds  z_StandaloneExecutor.__init__TcCs2||}|j|||}|rt|ddS|S)a  Args: feed_names(list): This parameter represents the input names of the model. fetch_list(list): This parameter represents the Tensors that need to be returned after the model runs. The default is None. return_numpy(bool): This parameter indicates whether convert the fetched Tensors (the Tensor specified in the fetch list) to numpy.ndarray. if it is False, the type of the return value is a list of :code:`LoDTensor`. The default is True. Tr)) _check_fetchrrun _move_to_listr%)rr feed_namesrortensorsrrrrks  z_StandaloneExecutor.runcCst|j|jj}|Sr)r ZStandaloneExecutorrrr>)rnew_exerrrr~sz(_StandaloneExecutor._create_new_executorcCs|duri}nt|ttfrt|dksJd|d}t|ts)tdt||j}t| D]}| |sG| |t d|q4|S)a6 Update the feed dict, remove the feed item which is pruned in program. Notes: This is a very low level API. Users should not use this API directly. Args: feed(list|dict): feed dict or list. Returns: feed:(list|dict) updated feed. NrNot compiled with data parallelr9feed requires dict as its Parameter. But you passed in %sr])r-r.rr1rrrJrrarrgpoprirj)rrEra feed_namerrr _update_feeds,     z _StandaloneExecutor._update_feedcCsX|durg}g}|D]}t|tr|j}nt|ts$tdt|j||q |S)Nz9Required fetch_var shall be str|Variable, but received {}) r-rrArrrNrJrr)rroresrurrrrs    z _StandaloneExecutor._check_fetchN)T)rrrrrrrrrrrrrbs   "rc@s<eZdZGdddeZddZddZddZd d Zd S) _ExecutorCachec@s$eZdZddZddZddZdS)z_ExecutorCache._CachedDatacCs||_||_||_||_||_||_||_t|jtj r8|jj s+t |jj |j_ tt|jj |||_dStt|j|||_dSr)rnrErorprqrr r-rrrrIrGraph_graph to_programhashrrrrnrErorprqrr rrrrs0   z#_ExecutorCache._CachedData.__init__cCst|tjo |j|jkSr)r-r _CachedDatar)rotherrrr__eq__s  z!_ExecutorCache._CachedData.__eq__cCs|jSr)rrrrr__hash__sz#_ExecutorCache._CachedData.__hash__N)rrrrrrrrrrrs rcCstdd|j|_dS)N)maxsize)r_get_program_and_executor _get_cached_program_and_executorrrrrrs z_ExecutorCache.__init__cC|jdSr)r cache_clearrrrrclearz_ExecutorCache.clearc Cs|||||||||Sr)rrrrrrget_program_and_executors  z'_ExecutorCache.get_program_and_executorcCs|j}t|tjr |jn|}|j}|j}|j}|j}|j }|j } t|tjs-t|j tjrWt|tjr5|n|j } | j } | | |t| j } | } t|drT|j| _| }nd} ddlm}m}|rl|tkrl||}t|||||dd}tjdddvr|js|jdkrtd n|jdkrtd ntd | dus| jrdnd }| dur| j rdnd }|s|rt!t"||}t#|||||$}t%||| }||fS) N lr_shedulerr) prim_enabled prim2origT)rnrErorprqrrFLAGS_CONVERT_GRAPH_TO_PROGRAMrrz'There are more than 1 block in program.zThere are 1 block in program.zThere are no block in program.F)&rnr-rrrrErorprqrr r_build_strategy_compilerrrhasattrrZpaddle.incubate.autogradrrrrwrenvirongetZ_is_start_up_program_Z num_blocksloggingwarningrzr{evalrr}r`r)rZ cached_datarnrrErorprqrr compiled_programZbuild_strategyZir_graphZconverted_programrrrzr{r|Z new_programrrrrrsr          z(_ExecutorCache._get_program_and_executorN) rrrobjectrrrrrrrrrrs # rc@sFeZdZdZd\ddZddZddZd d Zd d Zd dZ ddZ ddZ ddZ ddZ ddZddZddZddZedd Zd!d"Zd#d$Zed%d&Ze   d]d'd(Zed)d*Z d+d,Zd-d.Z    / 0  1 2 1 2d^d3d4Zd5d6Zd7d8Zd9d:Zd;d<Z d_d=d>Z!d?d@Z"    A 2   Bd`dCdDZ#    A 2 2   B dadEdFZ$    A 2 2   B  2dbdGdHZ% I    2dcdJdKZ&   / 0  2dddLdMZ'dNdOZ(e 2dedPdQZ)edfdRdSZ*    A 2 2   B  2dbdTdUZ+    A 2   B dgdVdWZ,   2   B dhdXdYZ-    A 2   B dgdZd[Z.dS)ira' :api_attr: Static Graph An Executor in Python, supports single/multiple-GPU running, and single/multiple-CPU running. Args: place(paddle.CPUPlace()|paddle.CUDAPlace(n)|str|None): This parameter represents which device the executor runs on. When this parameter is None, PaddlePaddle will set the default device according to its installation version. If Paddle is CPU version, the default device would be set to `CPUPlace()` . If Paddle is GPU version, the default device would be set to `CUDAPlace(0)` . Default is None. If ``place`` is string, it can be ``cpu``, and ``gpu:x``, where ``x`` is the index of the GPUs. Note: users only pass one Place or None to initialize Executor when using multiple-cards. Other APIs will override the cards. See `document for multiple-cards `_ Returns: Executor Examples: .. code-block:: python import paddle import numpy import os # Executor is only used in static graph mode paddle.enable_static() # Set place explicitly. # use_cuda = True # place = paddle.CUDAPlace(0) if use_cuda else paddle.CPUPlace() # exe = paddle.static.Executor(place) # If you don't set place, PaddlePaddle sets the default device. exe = paddle.static.Executor() train_program = paddle.static.Program() startup_program = paddle.static.Program() with paddle.static.program_guard(train_program, startup_program): data = paddle.static.data(name='X', shape=[None, 1], dtype='float32') hidden = paddle.static.nn.fc(data, 10) loss = paddle.mean(hidden) paddle.optimizer.SGD(learning_rate=0.01).minimize(loss) # Run the startup program once and only once. # Not need to optimize/compile the startup program. exe.run(startup_program) # Run the main program directly without compile. x = numpy.random.random(size=(10, 1)).astype('float32') loss_data, = exe.run(train_program, feed={"X": x}, fetch_list=[loss.name]) # Or, compiled the program and run. See `CompiledProgram` # for more details. # NOTE: If you use CPU to run the program or Paddle is # CPU version, you need to specify the CPU_NUM, otherwise, # PaddlePaddle will use all the number of the logic core as # the CPU_NUM, in that case, the batch size of the input # should be greater than CPU_NUM, if not, the process will be # failed by an exception. # Set place explicitly. # if not use_cuda: # os.environ['CPU_NUM'] = str(2) # If you don't set place and PaddlePaddle is CPU version os.environ['CPU_NUM'] = str(2) compiled_prog = paddle.static.CompiledProgram( train_program).with_data_parallel(loss_name=loss.name) loss_data, = exe.run(compiled_prog, feed={"X": x}, fetch_list=[loss.name]) NcCs|dur t}||_nt||_t|_t|_t|_t|_t|_ t|_ t }| |jt ||_d|_t|_d|_td|_t|_t|_d|_d|_dS)NFZ__auto_checkpoint_executor__)rZ_current_expected_placer_get_paddle_placerprogram_caches ctx_cachestrainer_caches scope_cachesZ var_cachespruned_program_cachesr rrr_default_executor_closedpruned_program_scope_cachesZ_prepare_to_run_calledr generateZ_auto_checkpoint_namer_enable_interpreter_corer_executor_cache_fleet_executor_fleet_executor_with_standalone)rrZexpected_placeprrrr|s.    zExecutor.__init__cCrr)r rrrrr__del__szExecutor.__del__cC|j|dSr)rrrprogram_cache_keyrrr_get_scope_cacherzExecutor._get_scope_cachecCrr)rrrrrr_get_ctx_cacherzExecutor._get_ctx_cachecCrr)rrrrrr_get_trainer_cacherzExecutor._get_trainer_cachecCrr)rrrrrr_get_program_cacherzExecutor._get_program_cachecC||j|<dSr)rrrrnrrr_add_program_cacherzExecutor._add_program_cachecCrr)rrrrrr_get_pruned_program_cacherz"Executor._get_pruned_program_cachecCrr)rrrrr_add_pruned_program_cacherz"Executor._add_pruned_program_cachecCrr)rrrrrr_get_pruned_program_scope_cacherz(Executor._get_pruned_program_scope_cachecCrr)rrrrr_add_pruned_program_scope_cacherz(Executor._add_pruned_program_scope_cachecCrr)r)rZ ctx_cache_keyctxrrr_add_ctx_cacherzExecutor._add_ctx_cachecCrr)r)rZtrainer_cache_keyrrrr_add_trainer_cacherzExecutor._add_trainer_cachecCrr)r)rZscope_cache_keyr rrr_add_scope_cacherzExecutor._add_scope_cachecCstd|ddS)Nz"use_program_cache is force set to z! by FLAGS_FORCE_USE_PROGRAM_CACHE)rr)ruse_program_cacherrr_log_force_set_program_caches z%Executor._log_force_set_program_cachec Cs|}|jD]F}|jdkrK|jdd}||}||} | jtjj j krrJrLrDrCr r6r7ZSTRINGSr-r/rrrFrUZset_feed_variable) rrnrErpr rarPrQZcur_feedrDrWrrr _feed_datas      zExecutor._feed_datacs$fddtjt|D}|S)Ncsg|] }t|qSr)r Zget_fetch_variable)r'r<rqr rrr+s z(Executor._fetch_data..)rkmovesr;r1)rrorqr Zoutsrr%r _fetch_datas zExecutor._fetch_datac Csg}g}dd}t|D]F\}}t|tr!|D]}||||qq t|trLt|dttfs>td|||t|dj|dD]}||||qBq ||||q ||fS)a6 Split optimize_ops from fetch_list, which provided to specify program prunning. Args: fetch_list(list): The original fetch_list. Possible types of fetch_list are: fetch_list = ['loss'] fetch_list = [[sgd, sgd], 'loss'] fetch_list = [([sgd, sgd], [(param, grad)]), 'loss'] Returns: optimize_ops(list): The optimize operators splited from fetch_list. fetch_list(list): The updated fetch_list which does not contain optimize operators. cSsdt|tr|r||dStdt|ts$t|ts$t|tjr+||dStdt |)Nz0The operator in fetch_list is not an optimize_opzOThe item in fetch_list should be str, variable or optimize_op, but received %s.) r-r _is_optimize_oprrrrrkrlrJ) _optimize_ops _fetch_listrrrr _get_targetss   z@Executor._split_optimize_ops_in_fetch_list.._get_targetsrzRequires fetch_list[{}][0] shall be one of (list, tuple) when type(fetch_list[{}]) is `tuple`, but received fetch_list[{}][0]'s type is `{}`.)rfr-r.rrrNrJr)clsror)r*r+indexrr<rrr!_split_optimize_ops_in_fetch_lists*    z*Executor._split_optimize_ops_in_fetch_listcCst|tj}|r|jr|j}n tddS|}g}t|tr&t|}nt|ts0t|t rAt |D] \}} |t| 7}q4|sX|j D]} | j D] } | rV|| qKqF||} ||| } |rs| |_t| j|_d|_|S| }|S)a Prune operators and variables which are not needed to generate :code:`fetch_list` and optimize operators. Prune operators and variables which are needed to generate variables to be feeded. Notes: This is a very low level API. Users should not use this API directly. Args: program(Program): the origin program feed(list|dict): feed dict or list. fetch_list(list|Variable): A list of variables need to be fetched optimize_ops(list[Operator]): A list of optimizer operators Returns: Program: A new, pruned program. z[The program holds no _program, maybe it is constructed by graph, which can't be pruned yet.NF)r-rrrrirjrr.rrrfrrIr(rZ_prune_with_inputr ZGraphr>rZ _compiled)r,rnrEro optimize_opscompiledZorigin_programrr<rrOrPtargetspruned_programrrr_prune_programs>      zExecutor._prune_programcCst|tj}|r|jr|j}n td|S|}t|tr=t| D]}| |s:| |td|q'|St|tsGt|t rjt |D]\}}t| D]}| |sh| |td|qUqK|S)ah Update the feed dict, remove the feed item which is pruned in program. Notes: This is a very low level API. Users should not use this API directly. Args: program(Program): the pruned program. feed(list|dict): feed dict or list. Returns: feed:(list|dict) updated feed. z@The program holds no _program, maybe it is constructed by graph.r])r-rrrrarirjrr.rrgrrrf)r,rnrEr0rarr<rrrrrZsB        zExecutor._update_feedcCs@|jsd|_|jD] \}}|j|~q |jdSdS)a Close the executor. This interface is used for distributed training (PServers mode). This executor can not be used after calling the interface, because this interface releases resources associated with the current Trainer. Returns: None Examples: .. code-block:: python import paddle cpu = paddle.CPUPlace() exe = paddle.static.Executor(cpu) # execute training or testing exe.close() TN)rritemsrrelease_trainerclose)rktrainer_instancerrrr6s zExecutor.closecCsddlm}|j} |jdu} | r|j} t|trXt} |D]2} || }| r,| | nd}t|tj sCt || t |r@|j nd}| rMt ||| || | <q| | n_t|tsbt|trt}t|D]H\}}t|tsvtdt}|D]0} || }| r| | nd}t|tj st || |j||r|j nd}| rt ||||| <q{||qi| |t|jdr|jj}t||sJd|}|jj|j}t |t |j }trtdn| |j|ittt|}| ||!}|rt"|S|S)Nr LRSchedulerz*Each element of feed list should be a dictrmust be LRSchedulerzCaution!!! When capturing CUDA Graph, the learning rate scheduler would not take any effect! Please set the learning rate manually before each batch!)#paddle.optimizer.lrr: _executorrrar-rrDr r/rCPUPlacerCrFZ device_countZ'feed_and_split_tensor_into_local_scopesr.rrfr_placesrZfeed_tensors_into_local_scopesrrrb _var_nameZis_cuda_graph_capturingrirjrrrrr%)rrnr rErorqr return_mergedr:exer?raZfeed_tensor_dictrZ feed_tensorrDrr<rrr5rlr_valuelr_varZ lr_tensorrrrrr _run_parallelsz                zExecutor._run_parallelrErSTFc  Cstjdd} | dur| dv}||z|j||||||||| | d } t| WStyD} ztj t WYd} ~ dSd} ~ ww)a) Run the specified :code:`Program` or :code:`CompiledProgram`. It should be noted that the executor will execute all the operators in :code:`Program` or :code:`CompiledProgram` without pruning some operators of the :code:`Program` or :code:`CompiledProgram` according to fetch_list. And you could specify the scope to store the :code:`Tensor` during the executor running if the scope is not set, the executor will use the global scope, i.e. :code:`paddle.static.global_scope()`. Args: program(Program|CompiledProgram): This parameter represents the :code:`Program` or :code:`CompiledProgram` to be executed. If this parameter is not provided, that parameter is None, the program will be set to :code:`paddle.static.default_main_program()`. The default is None. feed(list|dict): This parameter represents the input Tensors of the model. If it is single card training, the feed is dict type, and if it is multi-card training, the parameter feed can be dict or list of Tensors. If the parameter type is dict, the data in the feed will be split and sent to multiple devices (CPU/GPU), that is to say, the input data will be evenly sent to different devices, so you should make sure the number of samples of the current mini-batch must be greater than the number of places; if the parameter type is list, those data are copied directly to each device, so the length of this list should be equal to the number of places. The default is None. fetch_list(list): This parameter represents the Tensors that need to be returned after the model runs. The default is None. feed_var_name(str): This parameter represents the name of the input Tensor of the feed operator. The default is "feed". fetch_var_name(str): This parameter represents the name of the output Tensor of the fetch operator. The default is "fetch". scope(Scope): the scope used to run this program, you can switch it to different scope. default is :code:`paddle.static.global_scope()` return_numpy(bool): This parameter indicates whether convert the fetched Tensors (the Tensor specified in the fetch list) to numpy.ndarray. if it is False, the type of the return value is a list of :code:`LoDTensor`. The default is True. use_program_cache(bool): This parameter indicates whether the input :code:`Program` is cached. If the parameter is True, the model may run faster in the following cases: the input program is :code:`paddle.static.Program`, and the parameters(program, feed Tensor name and fetch_list Tensor) of this interface remains unchanged during running. The default is False. return_merged(bool): This parameter indicates whether fetched Tensors (the Tensors specified in the fetch list) should be merged according to the execution device dimension. If :code:`return_merged` is False, the type of the return value is a two-dimensional list of :code:`Tensor` / :code:`LoDTensorArray` ( :code:`return_numpy` is False) or a two-dimensional list of :code:`numpy.ndarray` ( :code:`return_numpy` is True). If :code:`return_merged` is True, the type of the return value is an one-dimensional list of :code:`Tensor` / :code:`LoDTensorArray` ( :code:`return_numpy` is False) or an one-dimensional list of :code:`numpy.ndarray` ( :code:`return_numpy` is True). Please see Examples 2 for more details. If the lengths of fetched results are variant, please set :code:`return_merged` as False, which denotes that the fetched results will not be merged. The default is True, but it is just for the compatibility, and may use False as default value in the future version. use_prune(bool): This parameter indicates whether the input :code:`Program` will be pruned. If the parameter is True, the program will be pruned accroding to the given feed and fetch_list, which means the operators and variables in program that generate :code:`feed` and are not needed to generate :code:`fetch_list` will be pruned. The default is False, which means the program will not pruned and all the operators and variables will be executed during running. Note that if the tuple returned from :code:`Optimizer.minimize()` is passed to :code:`fetch_list`, :code:`use_prune` will be overrided to True, and the program will be pruned. Returns: List: The fetched result list. NOTES: 1. If it is multi-card running and the feed parameter is dict type, the input data will be evenly sent to different cards. For example, using two GPUs to run the model, the input sample number is 3, that is, [0, 1, 2], the sample number on GPU0 is 1, that is, [0], and the sample number on GPU1 is 2, that is, [1, 2]. If the number of samples is less than the number of devices, the program will throw an exception, so when running the model, you should make sure that the number of samples of the last batch of the data set should be greater than the number of CPU cores or GPU cards, if it is less than, it is recommended that the batch be discarded. 2. If the number of CPU cores or GPU cards available is greater than 1, the fetch results are spliced together in dimension 0 for the same Tensor values (Tensors in fetch_list) on different devices. Examples: .. code-block:: python :name: code-example-1 import paddle import numpy # First create the Executor. paddle.enable_static() place = paddle.CPUPlace() # paddle.CUDAPlace(0) exe = paddle.static.Executor(place) data = paddle.static.data(name='X', shape=[None, 1], dtype='float32') hidden = paddle.static.nn.fc(data, 10) loss = paddle.mean(hidden) adam = paddle.optimizer.Adam() adam.minimize(loss) i = paddle.zeros(shape=[1], dtype='int64') array = paddle.fluid.layers.array_write(x=loss, i=i) # Run the startup program once and only once. exe.run(paddle.static.default_startup_program()) x = numpy.random.random(size=(10, 1)).astype('float32') loss_val, array_val = exe.run(feed={'X': x}, fetch_list=[loss.name, array.name]) print(array_val) # [array([0.02153828], dtype=float32)] .. code-block:: python :name: code-example-2 # required: gpu import paddle import numpy as np # First create the Executor. paddle.enable_static() place = paddle.CUDAPlace(0) exe = paddle.static.Executor(place) data = paddle.static.data(name='X', shape=[None, 1], dtype='float32') class_dim = 2 prediction = paddle.static.nn.fc(data, class_dim) loss = paddle.mean(prediction) adam = paddle.optimizer.Adam() adam.minimize(loss) # Run the startup program once and only once. exe.run(paddle.static.default_startup_program()) build_strategy = paddle.static.BuildStrategy() binary = paddle.static.CompiledProgram( paddle.static.default_main_program()).with_data_parallel( loss_name=loss.name, build_strategy=build_strategy) batch_size = 6 x = np.random.random(size=(batch_size, 1)).astype('float32') # Set return_merged as False to fetch unmerged results: unmerged_prediction, = exe.run(binary, feed={'X': x}, fetch_list=[prediction.name], return_merged=False) # If the user uses two GPU cards to run this python code, the printed result will be # (2, 3, class_dim). The first dimension value of the printed result is the number of used # GPU cards, and the second dimension value is the quotient of batch_size and the # number of used GPU cards. print("The unmerged prediction shape: {}".format( np.array(unmerged_prediction).shape)) print(unmerged_prediction) # Set return_merged as True to fetch merged results: merged_prediction, = exe.run(binary, feed={'X': x}, fetch_list=[prediction.name], return_merged=True) # If the user uses two GPU cards to run this python code, the printed result will be # (6, class_dim). The first dimension value of the printed result is the batch_size. print("The merged prediction shape: {}".format( np.array(merged_prediction).shape)) print(merged_prediction) # Out: # The unmerged prediction shape: (2, 3, 2) # [array([[-0.37620035, -0.19752218], # [-0.3561043 , -0.18697084], # [-0.24129935, -0.12669306]], dtype=float32), array([[-0.24489994, -0.12858354], # [-0.49041364, -0.25748932], # [-0.44331917, -0.23276259]], dtype=float32)] # The merged prediction shape: (6, 2) # [[-0.37789783 -0.19921964] # [-0.3577645 -0.18863106] # [-0.24274671 -0.12814042] # [-0.24635398 -0.13003758] # [-0.49232286 -0.25939852] # [-0.44514108 -0.2345845 ]] ZFLAGS_FORCE_USE_PROGRAM_CACHENr) rnrErorprqr rr" use_prunerA) rrrr# _run_implr Zupdate_autotune_statusrMrkreraiserexc_info)rrnrErorprqr rr"rArFZforce_use_program_cachererrrrs29  z Executor.runc % Cs|jrtd|du} |durt}||}t|trJ|jrJd|jvr7|jdur-t|_|j ||||j dSd|jvrB|jd}n|j |||dSt|tru|j ru|j d} t | } t} | | t| |_d|j vru|j d}t|trt|jdkr| rd}nd }t||durt}|}|}||\}}|rd } | rt|||}||}|durt|tjr|t t!|}t""|}||_#|t t!|dur|$t t!|||%||||}|&||n|}|'||}|}d d }| r|j(r|||j)r|duri}nt|t*t+fr,t|d ks(Jd|d}t|t,s:t-dt.||'||}|j/0||||||j)|\}}|1||||t2|drddl3m4}t|j5|snJd|j5}|}|j6|j7}t89|g:t;|j<}t=||j7}t>|t?}t@r|A||Bn|A||j)|C|t*|D||St|tj}| r|r|jE} n|} | j6D]F}!| jFGtHI|!}"| j6|!}#|"Jdkr|".tjKjLjMkr|"Nd kr|#jOd kr|#jPd kr|#jQdkr|!|vrtRd|!qtST|||sLt|jUtj}$|$r?|jUV||j)|jW|jU|||||| dS|jX||||||||dS|V||j)|jYr^|Z|j[|S|jW||||||| dS)Nz"Attempted to use a closed Executor fleet_opt)rnrErowith_standalone_executorZstartup_program)ror" heter_placerzNow you are using default_main_program, but there are no operators in the program to be executed. Please ensure you create model correctly or you can pass the Program or the CompiledProgram manually.zThere are no operators in the program to be executed. If you pass Program manually, please use fluid.program_guard to ensure the current Program is being used.TcSsDts t|tjr dStjdddv}ddlm}|j dur*|s*t dt dSt|t jp6t|jt j}|rt|t jrA|n|j}|jrZt|||jdkrZt dt dStd dvrjt d t dS|jrut d t dS|jdur|jjrt d t dS|jdur|jjrt d t dS|St|tsJdS)NFrrrfleetz)Standalone executor is not used for fleetrz1Standalone executor is not used for data parallelZFLAGS_enable_parallel_graphz2Standalone executor is not used for parallel graphz-Standalone executor is not used for inferencez.Standalone executor is not used for CUDA Graphz.Standalone executor is not used for async modeT)r Zis_compiled_with_mlur-Z CustomPlacerrrZpaddle.distributed.fleetrOZ _role_makerrirj UserWarningrrrZ_is_data_parallelr1Z _get_placesr?globals _is_inferencerZallow_cuda_graph_captureZ async_moder)rnrZ,use_standalone_executor_for_compiled_programrOr0rrrr_can_use_interpreter_cores  z5Executor._run_impl.._can_use_interpreter_corerrrrr9r;FzNeed feed data for variable %s)r rErorqrrA)rErorprqr rr")\rr2r_check_fetch_listr-r _pipeline_optr r_run_using_fleet_executorr  _run_pipeline_heter_pipeline_optrrr rrrrr1rarIrirjrr.rrrrrrrr*Z_share_vars_fromrr3rrr rr.rrrrJr rr$rr<r:rrbr@r3r4rrrCget_variable_tensorrr>Zis_compiled_with_ipu _copy_fromrrrrr>r~cptto_bytesrZr6r7Z LOD_TENSORr?Z stop_gradientis_dataZbelong_to_optimizerr@acpZ_auto_checkpointrrrE _run_programrR_run_inferencer=)%rrnrErorprqr rr"rArFZuse_default_main_programrMr error_infoZ_origin_fetch_listZ_origin_programr/ cache_keyZcached_pruned_programZprogram_scope_cacher2rSrr:rrCrDrr5Z cpu_tensorr0ravarnameZvardescZvarobjZhas_compiled_graphrrrrGsJ                     D                  zExecutor._run_implc CsFddlm} |dur i}nt|ttfr"t|dksJd|d}t|ts/tdt||dus7Jdt|t sDtdt|t|t sQtdt||rt |||} | | } | | } || } | durt|||||d } || | ttt|}|j| jd|d } |} |j| j| d|| | || | | }| }| }n t|||||d }|||||t|d rt|j| sJd |j}|}|j|j}t !|g"t#|j$}t%&||j}|'||j(|s|j)|j|dd d |gn |j*||d d d |+|,}|-}|r!t.|S|S)Nrr9rrrzThe program should not be Emptyz@Executor requires Program as its Parameter. But you passed in %szQThe name of fetch variable requires string as its Parameter. But you passed in %srnrErorprqFrr;T)/r<r:r-r.rr1rrrJrrrrrrrwrrrrpreparer>Z new_scopeZcreate_variablesrr!r$rrrarbr@r3r4rrrCr rYrrrZrun_prepared_ctxr~get_fetch_listrr%)rrnrErorprqr rr"r:rbcached_programZ cached_ctx cached_scopeZfetch_list_strrrrCrDrr5arrrrrrr_s              zExecutor._run_programcCs ||Sr)r)rrBrErrrr`rzExecutor._run_inferencecsdddd}|durgS|r|gS||s"Jdt|g}t|D]5\}}|r6||q(||rStfdd|DrM|t|q(||q(td|t|j|S)NcSst|tttjfSr)r-rrrkrlrrrrs z,Executor._check_fetch_list..cSst|ttfSr)r-rr.rrrrrjszCurrently , The fetch_list type only should be list or tuple, but the input type is {}. For more information please refer to the executor.run(...).c3s|]}|VqdSrr)r'vZ is_fetch_varrr +sz-Executor._check_fetch_list..zPRequire fetch_list[{}] 's type shall be one of (Variable, str), but received {}.) rNrJrfrallextendr.rr)rroZ is_tuple_listrr<rDrrlrrTs.     zExecutor._check_fetch_listcCsttt|dd}|t|Wdn1swY|jrLd|jvrNtdd}|t|jdWddS1sEwYdSdSdS)Nz_train_desc.prototxtwZ fleet_desczfleet_desc.prototxt)openrrr _fleet_opt)rrntrainerZfoutrrr_dump_debug_info7s "zExecutor._dump_debug_infocCs|t|j}||kr|}td||f|||ddkr1td|||f|||dd<||dd||S)Nz[Pipeline training: setting the pipeline num to %d is enough because there are only %d filesZconcurrency_listrznPipeline training: setting the 1st element in concurrency_list to %d is enough because there are only %d files)r1datasetZ get_filelistr set_thread)rZ pipeline_optruZ pipeline_numZfilelist_lengthrrr_adjust_pipeline_resource>s( z"Executor._adjust_pipeline_resourcerdc Csd} d} |jdur(|jdddkrd} |jdddkrd} |jdd r(d } |dur/t}|dur5g}|dur;g}t|t|ksEJt|tj} | radd lm} dd l m } | }| |}| s|j rnt |j }n|jryt |j}n t |j}||j||| r||n&|j rt |jj }n|jrt |jj}nt |jj}||j|dkr| r|t|jd n|jdkrtd||jn||||||||||fS)NrZ worker_classrZHeterCpuWorkerrrsZHeterXpuTrainer use_ps_gpuFTrN) FleetUtilZ worker_placeszSYou should set thread num first, either in Datasetor in Executor.train_from_dataset)rrrrr1r-rrZ2paddle.fluid.incubate.fleet.parameter_server.pslibrOZ,paddle.fluid.incubate.fleet.utils.fleet_utilrzZsplit_program_by_devicerUrZ_create_trainerrXZ_set_thread_barrierZ_is_distributedZ _set_programZ_set_heter_infornZ _set_thread thread_numr2Z _set_debugZ_set_fetch_var_and_info)rrnrur threaddebugro fetch_info print_periodZis_heterryr0rOrzZfuretrsrrr_prepare_trainerNsz             zExecutor._prepare_trainerc  Cs|jdurPddl} |durtdg} |jD] } | jr$| | qt r2| j d}n| j d}| d|d|dg|| n{|jdur|jd}|jd}|dkrd |jvrddl} |durttd g} |jD] } | jr| | q}| j d}| d|d|dg|| n|durtd t|}t}||t||_n|durtd |g}|jr%|jd }|D]}t|tr|j}n|}||jvr||qt|jd g|d dd|jd <|jd d}|jD]}|jdkr!| dtj!j"j#qd}|j$|||||||| d\}}|%||&|jdurP|jdurP|j'||d|j(dur`|j)j(r`t*+d|,|j)j-|jdur{|j.|j/|0||j1}n1|dkrg}t2|d|}|3|}|dur|j.|j/|0||j1}|4||n|5|j1| dur|6d}t7|| }|8|j9||:|jdur|j;|n|j9||jdur|j;||<|=|r|>d?}|@}tA|SdS)Nr(dataset should be None for pipeline modeInMemoryDatasetFileInstantDatasetrNoneZpipeline_stagerMZ is_fl_modez.dataset should be None for heter pipeline modez)dataset is need and should be initializedsection_programrErSrdop_rolernrur r|r}ror~rrnrsF0dataset should call set_use_ps_gpu in PsGpu mode)BrUpaddler2rarbvaluesr]rr is_compiled_with_npufluidDatasetFactorycreate_datasetset_batch_sizerv set_filelist set_use_varrXrrrrrr_prepare_to_runr-rrArwrOrIrJ _set_attrop_proto_and_checker_makerOpRoleOptimizer _set_infer_gen_trainer_descrtry proto_descrr_dynamic_adjust_before_trainr{init_for_datasetr>_descrurrr Z ResetDatasetZget_worker_scoperstartrun_from_datasetstopr5Z_dynamic_adjust_after_trainZ_finish_to_runr~rfrr%)rrnrur r|is_inferr}ror~r fetch_handlerr data_varsrDZstage_idrMrreal_fetch_list real_programrurq main_blockrPrsr8rbZscope0Z fetch_monitorrirrrr_run_from_datasets                                             zExecutor._run_from_datasetc  sjdusJ|dusJdtd} || } | r"| dur"| Sddlfdd}|}fdd}|\}}|jd<d|j|||||| d\}}||||jd uri|jjrit d | |jj | }|jj|||j}|||g} | r|| | | S) Nrrcsg}jD] }|jr||q tr!j d}nj d}| d| d| dg| |||S)Nrrrr)rarbrr]rr rrrrrrvrrr)rrDru)rrnrr _get_datasetHs$       z4Executor._prepare_pipeline_ctx.._get_datasetcsjd}g}D]}t|tr|j}n|}||jvr"||q t|g|ddd}|d}|j D]}|j dkrD| dt j jjq4||fS)NrrErSrdrr)rUr-rrArarbrrwrOrIrJrr rrr)rrrurqrrP)rornrr_get_real_program_fetch_list\s0      zDExecutor._prepare_pipeline_ctx.._get_real_program_fetch_listrrFr)rUrrrrrrryrrrrr{rrrr>rur)rrnrur r|rr}ror~rrr"rbrrrrrrsZ trainer_descr8r)rorrnr_prepare_pipeline_ctx0sD          zExecutor._prepare_pipeline_ctxrc Csd|vr|dnd}ttdd}tddd}t|} d|vs+d |vs+Jd d |vrId |vs7Jd td dd|d D} |d } n|d} | dkrddlm} d|vsid|dvsi|dddkrnt d| ||| dd| di| |\} } n>| dkrddlm }d|vrd|dvr|dddksJdd|vr|ddksJd|||\} } ndt | d| |d <| |d <t }||j|j||j|||| | gdS)Nnum_micro_batchesrrrrrr schedulertaskszFleet executor need configuration for scheduler, you can choose from 1F1B or Origin. Or you can provide a list of task nodes to init fleet executor directly.task_id_to_rankzUIf you provide tasks to init fleet executor, task_id_to_rank should also be provided.z/fleet executor will use user defined task nodescSsg|]}|qSr)Z task_node)r'taskrrrr+rz.Z1F1B)run1f1bZ dist_strategyZ pp_degreez)Using 1F1B scheduler with pp_degree == 1.ZOrigin)originzBFor pipeline mode, the scheduler should be 1F1B instead of Origin.z=For origin scheduler mode, the num micro batches should be 1.zEFleet_executor only supports 1F1B and Origin scheduler, but received .)rrrrr1rZ-paddle.distributed.fleet.fleet_executor_utilsrrirjrrrr rrrr initr>)rZ carrier_idrnr rKrLrrrrrrrrrrrrr_prepare_fleet_executor_carriersj         z(Executor._prepare_fleet_executor_carriercCsZt|||}||}||} | durt} ||| |dur|js(Jd|dur.gn|} |} d|jvr<|jd} t| | |||d}|d} | jD]} | j dkr]| dt j j jqM||||jd}d|vr|dd}td ||}|j|| |d }|||dd }td ||}|j|||d }|d} | jD]} | j dkr| dt j j jq|||j||| ||d|r||||| ddlm}t|dr|j}t||sJd|}|j|j}t !|g"t#|j$}t %| |j}|&||j'|j()||r+| *|+}|,}t-|SdS)Nz2program should have _pipeline_opt to start carrierrrdrrSrrKrzInserting feed ops for task)rnrErpzInserting fetch ops for task)rnrorq)rnr rKrLr9rr;).rrrrr!rUrwrOrIrJrr rrrrrtask_idZ get_program _add_feed_opsZ set_program_add_fetch_opsrr$r<r:rrr-rarbr@r3r4rrrCrYrrr rr~rfrr%)rrnrErprqrorLrbrgrhZ real_feedrrrPrKZ feed_taskZ feed_programZ fetch_taskZ fetch_programr:rrCrDrr5rirrrrrVs                     z"Executor._run_using_fleet_executorc Cs|}|}||jvr||}n |j|tjjjdd}t |||sPt |D]'\}}| |rH||} |j dd|gid| gid|idq(t d|q(|S) NTrYrErGrHrTr[r])r`rarbrDrcr r6r7rdrRrfrgrhrirj) rrnrErprsrartr<rArvrrrr4 s0     zExecutor._add_feed_opsc Cs|}|}||jvr||}n |j|tjjjdd}|r#d}nd}t ||||s[t |D]*\} } t | t sIt | t jsIJd| t| f|j|d| gid|gid| id q0|S) NTrYr^rSr_rGrHrTr[)r`rarbrDrcr r6r7rerXrfr-rrkrlrJrm) r,rnrorqrrrsrarurVr<rDrrrrQ s<    zExecutor._add_fetch_opscCsJ|}|}t|j}tt|D]}|j|j|kr"||q|Sr)r`rar1rIreversedr;rJZ _remove_op)r,rnZ fetch_op_namersraZop_numrWrrr_remove_fetch_opsw s  zExecutor._remove_fetch_opsc  Cs|||||||||| | | \}} } ddlm}t|drN|j}t||s)Jd|}|j|j}t |g t |j }t||j}|||j|j| | s\|j| | rm|d}|}t|SdS)Nrr9rr;rS)rr<r:rrr-rarbr@r3r4rrrCr rYrrrrr5r~rfrr%)rrnrur r|rr}ror~rrr"rr8r:rrCrDrr5rirrrrrW s.     zExecutor._run_pipelinec C|||||d||||| S)a2 Infer from a pre-defined Dataset. Dataset is defined in paddle.fluid.dataset. Given a program, either a program or compiled program, infer_from_dataset will consume all data samples in dataset. Input scope can be given by users. By default, scope is global_scope(). The total number of thread run in training is `thread`. Thread number used in training will be minimum value of threadnum in Dataset and the value of thread in this interface. Debug can be set so that executor will display Run-Time for all operators and the throughputs of current infer task. The document of infer_from_dataset is almost the same as train_from_dataset, except that in distributed training, push gradients will be disabled in infer_from_dataset. infer_from_dataset() can be used for evaluation in multi-threadvery easily. Args: program(Program|CompiledProgram): the program that needs to be run, if not provided, then default_main_program (not compiled) will be used. dataset(paddle.fluid.Dataset): dataset created outside this function, a user should provide a well-defined dataset before calling this function. Please check the document of Dataset if needed. default is None scope(Scope): the scope used to run this program, you can switch it to different scope for each run. default is global_scope thread(int): number of thread a user wants to run in this function. Default is 0, which means using thread num of dataset debug(bool): whether a user wants to run infer_from_dataset, default is False fetch_list(Tensor List): fetch Tensor list, each Tensor will be printed during training, default is None fetch_info(String List): print information for each Tensor, default is None print_period(int): the number of mini-batches for each print, default is 100 fetch_handler(FetchHandler): a user define class for fetch output. Returns: None Examples: .. code-block:: python import paddle paddle.enable_static() place = paddle.CPUPlace() # you can set place = paddle.CUDAPlace(0) to use gpu exe = paddle.static.Executor(place) x = paddle.static.data(name="x", shape=[None, 10, 10], dtype="int64") y = paddle.static.data(name="y", shape=[None, 1], dtype="int64", lod_level=1) dataset = paddle.fluid.DatasetFactory().create_dataset() dataset.set_use_var([x, y]) dataset.set_thread(1) # you should set your own filelist, e.g. filelist = ["dataA.txt"] filelist = [] dataset.set_filelist(filelist) exe.run(paddle.static.default_startup_program()) exe.infer_from_dataset(program=paddle.static.default_main_program(), dataset=dataset) Tr rrnrur r|r}ror~rrrrrinfer_from_dataset sAzExecutor.infer_from_datasetc Csf|j|d|d||||d\}}|d||j||d|j|j||d} |j| | S)NrrFr) rrrrtrrr>rr) rrnr r}ror~rrrsr8rrrstart_heter_trainer s"  zExecutor.start_heter_trainerc Cr)at Train from a pre-defined Dataset. Dataset is defined in paddle.fluid.dataset. Given a program, either a program or compiled program, train_from_dataset will consume all data samples in dataset. Input scope can be given by users. By default, scope is global_scope(). The total number of thread run in training is `thread`. Thread number used in training will be minimum value of threadnum in Dataset and the value of thread in this interface. Debug can be set so that executor will display Run-Time for all operators and the throughputs of current training task. Note: train_from_dataset will destroy all resources created within executor for each run. Args: program(Program|CompiledProgram): the program that needs to be run, if not provided, then default_main_program (not compiled) will be used. dataset(paddle.fluid.Dataset): dataset created outside this function, a user should provide a well-defined dataset before calling this function. Please check the document of Dataset if needed. scope(Scope): the scope used to run this program, you can switch it to different scope for each run. default is global_scope thread(int): number of thread a user wants to run in this function. Default is 0, which means using thread num of dataset debug(bool): whether a user wants to run train_from_dataset fetch_list(Tensor List): fetch Tensor list, each variable will be printed during training fetch_info(String List): print information for each Tensor, its length should be equal to fetch_list print_period(int): the number of mini-batches for each print, default is 100 fetch_handler(FetchHandler): a user define class for fetch output. Returns: None Examples: .. code-block:: python import paddle paddle.enable_static() place = paddle.CPUPlace() # you can set place = paddle.CUDAPlace(0) to use gpu exe = paddle.static.Executor(place) x = paddle.static.data(name="x", shape=[None, 10, 10], dtype="int64") y = paddle.static.data(name="y", shape=[None, 1], dtype="int64", lod_level=1) dataset = paddle.fluid.DatasetFactory().create_dataset() dataset.set_use_var([x, y]) dataset.set_thread(1) # you should set your own filelist, e.g. filelist = ["dataA.txt"] filelist = [] dataset.set_filelist(filelist) exe.run(paddle.static.default_startup_program()) exe.train_from_dataset(program=paddle.static.default_main_program(), dataset=dataset) Frrrrrtrain_from_dataset s@zExecutor.train_from_datasetr)NNN) NNNrErSNTFTF)NN)NNNrFNNrx) NNNrFFNNrxN) NNNrFFNNrxNF)rNNNF)NNrErSNFFrS) NNNrFNNrxN)NNFNNrxN)/rrr__doc__rrrrrrrrrrrrr r!rr#r$r' classmethodr.r3rr6rErrGr_r`rTrtrwrrrrrVrrrrWrrrrrrrr/s  L  4 ? ,C Q U  J  i 9 d %   ) F (rr)rr)NTr)E __future__rrrmultiprocessingrrinumpyr3wrapped_decoratorrrkZ data_feederrrrrrr r r rr r rrr[Ztrainer_factoryrrr*Zincubate.checkpointrr^r functoolsr__all__ZScoperZ NativeConfigZInferNativeConfigZAnalysisConfigZInferAnalysisConfigrr"rr%r:r=rFrRrXrwr}rrrrrrrrrrrrrrrrrrsl               (, #(* 2 < ! 0Ty