o Mes4@sddlmZddlZddlmZddlmZddlZddlmZm Z ddl Z ddl Z ddl Z ddl Z ddlZddlmZmZddlZddlZddlZddlZddlZdd lmZdd lmZdd lmZdd lmZddlm Z!ddl"Z"ddl#Z#dd l$m%Z%m&Z&gdZ'e(Z)e*Z+e,Z-e.Z/e0Z1da2e j34dddka5da6da7da8da9da:da;dae j34dda?e j34ddZ@ddZAddZBddZCddZDddZEdaFdd ZGeGd!d"ZHd#d$ZId%d&ZJedd'd(ZKd)aLd)aMd*ZNd+ZOedd,d-ZPedd.d/ZQdd0d1ZRdd2d3ZSd4d5ZTd6d7ZUd8d9ZVd:d;ZWdd?ZYd@dAZZe eTZ[e eUZ\e eWZ]e eYZ^e eVZ_dBdCZ`dDdEZadFdGZbdHdIZcdJdKZddLdMZedNdOZfdPdQZgdRdSZhdTdUZidVdWZjdXdYZkdZd[Zld\d]Zmd^d_Znd`daZodbdcZpddddeZqddfdgZrddhdiZsddjdkZtddldmZuddndoZvGdpdqdqewZxexayeddrdsZzdtduZ{dvdwZ|dxdyZ}dzd{Z~d|d}Zdd~dZejjjddddfddZddZGdddeZGdddeZe eGdddewZddZGdddewZGdddewZGdddewZiifddZGdddewZGdddeZGdddeZGdddewZGdddewZe eGdddeZGdddejZeedrjejjZnewZGdddeZeaeadt_ddZddZddZddZedddZdddZeddZeddZddZedddZddZedddZddZddZdd„ZddĄZdS))print_functionN) defaultdict)Iterable)signature_safe_contextmanagerwrap_decorator) MethodType FunctionType)compat) framework_pb2)core) unique_name)_getitem_impl__setitem_impl_)Programdefault_startup_programdefault_main_program program_guard name_scopeipu_shard_guard set_ipu_shard cuda_places cpu_places xpu_places mlu_placescuda_pinned_places_non_static_modein_dygraph_modeis_compiled_with_cinnis_compiled_with_cudais_compiled_with_rocmis_compiled_with_xpuis_compiled_with_npuVariablerequire_version device_guard set_flags get_flagsZFLAGS_enable_eager_mode1FZFLAGS_USE_STANDALONE_EXECUTORZ#FLAGS_DY2ST_USE_STANDALONE_EXECUTORcCsddlm}m}ddlm}ddlm}t|tsJ|r,| t s+||da n| t s:||da t |dS)zj Update monkey methods of VarBase or eager.Tensor while switching eager mode and legacy mode. r)_C_ops _legacy_C_opsr)monkey_patch_varbase)monkey_patch_math_varbaseTN)paddler*r+Zdygraph.varbase_patch_methodsr,Zdygraphr- isinstanceboolZswitch_to_eager_ops_already_patch_eager_tensorZswitch_to_core_ops_already_patch_varbase_switch_tensor_bind_type)is_eagerr*r+r,r-r5FD:\Projects\ConvertPro\env\Lib\site-packages\paddle/fluid/framework.py_update_monkey_methodsus"   r7cCs,ddl}|r tjj|_ntj|_d|j_dS)NrTensor)r.r eagerr8VarBase __qualname__)r4r.r5r5r6r3s   r3cCdatdddS)NFr4_in_eager_mode_r7r5r5r5r6_enable_legacy_dygraphr@cCr<)NTr=r>r5r5r5r6_disable_legacy_dygraphrArBcCtSN)r?r5r5r5r6_in_eager_without_dygraph_checkrETcCsTd}tptptpt}tr$|r$tddats"t d}d}da|S)NFzWe will fallback into legacy dygraph on NPU/XPU/MLU/IPU/ROCM devices. Because we only support new eager dygraph mode on CPU/GPU currently. T) r r"r#is_compiled_with_ipuis_compiled_with_mlur?warningswarn_is_first_import_r@)Z need_fallbackZis_not_supportr5r5r6_fallback_legacy_dygraphs&rLcCs tduotS)aH .. note:: Dynamic graph mode is turn ON by default since paddle 2.0.0 This API checks whether paddle runs in dynamic graph mode. You can turn ON static graph mode by `enable_static <../dygraph/base/disable_dygraph_en.html>`_ , and turn OFF static graph mode by `disable_static <../dygraph/base/enable_dygraph_en.html>`_ . Returns: bool: Whether paddle runs in dynamic graph mode. Examples: .. code-block:: python import paddle print(paddle.in_dynamic_mode()) # True, dynamic mode is turn ON by default since paddle 2.0.0 paddle.enable_static() print(paddle.in_dynamic_mode()) # False, Now we are in static mode paddle.disable_static() print(paddle.in_dynamic_mode()) # True, Now we are in dynamic mode N)_dygraph_tracer_r?r5r5r5r6rs rcCst otduSrD)r?rMr5r5r5r6_in_legacy_dygraphsrNcCstduSrDrMr5r5r5r6rrccs<t}|s tz dVW|stdSdS|stwwrD)rLrBr@)placeZalready_fallbackr5r5r6_test_eager_guards rRZ ipu_indexZ ipu_stageccs"t}|azdVW|adS|awrD)_enable_standalone_executor_)enableZ original_r5r5r6_enable_standalone_executors rVccsBts tdt}t}|a|az dVW|a|adS|a|aw)a Used to shard the graph on IPUs. Set each Op run on which IPU in the sharding and which stage in the pipelining. Args: index(int, optional): Specify which ipu the Tensor is computed on, (such as '0, 1, 2, 3'). The default value is -1, which means the Op only run on IPU 0. stage(int, optional): Specify the computation order of the sharded model(such as '0, 1, 2, 3'). The sharded model will be computed from small to large. The default value is -1, which means no pipelining computation order and run Ops in terms of graph. Note: Only if the enable_manual_shard=True, the 'index' is able to be set not -1. Please refer to :ref:`api_paddle_static_IpuStrategy`. Only if the enable_pipelining=True, the 'stage' is able to be set not -1. Please refer to :ref:`api_paddle_static_IpuStrategy`. A index is allowed to match none stage or a stage. A stage is only allowed to match a new or duplicated index. Examples: .. code-block:: python # required: ipu import paddle paddle.enable_static() a = paddle.static.data(name='data', shape=[None, 1], dtype='int32') with paddle.static.ipu_shard_guard(index=0, stage=0): b = a + 1 with paddle.static.ipu_shard_guard(index=1, stage=1): c = b + 1 with paddle.static.ipu_shard_guard(index=0, stage=2): d = c + 1 zECan not use this function since PaddlePaddle is not compiled with IPUN)r rG ValueErrorglobal_ipu_indexglobal_ipu_stage)indexstageZprev_ipu_indexZprev_ipu_stager5r5r6rs#rcslfdd}ddlm}t||st|r||StdGfdddt|}t|j|_||_|S)u Shard the ipu with the given call function. Set every ops in call function to the given ipu sharding. Note: Only when enable_manual_shard=True to set the index to a value other than -1. please refer to :ref:`api_paddle_static_IpuStrategy` . Only when enable_pipelining=True to set stage to a value other than -1. please refer to :ref:`api_paddle_static_IpuStrategy` . An index supports a corresponding None stage or a stage, and a stage only supports a new index or a duplicate index. Args: call_func(Layer|function): Specify the call function to be wrapped. index(int, optional): Specify which ipu the Tensor is computed on, (such as ‘0, 1, 2, 3’). The default value is -1, which means the Op only run on IPU 0. stage(int, optional): Specify the computation order of the sharded model(such as ‘0, 1, 2, 3’). The sharded model will be computed from small to large. The default value is -1, which means no pipelining computation order and run Ops in terms of graph. Returns: The wrapped call function. Examples: .. code-block:: python # required: ipu import paddle paddle.enable_static() a = paddle.static.data(name='data', shape=[None, 1], dtype='float32') relu = paddle.nn.ReLU() relu = paddle.static.set_ipu_shard(relu, index=1, stage=1) relu(a) csfdd}|S)Ncs>td|i|WdS1swYdSNrZr[)rargskwargs)funcrZr[r5r6wrapperss $z0set_ipu_shard..decorate..wrapperr5rarbr]rar6decoraterszset_ipu_shard..decorater)Layerz:Unsupported type. Only accept paddle.nn.Layer or function.cs eZdZfddZZS)zset_ipu_shard..BlockFncsBtdtj|i|WdS1swYdSr\)rsuper__call__)selfr_r`) __class__rZr[r5r6rhs$z'set_ipu_shard..BlockFn.__call__)__name__ __module__r;rh __classcell__r5r]rjr6BlockFnsro)Zdygraph.layersrfr/callable TypeErrortyperkrj)Z call_funcrZr[rerfror5r]r6rQs!   rc Cst|ts tdt|t|ttdfstdt|td|}|dus.||kr4td||durNtd|}|dusH||krNtd|tj tj tj tj g}gd}dd }|||d kr|durxt d ||tjfdSt d |tjfdS|d }||t|d}|dur|d }||t|d} ||| d ks|||d krtd||tjfdS|||d krtd|tj|fdS)a Check if the installed version of PaddlePaddle is in [min_version, max_version], if the installed version is lower than ``min_version`` or higher than ``max_version``, an exception will be thrown, NO returns if the installed version is satisfied. Args: min_version (str): the minimum version required (like '1.4.0'). max_version (str, optional): the max version required (like '1.6.0'), default is None, meaning any version equal or higher than ``min_version`` is acceptable. Returns: None. Raises: TypeError: if the type of ``min_version`` is not str. TypeError: if the type of ``max_version`` is not str or type(None). ValueError: if the value of ``min_version`` is not in version format. ValueError: if the value of ``max_version`` is not in version format or None. Exception: if the installed version is lower than ``min_version`` or higher than ``max_version``. Examples: .. code-block:: python import paddle.fluid as fluid # any version >= 0.1.0 is acceptable. fluid.require_version('0.1.0') # if 0.1.0 <= version <= 10.0.0, it is acceptable. fluid.require_version(min_version='0.1.0', max_version='10.0.0') zJThe type of 'min_version' in require_version must be str, but received %s.NzXThe type of 'max_version' in require_version must be str or type(None), but received %s.z\d+(\.\d+){0,3}zrThe value of 'min_version' in require_version must be in format '\d+(\.\d+){0,3}', like '1.5.2.0', but received %szrThe value of 'max_version' in require_version must be in format '\d+(\.\d+){0,3}', like '1.5.2.0', but received %s)0rsrsrscSsVtjt|D] }t||t||krdSt||t||kr(dSqdS)NrrSr)sixmovesrangelenint)Zver_aZver_bir5r5r6 version_cmpsz$require_version..version_cmprzPaddlePaddle version in [%s, %s] required, but %s installed. Maybe you are using a develop version, please make sure the version is good with your code.zPaddlePaddle version %s or higher is required, but %s installed, Maybe you are using a develop version, please make sure the version is good with your code..zJVersionError: PaddlePaddle version in [%s, %s] required, but %s installed.zVersionError: PaddlePaddle version %s or higher is required, but %s installed, please upgrade your PaddlePaddle to %s or other higher version.)r/strrqrrrematchgrouprW fluid_versionmajorminorpatchrcrIrJZ full_versionsplitrw Exception) min_versionZ max_versionZ check_formatZversion_installedZ zero_versionrzZmin_version_splitZmin_version_to_checkZmax_version_splitZmax_version_to_checkr5r5r6r%s         r%cfdd}|S)Nc"tr Jdj|i|S)Nz)We don't support %s in dynamic graph moderrkr^rdr5r6__impl__sz'_dygraph_not_support_..__impl__r5rarr5rdr6_dygraph_not_support_s rcr)Ncs"ts Jdj|i|S)NpWe only support '%s()' in dynamic graph mode, please call 'paddle.disable_static()' to enter dynamic graph mode.rr^rdr5r6r z _dygraph_only_..__impl__r5rr5rdr6_dygraph_only_ rcr)Ncs4ddlm}ts|sJdj|i|S)Nr)in_declarative_moder)Z dygraph.baserrrk)r_r`rrdr5r6rs z#_non_static_only_..__impl__r5rr5rdr6_non_static_only_  rcr)Ncr)NzIn PaddlePaddle 2.x, we turn on dynamic graph mode by default, and '%s()' is only supported in static graph mode. So if you want to use this api, please call 'paddle.enable_static()' before this api to enter static graph mode.rr^rdr5r6r)rz_static_only_..__impl__r5rr5rdr6 _static_only_(rrcCs|adSrD)_current_pipeline_stage)r[r5r5r6_set_pipeline_stage3rcr)Ncstdjjf)Na'%s' only can be called by `paddle.Tensor` in dynamic graph mode. Suggestions: 1. If you are in static graph mode, you can switch to dynamic graph mode by turning off `paddle.enable_static()` or calling `paddle.disable_static()`. 2. If you are using `@paddle.jit.to_static`, you can turn off ProgramTranslator by calling `paddle.jit.ProgramTranslator().enable(False)`. If you have to translate dynamic graph to static graph, please use other API to replace '%s'.)AssertionErrorrkr^rdr5r6r@s  z'_fake_interface_only_..__impl__r5rr5rdr6_fake_interface_only_?rrcstfdd}|S)Ncs8d|vrtdt|d|d<|d|i|S)NZ stat_dictzJThe argument `stat_dict` has deprecated, please change it to `state_dict`. state_dict)rIrJDeprecationWarningpopr^rdr5r6rbRs  z$deprecate_stat_dict..wrapper) functoolswrapsrcr5rdr6deprecate_stat_dictQs rcCrCrDrOr5r5r5r6_dygraph_tracergrcCrCrD)_global_flags_r5r5r5r6 _global_flagskrrc Csdtdurtrz_cuda_ids..,)rgetenvrrtrurvr r)Zgpus_env device_idsr5r5r6r rcCr)NZFLAGS_selected_xpuscSrr5rrr5r5r6rrz_xpu_ids..r)rrrrtrurvr r)Zxpus_envrr5r5r6rrrcCr)NZFLAGS_selected_npuscSrr5rrr5r5r6rrz_npu_ids..r)rrrrtrurvr Zget_npu_device_count)Znpus_envrr5r5r6_npu_idsrrcCr)NZFLAGS_selected_mluscSrr5rrr5r5r6rrz_mlu_ids..r)rrrrtrurvr r)Zmlus_envrr5r5r6rrrcCtS)z Whether this whl package can be used to run the model on XPU. Returns (bool): support xpu or not. Examples: .. code-block:: python import paddle.fluid as fluid support_xpu = fluid.is_compiled_with_xpu() )r r"r5r5r5r6r" r"cCr)z Whether this whl package can be used to run the model on NPU. Returns (bool): support npu or not. Examples: .. code-block:: python import paddle.fluid as fluid support_npu = fluid.is_compiled_with_npu() )r r#r5r5r5r6r#rr#cCs tdS)a Reset signal handler registered by Paddle. Paddle installs signal handlers at C++ level to log debug information upon failing. However, conflicts can happen if another python module is making use of such signal. Such being the case, one may disblae paddle signal handler via this interface. Known frameworks that require disabling signal handler includes: 1. TVM 2. ADLIK Make sure you called paddle.disable_signal_handler() before using above mentioned frameworks. Returns: None Examples: .. code-block:: python import paddle paddle.disable_signal_handler() N)r disable_signal_handlerr5r5r5r6r s rcCr)a! Whether this whl package can be used to run the model on CINN. Returns (bool): `True` if CINN is currently available, otherwise `False`. Examples: .. code-block:: python import paddle support_cinn = paddle.device.is_compiled_with_cinn() )r rr5r5r5r6r%rrcCr)a Whether this whl package can be used to run the model on GPU. Returns (bool): `True` if CUDA is currently available, otherwise `False`. Examples: .. code-block:: python import paddle support_gpu = paddle.device.is_compiled_with_cuda() )r r r5r5r5r6r 4rr cCr)a2 Whether this whl package can be used to run the model on AMD or Hygon GPU(ROCm). Returns (bool): `True` if ROCm is currently available, otherwise `False`. Examples: .. code-block:: python import paddle support_gpu = paddle.device.is_compiled_with_rocm() )r r!r5r5r5r6r!Crr!cCBtsJd|durt}n t|ttfs|g}dd|DS)aG Note: For multi-card tasks, please use `FLAGS_selected_gpus` environment variable to set the visible GPU device. The next version will fix the problem with `CUDA_VISIBLE_DEVICES` environment variable. This function creates a list of :code:`paddle.CUDAPlace` objects. If :code:`device_ids` is None, environment variable of :code:`FLAGS_selected_gpus` would be checked first. For example, if :code:`FLAGS_selected_gpus=0,1,2`, the returned list would be [paddle.CUDAPlace(0), paddle.CUDAPlace(1), paddle.CUDAPlace(2)]. If :code:`FLAGS_selected_gpus` is not set, all visible gpu places would be returned according to the :code:`CUDA_VISIBLE_DEVICES` environment variable. If :code:`device_ids` is not None, it should be the device ids of GPUs. For example, if :code:`device_ids=[0,1,2]`, the returned list would be [paddle.CUDAPlace(0), paddle.CUDAPlace(1), paddle.CUDAPlace(2)]. Parameters: device_ids (list|tuple, optional): A list/tuple of int of GPU device ids. Returns: list of paddle.CUDAPlace: Created GPU place list. Examples: .. code-block:: python import paddle import paddle.static as static # required: gpu paddle.enable_static() cuda_places = static.cuda_places() Not compiled with CUDANcSg|]}t|qSr5)r rrZdev_idr5r5r6rzcuda_places..)r r rr/listtuplerr5r5r6rRs (rcCr)a **Note**: For multi-card tasks, please use `FLAGS_selected_xpus` environment variable to set the visible XPU device. This function creates a list of :code:`paddle.XPUPlace` objects. If :code:`device_ids` is None, environment variable of :code:`FLAGS_selected_xpus` would be checked first. For example, if :code:`FLAGS_selected_xpus=0,1,2`, the returned list would be [paddle.XPUPlace(0), paddle.XPUPlace(1), paddle.XPUPlace(2)]. If :code:`FLAGS_selected_xpus` is not set, all visible xpu places would be returned. If :code:`device_ids` is not None, it should be the device ids of XPUs. For example, if :code:`device_ids=[0,1,2]`, the returned list would be [paddle.XPUPlace(0), paddle.XPUPlace(1), paddle.XPUPlace(2)]. Parameters: device_ids (list or tuple of int, optional): list of XPU device ids. Returns: list of paddle.XPUPlace: Created XPU place list. Examples: .. code-block:: python # required: xpu import paddle import paddle.static as static paddle.enable_static() xpu_places = static.xpu_places() zNot compiled with XPUNcSrr5)r rrr5r5r6rrzxpu_places..)r r"rr/rrrr5r5r6rs rcCr)a **Note**: For multi-card tasks, please use `FLAGS_selected_npus` environment variable to set the visible NPU device. This function creates a list of :code:`paddle.NPUPlace` objects. If :code:`device_ids` is None, environment variable of :code:`FLAGS_selected_npus` would be checked first. For example, if :code:`FLAGS_selected_npus=0,1,2`, the returned list would be [paddle.NPUPlace(0), paddle.NPUPlace(1), paddle.NPUPlace(2)]. If :code:`FLAGS_selected_npus` is not set, all visible npu places would be returned. If :code:`device_ids` is not None, it should be the device ids of NPUs. For example, if :code:`device_ids=[0,1,2]`, the returned list would be [paddle.NPUPlace(0), paddle.NPUPlace(1), paddle.NPUPlace(2)]. Parameters: device_ids (list or tuple of int, optional): list of NPU device ids. Returns: list of paddle.NPUPlace: Created NPU place list. Examples: .. code-block:: python # required: npu import paddle import paddle.static as static paddle.enable_static() npu_places = static.npu_places() zNot compiled with NPUNcSrr5)r NPUPlacerr5r5r6rrznpu_places..)r r#rr/rrrr5r5r6 npu_placess  rcCs|durt}tg|S)aV This function creates a list of :code:`paddle.CPUPlace` objects, and returns the created list. If :code:`device_count` is None, the device count would be determined by environment variable :code:`CPU_NUM`. If :code:`CPU_NUM` is not set, the default value is 1, i.e. CPU_NUM=1. :code:`CPU_NUM` indicates the number of devices used in the current task. The running of the program can be accelerated if :code:`CPU_NUM` is the same as the number of physical cores. Parameters: device_count (int, optional): device number. Default: None. Returns: list of paddle.CPUPlace: Created list of CPU places. Examples: .. code-block:: python import paddle import paddle.static as static paddle.enable_static() cpu_places = static.cpu_places() N)rr rrr5r5r6rsrcCs0tsJd|durtt}tg|S)ap This function creates a list of :code:`fluid.CUDAPinnedPlace` objects. If :code:`device_count` is None, the device count would be determined by environment variable :code:`CPU_NUM`. If :code:`CPU_NUM` is not set, the default value is 1, i.e. CPU_NUM=1. :code:`CPU_NUM` indicates the number of devices used in the current task. The running of the program can be accelerated if :code:`CPU_NUM` is the same as the number of physical cores. Parameters: device_count (int, optional): device number. Default: None. Returns: list of fluid.CUDAPinnedPlace: Created list of CUDA pinned places. Examples: .. code-block:: python import paddle.fluid as fluid cuda_pinned_places_cpu_num = fluid.cuda_pinned_places() # or cuda_pinned_places = fluid.cuda_pinned_places(1) rN)r r rwrCUDAPinnedPlacerr5r5r6rs rcCr)a This function creates a list of :code:`paddle.device.MLUPlace` objects. If :code:`device_ids` is None, environment variable of :code:`FLAGS_selected_mlus` would be checked first. For example, if :code:`FLAGS_selected_mlus=0,1,2`, the returned list would be [paddle.device.MLUPlace(0), paddle.device.MLUPlace(1), paddle.device.MLUPlace(2)]. If :code:`FLAGS_selected_mlus` is not set, all visible mlu places would be returned. If :code:`device_ids` is not None, it should be the device ids of MLUs. For example, if :code:`device_ids=[0,1,2]`, the returned list would be [paddle.device.MLUPlace(0), paddle.device.MLUPlace(1), paddle.device.MLUPlace(2)]. Note: For multi-card tasks, please use `FLAGS_selected_mlus` environment variable to set the visible MLU device. Parameters: device_ids (list or tuple of int, optional): list of MLU device ids. Returns: list of paddle.device.MLUPlace: Created MLU place list. Examples: .. code-block:: python # required: mlu import paddle import paddle.static as static paddle.enable_static() mlu_places = static.mlu_places() zNot compiled with MLUNcSrr5)r rrr5r5r6r:rzmlu_places..)r rHrr/rrrr5r5r6rs "rc@s.eZdZd ddZddZddZd d ZdS) NameScopeNcCst|_||_||_dSrD)dict _children_name_parent)rinameparentr5r5r6__init__>s zNameScope.__init__cCsT||jvrt||}|g|j|<|St|dt|j||}|j|||S)Nz_%d)rrrwappend)riprefix new_childr5r5r6childCs   zNameScope.childcC|jSrD)rrir5r5r6rNzNameScope.parentcCrrD)rrr5r5r6rQrzNameScope.name)rN)rkrlr;rrrrr5r5r5r6r=s   rccsHtr dVdS|sJdt|az dVWtadStaw)ab Generate hierarchical name prefix for the operators in Static Graph. Note: This should only used for debugging and visualization purpose. Don't use it for serious analysis such as graph/program transformations. Don't use it in dygraph, since it will cause memory leak. Args: prefix(str, optional): prefix. Default is none. Examples: .. code-block:: python import paddle paddle.enable_static() with paddle.static.name_scope("s1"): a = paddle.static.data(name='data', shape=[None, 1], dtype='int32') b = a + 1 with paddle.static.name_scope("s2"): c = b * 1 with paddle.static.name_scope("s3"): d = c / 1 with paddle.static.name_scope("s1"): f = paddle.tensor.pow(d, 2.0) with paddle.static.name_scope("s4"): g = f - 1 # Op are created in the default main program. for op in paddle.static.default_main_program().block(0).ops: # elementwise_add is created in /s1/ if op.type == 'elementwise_add': assert op.desc.attr("op_namescope") == '/s1/' # elementwise_mul is created in '/s1/s2' elif op.type == 'elementwise_mul': assert op.desc.attr("op_namescope") == '/s1/s2/' # elementwise_div is created in '/s1/s3' elif op.type == 'elementwise_div': assert op.desc.attr("op_namescope") == '/s1/s3/' # elementwise_sum is created in '/s4' elif op.type == 'elementwise_sub': assert op.desc.attr("op_namescope") == '/s4/' # pow is created in /s1_1/ elif op.type == 'pow': assert op.desc.attr("op_namescope") == '/s1_1/' Nz"namescope prefix can not be empty.)r _name_scoperr)rr5r5r6rXs4   rcCs,t}d}|r|d|}|}|s|S)Nr/)rrr)scoperr5r5r6_full_name_scopesrcCsddl}tdt|S)Nr@)randomCONTROL_DEP_VAR_PREFIXr|)rr5r5r6generate_control_dev_var_namesrcCs|tS)zD Returns: str: gradient name for a certain var name )GRAD_VAR_SUFFIX)var_namer5r5r6 grad_var_namercCst|}|tjkrtjjjS|tjkrtjjjS|tj kr#tjjj S|tj kr-tjjj S|tj kr7tjjjS|tjkrAtjjjS|tjkrKtjjjS|tjkrUtjjjS|tjkr_tjjjS|tjkritjjjS|tjkrstjjjS|tjkr}tjjjStd|)z Convert the data type in numpy to the data type in Paddle Args: np_dtype(np.dtype): the data type in numpy. Returns: core.VarDesc.VarType: the data type in Paddle. zNot supported numpy dtype %s)npdtypeZfloat32r VarDescVarTypeFP32Zfloat64FP64Zfloat16FP16Zint32ZINT32Zint16ZINT16Zint64INT64Zbool_BOOLZuint16ZBF16Zuint8ZUINT8Zint8ZINT8Z complex64Z COMPLEX64Z complex128Z COMPLEX128rW)Znp_dtyperr5r5r6convert_np_dtype_to_dtype_s4                         rcCs6t|tjjs t|}|tjjjtjjjtjjjfvS)z Check the data type is floating or not. Args: dtype(np.dtype|core.VarDesc.VarType): data type. Could be numpy format or Paddle format Returns(bool): True if data type is a float value )r/r rrrrrr)rr5r5r6dtype_is_floatings rcCs,t}||s|rtd|||S)aZ Get the debug string of a protobuf message. The message could be not initialized. Args: proto(google.protobuf.message.Message): The protobuf message throw_on_error(bool): True if raise an error when the protobuf message is not initialized. Returns(str): The debug string of the protobuf message z-{0} are not initialized. The message is {1}: )rZ IsInitializedrWr__str__)protothrow_on_errorZ error_fieldsr5r5r6_debug_string_s r cKs|durt|tjjst|}tr9tj|r|ntjjj|r"t |ng||r(|ntjjj |r0dnd}| |St |r?|ntjjj|rIt |ng||rO|ntjjj |rXdSdSNTF) r/r rrrr?r9r8rr LOD_TENSOR retain_gradsr:)rrrshaper persistabler`Z eager_tensorr5r5r6_varbase_creators, rcs0t|ttfs J|s dStfdd|DS)z Return True if type of each element is expected_type. NOTE: BuiltIn all() will always return True if vals is empty. Fc3s|]}t|VqdSrD)r/rv expected_typer5r6 -sz_all_is_type..)r/rrall)valsrr5rr6 _all_is_type$src@eZdZeddZdS)VariableMetaClasscCs8t|}trt|tjjStrt|tjSt|tSrD) rrr issubclassr r9r8rNr:r$clsinstancetr5r5r6__instancecheck__1s   z#VariableMetaClass.__instancecheck__Nrkrlr; classmethodr r5r5r5r6r0rc@r)ParameterMetaClasscCs2t|}tr t|tStrt|tSt|tSrD)rrrrEagerParamBaserN ParamBase Parameterrr5r5r6r =s    z$ParameterMetaClass.__instancecheck__Nr!r5r5r5r6r$<r#r$c @s0eZdZdZejjjdddddddddddf ddZddZ e dd Z e dcd d Z e d d Z e ddZe ddZddZddZdcddZeZddZeddZejddZeddZejddZed d!Zejd"d!Zed#d$Zed%d&Zejd'd$Zed(d)Zed*d+Zed,d-Zed.d/Zed0d1Z d2d3Z!d4d5Z"d6d7Z#d8d9Z$d:d;Z%dd?Z'd@dAZ(dcdBdCZ)dDdEZ*dFdGZ+dHdIZ,dJdKZ-dLdMZ.dddNdOZ/dddPdQZ0dRdSZ1dTdUZ2dVdWZ3dXdYZ4dZd[Z5ed\d]Z6d^d_Z7ed`daZ8e8jdbdaZ8dS)er$a **Notes**: **The constructor of Variable should not be invoked directly.** **In Static Graph Mode: Please use** `Block.create_var` **to create a Static variable which has no data until being feed.** **In Dygraph Mode: Please use** :ref:`api_fluid_dygraph_to_variable` **to create a dygraph variable with real data** In Fluid, every input and output of an OP is a variable. In most cases, variables are used for holding different kinds of data or training labels. A variable belongs to a :ref:`api_guide_Block_en` . All variable has its own name and two variables in different :ref:`api_guide_Block_en` could have the same name. There are many kinds of variables. Each kind of them has its own attributes and usages. Please refer to the `framework.proto `_ for details. Most of a Variable's member variables can be set to be None. It mean it is not available or will be specified later. Examples: In Static Graph Mode: .. code-block:: python import paddle.fluid as fluid cur_program = fluid.Program() cur_block = cur_program.current_block() new_variable = cur_block.create_var(name="X", shape=[-1, 23, 48], dtype='float32') In `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ Mode: .. code-block:: python import paddle.fluid as fluid import numpy as np with fluid.dygraph.guard(): new_variable = fluid.dygraph.to_variable(np.arange(10)) NFcKs<||_|dur td}|durt|tjjst|}|tjjjkr)tjjj}d}|tjjj kr2d}| |_ | |_ d}t |}|jjt ||_|jdur\|jjt ||_d}|re|j|n|j|krytd|j|j||dur|r|j|n|j}t|}||krtd|j|||dur|r|j|n|j}||krtd|j|||dur|r|j|n||jkrtd|j|j||dur|r|j|n||jkrtd|j|j|| r|r|j | |dur |r |j!|n ||jj"|<d|_#| |_$| |_%dS) NZ_generated_varFTzkVariable '{0}' has been created before. The previous type is {1}, the new type is {2}. They are not matchedznVariable '{0}' has been created before. The previous shape is {1}, the new shape is {2}. They are not matched.zvVariable '{0}' has been created before. The previous data type is {1}, the new data type is {2}. They are not matched.zuVariable '{0}' has been created before. The previous lod_level is {1}, the new lod_level is {2}. They are not matchedzxVariable '{0}' has been created before.The previous persistable is {1}, the new persistable is {2}. They are not matched)&blockrgenerater/r rrrSTRINGSZ SPARSE_COObelong_to_optimizer error_clipcptto_textdescfind_varto_bytesvarset_typerrrWrr set_shaperr set_dtyperZ set_lod_level lod_levelset_persistablerset_need_check_feedZ set_capacityvarsop stop_gradientis_data)rir(rrrrrr6capacityrr,r;r<need_check_feedr+r`Z is_new_varZ old_shapeZ old_dtyper5r5r6rus             zVariable.__init__cCsr|jtjjjks|jtjjjksJd|jjt d|j |j |j|j dd}|jj dd|gid|gid|S) a Returns a new Variable, detached from the current graph. It will share data with origin Variable and without tensor copy. In addition, the detached Variable doesn't provide gradient propagation. Returns: ( :ref:`api_guide_Variable_en` | dtype is same as current Variable): The detached Variable. Examples: .. code-block:: python import paddle paddle.enable_static() # create a static Variable x = paddle.static.data(name='x', shape=[3, 2, 1]) # create a detached Variable y = x.detach() zGonly support a variable with SELECTED_ROWS or LOD_TENSOR to be detachedZdetach_Trrrrrr;Z share_dataXOutrrinputsoutputs)rrr rr SELECTED_ROWSr r( create_varrgenerate_with_ignorable_keyrrr append_oprioutputr5r5r6detachszVariable.detachcCdS)aj **Notes**: **This API is ONLY available in Dygraph mode** Returns a numpy array shows the value of current :ref:`api_guide_Variable_en` Returns: ndarray: The numpy value of current Variable. Returns type: ndarray: dtype is same as current Variable Examples: .. code-block:: python import paddle.fluid as fluid from paddle.fluid.dygraph.base import to_variable from paddle.fluid.dygraph import Linear import numpy as np data = np.random.uniform(-1, 1, [30, 10, 32]).astype('float32') with fluid.dygraph.guard(): linear = Linear(32, 64) data = to_variable(data) x = linear(data) print(x.numpy()) Nr5rr5r5r6rszVariable.numpycCrL)a$ **Notes**: **This API is ONLY available in Dygraph mode** Run backward of current Graph which starts from current Tensor. Args: retain_graph(bool, optional): If False, the graph used to compute grads will be freed. If you would like to add more ops to the built graph after calling this method( :code:`backward` ), set the parameter :code:`retain_graph` to True, then the grads will be retained. Thus, seting it to False is much more memory-efficient. Defaults to False. Returns: NoneType: None Examples: .. code-block:: python import numpy as np import paddle paddle.disable_static() x = np.ones([2, 2], np.float32) inputs = [] for _ in range(10): tmp = paddle.to_tensor(x) # if we don't set tmp's stop_gradient as False then, all path to loss will has no gradient since # there is no one need gradient on it. tmp.stop_gradient=False inputs.append(tmp) ret = paddle.add_n(inputs) loss = paddle.sum(ret) loss.backward() Nr5)riZ retain_graphr5r5r6backward4s%zVariable.backwardcCrL)a **Notes**: **This API is ONLY available in Dygraph mode** Get the Gradient of Current Variable Returns: ndarray or tuple of ndarray: if Variable's type is LoDTensor, return numpy value of the gradient of current Variable, if Variable's type is SelectedRows, return tuple of ndarray, first element of tuple is numpy value of the gradient of current Variable, second element of tuple is numpy value of the rows of current Variable. Examples: .. code-block:: python import paddle.fluid as fluid import numpy as np # example1: return ndarray x = np.ones([2, 2], np.float32) with fluid.dygraph.guard(): inputs2 = [] for _ in range(10): tmp = fluid.dygraph.base.to_variable(x) tmp.stop_gradient=False inputs2.append(tmp) ret2 = fluid.layers.sums(inputs2) loss2 = fluid.layers.reduce_sum(ret2) loss2.backward() print(loss2.gradient()) # example2: return tuple of ndarray with fluid.dygraph.guard(): embedding = fluid.dygraph.Embedding( size=[20, 32], param_attr='emb.w', is_sparse=True) x_data = np.arange(12).reshape(4, 3).astype('int64') x_data = x_data.reshape((-1, 3, 1)) x = fluid.dygraph.base.to_variable(x_data) out = embedding(x) out.backward() print(embedding.weight.gradient()) Nr5rr5r5r6gradient[s,zVariable.gradientcCrL)aF **Notes**: **1. This API is ONLY available in Dygraph mode** **2. Use it only Variable has gradient, normally we use this for Parameters since other temporal Variable will be deleted by Python's GC** Clear (set to ``0`` ) the Gradient of Current Variable Returns: None Examples: .. code-block:: python import paddle.fluid as fluid import numpy as np x = np.ones([2, 2], np.float32) with fluid.dygraph.guard(): inputs2 = [] for _ in range(10): tmp = fluid.dygraph.base.to_variable(x) tmp.stop_gradient=False inputs2.append(tmp) ret2 = fluid.layers.sums(inputs2) loss2 = fluid.layers.reduce_sum(ret2) loss2.backward() print(loss2.gradient()) loss2.clear_gradient() print("After clear {}".format(loss2.gradient())) Nr5rr5r5r6clear_gradient!zVariable.clear_gradientcCsdSrDr5)rihookr5r5r6 register_hookrFzVariable.register_hookcC|SrD_to_readable_coderr5r5r6rrPzVariable.__str__cCst|jdd}|jtjjjks|jtjjjkr2t|jdd}dj |j ||j ||j d}ndj |j |d}|j rJ|jrEd|}n d|}nd |}|jrUd |}d d lm}|}||}|d urp|dj d|d7}|S)a Get readable debug string of Variable. .. note:: If you want to get the debug string in protobuf format, please use :code:`to_string` method. Returns: string: The formatted Variable string. Examples: .. code-block:: python import paddle import paddle.static as static paddle.enable_static() cur_program = static.Program() cur_block = cur_program.current_block() new_variable = cur_block.create_var(name="X", shape=[-1, 23, 48], dtype='float32') print(new_variable._to_readable_code()) r{rzJ{name} : {type}.shape{shape}.dtype({dtype}).stop_gradient({stop_gradient}))rrrrrr;z{name} : {type}))rrrztrainable param param zvar zpersist rget_default_distributed_contextN, {name} = {value} dist_attrrvalue)r|rrrr rrrEr rrrrr; is_parameter trainabler-paddle.distributed.auto_parallel.dist_contextrXZget_dist_tensor_for_program)riZtype_strZ dtype_strZvar_strrX dist_contextZ dist_tensorr5r5r6rUs6    zVariable._to_readable_codec Cspt|tr t|ts J|j}tjt|}t ||}|r6d}|D]}|d|t t ||f7}q%|S)a Get debug string. Args: throw_on_error (bool): True if raise an exception when self is not initialized. with_details (bool): more details about variables and parameters (e.g. trainable, optimize_attr, ...) will be printed when with_details is True. Default value is False; Returns: str: The debug string. Examples: .. code-block:: python import paddle.fluid as fluid import paddle paddle.enable_static() cur_program = fluid.Program() cur_block = cur_program.current_block() new_variable = cur_block.create_var(name="X", shape=[-1, 23, 48], dtype='float32') print(new_variable.to_string(True)) print("=============with detail===============") print(new_variable.to_string(True, True)) r,%s: %s ) r/r0r/serialize_to_stringr r FromStringrt binary_typer r-r.getattr)rir  with_detailsprotostrrres_stradditional_attr attr_namer5r5r6 to_strings    zVariable.to_stringcC |jS)a Returns the size in bytes of an element in the Tensor. Examples: .. code-block:: python import paddle paddle.enable_static() x = paddle.static.data(name='x1', shape=[3, 2], dtype='bool') x.element_size() # 1 x = paddle.static.data(name='x2', shape=[3, 2], dtype='int16') x.element_size() # 2 x = paddle.static.data(name='x3', shape=[3, 2], dtype='float16') x.element_size() # 2 x = paddle.static.data(name='x4', shape=[3, 2], dtype='float32') x.element_size() # 4 x = paddle.static.data(name='x5', shape=[3, 2], dtype='float64') x.element_size() # 8 )r/ element_sizerr5r5r6rn% zVariable.element_sizecCrm)a, Indicating if we stop gradient from current Variable **Notes: This Property has default value as** ``True`` **in** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **mode, while Parameter's default value is False. However, in Static Graph Mode all Variable's default stop_gradient value is** ``False`` Examples: .. code-block:: python import paddle.fluid as fluid import numpy as np with fluid.dygraph.guard(): value0 = np.arange(26).reshape(2, 13).astype("float32") value1 = np.arange(6).reshape(2, 3).astype("float32") value2 = np.arange(10).reshape(2, 5).astype("float32") linear = fluid.Linear(13, 5, dtype="float32") linear2 = fluid.Linear(3, 3, dtype="float32") a = fluid.dygraph.to_variable(value0) b = fluid.dygraph.to_variable(value1) c = fluid.dygraph.to_variable(value2) out1 = linear(a) out2 = linear2(b) out1.stop_gradient = True out = fluid.layers.concat(input=[out1, out2, c], axis=1) out.backward() assert linear.weight.gradient() is None assert (out1.gradient() == 0).all() )r/r;rr5r5r6r;@s zVariable.stop_gradientcC|j|dSrD)r/Zset_stop_gradient)rirr5r5r6r;acCrm)a] Indicating if we current Variable should be long-term alive **Notes: This Property will be deprecated and this API is just to help user understand concept** **1. All Variable's persistable is** ``False`` **except Parameters.** **2. In** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **mode, this property should not be changed** Examples: .. code-block:: python import paddle.fluid as fluid cur_program = fluid.Program() cur_block = cur_program.current_block() new_variable = cur_block.create_var(name="X", shape=[-1, 23, 48], dtype='float32') print("persistable of current Var is: {}".format(new_variable.persistable)) )r/rrr5r5r6res zVariable.persistablecCrprD)r/r7ripr5r5r6r~rqcCrm)a+ Indicating if current Variable is a Parameter Examples: .. code-block:: python import paddle new_parameter = paddle.static.create_parameter(name="X", shape=[10, 23, 48], dtype='float32') if new_parameter.is_parameter: print("Current var is a Parameter") else: print("Current var is not a Parameter") # Current var is a Parameter )r/r]rr5r5r6r]s zVariable.is_parametercCrprD)r/Zset_is_parameterrrr5r5r6r]rqcCst|jS)a  Indicating name of current Variable **Notes: If it has two or more Varaible share the same name in the same** :ref:`api_guide_Block_en` **, it means these Variable will share content in no-** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **mode. This is how we achieve Parameter sharing** Examples: .. code-block:: python import paddle.fluid as fluid cur_program = fluid.Program() cur_block = cur_program.current_block() new_variable = cur_block.create_var(name="X", shape=[-1, 23, 48], dtype='float32') print("name of current Var is: {}".format(new_variable.name)) )r-r.r/rrr5r5r6rsz Variable.namecCs |jdS)a Indicating name of the gradient Variable of current Variable. **Notes: This is a read-only property. It simply returns name of gradient Variable from a naming convention but doesn't guarantee the gradient exists.** Examples: .. code-block:: python import paddle.fluid as fluid x = fluid.data(name="x", shape=[-1, 23, 48], dtype='float32') print(x.grad_name) # output is "x@GRAD" z@GRADrrr5r5r6 grad_name zVariable.grad_namecCrprD)r/set_name)rinew_namer5r5r6rrqcCt|jS)a/ Indicating shape of current Variable **Notes: This is a read-only property** Examples: .. code-block:: python import paddle.fluid as fluid cur_program = fluid.Program() cur_block = cur_program.current_block() new_variable = cur_block.create_var(name="X", shape=[-1, 23, 48], dtype='float32') print("shape of current Var is: {}".format(new_variable.shape)) )rr/rrr5r5r6rszVariable.shapecCrm)a2 Indicating data type of current Variable **Notes: This is a read-only property** Examples: .. code-block:: python import paddle.fluid as fluid cur_program = fluid.Program() cur_block = cur_program.current_block() new_variable = cur_block.create_var(name="X", shape=[-1, 23, 48], dtype='float32') print("Dtype of current Var is: {}".format(new_variable.dtype)) )r/rrr5r5r6rrvzVariable.dtypecCs6|jtjjjkr td|jtjjjkrdS|jS)a~ Indicating ``LoD`` info of current Variable, please refer to :ref:`api_fluid_LoDTensor_en` to check the meaning of ``LoD`` **Notes**: **1. This is a read-only property** **2. Don't support this property in** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **mode, it's value should be** ``0(int)`` Examples: .. code-block:: python import paddle import paddle.fluid as fluid paddle.enable_static() cur_program = fluid.Program() cur_block = cur_program.current_block() new_variable = cur_block.create_var(name="X", shape=[-1, 23, 48], dtype='float32') print("LoD Level of current Var is: {}".format(new_variable.lod_level)) zSelectedRows DO NOT supprt lodN) rrr rrrErr*r/r6rr5r5r6r6s  zVariable.lod_levelcCrm)a+ Indicating Type of current Variable **Notes: This is a read-only property** Examples: .. code-block:: python import paddle.fluid as fluid cur_program = fluid.Program() cur_block = cur_program.current_block() new_variable = cur_block.create_var(name="X", shape=[-1, 23, 48], dtype='float32') print("Type of current Var is: {}".format(new_variable.type)) r/rrrr5r5r6rrrvz Variable.typecCst|jdkr |Sg}tt|jD]}|d|q|jjt|jd|j |j ddd}|jjt|jd|j t j j jddd}|jjdd|gi|g|gdd |id |S) aB Permute current Variable with its dimensions reversed. If `n` is the dimensions of `x` , `x.T` is equivalent to `x.transpose([n-1, n-2, ..., 0])`. Examples: .. code-block:: python import paddle paddle.enable_static() x = paddle.ones(shape=[2, 3, 5]) x_T = x.T exe = paddle.static.Executor() x_T_np = exe.run(paddle.static.default_main_program(), fetch_list=[x_T])[0] print(x_T_np.shape) # (5, 3, 2) rrz.tmpFr?Z transpose2r@)rAZXShapeaxisrrrCrDattrs)rwrrvinsertr(rFrrGrrrrr rrr rH)ripermryoutZ input_shaper5r5r6T%s4 z Variable.TcCsL|jjt|jd|j|j|j|jd}|jj dd|gid|gid|S)a Returns a new static Variable, which is the clone of the original static Variable. It remains in the current graph, that is, the cloned Variable provides gradient propagation. Calling ``out = tensor.clone()`` is same as ``out = assign(tensor)`` . Returns: Variable: The cloned Variable. Examples: .. code-block:: python import paddle paddle.enable_static() # create a static Variable x = paddle.static.data(name='x', shape=[3, 2, 1]) # create a cloned Variable y = x.clone() Z_cloner?Zassignr@rArB) r(rFrrGrrrrrr;rHrIr5r5r6cloneXszVariable.clonecCs ||_dS)z Set the error_clip. Args: error_clip(BaseErrorClipAttr) : The new error_clip. Returns: None Nra)rir,r5r5r6_set_error_clip|s zVariable._set_error_clipcCst|dsi|_||j|<dS)z Set key-value information for this variable. Args: key(str): Key for this information. value(object): The value associated to the key. Returns: None _infoNhasattrr)rikeyr\r5r5r6 _set_infos zVariable._set_infocCs"t|dr||jvr|j|SdS)z Get the information of this variable corresponding to key. Args: key(str): Key for this information. Returns: object rNr)rirr5r5r6 _get_infos zVariable._get_infocCs|jdurdn|j}|dkrtd|dkrtd|dkr dnd}|dkr*|dn|}|jdur:|dkr7|n|}n|j}|dkrHt|||nt||}|jdur[|dkrX|n|}n|j}|dkrit|||nt||}|||fS)zH Reference implementation for the slice.indices method. Nrrzlength should not be negativezslice step can not be zerorS)steprWstartmaxminstop)rislicelengthrlowerupperrrr5r5r6_slice_indicess"    zVariable._slice_indicescCsTd}d}t|j}t|D]\}}|tur |rtdd}|}q |r$|}q |||fS)NFrz!Index can have one ellipsis only.T)rwr enumerateEllipsisrW)riitem has_ellipsisrendrZor5r5r6_detectEllipsiss  zVariable._detectEllipsiscCs||\}}}|r>g}t|D] }|||qt||D] }|tdddqt|t|D] }|||q2|SdSrD)rrvrrrw)rirrrrnewitemryr5r5r6_reconstructSliceinfos zVariable._reconstructSliceinfoc Cs g}g}t|D]v\}}t|trTt|}|dkr ||j|ks-|dkr1||j|dkr1td|dkr?t||j|dnt||j|}||||dqt|tr{| ||j|\}}}|dksm|dkrx||||qdStdd||gfS)Nr invalid indexrrS)FNz+Valid index accept int or slice or ellipsisT) rr/rxr IndexErrorrrrrr) rirstartsendsrZrrrrr5r5r6_detectContinuesSlices,      zVariable._detectContinuesSlicecCs"|s|jjt|j|jdS|S)Nrr)r(rFrrGrr)ricopyr5r5r6 _cloneVar s  zVariable._cloneVarcCs4|}|jjdd|gid|gi|||dd|S)NrInputrA)axesrrr|rr(rH)rirrrnew_varr5r5r6 _sliceVar s zVariable._sliceVarcCs.|}|jjdd|id|gid|id|S)Nconcatr@rAr{r|r)rirCr{rr5r5r6 _concatVar szVariable._concatVarcCs^t|trn|j|dkr|dS|||j|\}}}|dkr+||g|g|gSg}|dkrM||krL|||g|g|dg||7}||ks5n||krh|||g|g|dg||7}||ksQ|||St|tr|j|dkr|dSt|}|dkr||j|ks|dkr||j|dkrt d||g|g|dgSt d)NrTrrz(Valid index accept int or slice or tuple) r/rrrrrrrrxr)rirr{rrrr9rZr5r5r6_sliceAndConcatVar s>     zVariable._sliceAndConcatVarcCs t||SrD)r)rirr5r5r6 __getitem__B  zVariable.__getitem__cCs t|||SrD)r)rirr\r5r5r6 __setitem__E  zVariable.__setitem__cCspddlm}|durt|tjstdt||dur |}||j }|dur2t d|j | }|S)a Get the value of variable in given scope. Args: scope(Scope, optional) : If `scope` is None, it will be set to global scope obtained through 'paddle.static.global_scope()'. Otherwise, use `scope`. Default: None Returns: Tensor: the value in given scope. Examples: .. code-block:: python import paddle import paddle.static as static import numpy as np paddle.enable_static() x = static.data(name="x", shape=[10, 10], dtype='float32') y = static.nn.fc(x, 10, name='fc') place = paddle.CPUPlace() exe = static.Executor(place) prog = paddle.static.default_main_program() exe.run(static.default_startup_program()) inputs = np.ones((10, 10), dtype='float32') exe.run(prog, feed={'x': inputs}, fetch_list=[y, ]) path = 'temp/tensor_' for var in prog.list_vars(): if var.persistable: t = var.get_value() paddle.save(t, path+var.name+'.pdtensor') for var in prog.list_vars(): if var.persistable: t_load = paddle.load(path+var.name+'.pdtensor') var.set_value(t_load) r global_scopeNF`scope` should be None or `paddle.static.Scope` type, but received {}.(Can not find Variable '{}' in the Scope.) executorrr/r _Scoperqrrrr0rrW get_tensor)rirrvar_temprr5r5r6 get_valueH s ,  zVariable.get_valuec Csddlm}t|tjst|dstdt||dur-t|t j s-tdt||dur4|}| |j }|durFt d|j |}t|dryt|jttfr\|}n|j}t|t|kryt d |j t|t||}|rt }n`|rt }nW|rt }||t |}n@|rt }||t |}n)| rt }||t !|"}nt }||t #|$}|%||dS) a Set the value to the tensor in given scope. Args: value(Tensor/ndarray) : The value to be set. scope(Scope, optional) : If `scope` is None, it will be set to global scope obtained through 'paddle.static.global_scope()'. Otherwise, use `scope`. Default: None Returns: None Examples: .. code-block:: python import paddle import paddle.static as static import numpy as np paddle.enable_static() x = static.data(name="x", shape=[10, 10], dtype='float32') y = static.nn.fc(x, 10, name='fc') place = paddle.CPUPlace() exe = static.Executor(place) prog = paddle.static.default_main_program() exe.run(static.default_startup_program()) inputs = np.ones((10, 10), dtype='float32') exe.run(prog, feed={'x': inputs}, fetch_list=[y, ]) path = 'temp/tensor_' for var in prog.list_vars(): if var.persistable: t = var.get_value() paddle.save(t, path+var.name+'.pdtensor') for var in prog.list_vars(): if var.persistable: t_load = paddle.load(path+var.name+'.pdtensor') var.set_value(t_load) rrZ __array__zB`value` should be `numpy.ndarray` or `LoDTensor`, but received {}.Nrrrz5{} expected a shape {}, but the received shape is {}.)&rrr/rZndarrayrrqrrrr rr0rrWrrrr rZ_placeZ is_cpu_placerZis_cuda_pinned_placerZ is_xpu_placePlaceZ set_placerZ xpu_device_idZ is_npu_placerZ npu_device_idZ is_mlu_placerZ mlu_device_idrZ gpu_device_idset) rir\rrrrZ value_shapersrQr5r5r6 set_value sh .      zVariable.set_valuecCsD|jjt|jdtjjjd}|jj dd|gid|gid|S)a  Returns the number of elements for current Variable, which is a int64 Variable with shape [1] Returns: Variable: the number of elements for current Variable Examples: .. code-block:: python import paddle paddle.enable_static() # create a static Variable x = paddle.static.data(name='x', shape=[3, 2, 1]) # get the number of elements of the Variable y = x.size() _sizersizerrArB) r(rFrrGrr rrrrHrIr5r5r6r sz Variable.sizecC|||dS)z Set the value of attribute by attribute's name. Args: name(str): the attribute name. val(int|str|list): the value of the attribute. N_update_desc_attrrirvalr5r5r6 _set_attr zVariable._set_attrcC |j|S)z Whether this Variable has the attribute with the name `name` or not. Args: name(str): the attribute name. Returns: bool: True if has this attribute. r/has_attrrirr5r5r6 _has_attr  zVariable._has_attrcCrprDr/ remove_attrrr5r5r6 _remove_attr) zVariable._remove_attrcC|j||dS)z Update the value of desc's attribute by attribute's name. Args: name(str): the attribute name. val(int|str|list): the value of the attribute. N)r/rrr5r5r6r, zVariable._update_desc_attrcCrm)z(Get the names of all attributes defined.r/ attr_namesrr5r5r6r6 s zVariable.attr_namescCr)z Get the attribute by name. Args: name(str): the attribute name. Returns: int|str|list: The attribute value. The return value can be any valid attribute type. r/attrrr5r5r6 _get_attr;  zVariable._get_attrcC|jjSz= Get distributed attribute of this Variable. r/rZrr5r5r6rZH rzVariable.dist_attrcC ||j_dSz= Set distributed attribute of this Variable. NrrirZr5r5r6rZO  FrD)9rkrlr;__doc__r rrr rrKfake_interface_onlyrrMrNrOrRrrUrl__repr__rnpropertyr;setterrr]rrurrr6rrrrrrrrrrrrrrrrrrrrrrrrrrrZr5r5r5r6r$Hs. v)  & - "  C-              2$ #    "  ?m    r$cCs6t}g}|D]}tjt|}||q|S)zl Get all registered op proto from PaddlePaddle C++ end. Returns: list: list of OpProto. )r get_all_op_protosr ZOpProtordrtrer)Z protostrsZ ret_valuesZpbstrZop_protor5r5r6rW s  rc@s@eZdZdZeddZddZddZdd Ze d d Z d S) OpProtoHolderzB A global variable to hold all OpProtos from C++ as a map cCst|ds ||_|jS)N _instance)rr)rr5r5r6rk s zOpProtoHolder.instancecCs:t|jdr Jdt}i|_|D]}||j|j<qdS)Nrz4Please use `instance()` to get OpProtoHolder object!)rrjr op_proto_maprr)ri op_protosrr5r5r6rq szOpProtoHolder.__init__cCs ||jvr td||j|S)z Get OpProto by a type string. Args: type(str): The type that operator registered in C++ side. Returns(framework_pb2.OpProto): The OpProto z&Operator "%s" has not been registered.)rrW)rirrr5r5r6 get_op_protoz s  zOpProtoHolder.get_op_protocCs<t}g}|D]}|j|jvr||j|j<||jq|SrD)rrrrr)rirZcustom_op_namesrr5r5r6update_op_proto s   zOpProtoHolder.update_op_protocCs,tjtjtjtjtjhSrD)r op_proto_and_checker_makerkOpRoleAttrNamekOpRoleVarAttrNamekOpNameScopeAttrNamekOpCreationCallstackAttrNamekOpDeviceAttrNamer5r5r5r6generated_op_attr_names s z%OpProtoHolder.generated_op_attr_namesN) rkrlr;rr"rrrr staticmethodrr5r5r5r6rf s    rc@sXeZdZdZhdZ dHddZddZdd ZdId d Zd dZ e Z e ddZ ddZ ddZddZe ddZe ddZe ddZddZe dd Ze d!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Ze d/d0Zd1d2Zd3d4Zd5d6Zd7d8Z d9d:Z!d;d<Z"d=d>Z#d?d@Z$dAdBZ%dCdDZ&e dEdFZ'e'j(dGdFZ'dS)JOperatora In Fluid, all the operation are represented by Operator, and Operator is regarded as a build in an instruction of a Block. Users can use the build in instructions to describe their neural network. Args: block(Block): The block has the current operator. desc(core.OpDesc): The protobuf description of Operator. type(str): The type of operator. Default None. inputs(dict): The input of this Operator. it is a dictionary, for every element, key is the input parameter name, and value is a list of variables. Default None. outputs(dict): The output of this Operator. it is a dictionary, for every element, key is the input parameter name, and value is a list of variables. Default None. attrs(dict): The attributes of this Operator. it is a dictionary, for every element, key is attribute name, and value is the attribute value. The attribute type should be as same as the type registered in C++ side. Default None. Returns: Operator: The initialized Operator. Raises: ValueError: If the passed input, output and attrs doesn't match the initializing Operator's that registered in C++ side. Notes: The constructor of operator should not be invoked directly. Use Block.append_op or Block._prepend_op instead. Examples: .. code-block:: python import paddle.fluid as fluid cur_program = fluid.Program() cur_block = cur_program.current_block() # var1 += var2 + var3 cur_block.append_op(type="sum", inputs={"X": [var1, var2, var3]}, outputs={"Out": [var1]}) >Z c_comm_initwhileZ c_gen_bkcl_idZcheckpoint_notifyselectZ c_gen_hccl_idZc_sync_calc_streamZncclInitZ c_gen_cncl_idZfl_listen_and_servZheter_listen_and_servgoZ c_wait_commZcopy_cross_scopeZ gen_bkcl_iddequeueZc_comm_init_hcclenqueueZ gen_nccl_idrecvZ c_gen_nccl_idc_sync_comm_streamZlisten_and_servZ recurrentfeedZc_wait_computeZconditional_blocksendZqueue_generatorfetchZrnn_memory_helper_gradNc Cs6zt|}i|_|jD] }|j|j|j<qWn ty"Ynwtr=|dur.td||_ |r8||_dSi|_dS||_ ||_ |} | durLt } ~t |_tj} | | vrb|j jj| | <| } t|j jjdkrz| | vrz|j jj| | <| | vrt| | dkr| | =t|j dkr|j D]} || r|| jdur||| _qdS|durtd| } g| | <tD] }| | d|d|d|d| | d|dq|j |t|}| !}t"| |<t#dur4|$|r| %}t#| |<nt&'d|d | vr4|d kr&| d dks-| d d kr4t&'d |t(durEd t)}|*|t(dd}|dur|j+D]}|||j}|sh|j,shJd|j|r||j}t-|t.t/fs{|g}|j0st|dkrtd|jt|fg}t1|D]?\}} t-| t2j3r|| qt-| t2j4r|| 5qt-| t6tj7fr|t89| jqt:d|j|| f|j ;|j|qQ|j ;|jgqQ|dur|j|}| durt-| t st:d|jD]}|j}|| vs| |durq| |}|*||q|?D]!}|| vs| |dur|*|||q|*|| |qt@rtAdkr|*tBtAtCdkr|*tDtC|j E|$|r|j F|j j |j G|j j dSdS)Nz2`type` to initialized an Operator can not be None.rz File "{}", line {}, in {}rr z {}z(The Op(%s) is not support to set device.Z force_cpu less_thanFzThe Attr(force_cpu) of Op(%s) will be deprecated in the future, please use 'device_guard' instead. 'device_guard' has higher priority when they are used at the same time.Zpipeline_stagecSs(|D]}||dur||krdSqdSr r5)var_listrrr5r5r6 find_nameV s z$Operator.__init__..find_namezInput {} not foundz2Input %s expects only one input, but %d are given.zThe type of '%s' in operator %s should be one of [basestring(), str, Varibale] in python2, or one of [str, bytes, Variable] in python3.but received : %szCIncorrect setting for output(s) of operator "%s", should set: [%s].z4Output %s expects only one output, but %d are given.z'attrs' should be a dict.)Hrrr _attr_typesr}rrrrWr_typer(r/r_current_cuda_graph_modeZ_cuda_graph_attrr rrprogram_op_rolerrw _op_role_varoutput_arg_nameshas_varr2r:r traceback extract_stackrrr3rr_current_device _has_kernelrrIrJrZkAutoParallelSuffixrrCZ dispensabler/rrZ duplicablerrt string_typesredecoder$r:r-r.rq set_inputrD set_outputget_op_extra_attrsrrGrXipu_index_attr_namerYipu_stage_attr_nameZ check_attrsZinfer_var_typeZ infer_shape)rir(r/rrrCrDr}rrZop_attrsop_makerZ role_var_nameargZcallstack_var_nameframeZnamescope_var_nameZ op_deviceZpipeline_attr_namerZin_protofoundZin_argsZ in_arg_namesrZmZ out_protoZout_argsZ out_arg_namesextra_attrs_maprkZattr_valr5r5r6r sl                                         zOperator.__init__cCs ||jvSrD)OP_WITHOUT_KERNEL_SET)riop_typer5r5r6r rzOperator._has_kernelcCs&|j}tjt|}t||S)z Get debug string. Args: throw_on_error(bool): Whether to raise exception if self is not initialized. Returns: str: The debug string. )r/rcr OpDescrdrtrer )rir rhrr5r5r6rl s  zOperator.to_stringTcCst|tsJdt|d}tdt|jD]*}|dj|j|d7}||j|}|dj|d7}|t|jdkrB|d 7}q|d 7}d}tdt|jD]*}|dj|j|d7}| |j|}|dj|d7}|t|jdkr{|d 7}qQ|d 7}t |j }d }tdt|D] }||}|r|d krq|j |d } | tjjkr|j |d } dj|| | d} || 7}|t|dkr|d 7}q| tjjkrdd|j |d D} dj|| d| d} || 7}|t|dkr|d 7}q| tjjkrdj|| ||d} || 7}|t|dkr|d 7}q| tjjkrAdj|| ||d} || 7}|t|dkr@|d 7}qtr{|jdkr{|dkr{|j |} t| }t}||}|}|d}ddd|D}d|}n|j |}dj|| |d} || 7}|t|dkr|d 7}qddlm }|}|!|}|dur|djd|d7}|d krd!j||j||d"}|Sd#j|j||d$}|S)%a Get readable debug string of Operator. .. note:: If you want to get the debug string in protobuf format, please use :code:`to_string` method. Args: skip_op_callstack(bool): whether to skip parsing Operator's attribute op_callstack, default value is True Returns: string: The formatted Operator string. Examples: .. code-block:: python import paddle.fluid as fluid cur_program = fluid.Program() cur_block = cur_program.current_block() var = cur_block.create_var(name="X", shape=[-1, 23, 48], dtype='float32') new_op = cur_block.append_op(type="abs", inputs={"X": [var]}, outputs={"Out": [var]}) print(new_op._to_readable_code()) Eskip_op_callstack parameter's type is error, expect bool, received {}{rz{name}=rtz{value})r\rz, }r op_callstackTz{name} = Var['{value}'])rrrr\cSsg|]}d|qS)z'%s'rtrr2r5r5r6r& s z.Operator._to_readable_code..z{name} = Vars[{value}]rz{name} = block[{value}]z{name} = blocks{value}Z cinn_launchZcompilation_key cSsg|]}d|qS)z r5)rliner5r5r6rO rz{name} = {value}rWNrYrZr[z{}z/{outputs} = {op_type}(inputs={inputs}, {attrs}))rDrrCr}z#{op_type}(inputs={inputs}, {attrs}))rrCr})"r/r0rrrrvrw output_namesrJ input_namesinputsortedrr/ attr_typer AttrTypeVARrrVARSjoinBLOCK_block_attr_idBLOCKS_blocks_attr_idsrZget_serialize_comile_keyrparse_from_stringrUrr_rXZget_dist_op_for_program)riskip_op_callstackZ outputs_strryrZ inputs_strrZ attrs_strrr* attr_var_nameaZattr_var_namesrrprogrlinesr\rXr`Zdist_opZop_strr5r5r6rU s                     zOperator._to_readable_codecCrSrDrTrr5r5r6rt rPzOperator.__str__cCrmrDrzrr5r5r6rry  z Operator.typecCr)a Get the input arguments according to the input parameter name. Args: name(str): The input parameter name. Returns: list: return the list of argument names that associated with \ the specific parameter name. )r/r(rr5r5r6r(} rzOperator.inputcCr)z Rename the `old_name` to `new_name`. Args: old_name(str): The old name of the Operator's input. new_name(str): The new name of the Operator's input. Returns: None N)r/ _rename_inputriZold_namerxr5r5r6r:  zOperator._rename_inputcCr)z Rename the `old_name` to `new_name`. Args: old_name(str): The old name of the Operator's output. new_name(str): The new name of the Operator's output. Returns: None N)r/_rename_outputr;r5r5r6r= r<zOperator._rename_outputcCrmrD)r/r'rr5r5r6r' r9zOperator.input_namescCrmrD)r/input_arg_namesrr5r5r6r> r9zOperator.input_arg_namescCrmrD)r/r rr5r5r6r  r9zOperator.output_arg_namescCr)a  Get output arguments by the output parameter name. Args: name(str): The output parameter name. Returns: list: return the list of argument names associated with \ the specific parameter name. )r/rJrr5r5r6rJ rzOperator.outputcCrmrD)r/r&rr5r5r6r& r9zOperator.output_namescCs.t|jjD] \}}||kr|Sqtd)Nz@Can't find op itself in it's block. It could be a bug of Paddle.)rr(opsrW)riryr:r5r5r6idx sz Operator.idxcCr)z Whether this Operator has the attribute with name or not. Args: name(str): the attribute name. Returns: bool: True if has this attribute. rrr5r5r6r rzOperator.has_attrcCs|j|dS)z Get the type of attribute by attribute's name. Args: name(str): the attribute name. Returns: core.AttrType: the attribute type. T)r/r*rr5r5r6r* s zOperator.attr_typecCr)a( Set the value of attribute by attribute's name. Args: name(str): the attribute name. val(bool|int|str|float|list): the value of the attribute. Raises: ValueError: If the type of value doesn't match with desc.attr_type(name). Nrrr5r5r6r  zOperator._set_attrcCrprDrrr5r5r6r rzOperator._remove_attrcCst|tr|j||jdSt|tr't|tr'|j|dd|DdSt|tr6|j||jdSt|trP|rPt|trP|j |dd|DdSt|t j s\t|t j rg|j ||dS|||dS)a2 Update the value of desc's attribute by attribute's name. Args: name(str): the attribute name. val(bool|int|str|float|list): the value of the attribute. Raises: ValueError: If the type of value doesn't match with desc.attr_type(name). cSg|]}|jqSr5r/rr5r5r6r z.Operator._update_desc_attr..cSrBr5rCrr5r5r6r rDN)r/r$r/ set_var_attrrr set_vars_attrBlockset_block_attrset_blocks_attrr BlockDesc ProgramDescset_serialized_attrrc_update_desc_plain_attrrr5r5r6r s  zOperator._update_desc_attrcCsx|j}t|dr ||jvr|||dS|j|}|tjjkr(|||dS|tjjkr6| ||dS|tjj krD| ||dS|tjj krR| ||dS|tjjkr`|||dS|tjjkrn|||dS|tjjkr||||dS|tjjkr|||dS|tjjkr|||dS|tjjkr|||dS|tjjkr|||dS|||dS)Nr)r/rrrr r+r_set_bool_attrINTZ_set_int32_attrLONGZ_set_int64_attrFLOATZ_set_float32_attrSTRINGZ _set_str_attrZBOOLSZ_set_bools_attrZINTSZ_set_int32s_attrZLONGSZ_set_int64s_attrZFLOATSZ_set_float32s_attrZFLOAT64SZ_set_float64s_attrr*Z_set_strs_attr)rirrr/Z type_indexr5r5r6rM s8             z Operator._update_desc_plain_attrcCs |jdSNTrrr5r5r6r0 s zOperator.attr_namescCr)z Get the attribute by name. Args: name(str): the attribute name. Returns: bool|int|str|float|list: The attribute value. The return value can be any valid attribute type. rrr5r5r6r4 rz Operator.attrcCr)z Get the block attribute's id by name. Args: name(str): the attribute name. Returns: int: the block index. )r/r0rr5r5r6r0A rzOperator._block_attr_idcCs6||}|dkr|t|jjjksJ|jjj|S)z Get the block attribute by name. Args: name(str): the attribute name. Returns: block: the block attribute. r)r0rwr(rblocks)riridr5r5r6 _block_attrM s zOperator._block_attrcCsJg}||D]}|dkr|t|jjjksJ||jjj|q|S)z Get the blocks attribute by name. Args: name(str): the attribute name. Returns: list: list of the blocks attribute. r)r2rwr(rrTr)rirr}ryr5r5r6 _blocks_attr\ s  zOperator._blocks_attrcCr)z Get the blocks attribute's ids by name. Args: name(str): the attribute name. Returns: list: list of the blocks ids. )r/r2rr5r5r6r2m rzOperator._blocks_attr_idscCsH|j|d}|tjjksJd|||j|d}|j |S)z Get the Variable attribute by name. Args: name(str): the attribute name. Returns: Variable: the Variable attribute. Tz3Required type attr({}) is Variable, but received {}) r/r*r r+r,rrrr(_var_recursive)rirr*r5r5r5r6 _var_attrz s  zOperator._var_attrcsJj|d}|tjjksJd||fddj|dD}|S)z Get the Variables attribute by name. Args: name(str): the attribute name. Returns: Variables: the Variables attribute. Tz9Required type attr({}) is list[Variable], but received {}csg|] }j|qSr5)r(rXrr#rr5r6r sz'Operator._vars_attr..)r/r*r r+r-rr)rirr*Z attr_varsr5rr6 _vars_attr s   zOperator._vars_attrcCs|j}i}|D]H}|j|d}|tjjkr||||<q|tjjkr,||||<q|tjj kr:| |||<q|tjj krH| |||<q| |||<q|S)zx Get the attribute dict. Returns: dict: The Operator's attribute dict, name->attr. T)rr/r*r r+r/rVr1rWr,rYr-rZr)rirZattr_mapnr*r5r5r6 all_attrs s    zOperator.all_attrscCHtj}tjjj}|j|sdS|j|}|t|@r"dSdSNFT) r rOpRoleOptimizer/rrrrx)rirZOPTIMIZEop_roler5r5r6_is_optimize_op   zOperator._is_optimize_opcCr]r^) r rr_Backwardr/rrrrx)rirZBACKWARDrar5r5r6_is_backward_op rczOperator._is_backward_opcCrrrrr5r5r6rZ rzOperator.dist_attrcCrrrrr5r5r6rZ r)NNNNT))rkrlr;rrrrrlrUrrrrrr(r:r=r'r>r rJr&r@rr*rrrrMrrr0rVrWr2rYrZr\rbrerZrr5r5r5r6r sd+# a            #      rc@seZdZdZddZddZd=ddZd>d d ZeZe d d Z e ddZ ddZ e ddZ e ddZddZddZddZddZddZd d!Zd"d#Zd$d%Zd=d&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd=d0d1Zd2d3Zd4d5Zd6d7Zd8d9Z d=d:d;Z!d.)rt iteritemsr9rr5r5r6rvs zBlock.iter_parameterscOsDtr t|i|}|St|d|i|}d|vr |d|||S)Nr( initializer)rrr$)rir_r`r2r5r5r6rFszBlock.create_varcCs ||jvSrD)r9rr5r5r6r rz Block.has_varc Cs|t|}t|}||std|||}t|tkr2d}|j}|j}|j }|j }|j } nt|t krAd}|j } |j}ntdt||j} |j t|t||j t|} |dkrtrzt| | | |||||| d } n5trt| | | |||||| d } n t|| | | |||||| d } n |dkrt || || |d} | |j|<|j|=|| S)a Rename variable in vars and ops' inputs and outputs Args: name(str): the name that need to be renamed. new_name(str): the name that need to rename to. Raises: ValueError: If this block doesn't have this the giving name, or the type of the var with the giving name is not Parameter or Variable. Returns: Variable: the Variable with the giving name. zvar %s is not in current blockr'r$zunsupported var type: %s)rrrr;r^ optimize_attr regularizerr,)rrrr,r;)r-r.r rWr2rrr'r;r^r{r|r,r$r/ _rename_varr1r0rr%rrrNr&r9_sync_with_cpp) rirrxrvar_typer;r^r{r|r,Z orig_var_typedr2r5r5r6r}s           zBlock._rename_varcCs.|dkr||jt||j|=dSrS)r~r/ _remove_varr-r1r9)rirsyncr5r5r6rKs zBlock._remove_varc Os|j}d}trt|i|}ntrt|i|}n t|g|Ri|}d|vrZdd}|d}|||}t|}|dkrNtd|j dt ||dkrU |S||||S)NrzcSs6g}|jD]}|j|jvr|jdvrq||q|S)N)Z c_broadcastrZcoalesce_tensor)r?rr rrr)r(r2init_opsr:r5r5r6 _is_inited_by^s    z-Block.create_parameter.._is_inited_byrrVz is inited by multiple init ops ) r global_blockrr%rNr&r'rw RuntimeErrorrr|) rir_r`rparamrrzrZ init_ops_lenr5r5r6create_parameterQs6   zBlock.create_parameterc Os:trD|di}|dd}|dd}td|tt|d|dd|d}t||di|di|r9|ni|d d ||Sd d lm }|j }|dd} |dd} || .|| t|||dd| | |ddd}Wdn1swYWdn1swY|j ||S) z Appends a new Operator according to the giving arguments. Returns: Operator: the append Operator. r} inplace_mapNrrzOp `%s` is executed through `append_op` under the dynamic mode, the corresponding API implementation needs to be upgraded to using `_C_ops` method.)r(r/rrrCrDr}rCrDr;Fr) param_guard)rrrIrJrrrtrace_opZpaddle.fluid.dygraph.baserr/rHr?r) rir_r`r}rrrr:rop_descrCrDr5r5r6rHsZ             zBlock.append_opcOs ||j|g|Ri|S)z Insert a Operator according to the giving arguments. Args: index(int): the place that the operator to insert. Returns: Operator: the insert Operator. )r~_insert_op_without_sync)rirZr_r`r5r5r6 _insert_ops zBlock._insert_opcOs2|j|}t|||d|}|j|||S)a Insert an Operator according to the giving arguments, without sync_with_cpp to meke the compilation faster. Args: index(int): the place that the operator to insert. Returns: Operator: the insert Operator. r(r/)r/rrr?r~)rirZr_r`rr:r5r5r6rs zBlock._insert_op_without_synccCs.|dkr||j||d|j|=dS)z Remove the specific position operator. Args: index(int): the position that the operator to insert. Returns: None TrN)r~r/ _remove_opr?)rirZrr5r5r6rs  zBlock._remove_opcCs|j||S)z Return the Operator between start and end. Args: start(int): the start position. end(int): the end position. Returns: list: the Operators between start and end. )r?)rirrr5r5r6 _slice_opss zBlock._slice_opsc Ostr5|dd}|di}t|d|dd|d}t||di|di|r+|ni|dd|S|j}t|||dd|dd|dd|ddd}|jd||S) Nrrr}r|rCrDr;Fr) rrrrrr/ _prepend_opr?r~)rir_r`rrr}r:rr5r5r6rs2            zBlock._prepend_opc Cs|jD]<}||sAd}|r|}|r4|r4|j||| | | |dq|j ||| |dqt |jD]}|jt|sZ|j|qIg}td|jD] }||j|qet|jdkr|jdj}|jt|jdj}d}d}tt|D]} ||| kr| }||| kr| }q|dusJ|dusJ||ksJnd}d}t|ddddD]} || } t|| } |jd| qt|dt|D]} || } t|| } |j| q|dkr<|t|jkr)rrrrrr6rr<r>)r/r$rrr rrZ STEP_SCOPESrFrrZRAWrErrr<r/r>r6)rir2Zforce_persistableZret_varr5r5r6_clone_variablesD      zBlock._clone_variableNrfr)"rkrlr;rrrrUrlrrrkrmrorqr@r2rurXrwrvrFr r}rrrHrrrrrr~rrr5r5r5r6rG sF  /(    $  ^/>  WGrGcCsft|ts Jdt|tsJdt|j}t|j}t|||||}|||||S)Nzpass_attrs must be dictzpass_attr_types must be dict)r/rr rKr/Z apply_pass_rebuild_from_desc) main_programstartup_programZ pass_nameZ pass_attrsZpass_attr_typesZtmp_main_programZtmp_startup_programr}r5r5r6 _apply_passs    rc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd d!Zd"d#Zed$d%Zed&d'Zd(S))IrNodezN Python IrNode. Beneath it is a core.Node, which is used for Ir Pass. cCst|tjs Jd||_dS)zl Construct an IrNode using core.Node. Args: node(core.Node): C++ Node. z'node must be the instance of core.Node.N)r/r Nodenoderirr5r5r6rs  zIrNode.__init__cCrm)zU Return the node name. Returns: str: node name. )rrrr5r5r6r  z IrNode.namecCrm)z Return the node type. Returns: core.Node.Type: node type(core.Node.Type.Operation or core.Node.Type.Variable). )r node_typerr5r5r6rrzIrNode.node_typecCrm)z~ Return the node variable description. Returns: core.VarDesc: node variable description. )rr2rr5r5r6r2rz IrNode.varcCrm)z} Return the node operator description. Returns: core.OpDesc: node operator description. )rr:rr5r5r6r:'rz IrNode.opcCrm)zQ Return the node id. Returns: int: node id. )rrUrr5r5r6rU0rz IrNode.idcCrm)z If the node is an operator, then return true. Returns: bool: indicate whether the node is an operator. )ris_oprr5r5r6r9rz IrNode.is_opcCrm)z If the node is a variable, then return true. Returns: bool: indicate whether the node is a variable. )ris_varrr5r5r6rBrz IrNode.is_varcCrm)z If the node is a control dependence variable, then return true. Returns: bool: indicate whether the node is a control dependence variable. )r is_ctrl_varrr5r5r6rKrzIrNode.is_ctrl_varcC|jdS)z| Clear the node inputs. After executing the `clear_inputs` function, the node inputs will be empty. N)r clear_inputsrr5r5r6rTzIrNode.clear_inputscCrn)z} Remove a node from inputs by the given node id. Args: node_id(int): the given node id. Nr remove_inputriZnode_idr5r5r6remove_input_by_id[zIrNode.remove_input_by_idcC|j|jdS)zm Remove a node from inputs. Args: node(IrNode): the node being removed. Nrrr5r5r6rdzIrNode.remove_inputcCr)zl Append a node in inputs. Args: node(IrNode): the node being appended. N)r append_inputrr5r5r6rmrzIrNode.append_inputcCr)z Clear the node outputs. After executing the `clear_outputs` function, the node outputs will be empty. N)r clear_outputsrr5r5r6rvrzIrNode.clear_outputscCrn)z~ Remove a node from outputs by the given node id. Args: node_id(int): the given node id. Nr remove_outputrr5r5r6remove_output_by_id}rzIrNode.remove_output_by_idcCr)zn Remove a node from outputs. Args: node(IrNode): the node being removed. Nrrr5r5r6rrzIrNode.remove_outputcCr)zm Append a node in outputs. Args: node(IrNode): the node being appended. N)r append_outputrr5r5r6rrzIrNode.append_outputcCdd|jjDS)zt Return the node inputs. Returns: list(IrNode): node inputs wrapped by IrNode. cSrr5rrr[r5r5r6rrz!IrNode.inputs..rrCrr5r5r6rCrz IrNode.inputscCr)zv Return the node outputs. Returns: list(IrNode): node outputs wrapped by IrNode. cSrr5rrr5r5r6rrz"IrNode.outputs..rrDrr5r5r6rDrzIrNode.outputsN)rkrlr;rrrrr2r:rUrrrrrrrrrrrrrCrDr5r5r5r6rs.                rcs`eZdZdZfddZddZddZdd Zd d Zd d Z e ddZ e ddZ Z S) IrVarNodezO Python IrVarNode. Beneath it is a core.Node, it inherits from IrNode. c6t|tjr |sJdtt||||_dS)zo Construct an IrVarNode using core.Node. Args: node(core.Node): C++ Node. zFnode must be the instance of core.Node and it must be a variable node.N)r/r rrrgrrrrrnr5r6r  zIrVarNode.__init__cCs*|jdus Jd|j|dS)zg Set the node variable shape. Args: shape(list): shape to be set. N.The node variable description can not be None.)rr2r4)rirr5r5r6r4szIrVarNode.set_shapecC$|jdus Jd|jS)z If the variable node is a persistable variable, then return true. Returns: bool: indicate whether the variable is persistable. Nr)rr2rrr5r5r6rzIrVarNode.persistablecCr)zr Return the variable type. Returns: core.VarDesc.VarType: the variable type. Nr)rr2rrrr5r5r6rrrzIrVarNode.typecCr)z| Return the variable data type. Returns: core.VarDesc.VarType: the variable data type. Nr)rr2rrr5r5r6rrzIrVarNode.dtypecCr)zd Return the variable shape. Returns: list: the variable shape. Nr)rr2rrr5r5r6rrzIrVarNode.shapecCr)zx Return the node inputs. Returns: list(IrOpNode): node inputs wrapped by IrOpNode. cSrr5IrOpNoderr5r5r6rrz$IrVarNode.inputs..rrr5r5r6rCrzIrVarNode.inputscCr)zz Return the node outputs. Returns: list(IrOpNode): node outputs wrapped by IrOpNode. cSrr5rrr5r5r6r rz%IrVarNode.outputs..rrr5r5r6rDrzIrVarNode.outputs)rkrlr;rrr4rrrrrrrCrDrmr5r5rnr6rs        rcseZdZdZfddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ eddZeddZZS)rzN Python IrOpNode. Beneath it is a core.Node, it inherits from IrNode. cr)zn Construct an IrOpNode using core.Node. Args: node(core.Node): C++ Node. zFnode must be the instance of core.Node and it must be a operator node.N)r/r rrrgrrrrrnr5r6rrzIrOpNode.__init__cC,|jdus Jd|j||dS)z Rename the input of this node. Args: old_input_name(str): the old input name. new_input_name(str): the new input name. N.The node operator description can not be None.)rr:r:)riZold_input_nameZnew_input_namer5r5r6 rename_input" zIrOpNode.rename_inputcCr)z Rename the output of this node. Args: old_output_name(str): the old output name. new_output_name(str): the new output name. Nr)rr:r=)riZold_output_nameZnew_output_namer5r5r6 rename_output/rzIrOpNode.rename_outputcC&|jdus Jd|j|S)z Get the argument name list by the parameter name for input. Args: name(str): the parameter name. Returns: list(str): the argument name list. Nr)rr:r(rr5r5r6r(< zIrOpNode.inputcCr)z Get the argument name list by the parameter name for output. Args: name(str): the parameter name. Returns: list(str): the argument name list. Nr)rr:rJrr5r5r6rJKrzIrOpNode.outputcCr)z Change the operator type into new type. Args: new_type(str): new operator type to be set. Nr)rr:r3)rinew_typer5r5r6r3ZszIrOpNode.set_typecCr)z Set the value of attribute by attribute's name. Args: name(str): the attribute name. val(bool|int|str|float|list): the value of the attribute. Nrrr5r5r6set_attrfrzIrOpNode.set_attrcCs|jdus Jd|j}t|tr|||jdSt|tr5t|tr5||dd|DdSt|t rC| ||jdSt|tr\|r\t|t r\| |dd|DdSt|t j sht|t jrr|||dS|||dS)zR Update the value of the op desc's attribute by attribute's name. NrcSrBr5rCrr5r5r6r{rDz.IrOpNode._update_desc_attr..cSrBr5rCrr5r5r6rrD)rr:r/r$rEr/rrrFrGrHrIr rJrKrLrcr)rirrr/r5r5r6rps"   zIrOpNode._update_desc_attrcCr)z Return input arguments' names of this op node. Returns: list(str): input arguments' names of this op node. Nr)rr:r>rr5r5r6r>rzIrOpNode.input_arg_namescCr)z Return output arguments' names of this op node. Returns: list(str): output arguments' names of this op node. Nr)rr:r rr5r5r6r rzIrOpNode.output_arg_namescCr)zz Return the node inputs. Returns: list(IrVarNode): node inputs wrapped by IrVarNode. cSrr5rrr5r5r6rrz#IrOpNode.inputs..rrr5r5r6rCrzIrOpNode.inputscCr)z| Return the node outputs. Returns: list(IrVarNode): node outputs wrapped by IrVarNode. cSrr5rrr5r5r6rrz$IrOpNode.outputs..rrr5r5r6rDrzIrOpNode.outputs)rkrlr;rrrrr(rJr3rrr>r rrCrDrmr5r5rnr6rs          rc@seZdZdZd=ddZddZddZd d Zd d Zd dZ ddZ d=ddZ d=ddZ ddZ ddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd>d5d6Zd7d8Zd9d:Zd;d<Zd3S)?IrGraphz Python IrGraph. Beneath it is a core.Graph, which is used for creating a c++ Ir Pass Graph. An IrGraph is just a graph view of a Program. In an IrGraph, both Variables and Operators are graph nodes. FcCs$t|tjs Jd||_||_dS)z Construct an IrGraph using core.Graph. Args: graph(core.Graph): C++ Graph. for_test(bool): True for the test graph and false for the train graph. z)graph must be the instance of core.Graph.N)r/r ZGraphgraph _for_test)rirfor_testr5r5r6rs zIrGraph.__init__cCs|j}t||jS)z Create a new and duplicated IrGraph. Warns: The method only clones the graph structure, not its attributes. Returns: IrGraph: A new and duplicated graph. )rrrr)rigr5r5r6rs z IrGraph.clonecCr)zh If the graph is used for testing, the function returns true. Otherwise, returns false. )rrr5r5r6is_testszIrGraph.is_testcCdd|jDS)zB Return all nodes included in the graph as a set. cSh|]}t|qSr5rrrr5r5r6 rz$IrGraph.all_nodes..rnodesrr5r5r6 all_nodeszIrGraph.all_nodescCr)zK Return all variable nodes included in the graph as a set. cSh|] }|rt|qSr5)rrrr5r5r6rz(IrGraph.all_var_nodes..rrr5r5r6 all_var_nodesrzIrGraph.all_var_nodescCsNt}|jD]}|r|dur|r||qdd|DS)zW Return all persistable variable nodes included in the graph as a set. NcSrr5r)rrsr5r5r6rrz0IrGraph.all_persistable_nodes..)rrrrr2rrr)riZpersistable_nodesrr5r5r6all_persistable_nodess   zIrGraph.all_persistable_nodescCr)zK Return all operator nodes included in the graph as a set. cSrr5)rrrr5r5r6rrz'IrGraph.all_op_nodes..rrr5r5r6 all_op_nodesrzIrGraph.all_op_nodescsfddtjDS)zL Return all sub_graphs included in the main graph as a set. cs g|] }tj|dqS)rrr get_sub_graphrryrrir5r6rz*IrGraph.all_sub_graphs..)rvrZsub_graph_size)rirr5rr6all_sub_graphss  zIrGraph.all_sub_graphscCst|j||dS)z: Return i-th sub_graph in the main graph. rr)riryrr5r5r6rrzIrGraph.get_sub_graphcCsBt|}|||||||dt|j|S)a6 Create a persistable variable node in the graph. In IrGraph, it can not distinguish between persistable variables and parameters. Args: name(str): the name of the persistable variable node. vart_type(core.VarDesc.VarType): the type of the persistable variable node. shape(list): the shape of the persistable variable node. var_dtype(core.VarDesc.VarType): the data type of the persistable variable node. Returns: IrVarNode: the created persistable variable node. T) r rr3r4r5r7rrcreate_var_noderirrrZ var_dtypevar_descr5r5r6create_persistable_node s     zIrGraph.create_persistable_nodecCs8t|}||||||t|j|S)a Create a variable node in the graph. The created variable node is not persistable. Args: name(str): the name of the variable node. vart_type(core.VarDesc.VarType): the type of the variable node. shape(list): the shape of the variable node. var_dtype(core.VarDesc.VarType): the data type of the variable node. Returns: IrVarNode: the created variable node. )r rr3r4r5rrrrr5r5r6r"s    zIrGraph.create_var_nodecCry)z& create a control var )rrcreate_control_dep_varrr5r5r6r7szIrGraph.create_control_dep_varcCt|j|S)a? Create a variable node by using an existing VarDesc in the graph. Depend on the giving VarDesc, the created variable node may be persistable. Args: var_desc(core.VarDesc): the giving variable description. Returns: IrVarNode: the created variable node. )rrr)rirr5r5r6create_var_node_from_desc=rAz!IrGraph.create_var_node_from_descc Cst}||t|D] \}}||||qt|D]\}} t| ts+| g} ||dd| Dqt|D]\} } t| tsH| g} | | dd| Dq.cSrr5rtrr5r5r6rer) r rr3rtryrr/rrrrrcreate_op_node) rirr}rCrDrrr\Z input_name var_nodesZ output_namer5r5r6rJs"   zIrGraph.create_op_nodecCr)z Create a operator node by using an existing OpDesc in the graph. Args: op_desc(core.VarDesc): the giving operator description. Returns: IrOpNode: the created operator node. )rrr)rirr5r5r6create_op_node_from_descirpz IrGraph.create_op_node_from_desccCx|j|jvr|j|jvr|j|jvsJd|||||||||||dS)a@ Update the input's link of a operator node. Args: old_input_node(IrNode): the old input node of the giving op_node. new_input_node(IrNode): the new input node of the giving op_node. op_node(IrOpNode): the operator node that is needed to update input's link. zVThe three arguments(old_input_node&new_input_node&op_node) must be in the graph nodes.N) rrrrrrrrr)riZold_input_nodeZnew_input_nodeop_noder5r5r6update_input_linku     zIrGraph.update_input_linkcCr)aF Update the output's link of an operator node. Args: old_output_node(IrNode): the old output node of the giving op_node. new_output_node(IrNode): the new output node of the giving op_node. op_node(IrOpNode): the operator node that is needed to update input's link. zZThe three arguments(old_output_node &new_output_node &op_node) must be in the graph nodes.N) rrrrrrrrr)riZold_output_nodeZnew_output_noderr5r5r6update_output_linkrzIrGraph.update_output_linkcCs\|j|jvsJd|j|j|jvs"Jd|j||||dS)z Connect two nodes. Args: node_in(IrNode): the input node. node_out(IrNode): the output node. z'node_in(%s) must be in the graph nodes.z(node_out(%s) must be in the graph nodes.N)rrrrrr)riZnode_inZnode_outr5r5r6link_tos   zIrGraph.link_tocCsDt|tst|trt|}n|h}dd|D}t|j|dS)z Remove nodes safely since links connected to these removed nodes are also removed. Args: remove_nodes(set): the nodes prepared to be removed. cSh|]}|jqSr5rrr5r5r6rrDz,IrGraph.safe_remove_nodes..N)r/rrr Zgraph_safe_remove_nodesr)riZ remove_nodesZoriginal_nodesr5r5r6safe_remove_nodess   zIrGraph.safe_remove_nodescCst|j}t}|D]G}|rR|durR|D]}||vr-||j|g||<q| D]}||vrE||j |g||<q4|| ||j |q4q |j |dSrD) r topology_sortrrrr:r>_find_node_by_namerCr rDrresolve_hazard)ri ordered_nodesrrZ each_var_namer5r5r6rs$     zIrGraph.resolve_hazardcC t|jS)z Check if the graph has a circle. Returns: bool: True if the graph has a circle else False. )r has_circlerrr5r5r6r zIrGraph.has_circlecCr)z Count the number of unconnected graphs in this graph. Returns: int: the number of unconnected graphs. )r graph_numrrr5r5r6rrzIrGraph.graph_numcCst|j}dd|DS)z Perform the topology sort operation on the graph. Notes: the `graph` can not contain a circle. Returns: list(IrNode): nodes in topology order. cSrr5rrr5r5r6rrz)IrGraph.topology_sort..)r rr)rirr5r5r6rs zIrGraph.topology_sortcCs@t|j}t}t|D]\}}dd|D|t|<q|S)z Build an adjacency list of operations for the `graph`. Returns: dict{IrNode: set(IrNode)}: the adjacency list. cSrr5rrr5r5r6rrz/IrGraph.build_adjacency_list..)r build_adjacency_listrrrtryr)riZadj_listZwrapped_adj_listkrr5r5r6rs zIrGraph.build_adjacency_listNTc Csdd}t}|r|D] }|r||q ||tdt||durdt |ts?t |t r._convert_to_pdfzTotal ops num = {}.NcSrr5rrr5r5r6r&rDzIrGraph.draw..cSrr5rrr5r5r6r'rDZ__graphviz__marked_node__z.dotZgraph_viz_passZgraph_viz_path)rrrrrrr rrwrr/rrhasZeraserrexistsmakedirsr.r get_passapply) riZ save_pathrZ marked_nodesZremove_ctr_varr Zremove_ctr_varsrZ viz_dot_pathZviz_passr5r5r6draws6               z IrGraph.drawcCs8td}t}|d|||jt|}|S)a1 Convert the graph into a Program. WARN: When the graph includes backward operator nodes, the conversion process may be failed. Usually, this function is only used to convert a test graph. Returns: Program: a program converted from the graph. Zgraph_to_program_passr)r rrKZ set_not_ownedrrr_construct_from_desc)riZ convert_passr/rr5r5r6 to_program4s    zIrGraph.to_programcCs6d}|D] }||kr|}q|dusJd||S)zB Find a node in the giving nodes set by the name. Nz2Cannot find the target node (%s)in the giving set.rt)rirZ node_nameZ target_noder[r5r5r6rFs  zIrGraph._find_node_by_namecCst|tr|||jdSt|tr%t|tr%||dd|DdSt|tr3|||jdSt|trL|rLt|trL| |dd|DdSt|t j sXt|t j rb| ||dS|||dS)zK Update the value of desc's attribute by attribute's name. cSrBr5rCrr5r5r6rZrDz-IrGraph._update_desc_attr..cSrBr5rCrr5r5r6r^rDN)r/r$rEr/rrrFrGrHrIr rJrKrLrcr)rir/rrr5r5r6rSs  zIrGraph._update_desc_attrrrS) rkrlr;rrrrrrrrrrrrrrrrrrrrrrrrrrrrrr5r5r5r6rs<         6 rc@seZdZdZddZddZddZdSd d Zed d Z e j d d Z eddZ e ddZ e ddZe dTddZddZdUddZdTddZddZd d!ZdTd"d#Zd$d%Zd&d'ZdUd(d)ZdUd*d+Zed,d-Zed.d/Zed0d1Zed2d3Zej d4d1Zd5d6Zd7d8Z d9d:Z!d;d<Z"dVd>d?Z#d@dAZ$dBdCZ%dDdEZ&dFdGZ'dVdHdIZ(dJdKZ)dLdMZ*dWdOdPZ+dVdQdRZ,d=S)Xra Create Python Program. It has at least one :ref:`api_guide_Block_en`, when the control flow op like conditional_block, while :ref:`api_paddle_fluid_layers_While` is included, it will contain nested block. Please reference the `framework.proto `_ for details. A set of Program usually contains startup program and main program. A startup program is set to contain some initial work, eg. initialize the ``Parameter``, and the main program will contain the network structure and vars for train. A set of Program can be used for test or train, in train program , Paddle will contain all content to build a train network, in test program Paddle will prune some content which is irrelevant to test, eg. backward ops and vars. **Notes**: **we have** :ref:`api_paddle_fluid_framework_default_startup_program` **and** :ref:`api_paddle_fluid_framework_default_main_program` **by default, a pair of them will shared the parameters. The** :ref:`api_paddle_fluid_framework_default_startup_program` **only run once to initialize parameters,** :ref:`api_paddle_fluid_framework_default_main_program` **run in every mini batch and adjust the weights.** Returns: Program: An empty Program. Examples: .. code-block:: python import paddle import paddle.static as static paddle.enable_static() main_program = static.Program() startup_program = static.Program() with static.program_guard(main_program=main_program, startup_program=startup_program): x = static.data(name="x", shape=[-1, 784], dtype='float32') y = static.data(name="y", shape=[-1, 1], dtype='int32') z = static.nn.fc(name="fc", x=x, size=10, activation="relu") print("main program is: {}".format(main_program)) print("start up program is: {}".format(startup_program)) cCst|_t|dg|_d|_t|_tjj j |_ g|_ d|_ d|_d|_g|_d|_g|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_td|_ d|_!d|_"dS)NrFrZ__auto_checkpoint_program__)#r rKr/rGrTcurrent_block_idxglobal_prog_seed_seedrr_Forward _current_role_Program__op_role_var_is_distributed _is_chief_parameters_on_pservers _endpoints _ps_endpointZ_trainers_endpoints_distributed_lookup_tableZ _enable_dgcZ _use_lambZ_nccl_comm_numZ_use_hierarchical_allreduceZ$_hierarchical_allreduce_inter_nranksZ _fleet_optZ_program_configZ _pipeline_optZ_heter_pipeline_opt_appending_grad_timesrr)Z_auto_checkpoint_nameZ_graph_is_start_up_program_rr5r5r6rs8   zProgram.__init__c Csdd}|j}g}|}t|D]}|t|jdkr |||}|g|d}|D]} |j| | rI|j| | } nd} | | || dt jjjt jjjt jjjg|| dt jjjt jjjt jjjg|| dt jjjt jjjg| dur| jnd| dur| jnd| dur| jnd| | dur| jndd } t| tr| | j| j| j| j| j| j | j!d |tt"#| d q2| $| d <|t%t"#| d q2q|S) NcSs||vr t||SdSrD)rrrf)rrkZ allowed_typesr5r5r6get_var_desc_attr_or_nones  zAProgram._find_var_class_kwargs..get_var_desc_attr_or_nonerrSrrr6F) rrrrrr6r,r;r<r>r+)r^r{r|do_model_average need_clipis_distributedr])classr`r)&r/ num_blocksrvrwrT _create_blockr(rrr rr2rrr rrr rEZLOD_TENSOR_ARRAYr,r;r<r>r+r/r'updater^r{r|r$r%r&r]rdeepcopyrr$) riZnew_descr#Zold_desc all_new_vars block_numr@new_block_descZblock_new_varsZ new_var_descZold_varr`r5r5r6_find_var_class_kwargss        ,  MzProgram._find_var_class_kwargscCs8||}|}|t|ksJ||jksJt|D]}|j|}|j|jqt|D]}|j|j}| |}| |q4~t|D]!}|j|}||D]}|d} |d} || d<| di| qWqLt|D]'}|j|}|j |}t| D]} | | } t || d} |j| qqrdS)Nr'r`r(rr5)r/r(rwr/rvrTr9clearr?r(Z _move_fromrr:rr)rir/r,r-r@r(Z block_descr.rZclazzr`rrr:r5r5r6r0s<                 zProgram._rebuild_from_descrcCs|at|_dS)ag Set global seed for Program Returns: None. Examples: .. code-block:: python import paddle import paddle.static as static paddle.enable_static() prog = static.default_main_program() print(prog.random_seed) ## 0 ## the default random seed is 0 prog.global_seed(102) prog1 = static.default_main_program() print(prog1.random_seed) ## 102 ## the random seed is 102 N)rrriseedr5r5r6 global_seedUs zProgram.global_seedcCr)a The operator role. In a enum {Forward, Backward, Optimize}. Notes: this is a low level API. It is used only for ParallelExecutor to duplicate or schedule operator to devices. For example, the forward operator should be executed on every device. The backward operator should be executed on every device and the parameter gradient of backward (use :code:`_op_role_var` to get this variable) operator should be merged to one device. The optimization operators should be executed on only one device and broadcast the optimization result, i.e., the new parameter, to every other device. rrr5r5r6rsszProgram._op_rolecC ||_dSrDr4)riZroler5r5r6rr9cCr)z The auxiliary variables for :code:`_op_role` property. See Also: :code:`Program._op_role`'s documentation for details. Notes: This is a very low-level API. Users should not use it directly. )rrr5r5r6rs zProgram._op_role_varccs4|j}tjj}|j|_z dVW||_dS||_wrD)rr rr_rd)ritmp_roler_r5r5r6_backward_role_guardszProgram._backward_role_guardccsV|j}|j}tjj}|j|_dd|D|_z dVW||_||_dS||_||_w)a A with guard to set :code:`Optimization` :code:`OpRole` and :code:`OpRoleVar` automatically. Notes: This is a very low level API. Users should not use it directly. Args: param_and_grads(list): The variables (names) to be optimized. Examples: >>> import paddle.fluid as fluid >>> p, g = backward(...) >>> with program._optimized_guard([p,g]): >>> p = p - 0.001 * g cSs g|] }t|tr |jn|qSr5)r/r$rr#r5r5r6rrz,Program._optimized_guard..N)rrr rr_r`)riZparam_and_gradsr6tmp_varr_r5r5r6_optimized_guards zProgram._optimized_guardFccsf|j}|j}tjj}|j|_|rt|jt|jB|_g|_z dVW||_||_dS||_||_w)a A with guard to set :code:`LRSched` :code:`OpRole` and :code:`OpRoleVar` automatically. The :code:`OpRoleVar` is set to the target learning rate. Notes: This is a very low level API. Users should not use it directly. Args: is_with_opt: Only set to true if these ops a in the middle of a bunch of optimize ops so that it can be treated correctly. For example, sgd->lr_op->sgd->lr_op->sgd. Examples: >>> import paddle.fluid as fluid >>> p, g = backward(...) >>> with program.lr_schedule_guard(): >>> lr = lr * decay N)rrr rr_ZLRSchedrxr`)riZ is_with_optr6r8r_r5r5r6_lr_schedule_guards zProgram._lr_schedule_guardcCrS)z Get the protobuf debug string of this Program. Returns: (str): The protobuf debug string. Raises: ValueError: If any of required fields is not set. rTrr5r5r6rs zProgram.__str__TcCsFt|tsJdt|d}|jD] }|||7}|d7}q|S)a% Get readable debug string of Program. .. note:: If you want to get the debug string in protobuf format, please use :code:`to_string` method. Args: skip_op_callstack(bool): whether to skip parsing Operator's attribute op_callstack, default value is True Returns: string: The formatted Program string. Examples: .. code-block:: python import paddle import paddle.static as static paddle.enable_static() cur_program = static.Program() cur_block = cur_program.current_block() new_var = cur_block.create_var(name="X", shape=[-1, 23, 48], dtype='float32') new_op = cur_block.append_op(type="abs", inputs={"X": [new_var]}, outputs={"Out": [new_var]}) print(cur_program._to_readable_code()) rrr$)r/r0rrrrTrU)rir4Z program_strr(r5r5r6rUs!  zProgram._to_readable_codecCst|tsJdt|t|tsJdt||r0d}|jD] }||||7}q#|S|j}tj t |}t ||}|S)a To debug string. Args: throw_on_error (bool): raise Value error when any of required fields is not set. with_details (bool): True if more details about variables and parameters, e.g., :code:`trainable`, :code:`optimize_attr`, need to print. Returns: str: The debug string describe current Program. Raises: ValueError: If any of required fields is not set and throw_on_error is True. Examples: .. code-block:: python import paddle import paddle.static as static paddle.enable_static() prog = static.default_main_program() x = static.data(name="X", shape=[2,3], dtype="float32") pred = static.nn.fc(x, size=3) prog_string = prog.to_string(throw_on_error=True, with_details=False) prog_string_with_details = prog.to_string(throw_on_error=False, with_details=True) print("program string without detail: {}".format(prog_string)) print("program string with detail: {}".format(prog_string_with_details)) zNThe type of throw_on_error parameter is wrong, expected bool, but received {}.zLThe type of with_details parameter is wrong, expected bool, but received {}.r)r/r0rrrrTrlr/rcr rKrdrtrer )rir rgrir(rhrr5r5r6rls2    zProgram.to_stringcCr)z Get the C++ side of `ProgramDesc` object pointer. The C++ object is exposed by :code:`pybind`. Notes: This is a very low level API. Users should not use this API directly. rCrr5r5r6 _get_descSszProgram._get_desccCrmrD)r/_versionrr5r5r6r<]rzProgram._versioncs|d}|r0tt|j\_}fddtjjD_ j ddn