͑iSSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK r SSK r SSK r SSK r SSKJr SSKJr SSKJrJr SSKJrJrJrJr SSKrSSKJr SSKrSS KJ r S S KJ!r!J"r" S S K#J$r$ S S K%J&r&J'r' S SK(J)r)J*r* S SK+J,r,J-r- \"S5r.\"S5r/\(aSSKJ0r0J1r1 SSK2J3r3 /r4\!Rj"5r6\!Rn"5r8\!Rr"5r:\!Rv"5r<\!Rz"5r>\!R~"5r@0SSS/_SSS/_SSS/_SSS/_SSS/_SSS/_SSS/_SSS/_SSS/_SSS/_S SS/_S!SS/_S"SS/_S#SS/_S$SS/_S%SS/_S&SS/_0S'SS/_S(SS/_S)SS/_S*SS/_S+SS/_S,SS/_S-SS/_S.SS/_S/SS/_S0SS/_S1SS/_S2SS/_S3SS/_S4SS/_S5SS/_S6SS/_S7SS/_ESS/S8S9/S:S;/S:S;/S<.ErA/S=QrBS>rCSS?jrDSS@jrE\SA5rF"SBSC\ R5rHSqI\H"5rJSqKSqLSqMSqNSrOSDqP0SSESF0/_SSESF0/_SSESF0/_SSESF0/_S1SESF0/_S3SESF0/_S SESF0/_S5SESF0/_SSESF0/_S&SESF0/_S'SESF0/_S(SESF0/_S)SESF0/_S$SESF0/_S%SESF0/_SGSHSD0/_SISHSD0/_SHSD0/SHSD0/SHSD0/SHSD0/SHSD0/SHSD0/SHSD0/SHSD0/SJ.ErQSK/SL/SM/SN/SO/SP/SQ/SR/SS/ST. rR\$R\!RRR\$R\!RRR\$R\!RRR\$R\!RRR\$R\!RRR\$R\!RRR\$R\!RRR\$R\!RRR\$R\!RRR\$R\!RRR\$R\!RRR\$R\!RRR\$R\!RRR\$R\!RRR\$R\!RRR0rjSSUjrkSSVjrlSSWjrmSSXjrnSSYjroSSZjrpSS[jrqSFqrSFqsS\rtS]ru\,SSS^jj5rv\SSS_jj5rw\SSS`jj5rwSSajrwSSSbjjrxSScjrySSdjrzSSejr{SSfjr|Sgr}SShjr~SSijr\-"\y5r\-"\z5r\-"\|5r\-"\~5r\-"\{5rSjrSkrSlrSmrSnrSorSprSqrSrrSSsjrSStjrSSujrSSvjrSSwjrSSxjrSSSyjjrSSSzjjrSSS{jjrSSS|jjrSSS}jjr"S~S5r\"5q\,SSSjj5r"SS5r\"5q\,SSj5rSrSrSrSrSSjrSSjrSrSrSSjr\!RRGRPSSSS4SjrSrSrSrSrSr"SS\5r"SS\5r"SS\S9rSr"SS5r"SS5r\,S5rSrSr"SS5r004Sjr"SS5r"SS\5r"SS\5r"SS5r"SS5r"SS\\S9r"SS\!GRGR5r\"5q\"5qSG[lSSjrSSjrSSjrSSjr\,SSSjj5rSSjr\,S5r\,S5r\,S5rSr\,SSSjj5rSrSrSrSrSrSr\,S5r\,SSj5r\,SSj5r\,SSj5r\,SSj5r\,SSj5rg)) annotationsN)Iterable)contextmanager) FunctionType MethodType) TYPE_CHECKINGCallableTypeVaroverload) ParamSpec)pir)core unique_name)DataType) data_feed_pb2 framework_pb2)_getitem_static_setitem_static)signature_safe_contextmanagerwrap_decorator_InputT_RetT) GeneratorSequence) AmpOptionselementwise_addXYelementwise_add_gradelementwise_subelementwise_sub_gradelementwise_mulelementwise_mul_gradelementwise_divelementwise_div_gradelementwise_floordivelementwise_floordiv_gradelementwise_powelementwise_pow_gradwhere where_gradequal not_equal less_than less_equal greater_than greater_equal logical_and logical_or logical_xorelementwise_fmaxelementwise_fmax_gradelementwise_fminelementwise_fmin_gradelementwise_maxelementwise_max_gradelementwise_minelementwise_min_gradelementwise_modelementwise_mod_grad huber_lossxyX1X2)huber_loss_grad nextafteratan2 atan2_grad)z pd_op.slicezpd_op.strided_slicezpd_op.index_selectz pd_op.splitzpd_op.unsqueezezpd_op.unsqueeze2z pd_op.squeezezpd_op.squeeze2zpd_op.transposezpd_op.transpose2z pd_op.unbindzpd_op.diagonalz pd_op.flattenz pd_op.imagz pd_op.realz pd_op.reshapezpd_op.reshape2z pd_op.as_realc[$N)_global_flags_U/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/paddle/base/framework.py _global_flagsrPs rNc|[U[5(d [S5eUR5Hup[ 5R U5(aXU[ 5U'SnUR U5(a1[ 5RU[U5S[U55 MyM{[SUS35e g)a6 This function sets the GFlags value in Paddle. For FLAGS please refer to :ref:`en_guides_flags_flags` Args: flags (dict): A dict contains flags and its value. Examples: .. code-block:: python >>> import paddle >>> paddle.set_flags({'FLAGS_eager_delete_tensor_gb': 1.0}) z#flags in set_flags should be a dictFLAGS_NFlag z, cannot set its value through this function.) isinstancedict TypeErroritemsrP is_public startswithupdate_linked_varslenstr ValueError)flagskeyvalueprefixs rO set_flagsrbs eT " "=>>kkm  ? $ $S ) )#(MOC F~~f%%22F &E & uHI $rNc0n[U[[45(aYUHQn[5R U5(a#[5UnX#0nUR U5 MD[ SUS35e U$[U[5(aP[5R U5(a#[5UnX0nUR U5 U$[ SUS35e[S5e)a This function gets the GFlags value in Paddle. For FLAGS please refer to :ref:`en_guides_flags_flags` Args: flags(list|tuple|str): A list/tuple of string or a string which is the flag's name. Returns: flag's value in Paddle. Examples: .. code-block:: python >>> import paddle >>> flags = ['FLAGS_eager_delete_tensor_gb', 'FLAGS_check_nan_inf'] >>> res = paddle.get_flags(flags) >>> print(res) {'FLAGS_eager_delete_tensor_gb': 0.0, 'FLAGS_check_nan_inf': False} rSz, cannot get its value through this function.z5Flags in get_flags should be a list, tuple or string.) rTlisttuplerPrXupdater]r\rV)r^ flags_valuer_r`temps rO get_flagsris*K%$''C((--%,|""4( C5 LM (  E3   ? $ $U + +!OE*E>D   t $  wJK OPPrNc## [R"U5Un[R"X05 Sv [R"X05 g![R"X05 f=f7frK)paddlerirb) flag_name flag_value old_values rO flag_guardrosU  +I6I i,-1 )/0)/0s1A,AA,A))A,c&\rSrSrSrSrSrSrg)GlobalThreadLocalcSUlSUl[Ul[RR S5nUb UR 5S;n[SU05 [S5SUl g)zW init the thread local data. TODO(xiongkun): how to access another thread local data ? FNFLAGS_enable_pir_api)nnoffalseoff0) _in_to_static_mode_#_functional_dygraph_context_manager_dygraph_tracer_osenvirongetlowerrbri _use_pir_api_)selfenv_pir_enabled pir_enableds rO__init__GlobalThreadLocal.__init__ss $) 370 0**..)?@  &)//1:K -{; <&'=> " rNc/nURS[UR5-5 URS[UR5-5 URS[UR5-5 SR U5$)Nz_in_to_static_mode_:z$_functional_dygraph_context_manager:z_dygraph_tracer_: )appendr\r{r|r}join)rstringss rO__str__GlobalThreadLocal.__str__st-D4L4L0MMN 2$::; <  *S1F1F-GGHyy!!rNc\US:XaUq[R"U5 X RU'g)Nr})r}r_switch_tracer__dict__rnamevals rO __setattr__GlobalThreadLocal.__setattr__s+ % %"     $! drN)r}r|r{rN)__name__ __module__ __qualname____firstlineno__rrr__static_attributes__rMrNrOrqrqs 2""rNrqFaxisamax reduce_allamin)anyfrobenius_norm logsumexp reduce_max reduce_min reduce_mean reduce_prod reduce_sum overwriteflag_buffer_hashtableflag_perm_buffer thresholdbetaremote_prefetchglobal_poolingdiag_num is_sorted) gather graph_reindexgraph_sample_neighborsrelu6swish hsigmoid_lossmax_pool2d_with_indexuniformuniquec&[RSL$)a: .. 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()) # dynamic mode is turn ON by default since paddle 2.0. True >>> paddle.enable_static() >>> print(paddle.in_dynamic_mode()) # Now we are in static graph mode False >>> paddle.disable_static() >>> print(paddle.in_dynamic_mode()) # Now we are in dynamic mode True N global_varr}rMrNrOin_dygraph_moderOs<  & &d 22rNcN[R=(a [5(+$)a This API checks whether paddle runs in static graph mode and use pir api. Returns: bool: Whether paddle runs in static graph mode and use pir api. Examples: .. code-block:: python >>> import paddle >>> print(paddle.framework.in_pir_mode()) False >>> paddle.enable_static() >>> with paddle.pir_utils.IrGuard(): ... print(paddle.framework.in_pir_mode()) True )rrrrMrNrO in_pir_moderps,  # # =O,=(==rNc"[R$rK)rrrMrNrO use_pir_apirs  # ##rNcT[RSL=(d [R$)a  This API checks whether paddle runs in dynamic graph or pir mode. Returns: bool: Whether paddle runs in static graph mode and use pir api. Examples: .. code-block:: python >>> import paddle >>> print(paddle.framework.in_dynamic_or_pir_mode()) True >>> paddle.enable_static() >>> print(paddle.framework.in_dynamic_or_pir_mode()) False >>> with paddle.pir_utils.IrGuard(): ... print(paddle.framework.in_dynamic_or_pir_mode()) True N)rr}rrMrNrOin_dynamic_or_pir_moders 2  & &d 2 Nj6N6NNrNcx[[RRS55R 5nUS;$)z{ This API checks whether paddle runs in pir executor mode. Returns: bool: Whether paddle runs in pir executor mode. FLAGS_enable_pir_in_executor)true1)r\r~rrr)flags rOin_pir_executor_moders0 rzz~~<= > D D FD =  rNcXSn[5(dg[R"U5U$)zk This API checks whether paddle runs in cinn mode. Returns: bool: Whether paddle runs in cinn mode. FLAGS_use_cinnFis_compiled_with_cinnrkri)CINN_FLAG_NAMEs rO in_cinn_moders+&N " "   N +N ;;rNcXSn[5(dg[R"U5U$)NFLAGS_cinn_debugFr)CINN_DEBUG_FLAG_NAMEs rOin_cinn_debug_moders,- " "   0 12F GGrN ipu_index ipu_stagec## [R"5(d [S5e[n[nUqUqSv UqUqg!UqUqf=f7f)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 >>> # doctest: +REQUIRES(env:IPU) >>> import paddle >>> paddle.device.set_device('ipu') >>> 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)ris_compiled_with_ipur]global_ipu_indexglobal_ipu_stage)indexstageprev_ipu_indexprev_ipu_stages rOipu_shard_guardrsbJ  $ $ & & S  &N%N* ))*)s6A AA AA cgrKrM call_funcrrs rO set_ipu_shardr s #rNcgrKrMrs rOrrsrNc^^SUU4SjjnSSKJn [X5(d#[U5(aU"U5$[ S5e"UU4SjS[ U55n[ U5R UlXPlU$)a 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 >>> # doctest: +REQUIRES(env:IPU) >>> import paddle >>> paddle.device.set_device('ipu') >>> 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) c>^SUUU4SjjnU$)Nc^>[TTS9 T"U0UD6sSSS5 $!,(df  g=fN)rr)r)argskwargsfuncrrs rOwrapper0set_ipu_shard..decorate..wrapper9s& uE:T,V,;::s ,rz _InputT.argsrz_InputT.kwargsreturnrrM)rrrrs` rOdecorateset_ipu_shard..decorate8s - -rNr)Layerz:Unsupported type. Only accept paddle.nn.Layer or function.c.>^\rSrSrUUU4SjrSrU=r$)set_ipu_shard..BlockFniJcn>[TTS9 [TU]"U0UD6sSSS5 $!,(df  g=fr)rsuper__call__)rrr __class__rrs rOr'set_ipu_shard..BlockFn.__call__Ks+ uE:w'88;::s& 4rM)rrrrrr __classcell__)rrrs@rOBlockFnrJs  9 9rNrrCallable[_InputT, _RetT]rr) paddle.nnrrTcallablerVtyperr)rrrrrrs `` rOrrsyB i ' ' I  I& &L  99$y/9 I//G! rNc "[U[5(d[S[U5S35e[U[[S545(d[S[U5S35e[R "SU5nUbUR 5U:wa[SU35eUb<[R "SU5nUbUR 5U:wa[SU35e[RR[RR[RR[RR/n/SQnS nU"X45S :XarUb9[R"S US US [RR S35 g[R"SUS[RR S35 gUR#S5nXd[%U5S-nUbgUR#S5nX[%U5S-n U"X95S :d U"X75S :a-['SUS US [RR S35egU"X75S :a-['SUS[RR SUS35eg)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 >>> # any version >= 0.1.0 is acceptable. >>> paddle.utils.require_version('0.1.0') >>> # if 0.1.0 <= version <= 10.0.0, it is acceptable. >>> paddle.utils.require_version(min_version='0.1.0', max_version='10.0.0') zGThe type of 'min_version' in require_version must be str, but received .NzUThe type of 'max_version' in require_version must be str or type(None), but received z\d+(\.\d+){0,3}zpThe value of 'min_version' in require_version must be in format '\d+(\.\d+){0,3}', like '1.5.2.0', but received zpThe value of 'max_version' in require_version must be in format '\d+(\.\d+){0,3}', like '1.5.2.0', but received )rzrzrzrzc[[U55H?n[X5[X5:a g[X5[X5:dM? g g)Nrrr)ranger[int)ver_aver_bis rO version_cmp$require_version..version_cmpsHs5z"A58}s58},UXUX. # rNrzPaddlePaddle version in [, z] required, but zg installed. Maybe you are using a develop version, please make sure the version is good with your code.zPaddlePaddle version z or higher is required, but zg installed, Maybe you are using a develop version, please make sure the version is good with your code.z'VersionError: PaddlePaddle version in [z installed.z#VersionError: PaddlePaddle version z0 installed, please upgrade your PaddlePaddle to z or other higher version.)rTr\rVrrematchgroupr]rkversionmajorminorpatchrcwarningswarn full_versionsplitr[ Exception) min_version max_version check_formatversion_installed zero_versionr min_version_splitmin_version_to_checkmax_version_splitmax_version_to_checks rOrequire_versionr"Ts@ k3 ' 'UVZ[fVgUhhi j   kCd#4 5 5cdhitducvvw x  88.     (L$3q8  " MM+K=;-GWX^XfXfXsXsWtuGG   MM' }4PQWQ_Q_QlQlPmnGG  #))#.->)?)ABB'--c2 S1B-C-E F F  ) @1 D,CaG9+b UeflftftgBgBfCCNO H ( ?! C5k]B^_e_m_m_z_z^{|77BmC\^  DrNc^SU4SjjnU$)Nc\>[5(aSTRS35eT"U0UD6$)NzWe don't support z in dynamic graph moderrrrrs rO__impl__'_dygraph_not_support_..__impl__s<"$$  .D E $T$V$$rNrrMrr's` rO_dygraph_not_support_r*s% OrNc^SU4SjjnU$)Nc\>[5(dSTRS35eT"U0UD6$)NWe only support ']()' in dynamic graph mode, please call 'paddle.disable_static()' to enter dynamic graph mode.r%r&s rOr' _dygraph_only_..__impl__sB    /L M  T$V$$rNrrMr)s` rO_dygraph_only_r0% OrNc^SU4SjjnU$)Nc>SSKJn [5(d!U"5(dSTRS35eT"U0UD6$)Nrin_to_static_moder-r.) dygraph.baser5rr)rrr5rs rOr'#_non_static_only_..__impl__sN3  $5$7$7  /L M 7T$V$$rNrrMr)s` rO_non_static_only_r8s% OrNc^SU4SjjnU$)Nc\>[5(aSTRS35eT"U0UD6$)NzDIn PaddlePaddle 2.x, we turn on dynamic graph mode by default, and 'z()' 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.r%r&s rOr'_static_only_..__impl__sG"$$ RSWS`S`Rab~  $T$V$$rNrrMr)s` rO _static_only_r<r1rNcUqgrK)_current_pipeline_stage)rs rO_set_pipeline_stager?s#rNc^SU4SjjnU$)NcP>[STRSTRS35e)N'a' 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 call `paddle.jit.enable_to_static(False)`. If you have to translate dynamic graph to static graph, please use other API to replace 'z'.)AssertionErrorrr&s rOr''_fake_interface_only_..__impl__s: himhuhugvvx z  rNrrMr)s` rO_fake_interface_only_rEs  OrNcJ^[R"T5SU4Sjj5nU$)Nc>SU;a4[R"S[5 USUS'URS5 T"U0UD6$)N stat_dictzJThe argument `stat_dict` has deprecated, please change it to `state_dict`. state_dict)rrDeprecationWarningpopr&s rOr$deprecate_stat_dict..wrappersJ & MM\" $*+#6F< JJ{ #T$V$$rNr) functoolswraps)rrs` rOdeprecate_stat_dictrOs'__T%% NrNc"[R$rKrrMrNrO_dygraph_tracerrQ+s  & &&rNc[b![[5[RLGa[R"5(au[R "5nUS:a'[R"[5S5q[$[R"S5 [R"5q[$[R"5(au[R"5nUS:a'[R"[5S5q[$[R"S5 [R"5q[$[![R""55S:a[R""5Sn[R$"U5nUS:a)[R&"U[)U5S5q[$[R"S5 [R"5q[$[R"5q[$![ a nSnSnAGNSnAff=f![ a nSnSnAGNXSnAff=f![ a nSnSnANSnAff=f)NrzoYou are using GPU version Paddle, but your CUDA device is not set properly. CPU device will be used by default.znYou are using XPU version Paddle, but your XPU device is not set properly. CPU device will be used by default.z{You are using CUSTOM_DEVICE version Paddle, but your custom device is not set properly. CPU device will be used by default.)_global_expected_place_rrPlaceis_compiled_with_cudaget_cuda_device_countr CUDAPlace _cuda_idsrrCPUPlaceis_compiled_with_xpuget_xpu_device_countXPUPlace_xpu_idsr[get_all_custom_device_typeget_custom_device_count CustomPlace_custom_device_ids) device_countedev_types rO_current_expected_place_re/s ' ' (DJJ 6  % % ' ' !#99; a*...Q*H'H #"E F+/--/'> #"= & & ( ( !#88: a*.-- 1 *F'0 #"- E+/--/'& #"%002 3a 7668;H !#;;HE a*.*:*:0:1=+' #" R+/--/' #"'+mmo # ""O !  ! !  ! !  !sHHH.I H+H&&H+. I8II IIIc^[5(a[R"5$[5$rK)rrrTrerMrNrO_current_expected_placergbs}}zz| # %%rNcR[RbU[RlggrK)rr}_expected_placeplaces rO"_set_dygraph_tracer_expected_placerlhs!"".6; ##3/rNcUq[U5 grKrSrlrjs rO_set_expected_placeroms#&u-rNcS[RR5;a[R"5S:aL[ R RS[R"5S[R"5S35 [S5[RS'[RRS5n[U5$)NCPU_NUMra!!! The CPU_NUM is not specified, you should set CPU_NUM in the environment variable list. CPU_NUM indicates that how many CPUPlace are used in the current task. And if this parameter are set as N (equal to the number of physical CPU core) the program may be faster. export CPU_NUM=zD # for example, set CPU_NUM as number of physical CPU core which is z(. !!! The default number of CPU_NUM=1. ) r~rkeysmultiprocessing cpu_countsysstderrwriter\rr)cpu_nums rO_cpu_numryss ))  $ $ & * JJ  "#2";";"=!>?CDSD]D]D_C``99 !$A 9jjnnY'G w<rNc[R"S5nU(a,URS5Vs/sHn[U5PM nnU$[ [ R "55nU$s snf)NFLAGS_selected_gpus,)r~getenvrrrrrV)gpus_envs device_idss rOrXrXs_yy./H&.nnS&9:&9c!f&9 : 45578 ;A*c[R"S5nU(a,URS5Vs/sHn[U5PM nnU$[ [ R "55nU$s snf)NFLAGS_selected_xpusr|)r~r}rrrrr[)xpus_envrrs rOr]r]s_yy./H&.nnS&9:&9c!f&9 : 44467 ;rc[R"SU-S-5nU(a,URS5Vs/sHn[U5PM nnU$[ [ R "U55nU$s snf)NFLAGS_selected_rr|)r~r}rrrrr_) device_typecustom_devices_envrrs rOraraso#4{#BS#HI&8&>&>s&CD&Cc!f&C D 477 DE EsA1c,[R"5$)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.base as base >>> support_xpu = base.is_compiled_with_xpu() )rrZrMrNrOrZrZs  $ $ &&rNc.[R"5 g)aV 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 disable 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)rdisable_signal_handlerrMrNrOrrs. !rNc,[R"5$)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() )rrrMrNrOrr  % % ''rNc,[R"5$)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() )rrUrMrNrOrUrUrrNc,[R"5$)a* Whether this whl package can be used to run the model with distribute. Returns: Bool: `True` if distribute is currently available, otherwise `False`. Examples: .. code-block:: python >>> import paddle >>> support_distribute = paddle.device.is_compiled_with_distribute() )ris_compiled_with_distributerMrNrOrrs  + + --rNc,[R"5$)a! 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() )ris_compiled_with_rocmrMrNrOrrrrNc[R"5(dS5eUc [5nO[U[[ 45(dU/nUVs/sHn[R "U5PM sn$s snf)a, 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 >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> import paddle.static as static >>> paddle.device.set_device('gpu') >>> paddle.enable_static() >>> cuda_places = static.cuda_places() Not compiled with CUDA)rrUrXrTrdrerWrdev_ids rO cuda_placesrsfT  % % ' 'A)AA '[  T5M 2 2 \ 1; <vDNN6 " << < A5c[R"5(dS5eUc [5nO[U[[ 45(dU/nUVs/sHn[R "U5PM sn$s snf)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 >>> # doctest: +REQUIRES(env:XPU) >>> import paddle >>> import paddle.static as static >>> paddle.device.set_device('xpu') >>> paddle.enable_static() >>> xpu_places = static.xpu_places() zNot compiled with XPU)rrZr]rTrdrer\rs rO xpu_placesr8se>  $ $ & &?(?? &Z  T5M 2 2 \ 0: ; fDMM& ! ;; ;rcNUc [5n[R"5/U-$)a 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() )ryrrYrbs rO cpu_placesr_s%:z MMO | ++rNc[R"5(dS5eUc[[55n[R"5/U-$)a\ This function creates a list of :code:`base.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 base.CUDAPinnedPlace: Created list of CUDA pinned places. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle.base as base >>> cuda_pinned_places_cpu_num = base.cuda_pinned_places() >>> # or >>> cuda_pinned_places = base.cuda_pinned_places(1) r)rrUr[rXCUDAPinnedPlacers rOcuda_pinned_placesrsH:  % % ' 'A)AA '9;'  " #l 22rNc[R"5(dS5eUc[[55n[R"5/U-$)aU This function creates a list of :code:`base.XPUPinnedPlace` 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 base.XPUPinnedPlace: Created list of XPU pinned places. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle.base as base >>> xpu_pinned_places_cpu_num = base.xpu_pinned_places() >>> # or >>> xpu_pinned_places = base.xpu_pinned_places(1) r)rrUr[rXXPUPinnedPlacers rOxpu_pinned_placesrsH:  % % ' 'A)AA '9;'    ! "\ 11rNc0\rSrSrSSjrSrSrSrSrg) NameScopeiNc*0UlXlX lgrK _children_name_parentrrparents rOrNameScope.__init__  rNcXR;a[X5nU/URU'U$[US[URU53U5nURURU5 U$N_)rrr[rrra new_childs rOchildNameScope.childsx  '!&/I&/[DNN6 "  "(!Cv 67894I NN6 " ) )) 4rNcUR$rKrrs rOrNameScope.parent ||rNcUR$rKrrs rOrNameScope.name zzrNrN rrrrrrrrrrMrNrOrr rNrc## [5(aSv gU(dS5e[RU5qSv [R5qg![R5qf=f7f)a 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 + paddle.to_tensor(1) ... with paddle.static.name_scope("s2"): ... c = b * paddle.to_tensor(1) ... with paddle.static.name_scope("s3"): ... d = c / paddle.to_tensor(1) >>> with paddle.static.name_scope("s1"): ... f = paddle.tensor.pow(d, paddle.to_tensor(2.0)) >>> with paddle.static.name_scope("s4"): ... g = f - paddle.to_tensor(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/' N"namescope prefix can not be empty.)r _name_scoperr)ras rO name_scopersVh ;;;v!''/  / %,,.K+,,.Ks8A-AA-A**A-c0\rSrSrSSjrSrSrSrSrg) NameStructi"Nc*0UlXlX lgrKrrs rOrNameStruct.__init__#rrNcXR;a[X5nU/URU'U$[US[URU53U5nURURU5 U$r)rrr[rrs rOrNameStruct.child(sx  '"60I&/[DNN6 "  #(!Cv 67894I NN6 " ) )) 4rNcUR$rKrrs rOrNameStruct.parent3rrNcUR$rKrrs rOrNameStruct.name6rrNrrrrMrNrOrr"rrNrc## [5(aSv gU(dS5e[RU5q[5(a?[ [ R R5R5R5nSv [5(a[ R R5R5Rn[ U5n[[WU55H9nX$nURS5(aMURS[55 M; [R5qg![5(a[ R R5R5Rn[ U5n[[WU55H9nX$nURS5(aMURS[55 M; [R5qf=f7f)z Note: This should only used in Paddle/python/paddle/nn/layer/layers.py to record the call path for the operators in Static Graph of AutoParallel. Args: prefix(str, optional): prefix. Default is none. Nr struct_name)r _name_structrrr[rkstaticdefault_main_program global_blockopsreversedrhas_attr set_str_attr_full_name_structr)ra op_num_beforeall_opsop_numidxops rO name_structr=s| ;;;v#))&1 == 224AACGGM 1 }}MM668EEGKKW#E-$@AC B{{=11 OOM3D3FG B (..0L}}MM668EEGKKW#E-$@AC B{{=11 OOM3D3FG B (..0Ls BG? E B7G?B8G<<G?c[nSnU(a/UR5S-U-nUR5nU(aM/U$Nr/)rrr)structrs rOrrds= F D {{}s"T) & KrNc[nSnU(a/UR5S-U-nUR5nU(aM/U$r)rrr)scopers rO_full_name_scoperns= E D zz|c!D(  % KrNcPSSKn[S-[UR55-$)Nr@)randomCONTROL_DEP_VAR_PREFIXr\)rs rOgenerate_control_dev_var_namerxs  !C '#fmmo*> >>rNcU[-$)z8 Returns: str: gradient name for a certain var name )GRAD_VAR_SUFFIX)var_names rO grad_var_namer~s o %%rNc[RRR[RRR[RRR [RRR [RRR[RRR[RRR[RRR[RRR[RRR[RRR[RRR[RRR[RRR S.n0["R$"S5[RRR_["R$"S5[RRR_["R$"S5[RRR _["R$"S5[RRR _["R$"S5[RRR_["R$"S5[RRR_["R$"S5[RRR_["R$"S 5[RRR_["R$"S 5[RRR_["R$"S 5[RRR_["R$"S 5[RRR_["R$"S 5[RRR_["R&[RRR_["R([RRR_["R*[RRR _["R,[RRR _["R.[RRR_["R0[RRR["R2[RRR["R4[RRR["R6[RRR["R8[RRR["R:[RRR["R<[RRR0En[?U[@5(a X;aX$["R$"U5nX2;aX#$[CSU35e)z Convert the data type in numpy to the data type in Paddle. Args: np_dtype (np.dtype|str): The data type in numpy or valid data type string. Returns: core.VarDesc.VarType : The data type in Paddle. )float32float64float16int32int16int64booluint8int8 complex64 complex128bfloat16 float8_e4m3fn float8_e5m2rrrrrrbool_uint16rrrrzNot supported numpy dtype )"rVarDescVarTypeFP32FP64FP16INT32INT16INT64BOOLUINT8INT8 COMPLEX64 COMPLEX128BF16 FP8_E4M3FNFP8_E5M2npdtyperrrrrrrrrrrrrTr\r])np_dtypestr_to_var_typenp_dtype_to_var_typers rOconvert_np_dtype_to_proto_typersy$<<'',,<<'',,<<'',,%%++%%++%%++ $$))%%++ $$))\\))33ll**55LL((----88||++44O" T\\1166 T\\1166 T\\1166 4<<//55  4<<//55  4<<//55  4<<//44 DLL0055 4<<//55 $,,..33 t||33==  4 4 ? ? DLL((-- DLL((-- DLL((-- $,,&&,,!" $,,&&,,#$ $,,&&,, $,,&&++ $,,&&,, %%** 4<<'',, dll**44 t||++6616(C   &", , HHX E $#**5eW=>>rNc [5(a@[U[R5(aU$[RR U5$[U[R R5(aU$[U5$)z Convert the data type in numpy to the data type in Paddle. Args: np_dtype (np.dtype|str): The data type in numpy or valid data type string. Returns: core.VarDesc.VarType / core.DataType : The data type in Paddle. ) rrTrrrconvert_np_dtype_to_dtype_rrr)rs rOrrs]}} h . .Oxx228<<(DLL0011 )( 33rNc[U[RR5(aU$[U[R5(a [ U$[ U5$)a Convert the data type in numpy to the data type in Paddle. Args: dtype (np.dtype|str|core.DataType|core.VarDesc.VarType): The data type in numpy, valid data type string or paddle dtype. Returns: core.VarDesc.VarType : The data type in Paddle. )rTrrrrpaddle_type_to_proto_typerrs rOconvert_to_proto_typersG%--.. E4== ) )(//-e44rNcF[U[RR5(d [ U5nU[RRR [RRR [RRR4;$)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 )rTrrrrrrrrs rOdtype_is_floatingr sp eT\\11 2 2*51  !! !! !! rNTc/nURU5(dU(a[USUS35eUR5$)a: 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% are not initialized. The message is z: ) IsInitializedr]r)protothrow_on_error error_fieldss rO_debug_string_r&sHL   | , ,nB5' M   ==?rNc ^Ub [U5nO$[RRRn[R R UU(a [U5O/UU(aUO#[RRRU(aSOS5nUR5 U$NTF) rrrrreagerTensorrd DENSE_TENSOR retain_grads)rrshaper persistabler eager_tensors rO_create_tensorr0"s %e, $$))::$$ U " $,,..;; L rNcx^[U[[45(deU(dg[U4SjU55$)zv Return True if type of each element is expected_type. NOTE: BuiltIn all() will always return True if vals is empty. Fc3<># UHn[UT5v M g7frK)rT).0v expected_types rO _all_is_type..Cs:Tz!]++Ts)rTrdreall)valsr5s `rO _all_is_typer::s3 dT5M * ** *  :T: ::rNc^[U[R5(aU$[U[[[ [ 45(a[R"U5$[U[R5(a$[R"UR55$[SUS35e)zWrap a number(either python scalar or numpy scalar) as core.Scalar if it is not a scalar. Args: number (Number): number Returns: Scalar: A Scalar that contains the value. z Cannot wrap z as core.Scalar) rTrScalarrrfloatcomplexrnumberitemrV)r?s rOwrap_as_scalarrAFsy&$++&& &4eW566{{6""&"))$${{6;;=)),vho>??rNc[U[R5(aUR5R 5nUVs/sHn[ U5PM sn$s snf)ahThis function is used to convert flat list, or numpy array(not necessarily flat) to list of core.Scalar, which correspond to std::vector in operator runtime. Args: array (List | np.ndarray): array of numbers Returns: List: list of core.Scalar, of which each element is a Scalar containing the corresponding value. )rTrndarrayraveltolistrAarrayr@s rOwrap_as_scalarsrH\sF%$$ $$&-2 3UTN4 U 33 3sAcLUVs/sHoR5PM sn$s snf)zextract value from a list of core.Scalar. Args: array (list): Scalars Returns: list: values extracted from the scalars. )r`rFs rOextract_plain_listrJms &+ +UTJJLU ++ +s!cUR5nURGH4nURnURnX@;dXcM(Xn[ U[ 5(aMC[ U[ 5(a[U[ 5(aMoU[RR:Xa[R"U5X$'MU[RR:XdM[U5S:dM[R"U5R!5R#5nUVs/sHn[R"U5PM nnXbU'GM7 U$s snf)a|This function is used to canonicalize attributes(as a string->any dict) according to the type specification in the OpProto. This is especially important for operators that has any attributes of type Scalar or Scalars. Though various frontends of phi kernels & paddle operators can wrap variables of concrete types into Scalars(a tagged union of several numeric types) or vector of Scalars. Paddle operator requires strict type matching. Args: attrs (Dict[str, Any]): attribute dict intended to pass to an operator. op_proto (OpProto): Proto (signature) of the operator. Returns: Dict[str, Any]: canonicalized attributes. r)copyattrsrrrTVariablerdr:rAttrTypeSCALARr<SCALARSr[rrGrDrE)rMop_protocanonicalized_attrsattr attr_name type_indexattr_valrBs rOcanonicalize_attrsrXys   **,II YY  "(8(@ # h ) )  h % %,x*J*J  -- --1[[-B  * 4==00 08}q 88H-335<<>4<=HqDKKNH=19I.-0 >s+ Ec$\rSrSr\S5rSrg)VariableMetaClassic[U5n[5(a$[U[RR 5$[U[ 5$rK)rr issubclassrr)r*rNclsinstancets rO__instancecheck__#VariableMetaClass.__instancecheck__s8 N   a!2!23 3a* *rNrMNrrrr classmethodrarrMrNrOrZrZs++rNrZc$\rSrSr\S5rSrg)ParameterMetaClassicv[U5n[5(a[U[5$[U[5$rK)rrr\EagerParamBase Parameterr]s rOra$ParameterMetaClass.__instancecheck__s. N   a0 0a+ +rNrMNrcrMrNrOrfrfs,,rNrfc \rSrSrSr\R RRSSSSSSSSSSS4 Sjr Sr \ S5r \ S9Sj5r\ S 5r\ S 5rS rS rS rSrS9Sjr\rSr\S5r\R4S5r\S5r\R4S5r\S5r\R4S5r\S5r\S5r\R4S5r\S5r\S5r \S5r!\S5r"\S5r#Sr$S r%S!r&S"r'S#r(S$r)S%r*S&r+S9S'jr,S(r-S)r.S*r/S+r0S,r1S:S-jr2S:S.jr3S/r4S0r5S1r6S2r7S3r8\S45r9S5r:\S65r;\;R4S75r;S8r`_ 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 :name: code-example-1 >>> import paddle.base as base >>> cur_program = base.Program() >>> cur_block = cur_program.current_block() >>> new_variable = cur_block.create_var(name="X", ... shape=[-1, 23, 48], ... dtype='float32') In Dygraph Mode: .. code-block:: python :name: code-example-2 >>> import paddle.base as base >>> import numpy as np >>> import paddle >>> with base.dygraph.guard(): ... new_variable = paddle.to_tensor(np.arange(10)) NFc "XlUcURRRS5nURRU5bCURRRS5nURRU5bMCUb [ U5nU[ R RR:Xa&[ R RRnSnU[ R RR:XaSnXl Xl SnURRRUR55Ul URc:URRRUR55Ul SnU(aURR!U5 OUURR#5U:wa7[%SUR&SURR#5SUS35eUb_U(aURR)U5 OU'SUl Xl!Xl"SUl#g)N_generated_varFTz Variable 'z0' has been created before. The previous type is z, the new type is z. They are not matchedz1' has been created before. The previous shape is z, the new shape is z. They are not matched.z5' has been created before. The previous data type is z, the new data type is z5' has been created before. The previous lod_level is z, the new lod_level is z6' has been created before.The previous persistable is z, the new persistable is )$blockprogram_name_generator_find_var_recursiverrrrSTRINGS SPARSE_COObelong_to_optimizer error_clipdescfind_varencodevarset_typerr]r set_shaper-re set_dtyper set_lod_level lod_levelset_persistabler.set_need_check_feed set_capacityvarsr stop_gradientis_data is_view_var)rrnrrr-rr~capacityr.rurrneed_check_feedrtr is_new_var old_shape old_dtypes rOrVariable.__init__s" <::%%556FGD**006Bzz))99:JK**006B  )%0E DLL((00 0<<''//DI 4<<''22 2I#6 $ JJOO,,T[[]; 99  ++DKKM:DIJ  II  t $ YY^^  %TYYK($$(IINN$4#55GvN##    ##E* JJ e I%$$TYYK0$$-;.A%I##   ##E* JJ I%$$TYYK055>K@((-w/##   '' 2.$$TYYK0559^^4DE((1{3""  " ))+6"2"22$$TYYK077;7G7G6HI**56LN z II ) )/ :   &&x0 $ *  rNc rUR[RRR:Xd9UR[RRR :XdS5e[ R"URRR5 URR[ R"SUR-5URURURSS9nSSS5 URR!SSU/0SW/0S 9 U$!,(df  N1=f) aA 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() zIonly support a variable with SELECTED_ROWS or DENSE_TENSOR to be detacheddetach_Trrrr.rN share_datarOutrinputsoutputs)rrrr SELECTED_ROWSr+rguardrnrorp create_vargenerate_with_ignorable_keyrrr. append_oproutputs rOdetachVariable.detach_s4 II--;; ;yyDLL00===  X   >   tzz11AA BZZ** << )jjYY ,,"+FC $=VH%   !C Bs AD(( D6cg)a **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 >>> import paddle.base as base >>> from paddle.nn import Linear >>> import numpy as np >>> data = np.random.uniform(-1, 1, [30, 10, 32]).astype('float32') >>> with base.dygraph.guard(): ... linear = Linear(32, 64) ... data_tensor = paddle.to_tensor(data) ... x = linear(data_tensor) ... print(x.numpy()) NrMrs rOnumpyVariable.numpys< rNcbSSKJn USLa [S5eU"U5nUH upEXTlM g)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, setting 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() r)append_backwardTz_`retain_graph` == True is not supported in @to_static function.please set retain_graph = False.N)backwardrrCgrad)r retain_graphrparam_grad_listparam param_grads rOrVariable.backwards@J . 4  3 *$/!0 E#J"1rNcg)aq **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 DenseTensor, 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 >>> import paddle.base as base >>> import numpy as np >>> # example1: return ndarray >>> x = np.ones([2, 2], np.float32) >>> with base.dygraph.guard(): ... inputs2 = [] ... for _ in range(10): ... tmp = paddle.to_tensor(x) ... tmp.stop_gradient=False ... inputs2.append(tmp) ... ret2 = paddle.add_n(inputs2) ... loss2 = paddle.sum(ret2) ... loss2.retain_grads() ... loss2.backward() ... print(loss2.gradient()) >>> # example2: return tuple of ndarray >>> with base.dygraph.guard(): ... embedding = paddle.nn.Embedding( ... 20, ... 32, ... weight_attr='emb.w', ... sparse=True) ... x_data = np.arange(12).reshape(4, 3).astype('int64') ... x_data = x_data.reshape((-1, 3, 1)) ... x_tensor = paddle.to_tensor(x_data) ... out = embedding(x_tensor) ... out.backward() ... print(embedding.weight.gradient()) NrMrs rOgradientVariable.gradients^ rNcg)a **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 >>> import paddle.base as base >>> import numpy as np >>> x = np.ones([2, 2], np.float32) >>> inputs2 = [] >>> for _ in range(10): >>> tmp = paddle.to_tensor(x) >>> tmp.stop_gradient=False >>> inputs2.append(tmp) >>> ret2 = paddle.add_n(inputs2) >>> loss2 = paddle.sum(ret2) >>> loss2.retain_grads() >>> loss2.backward() >>> print(loss2.gradient()) >>> loss2.clear_gradient() >>> print("After clear {}".format(loss2.gradient())) 1.0 After clear 0.0 NrMrs rOclear_gradientVariable.clear_gradientsF rNc\^SSKnU4SjnSnURRUUUUU/S9 g)Nrc<>T"[R"U55$)zcall the backward hook in .)rrG)dyhooks rObackward_hook_wrapper5Variable.register_hook..backward_hook_wrapper;s % %rNcU$)z%do nothing but return a new variable.rM)rBs rOforward_hook_wrapper4Variable.register_hook..forward_hook_wrapper?sHrN)rrBout backward_funcskip_vars_in_backward_input)rkrpy_func)rrrkrrs ` rO register_hookVariable.register_hook8s: &   %/)-  rNcUR(d [S5eU"U5$! [SURS35e=f)Nz9Cannot apply function on a tensor that required gradient.z The PyFunc z could not be applied)r RuntimeErrorr]r)rrs rOapplyVariable.applyKsL!!K  Q:  Q{4==/9NOP Ps &Ac"UR5$rK_to_readable_coders rOrVariable.__str__U%%''rNc [UR5RS5SnUR[RR R :Xd2UR[RR R:XaW[UR5RS5SnURSUSURSUSURS3 nOURSUS3nUR(aUR(aSU-nO S U-nOS U-nUR(aS U-nS S KJn U"5nUR#U5nUbUSR%SUS9- nU$)aA 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 >>> # doctest: +SKIP("This has diff in xdoctest env") >>> 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()) var X : DENSE_TENSOR.shape(-1, 23, 48).dtype(float32).stop_gradient(False) rrz : z.shapez.dtype(z).stop_gradient()ztrainable param param var zpersist rget_default_distributed_context, {name} = {value} dist_attrrr`)r\rrrrrrr+rrr-r is_parameter trainabler.4paddle.distributed.auto_parallel.static.dist_contextrget_dist_tensor_for_programformat)rtype_str dtype_strvar_strr dist_context dist_tensors rOrVariable._to_readable_codeXsQ:tyy>'',Q/ II--;; ;yyDLL00===DJJ--c215I 3xjtzzl')TdeiewewdxxyzG 3xj2G   ~~,w6"W,w&G    7*G 78 ">>tD  " +22 3 GrNcB[U[5(a[U[5(deURR5n[R R [U55n[XA5nU(aSnUHnXWS[X5S3- nM U$)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 >>> # doctest: +SKIP("This has diff in xdoctest env") >>> import paddle.base as base >>> import paddle >>> paddle.enable_static() >>> cur_program = base.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)) name: "X" type { type: DENSE_TENSOR lod_tensor { tensor { data_type: FP32 dims: -1 dims: 23 dims: 48 } } } stop_gradient: false error_clip: None ru: r) rTrrvserialize_to_stringrr FromStringbytesr&getattr)rr$ with_detailsprotostrr#res_stradditional_attrrUs rO to_stringVariable.to_stringsX.$//J $5 5   99002%%00xA 7 -O, [74+C*DBGG-rNc6URR5$)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') >>> print(x.element_size()) 1 >>> x = paddle.static.data(name='x2', shape=[3, 2], dtype='int16') >>> print(x.element_size()) 2 >>> x = paddle.static.data(name='x3', shape=[3, 2], dtype='float16') >>> print(x.element_size()) 2 >>> x = paddle.static.data(name='x4', shape=[3, 2], dtype='float32') >>> print(x.element_size()) 4 >>> x = paddle.static.data(name='x5', shape=[3, 2], dtype='float64') >>> print(x.element_size()) 8 )rv element_sizers rOrVariable.element_sizes<yy%%''rNc6URR5$)a Indicating if we stop gradient from current Variable **Notes: This Property has default value as** ``True`` **in** Dygraph **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 >>> import paddle.base as base >>> import numpy as np >>> with base.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 = paddle.nn.Linear(13, 5) ... linear2 = paddle.nn.Linear(3, 3) ... a = paddle.to_tensor(value0) ... b = paddle.to_tensor(value1) ... c = paddle.to_tensor(value2) ... out1 = linear(a) ... out2 = linear2(b) ... out1.stop_gradient = True ... out = paddle.concat(x=[out1, out2, c], axis=1) ... out.backward() ... assert linear.weight.gradient() is None ... assert out1.gradient() is None )rvrrs rOrVariable.stop_gradients>yy&&((rNc:URRU5 grK)rvset_stop_gradient)rrs rOrr s ##A&rNc6URR5$)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 **mode, this property should not be changed** Examples: .. code-block:: python >>> import paddle.base as base >>> cur_program = base.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)) persistable of current Var is: False )rvr.rs rOr.Variable.persistable s0yy$$&&rNc:URRU5 grK)rvrrps rOr.r1 s !!!$rNc6URR5$)a) Indicating if current Variable is a Parameter Examples: .. code-block:: python >>> import paddle >>> paddle.enable_static() >>> 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 )rvrrs rOrVariable.is_parameter5 s&yy%%''rNc:URRU5 grK)rvset_is_parameterrs rOrrJ s ""1%rNc6URR5$)a Indicating name of current Variable **Notes: If it has two or more Variable share the same name in the same** :ref:`api_guide_Block_en` **, it means these Variable will share content in no-** Dygraph **mode. This is how we achieve Parameter sharing** Examples: .. code-block:: python >>> import paddle.base as base >>> cur_program = base.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)) name of current Var is: X )rvrrs rOr Variable.nameN s&yy~~rNc URS-$)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 >>> paddle.enable_static() >>> x = paddle.static.data(name="x", shape=[-1, 23, 48], dtype='float32') >>> print(x.grad_name) x@GRAD z@GRADrrs rO grad_nameVariable.grad_namec s&yy7""rNc:URRU5 grK)rvset_name)rnew_names rOrrx s 8$rNcH[URR55$)a3 Indicating shape of current Variable **Notes: This is a read-only property** Examples: .. code-block:: python >>> import paddle.base as base >>> cur_program = base.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)) shape of current Var is: [-1, 23, 48] )rervr-rs rOr-Variable.shape| s(TYY__&''rNc6URR5$)a9 Indicating data type of current Variable **Notes: This is a read-only property** Examples: .. code-block:: python >>> import paddle.base as base >>> cur_program = base.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)) Dtype of current Var is: paddle.float32 )rvrrs rOrVariable.dtype s&yy  rNcUR[RRR:Xa [ S5eUR[RRR :XagURR5$)a- Indicating ``LoD`` info of current Variable, please refer to :ref:`api_paddle_Tensor` to check the meaning of ``LoD`` **Notes**: **1. This is a read-only property** **2. Don't support this property in** Dygraph **mode, it's value should be** ``0(int)`` Examples: .. code-block:: python >>> import paddle >>> import paddle.base as base >>> paddle.enable_static() >>> cur_program = base.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)) LoD Level of current Var is: 0 zSelectedRows DO NOT support lodN) rrrrrNotImplementedErrorrrrvr~rs rOr~Variable.lod_level s^6 99 ,,:: :%&GH H 99 ,,44 4yy""$$rNc6URR5$)au Indicating Type of current Variable **Notes: This is a read-only property** Examples: .. code-block:: python >>> # doctest: +SKIP("This has diff in xdoctest env") >>> import paddle.base as base >>> cur_program = base.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)) Type of current Var is: VarType.DENSE_TENSOR rvrrs rOr Variable.type s(yy~~rNc [UR5S:XaU$/n[[UR55HnURSU5 M [R "UR RR5 UR R[R"URS-5URURSSS9nUR R[R"URS-5UR[RR R"SSS9nUR R%SSU/0U/U/S.S U0S 9 UsS S S 5 $!,(df  g =f) a 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 transpose2r)rXShaperrrrrMN)r[r-rinsertrrrnrorprrrrrrrrr+r)rpermrr input_shapes rOT Variable.T sM. tzz?a Ks4::'A KK1 (  tzz11AA B**'' <<II&jjYY!#(C**// <<II&jj\\))66!#0K JJ !dV}!$+?tn !  5C B Bs C$E77 Fc [R"URRR5 URR [R "URS-5URURURURS9nURRSSU/0SU/0S9 UsSSS5 $!,(df  g=f)a2 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() _clonerassignrrrN) rrrnrorprrrrrr.rrrs rOcloneVariable.clone s.  tzz11AA BZZ** <<II(jjYY ,,"00+F JJ dV}) !  !C B Bs B C CcXlg)zi Set the error_clip. Args: error_clip(BaseErrorClipAttr) : The new error_clip. Returns: None Nr)rrus rO_set_error_clipVariable._set_error_clip@ s %rNcP[US5(d0UlX RU'g)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)rr_r`s rO _set_infoVariable._set_infoN s#tW%%DJ 3rNcb[US5(aXR;aURU$g)z Get the information of this variable corresponding to key. Args: key(str): Key for this information. Returns: object rNr)rr_s rO _get_infoVariable._get_info_ s+ 4 ! !cZZ&7::c? "rNcURcSO URnUS:a [S5eUS:Xa [S5eUS:aSOSnUS:aUS- OUnURc US:aUOUnO+URnUS:a[Xb-U5O [ Xe5nUR c US:aUOUnO+UR nUS:a[Xr-U5O [ Xu5nXgU4$)z: Reference implementation for the slice.indices method. rrzlength should not be negativezslice step can not be zeror)stepr]startmaxminstop)rslicelengthr&rupperr'r*s rO_slice_indicesVariable._slice_indiceso sJJ&qEJJ A:<= = 199: :QhA"Qh F ;; !AXE5EKKE.3aiENE*S=N  ::  1H5%D::D04q3t}e,c$>NDD  rNcSnSn[UR5n[U5H1upVU[LaU(a [ S5eSnUnM&U(dM/UnM3 X#U4$)NFrz!Index can have one ellipsis only.T)r[r- enumerateEllipsisr])rr@ has_ellipsisr'endros rO_detectEllipsisVariable._detectEllipsis s` $**o!$HEH}$%HII# <C(C''rNcFURU5up#nU(a/n[U5HnURX5 M [X45HnUR[SSS55 M! [U[ U55HnURX5 M U$grK)r6rrr+r[)rr@r3r'r4newitemrs rO_reconstructSliceinfoVariable._reconstructSliceinfo s#'#7#7#= S G5\tw'"5&uT467'3D *tw'+NrNc/n/n[U5GH5upE[U[5(a[U5nUS:aX@RU:dUS:a X@RU-S:a [ S5eUS:a[ X`RU-S5O[ X`RU5nURU5 URUS-5 M[U[5(aTURXPRU5upgnUS:XdUS:Xa%URU5 URU5 GM+ g[ S5e SX#/4$)Nr invalid indexrr)FNz+Valid index accept int or slice or ellipsisT) r1rTrr- IndexErrorr(r)rr+r.) rr@startsendsrr5r'r*r&s rO_detectContinuesSliceVariable._detectContinuesSlice s/!$HE!S!!AAI%::e+<"<AI5::e+<#<"A$_55qy 5 1115UJJu$56  e$ EAI&Au%%$($7$7::e;L$M!T19 MM%(KK%& !NOO-(.f^##rNcH[R"URRR5 U(dKURR [R "UR5URS9sSSS5 $UsSSS5 $!,(df  g=f)Nrr) rrrnrorprrrr)rrLs rO _cloneVarVariable._cloneVar sn   tzz11AA Bzz,,$@@K**-C BC B BsA BB B!c pUR5nURRSSU/0SU/0XUS.S9 U$)Nr+Inputr)axesr?r@rrErnr)rrIr?r@new_vars rO _sliceVarVariable._sliceVar sK.." dV$WI&4@  rNclUR5nURRSSU0SU/0SU0S9 U$)NconcatrrrrrJ)rrrrKs rO _concatVarVariable._concatVar sJ.." =WI&  rNcN[U[5(aURUS:aURS5$UR XRU5up4nUS:XaUR U/U/U/5$/nUS:a9X4:a3UR UR U/U/US-/55 X5- nX4:aM3O8X4:a3UR UR U/U/US-/55 X5- nX4:aM3URXb5$[U[5(aURUS:aURS5$[U5nUS:aXpRU:dUS:a XpRU-S:a [S5eUR U/U/US-/5$[S5e)NrTrr=z(Valid index accept int or slice or tuple) rTr+r-rEr.rLrrPrr>)rr@rr'r*r&rrs rO_sliceAndConcatVarVariable._sliceAndConcatVar s dE " "zz$!#~~d++ $ 3 3D**T:J K Eqy~~tfugv>>!8,  NND6E7UQYKH   ,  ,  NND6E7UQYKH   , t22 c " "zz$!#~~d++IE ezz$'77 uzz$'771< 11>>4&5'EAI;? ?GH HrNc[X5$rK)r)rr@s rO __getitem__Variable.__getitem__ s t**rNcTSSKJn U"5(a [XU5$[S5e)Nrr4zIn static mode, the __setitem__ (looks like: x[indices] = values) should not be used. Please use x = paddle.static.setitem(x, indices, values))r6r5rr)rr@r`r5s rO __setitem__Variable.__setitem__ s.3   "4u5 5a rNc(SSKJn Ub7[U[R5(d[ S[ U5S35eUcU"5nURUR5nUc[SURS35eUR5nU$)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_scopeC`scope` should be None or `paddle.static.Scope` type, but received rCan not find Variable '' in the Scope.) executorr]rTr_ScoperVrrwrr] get_tensor)rrr]var_tempr`s rO get_valueVariable.get_value sX +  Zt{{%C%CUVZ[`VaUbbcd  = NE>>$)),  )$))OD     !rNc SSKJn [U[R5(d)[ US5(d[ S[U5S35eUb7[U[R5(d[ S[U5S35eUcU"5nURUR5nUc[SURS 35eUR5n[ US 5(a[UR[[ 45(aUR5nO URn[#UR55[#U5:wa>[URS [#UR55S [#U5S35eUR%5nUR'5(a[R("5nGOUR+5(a[R,"5nGOoUR/5(a[R0"5nGOCUR35(aY[R4"5nUR7UR%55 [R8"UR;55nOUR=5(ah[R4"5nUR7UR%55 [R>"URA5URC55nOX[R4"5nUR7UR%55 [RD"URG55nURIX5 g) 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) rr\ __array__zA`value` should be `numpy.ndarray` or `DenseTensor`, but received rNr^r_r`r-z expected a shape z, but the received shape is )%rar]rTrrCrrVrrrbrwrr]rcr-rrrd_place is_cpu_placerYis_cuda_pinned_placeris_xpu_pinned_placer is_xpu_placerT set_placer\ xpu_device_idis_custom_placer`custom_device_typecustom_device_idrW gpu_device_idset) rr`rr]rdr` value_shaperrks rO set_valueVariable.set_valueY s` +5"**-- 1L1LSTXY^T_S``ab   Zt{{%C%CUVZ[`VaUbbcd  = NE>>$)),  )$))OD     ! 5' " "%++ L'ABB#kkm #kk AGGI${"33 yyk!3DO3DD`aefqar`sstu HHJ >>  MMOE  # # % %((*E  " " $ $'')E ^^   A KK #MM!//"34E     A KK #$$$$&(:(:(<E A KK #NN1??#45E erNc[R"URRR5 URR [R "URS-5[RRRS9nURRSSU/0SU/0S9 UsSSS5 $!,(df  g=f)a Returns the number of elements for current Variable, which is a int64 Variable with shape [] . 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 _sizerDsizerHrrN) rrrnrorprrrrrrr rrs rOrz Variable.size s.  tzz11AA BZZ** <<II'll**00 +F JJ $() !  C B Bs BB?? C c&URX5 g)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_attrrs rO _set_attrVariable._set_attr s t)rNc8URRU5$)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. rvrrrs rO _has_attrVariable._has_attr syy!!$''rNc:URRU5 grKrv remove_attrrs rO _remove_attrVariable._remove_attr  d#rNc:URRX5 g)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)rvrrs rOr~Variable._update_desc_attr s D&rNc6URR5$)z(Get the names of all attributes defined.rv attr_namesrs rOrVariable.attr_names syy##%%rNc8URRU5$)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. rvrTrs rOrT Variable.attr yy~~d##rNc.URR$z- Get distributed attribute of this Variable. rvrrs rOrVariable.dist_attr!  yy"""rNc$XRlgz- Set distributed attribute of this Variable. Nrrrs rOrr(  ( rN) rrtrnrvrurrrrFrK)=rrrr__doc__rrrr+rrfake_interface_onlyrnon_static_onlyrrrrrrrr__repr__rpropertyrsetterr.rrrr-rr~rrrrr r#r.r6r:rArErLrPrSrVrYrervrzrrrr~rrTrrrMrNrOrNrNs-d\\ ! ! . . !t!l0d  >.$.$`. . `" " H &Q(=~7rH(@))@''''2%%(((&&  (##( [[%%((*!!(%%@  *66p'R % " #!J ( $8  ID+;zgR$L * ($'&& $## ((rNrN) metaclassc[R"5n/nUH<n[RR [ U55nUR U5 M> U$)z\ Get all registered op proto from PaddlePaddle C++ end. Returns: list: list of OpProto. )rget_all_op_protosrOpProtorrr) protostrs ret_valuespbstrrRs rOrr0 sQ&&(IJ ((33E%LA(# rNcP\rSrSrSr\S5rSrSrSr Sr \ S5r S r g ) OpProtoHolderi? z: A global variable to hold all OpProtos from C++ as a map cT[US5(d U"5UlUR$)N _instance)rr)r^s rOr_OpProtoHolder.instanceD s"sK((ECM}}rNc[URS5(aS5e[5n0UlUHnX RUR'M g)Nrz4Please use `instance()` to get OpProtoHolder object!)rrr op_proto_mapr)r op_protosr#s rOrOpProtoHolder.__init__J sQ4>>;77 B 7&' E,1  ejj )rNc\XR;a[SUS35eURU$)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 "z" has not been registered.)rr]rrs rO get_op_protoOpProtoHolder.get_op_protoS s6 (( (z$/IJK K  &&rNc&[5n/nUHRnURUR;dMX@RUR'URUR5 MT [ [ U5R [ U555nU$rK)rrrrrdrtunion)r new_op_listrcustom_op_namesr#s rOupdate_op_protoOpProtoHolder.update_op_proto` sv%' Ezz!2!2205!!%**-&&uzz2s?399#k:JKLrNcXR;$rKrrs rO has_op_protoOpProtoHolder.has_op_protoj s((((rNc([RR5[RR5[RR 5[RR 5[RR 51$rK)rop_proto_and_checker_makerkOpRoleAttrNamekOpRoleVarAttrNamekOpNameScopeAttrNamekOpCreationCallstackAttrNamekOpDeviceAttrNamerMrNrOgenerated_op_attr_names%OpProtoHolder.generated_op_attr_namesm sh  + + ; ; =  + + > > @  + + @ @ B  + + H H J  + + = = ?   rNrN)rrrrrrdr_rrrr staticmethodrrrMrNrOrr? sC 2 ')  rNrc\rSrSrSr1SkrS,SjrSrSrS-Sjr S r \ r \ S 5r S rS rS r\ S5r\ S5r\ S5rSr\ S5r\ S5rSrSrSrSrSrSr\ S5rSrSrSr Sr!Sr"S r#S!r$S"r%S#r&S$r'\ S%5r(\(RRS&5r(S'r*\ S(5r+\ S)5r,\,RRS*5r,S+r-g).Operatorix a 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 >>> paddle.enable_static() >>> cur_program = paddle.static.Program() >>> cur_block = cur_program.current_block() >>> var1 = cur_block.create_var(name="var1", shape=[-1, 23, 48], dtype='float32') >>> var2 = cur_block.create_var(name="var2", shape=[-1, 23, 48], dtype='float32') >>> var3 = cur_block.create_var(name="var3", shape=[-1, 23, 48], dtype='float32') >>> var1 += var2 + var3 >>> cur_block.append_op(type="sum", ... inputs={"X": [var1, var2, var3]}, ... outputs={"Out": [var1]}) >gofeedrecvsendfetchwhileselectpylayer c_comm_init c_wait_comm gen_bkcl_id gen_nccl_id c_gen_bkcl_id c_gen_nccl_idc_wait_computelisten_and_servcheckpoint_notifyconditional_blockc_sync_calc_streamc_sync_comm_streamfl_listen_and_servheter_listen_and_servNc r[R5RU5n0UlURH&nUR URUR 'M( [5(a%Uc [S5eX0l U(aUO0UlgXl X l Un U c0n A[Ul SSKJn Xl[#5Ul[&R(n U R+5U ;a0URR,R.XR+5'U R15n [3URR,R45S:wa'X;a"URR,R4X'X;a[3X5S:XaX [3URR 55S:wamURR75HNn UR9U 5(dMUR;U 5R<bM9XR;U 5lMP gUc [S5eU R?5n/X'[@RB"5HAnXRESUSSUSSUS35 XRES US 35 MC URRGU5 [R5RU5nU RI5n[K5U U'[Lb~UROU5(aU RQ5n[LU U'O[RRT"S US 35 S U ;a.US:XaU S cU S SLa[RRT"SUS35 [Vb.S[&RX"5-nUR[U[V5 SnUGbUR\GHnU"UUR 5nU(d&UR^(dSUR S35eU(GaxUUR n[aU[b[d45(dU/nURf(d4[3U5S:a%[SUR S[3U5S35e/n[iU5Hunn [aU [j5(aUREU 5 M.[aU [l5(a!UREU Ro55 Md[aU [p[&RrRt45(aUREU R 5 M[wSUR SUSU 35e URRyUR U5 GMURRyUR /5 GM UGb,URzHnUR U;aUR^(aM&[&R|"5(aTUR U;dBUR^(d/UR~(d[SUSUR S35eMMMUR U;aMUR^(aM[SUSUR S35e URzGH8nUR U;aMUUR nU5(dU/nURf(d4[3U5S:a%[SUR S[3U5S35e/nUHn [aU [j5(aUREU 5 OUREU R 5 [5(aMV[aU [j5(aXR;U 5lMX lM URRUR U5 GM; [&R"U5nU Gb%[aU [5(d [wS 5eURH4nUR nUU ;dU UcMU UnUR[UU5 M6 UR5H{n[RRS!S"5S#:Xa[RRT"S$US%U35 UU ;dU UcUR[UUU5 MfUR[UU U5 M} [RRS!S"5S#:XGa U[;aP[RU/5nUH4nXR5;dM[RRT"S$US%U35 M6 U[;a[RU/5nUHn[[UR555n [[UR555n!U U R5;dM]U!U U :wdMh[RRT"S$US&U S'U U S(U!35 M [&R"5(aH[S:aUR[[[5 [S:aUR[[[5 URR5 UROU5(a_URRURR5 URRURR5 gg![a G Nf=f))Nz2`type` to initialized an Operator can not be None.r)DEFAULT_AMP_OPTIONSz File "z", line rz, in r  zThe Op(z) is not support to set device. force_cpur0FzThe Attr(force_cpu) of Op(z) will be deprecated in the future, please use 'device_guard' instead. 'device_guard' has higher priority when they are used at the same time.pipeline_stagec2UHnXcM X!:XdM g gr(rM)var_listrrs rO find_name$Operator.__init__..find_name4 s" (H)5(:J#!)rNzInput z not foundz expects only one input, but z are given.zThe type of '%z' in operator z9 should be one of [str, bytes, Variable]. but received : z-Incorrect setting for output(s) of operator "z", should set: [z].zOutput z expects only one output, but z'attrs' should be a dict.FLAGS_print_extra_attrsrzrzop z use extra_attr: z's attr  = z is not the default value: )Trr_r _attr_typesrMrrr]r_typernrv_current_cuda_graph_mode_cuda_graph_attrpaddle.static.amp.fp16_utilsr _amp_optionsr _struct_namerrrro_op_rolerr[ _op_role_varoutput_arg_nameshas_varryrr traceback extract_stackrrzrr_current_device _has_kernelrrrr>kAutoParallelSuffixr~r dispensablerTrdre duplicabler1r\rdecoderNr)r*rV set_inputr_is_bwd_prim_enabled intermediate set_outputget_op_extra_attrsrUrrr~rrextra_op_attrsspecial_op_attrsnextitervaluesrripu_index_attr_nameripu_stage_attr_name check_attrsinfer_var_type infer_shape)"rrnrvrrrrMr#rTop_attrsrop_maker role_var_nameargcallstack_var_nameframenamescope_var_name op_devicepipeline_attr_namerin_protofoundin_args in_arg_namesrm out_protoout_args out_arg_namesextra_attrs_maprUrWa_name default_values" rOrOperator.__init__ s  !**,99$?E!D  .2ii  +$   | HJ"'RDJJIH%=D ! I,? !2 3D 66H'')9JJ&&//1134%779MDJJ&&3349!1*.***<*<*I*I'(S1H-IQ-N+499>>#$) 99557C}}S))eiin.?.?.G,0 #)8| H&.%J%J%L"/1,&446E077"58*HU1XJeE!H:N077$uQxj8IJ 7 II  t $!**,99$?E!)!>!>!@ +;+=H' ( *##D)) ( : : RVQWXUUXTY%['"!"+= ++HMM<H ++HMM2>9!-<"Ag-1== 0022VVw. }} ~~",!--1F2B166("!N# . -/"#7!2q}}}",!--1F2B166("!N#+'4"'I ~~W4 &y~~6H%h55$,:$//CMA4E(%inn%55STWX`TaSbbmn%'M'%c3//)005)00:.00)#s3348 # 1)- (II((G-"/0#55d;O#!(D11#$?@@!KKD $ I!1 +3 ' 2H**9h?("1!5!5!7Izz~~&?EL D61B9+&NO!1 +3..%y'A..y(9:MN"8::>>";SASH~- . 2 24 <$)D#}}6 ( &)$/@$G!"%* // 0 4 4T2 >$)D%)$tyy{*;%>> import paddle >>> paddle.enable_static() >>> cur_program = paddle.static.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()) Cskip_op_callstack parameter's type is error, expect bool, received {r=rr }r op_callstackTz = Var['z']rBz{name} = Vars[{value}]r|rz = block[]z = blocks cinn_launchcompilation_keyrz rrrrz{}z(inputs=r)"rTrrrr[ output_namesr input_namesinputsortedrrv attr_typerrOVARrTrVARSrrBLOCK_block_attr_idBLOCKS_blocks_attr_idsrget_serialize_compile_keyProgramparse_from_stringrrrrget_dist_op_for_program)rskip_op_callstack outputs_strrr5 inputs_strr attrs_strrr= attr_var_namearyattr_var_namesr_r4progrlinesliner`rrdist_opop_strs rOrOperator._to_readable_code s>+T22 QRVWhRiQj k 2 q#d//01A //2315 5K D--a01A S !KC))*Q..t# 2 s  q#d../0A --a013 3J 4++A./A C JC(()A--d" 1 c DOO,  q#j/*A=D T^%; ++D$7IDMM--- $ tT : ? ? A fH]O26 J!++%IDMM...15d1K"1K#a |1%1K"-33SXXn%=4 J!++%IDMM///fId&9&9$&?%@B J!++%IDMM000fId&;&;D&A%BC J!++%I&''II.--iinnT*2237y--a0**,  u"Eut8d?u"EFu  t,&E7#A NIC Oa''T! {+~ 78 66t<   -44 5 I $ -s499+Xj\I;aP    {(:,b 1EF C"J#Fs ?R."R3 c"UR5$rKrrs rOrOperator.__str__hrrNc6URR5$rKr rs rOr Operator.typemsyy~~rNc8URRU5$)z 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. )rvr;rs rOr;Operator.inputqsyyt$$rNc:URRX5 g)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)rv _rename_inputrold_namers rOr\Operator._rename_inputs 3rNc:URRX5 g)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)rv_rename_outputr]s rOraOperator._rename_outputs   4rNc6URR5$rK)rvr:rs rOr:Operator.input_namessyy$$&&rNc6URR5$rK)rvinput_arg_namesrs rOrfOperator.input_arg_namessyy((**rNc6URR5$rK)rvrrs rOrOperator.output_arg_namessyy))++rNc8URRU5$)z 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. )rvrrs rOrOperator.outputsyy%%rNc6URR5$rK)rvr9rs rOr9Operator.output_namessyy%%''rNcz[URR5HupX :XdM Us $ [S5e)Nz@Can't find op itself in it's block. It could be a bug of Paddle.)r1rnrr])rrrs rOr Operator.idxs7tzz~~.EAz/ N  rNc8URRU5$)z Whether this Operator has the attribute with name or not. Args: name(str): the attribute name. Returns: bool: True if has this attribute. rrs rOrOperator.has_attrsyy!!$''rNc:URRUS5$)z Get the type of attribute by attribute's name. Args: name(str): the attribute name. Returns: core.AttrType: the attribute type. T)rvr=rs rOr=Operator.attr_typesyy""4..rNc&URX5 g)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. Raises: ValueError: If the type of value doesn't match with desc.attr_type(name). Nr}rs rOrOperator._set_attrs t)rNc:URRU5 grKrrs rOrOperator._remove_attrrrNcf[U[5(a&URRXR5 g[U[5(aK[ U[5(a6URR XVs/sHo3RPM sn5 g[U[5(a&URRXR5 g[U[5(aRU(aK[ U[5(a6URRXVs/sHo3RPM sn5 g[U[R[R45(a*URRXR55 gURX5 gs snfs snf)z 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). N)rTrNrv set_var_attrrdr: set_vars_attrBlockset_block_attrset_blocks_attrr BlockDesc ProgramDescset_serialized_attrr_update_desc_plain_attr)rrrr4s rOr~Operator._update_desc_attrs c8 $ $ II " "4 2 T " "|C'B'B II # #D3*?3a663*? @ U # # II $ $T88 4 T " "s|C/G/G II % %dS,ASVVS,A B dnnd.>.>? @ @ II ) )$0G0G0I J  ( ( 3+@-Bs ?F) !F. c(URn[US5(aXR;aURX5 gURUnU[R R :XaURU[U55 gU[R R:XaURU[U55 gU[R R:XaURX5 gU[R R:XaURX5 gU[R R :XaUR#X5 gU[R R$:XaUR'X5 gU[R R(:XaUR+X5 gU[R R,:XaUR/X5 gU[R R0:XaUR3X5 gU[R R4:XaUR7X5 gU[R R8:XaUR;X5 gU[R R<:XaUR?X5 gU[R R@:XaURCX5 gU[R RD:XaURGX5 gURX5 g)Nr)$rvrrrrrOrP_set_scalar_attrrArQ_set_scalars_attrrHr _set_bool_attrINT_set_int32_attrLONG_set_int64_attrFLOAT_set_float32_attrFLOAT64_set_float64_attrSTRING _set_str_attrBOOLS_set_bools_attrINTS_set_int32s_attrLONGS_set_int64s_attrFLOATS_set_float32s_attrFLOAT64S_set_float64s_attrrr_set_strs_attr)rrrrvrVs rOr Operator._update_desc_plain_attrsyyt]++ 4==-- -    * 4==,, ,   + 4==-- -   + 4==.. .  " "4 - 4==00 0  " "4 - 4==// /   t ) 4==.. .   + 4==-- -  ! !$ , 4==.. .  ! !$ , 4==// /  # #D . 4==11 1  # #D . 4==00 0    * NN4 %rNc8URRS5$NTrrs rOrOperator.attr_names)syy##D))rNc8URRU5$)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. rrs rOrT Operator.attr-rrNc8URRU5$)zu Get the block attribute's id by name. Args: name(str): the attribute name. Returns: int: the block index. )rvrArs rOrAOperator._block_attr_id:syy''--rNcURU5nUS:a-U[URRR5:deURRRU$)zw Get the block attribute by name. Args: name(str): the attribute name. Returns: block: the block attribute. r)rAr[rnroblocks)rrids rO _block_attrOperator._block_attrFsX  &Qw2DJJ$6$6$=$= >>>>zz!!((,,rNc/nURU5HjnUS:a-U[URRR5:deUR URRRU5 Ml U$)z Get the blocks attribute by name. Args: name(str): the attribute name. Returns: list: list of the blocks attribute. r)rCr[rnrorr)rrrMrs rO _blocks_attrOperator._blocks_attrUso&&t,A6a#djj&8&8&?&?"@@ @@ LL++2215 6- rNc8URRU5$)z Get the blocks attribute's ids by name. Args: name(str): the attribute name. Returns: list: list of the blocks ids. )rvrCrs rOrCOperator._blocks_attr_idsfsyy))$//rNcURRUS5nU[RR:Xd SUSU35eURR US5R 5nURRU5$)z Get the Variable attribute by name. Args: name(str): the attribute name. Returns: Variable: the Variable attribute. TRequired type attr(z) is Variable, but received ) rvr=rrOr>rTrrn_var_recursive)rrr=rLs rO _var_attrOperator._var_attrss~II''d3 DMM--- !$'CI; O - tT2779 zz((77rNcDURRUS5nU[RR:Xd SUSU35eURR US5Vs/sH,nUR RUR55PM. nnU$s snf)z Get the Variables attribute by name. Args: name(str): the attribute name. Returns: Variables: the Variables attribute. Trz") is list[Variable], but received ) rvr=rrOr?rTrnrr)rrr=ry attr_varss rO _vars_attrOperator._vars_attrsII''d3 DMM... !$'I) U . yy~~dD1 1 JJ % %chhj 11    s&3Bc,URn0nUHnURRUS5nU[RR :XaUR U5X#'MRU[RR:XaURU5X#'MU[RR:XaURU5X#'MU[RR:XaURU5X#'MURU5X#'GM U$)zX Get the attribute dict. Returns: dict: The Operator's attribute dict, name->attr. T)rrvr=rrOr@rrBrr>rr?rrT)rrattr_maprur=s rO all_attrsOperator.all_attrss__ A ++At4IDMM///"..q1 dmm222"//2 dmm///"nnQ/ dmm000"ooa0 "iil rNcD[Rn[RRRnURR UR 55(dgURRUR 55nU[U5-(aggNFT) rrOpRoleOptimizervrrrTr)rrOPTIMIZEop_roles rO_is_optimize_opOperator._is_optimize_opr222299BByy!!(":":"<==))..!9!9!;< S] "rNcD[Rn[RRRnURR UR 55(dgURRUR 55nU[U5-(aggr) rrrBackwardrvrrrTr)rrBACKWARDrs rO_is_backward_opOperator._is_backward_oprrNc.URR$rrrs rOrOperator.dist_attrrrNc$XRlgrrrs rOrrrrNcXlg)zm Set auto cast attribute of this Operator. Args: amp_options (AmpOptions): AmpOptions of this Operator. Nr)r amp_optionss rOset_amp_optionsOperator.set_amp_optionss (rNcUR$)z\ Get auto cast attribute of this Operator. Returns: bool: AmpOptions of this Operator. rrs rOrOperator.amp_optionss   rNcUR$rKrrs rOrOperator.struct_names   rNcXlgrKr)rrs rOrrs'rN)rrrrrrMrnrv)NNNNT).rrrrrr*rrrrrrrrr;r\rar:rfrrr9rrr=rrr~rrrTrArrrCrrrrrrrrrrrrMrNrOrrx s.`4HLH7T95 GR(H    % 4 5''++,, &((   ( / *$40&&P** $ . -" 08"(0  ## (( (!!!!((rNrc#,# SqSv Sqg!Sqf=f7fr()#_stride_in_no_check_dy2st_diff_moderMrNrO_stride_in_no_check_dy2st_diffrs!+/'4 .3+e+s c US;agUbUR5Hup4[U[5(aCUR(a0US:XaUR SS5S:Xd[ SUSUS35eM[M][U[ 5(dMtUH[n[U[5(dMUR(dM-US:XaUR SS5S:XaMK[ SUSUS35e M gg)N>rrrvrHrz0Sorry about what's happened. In to_static mode, z's output variable z is a viewed Tensor in dygraph. This will result in inconsistent calculation behavior between dynamic and static graphs. If you are sure it is safe, you can call with paddle.base.framework._stride_in_no_check_dy2st_diff() in your safe code block.)rWrTrNrrr]rd)r+ inplace_maprkr4rys rO$check_if_to_static_diff_with_dygraphrs00 MMODA!X&&=={*#6%?$J7)Sfghfij`a@!At$$C!#x00???#{2 + >% G","RSZR[[nopnqrh!i# $rNcTUS:XaUb=[US[5(a%[USSS5(a SUSSlO[USS5(a SUSlUb>[US[5(a&[USSS5(aSUSSlgg[USS5(a SUSlggUS:XaUb=[US[5(a%[USSS5(a SUSSlO[USS5(a SUSlUb>[US[5(a&[USSS5(aSUSSlgg[USS5(a SUSlggUS:XaUb=[US [5(a%[US SS5(a SUS SlO[US S5(a SUS lUb>[US[5(a&[USSS5(aSUSSlgg[USS5(a SUSlggUS :XaUb=[US [5(a%[US SS5(a SUS SlO[US S5(a SUS lUb'USHn[US5(dMSUlM ggUS :XdUS :XaUb=[US [5(a%[US SS5(a SUS SlO[US S5(a SUS lUb>[US[5(a&[USSS5(aSUSSlgg[USS5(a SUSlggUS :XdUS:XaUb=[US [5(a%[US SS5(a SUS SlO[US S5(a SUS lUb>[US[5(a&[USSS5(aSUSSlgg[USS5(a SUSlggUS:XdUS:XaUb=[US [5(a%[US SS5(a SUS SlO[US S5(a SUS lUb>[US[5(a&[USSS5(aSUSSlgg[USS5(a SUSlggUS:XaUb=[US [5(a%[US SS5(a SUS SlO[US S5(a SUS lUb>[US[5(a&[USSS5(aSUSSlgg[USS5(a SUSlggUS:XaUb=[US[5(a%[USSS5(a SUSSlO[USS5(a SUSlUb>[US[5(a&[USSS5(aSUSSlgg[USS5(a SUSlggUS:XaUb=[US [5(a%[US SS5(a SUS SlO[US S5(a SUS lUb>[US[5(a&[USSS5(aSUSSlgg[USS5(a SUSlggUS:XaUb=[US [5(a%[US SS5(a SUS SlO[US S5(a SUS lUb>[US[5(a&[USSS5(aSUSSlgg[USS5(a SUSlggUS:XaUb=[US [5(a%[US SS5(a SUS SlO[US S5(a SUS lUb>[US[5(a&[USSS5(aSUSSlgg[USS5(a SUSlggUS:XdUS:XaUb=[US [5(a%[US SS5(a SUS SlO[US S5(a SUS lUb>[US[5(a&[USSS5(aSUSSlgg[USS5(a SUSlggUS:XaUb=[US [5(a%[US SS5(a SUS SlO[US S5(a SUS lUb>[US[5(a&[USSS5(aSUSSlgg[USS5(a SUSlggg)Nr+rHrrTr strided_slice index_selectrr unsqueeze unsqueeze2squeezesqueeze2 transposer unbinddiagonalflattenimagrealreshapereshape2as_real)rTrdrr)r+rrrs rOrecord_is_view_varrs '  *VG_d"C"Cvgq)=9915w".vg 66.2w+  :gend#C#Cwu~a(-8804q!-9wu~}55-1*6 O #  *VG_d"C"Cvgq)=9915w".vg 66.2w+  :gend#C#Cwu~a(-8804q!-9wu~}55-1*6 N "  *VC[$"?"?vc{1~}55-1s A*vc{M22*.s '  :gend#C#Cwu~a(-8804q!-9wu~}55-1*6 G   *VC[$"?"?vc{1~}55-1s A*vc{M22*.s '  u~3 ..&*CO&  K 7l#:  *VC[$"?"?vc{1~}55-1s A*vc{M22*.s '  :gend#C#Cwu~a(-8804q!-9wu~}55-1*6 I J!6  *VC[$"?"?vc{1~}55-1s A*vc{M22*.s '  :gend#C#Cwu~a(-8804q!-9wu~}55-1*6 K 7l#:  *VC[$"?"?vc{1~}55-1s A*vc{M22*.s '  :gend#C#Cwu~a(-8804q!-9wu~}55-1*6 H   *VC[$"?"?vc{1~}55-1s A*vc{M22*.s '  :gend#C#Cwu~a(-8804q!-9wu~}55-1*6 J   *VG_d"C"Cvgq)=9915w".vg 66.2w+  :gend#C#Cwu~a(-8804q!-9wu~}55-1*6 I   *VC[$"?"?vc{1~}55-1s A*vc{M22*.s '  :gend#C#Cwu~a(-8804q!-9wu~}55-1*6 F   *VC[$"?"?vc{1~}55-1s A*vc{M22*.s '  :gend#C#Cwu~a(-8804q!-9wu~}55-1*6 F   *VC[$"?"?vc{1~}55-1s A*vc{M22*.s '  :gend#C#Cwu~a(-8804q!-9wu~}55-1*6 I J!6  *VC[$"?"?vc{1~}55-1s A*vc{M22*.s '  :gend#C#Cwu~a(-8804q!-9wu~}55-1*6 I   *VC[$"?"?vc{1~}55-1s A*vc{M22*.s '  :gend#C#Cwu~a(-8804q!-9wu~}55-1*6 rNc\rSrSrSrSrSrS!SjrS"Sjr\r \ S5r \ S5r S r \ S 5r\ S 5rS rS rSrSrSrSrSrSrS!SjrSrSrSrSrS!SjrSrSrSr Sr!S!Sjr"Sr#g )#r{iat In Fluid, a Program is consistence of multi-Block, and Block stores VarDesc and OpDesc. In a specific Block, a VarDesc have a unique name. One block could have some child blocks, and child block's name scopes should inherit the parent's so that OpDesc in child block can reference a VarDesc that is stored in the parent block. Please reference the framework.proto for details. Args: program(Program): The Program that the Block belongs to. idx(int): The block's id in the Program. Notes: The constructor of Block should not be invoked directly. Please use `Program._create_block()` to create a block. Examples: .. code-block:: python >>> import paddle >>> paddle.enable_static() >>> cur_program = paddle.static.Program() >>> cur_block = cur_program.current_block() >>> var = cur_block.create_var(name="X", ... shape=[-1, 23, 48], ... dtype='float32') >>> cur_block.append_op(type="abs", ... inputs={"X": [var]}, ... outputs={"Out": [var]}) cURRU5Ul[R"5Ul/UlXlgrK)rvrn collections OrderedDictrrro)rrors rOrBlock.__init__s4LL&&s+ ++-  rNc"UR5$rKrrs rOr Block.__str__rrNc [U[5(dS[U535eSURSURSUR SUR S3 n[URR55HnUSUR5S3- nM US- nURHnUSURU5S3- nM US- nU$) a Get readable debug string of Block. .. 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 Block string. Examples: .. code-block:: python >>> import paddle >>> paddle.enable_static() >>> cur_program = paddle.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_block._to_readable_code()) r1z{ // block_idx:z parent_idx:z forward_idx:z backward_idx:rrr4) rTrrr parent_idxforward_block_idxbackward_block_idxrdrrrr)rrH block_strryrs rOrBlock._to_readable_codes >+T22 QRVWhRiQj k 2'txxj doo=Nn]a]s]s\tuDEIE\E\D]]_`  ((*+C 4 5 5 78; ;I,T ((B 4 4 45F GHK KIS rNc [U[5(a[U[5(deU(a[R"S5nSURSUR 3n[ URR55H6nUSRURSURX555- nM8 URH6nUSRURSURU555- nM8 US- nU$URR5n[R R#[%U55n['X5nU$)a^ Get debug string. Args: throw_on_error(bool): raise exception when self is not initialized when throw_on_error is True. with_details(bool): more details about variables and parameters (e.g. trainable, optimize_attr, ...) will be printed when with_details is True. Default False. Returns: str: The debug string. z\n(.)zblocks { idx: z parent_idx: z vars {{ {} }}z\n \1z ops {{ {} }}z })rTrr compilerrrdrrrsubrrrvrrr~rrr&) rr$r re_add_indentrryrrr#s rOrBlock.to_string%sA.$//J $5 5    JJx0M$TXXJ.>t>OP DII,,./4;;!%%#S]]>%P0 hh3::!%%k2<<3OP u G yy446H!++66uXGE$U;GrNc.URR$rK)rvrrs rOrBlock.parent_idxNsyyrNc6URR5$rK)rvget_forward_block_idxrs rOrBlock.forward_block_idxRsyy..00rNc:URRU5 g)zU Set the forward block Idx. Args: idx(int): the block index. Returns: None N)rv_set_forward_block_idx)rrs rOrBlock._set_forward_block_idxVs ((-rNcURnURRH!nURU:XdMURs $ gNr)rrorr)r cur_block_idxrns rOrBlock.backward_block_idxbs< \\((E&&-7yy )rNc.URR$rK)rvrrs rOr Block.idxjsyy||rNc[U[5(d[S[U5S35eURR US5nUc[ SUS35eU$)a  Get a Variable by name from this block. Args: name(str): the Variable's name. Raises: ValueError: The If input's type is not str, or this block doesn't have a Variable with the giving name. Returns: Variable: the Variable with the giving name. z)var require string as parameter, but get z instead.Nrz not in this block)rTr\rVrrrr])rrr4s rOry Block.varnsc$$$;DJ> :;$$* 3+@+@ AB KK3 !(mq "rNcTURU5nU(aU$[SUS35e)a  Get a Variable by name from this block recursively. Args: name(str): the Variable's name. Raises: ValueError: this block and this parent block doesn't have a Variable with the giving name. Returns: Variable: the Variable with the giving name. zVar z is not found recursively)rqr])rrrys rOrBlock._var_recursives1&&t, JtD6)BCD DrNc4[UR55$rK)rditer_parametersrs rOall_parametersBlock.all_parameterssD((*++rNcDSURR55$)Nc3`# UH$n[US[5(dMUSv M& g7f)rNrTri)r3r@s rOr6(Block.iter_parameters..s+ )$q'9- DG)s. .)rrWrs rOrBlock.iter_parameterss  )  rNcz[5(a [U0UD6nU$[USU0UD6nSU;a US"X05 U$)Nrn initializer)rr0rN)rrrrys rOrBlock.create_varsQ    $1&1C  777C&}%c0 rNcXR;$rK)rrs rOr Block.has_varsyy  rNc x[U[5(aUR5OUn[U[5(aUR5OUnURU5(d[ SUS35eUR U5n[ U5[:Xa?SnURnURnURnURnURn OE[ U5[:XaSnURn URnO[ S[ U535eUR n URRUR!5UR!55 URR#UR!55n US:Xal[%5(a.['U R)5U R+5U UUWWWU S9 n OB[UU R)5U R+5U UUWWWU S9 n OUS:Xa [UU UU US9n W UR,U'UR,U UR/5 U $)a Rename variable in vars and ops' inputs and outputs Args: name(str|bytes): the name that need to be renamed. new_name(str|bytes): 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. rz is not in current blockrirNzunsupported var type: )rrrr optimize_attr regularizerru)rrrur)rTrrrr]ryrrirrr)r*rurNrv _rename_varrxrwrrhr-rr_sync_with_cpp) rrrr4var_typerrr)r*ru orig_var_typedrys rOr+Block._rename_vars"!+4 7 7t{{}T!+He!? II  x0 1 { "  $GGIGGI&!"/'"/ +)  GGIGGI&!"/'"/ +)  #"%+ C" ( IIdO  rNcUSLaUR5 URRUR55 URU gr)r,rv _remove_varrxr)rrsyncs rOr2Block._remove_var's8 4<    ! dkkm, IIdOrNcpURR5nSn[5(a [U0UD6nO[ U/UQ70UD6nUR nSU;aWSnUSnU"X45n[ U5n U S:a'[SUR-S-[U5-5eU S:XaOU"X@5 XTlU$)Nr$c/nURHBnURUR;dMURS;aM1UR U5 MD U$)N) broadcastrcoalesce_tensor)rrrrr)rnryinit_opsrs rO _is_inited_by-Block.create_parameter.._is_inited_by:sR))Bxx2#6#66 77' % +$ rNrrz is inited by multiple init ops ) rorrrhrirr[rrr\) rrrrrrr:r$r9 init_ops_lens rOcreate_parameterBlock.create_parameter-s||002    "D3F3ElSnT"U5Hn[USS5SLdMSn O U(a.T"U5H!n[U[5(dMSUlM# gg)zC Set out.stop_gradient = True if all inputs stop_gradient is True. TrNF)rrTrNr)insouts need_resetryrs rOpass_stop_gradient+Block.append_op..pass_stop_gradients^" "3rr while_grad pylayer_gradrconditional_block_gradrr4)rrrrrJrrQtrace_oppaddle.base.dygraph.baser@ paddle.utilsrrvrr6r5rrrrr)rrrrr+rMrr@rEop_descrr ignore_opsr5rs @rOrBlock.append_op]sjj5 **VT*   JJw+E MMwi ))#    B   & & 8R( 9b)B ?E2  | k = , 5ii))+GZZ$/FjjD1GJ 8 ""+N+N4'("63V$k'&:  !# **Wd3 ';$ HHOOB  """7G< ';&:$$s$ G(G G G G G+cNUR5 UR"U/UQ70UD6$)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)rrrrs rO _insert_opBlock._insert_ops+ ++ECDCFCCrNcURRU5n[X US.UD6nURR X5 U$)z Insert an Operator according to the giving arguments, without sync_with_cpp to make the compilation faster. Args: index(int): the place that the operator to insert. Returns: Operator: the insert Operator. rnrv)rvrRrrr)rrrrrMrs rOrQBlock._insert_op_without_syncs>))&&u- w @ @ " rNcUSLaUR5 URRXS-5 URU g)z| Remove the specific position operator. Args: index(int): the position that the operator to insert. Returns: None TrN)r,rv _remove_opr)rrr3s rOrXBlock._remove_ops8 4<    ! UAI. HHUOrNcURX$)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)rr'r4s rO _slice_opsBlock._slice_opssxx""rNc @[5(aURSS5nURS05n[USUSSUS9n[5R UURS05URS05U(aUO0URSS55 U$UR R 5n[UUURSS5URSS5URSS5URSS5S9nURRSU5 U$) NrrMrrrrFr) rrrrQrJrv _prepend_oprr)rrrrrMrrMs rOr^Block._prepend_ops   ::fd+DJJw+EddDB   & & 8R( 9b)B ?E2  & ii++-GZZ-zz(D1 9d3jj$/ B HHOOAr " rNc dURR5HnURUR55(aM)SnUR 5(aUR 5nUR 5(acUR5(aNURUR5UUR5UR5UR5US9 MURUR5UUR5US9 M [URR55HNnURR!UR#55(aM3URR%U5 MP /n['SURR)55H-nUR+URR-U55 M/ [/UR05S:waUR0SRnUR0[/UR05S- RnSnSn['[/U55Hn XSU :XaU nXcU :XdMU nM UceUceXx::deOSnSn['US- S- SS5H.n X9n [3X 5n UR0R5SU 5 M0 ['US-[/U55H-n X9n [3X 5n UR0R+U 5 M/ US:waU[/UR05:aSn Sn U [/UR05:apU [/U5:aaUR0U RX<:waUR0U O U S- n U S- n U [/UR05:aU [/U5:aMa[/UR05[/U5:Xde['[/UR055H$n UR0U RX9:XaM$e g)zt Sync from the desc on the c++ end. This method is used to synchronize the c++ desc instance generated by backward. F)rrvrr-rr)rrvrrrrNr)rvall_varsrrhas_stop_gradientrhas_is_parameterrr=rr-rrrdrrrrwrxrKrop_sizerrr[rrr)rryis_stop_gradient ops_in_cppop_idxfirst_op_in_pythonlast_op_in_python start_index end_indexrrMrops_in_cpp_indexops_in_python_indexs rOr,Block._sync_with_cpps 99%%'C<< ++#( ((**'*'8'8':$''))c.>.>.@.@)) XXZ  XXZ!iik!iik&6 *OO XXZ  XXZ&6 $(. ()C99%%cjjl33 c"*  Atyy0023F   diill62 34 txx=A !%!!1!1  $TXX): ; @ @ KIs:/%E)::"'K$5(99 %I 0 * **( ((+ ++KIK!Oa/"b9E 'G$(B HHOOAr ": IMC O[U[R5(aUR5(dS5e[TU]U5 Xlg)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)rTrrrrrrrrrs rOrIrVarNode.__init__sD$ **t{{}} T <  rNcURR5cS5eURR5RU5 g)zG Set the node variable shape. Args: shape(list): shape to be set. N.The node variable description can not be None.)rryr{)rr-s rOr{IrVarNode.set_shapes>yy}}* < * !!%(rNcURR5cS5eURR5R5$)z If the variable node is a persistable variable, then return true. Returns: bool: indicate whether the variable is persistable. r)rryr.rs rOr.IrVarNode.persistables?yy}}* < *yy}}**,,rNcURR5cS5eURR5R5$)zR Return the variable type. Returns: core.VarDesc.VarType: the variable type. r)rryrrs rOrIrVarNode.types?yy}}* < *yy}}##%%rNcURR5cS5eURR5R5$)z\ Return the variable data type. Returns: core.VarDesc.VarType: the variable data type. r)rryrrs rOrIrVarNode.dtype?yy}}* < *yy}}$$&&rNcURR5cS5eURR5R5$)zD Return the variable shape. Returns: list: the variable shape. r)rryr-rs rOr-IrVarNode.shaperrNclURRVs/sHn[U5PM sn$s snf)zX Return the node inputs. Returns: list(IrOpNode): node inputs wrapped by IrOpNode. )rrIrOpNoders rOrIrVarNode.inputss,&*YY%5%56%5 %5666rclURRVs/sHn[U5PM sn$s snf)zZ Return the node outputs. Returns: list(IrOpNode): node outputs wrapped by IrOpNode. )rrrrs rOrIrVarNode.outputss,&*YY%6%67%6 %6777rr)rrrrrrr{r.rrr-rrrrrrs@rOrrsN  ) - & ' '7788rNrc^\rSrSrSrU4SjrSrSrSrSr Sr S r S r S r S r\S 5r\S5rSrU=r$)rizF Python IrOpNode. Beneath it is a core.Node, it inherits from IrNode. c>[U[R5(aUR5(dS5e[TU]U5 Xlg)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)rTrrrrrrrs rOrIrOpNode.__init__sD$ **tzz|| T ;  rNcURR5cS5eURR5RX5 g)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.)rrr\)rold_input_namenew_input_names rO rename_inputIrOpNode.rename_inputs>yy||~) < ) $$^DrNcURR5cS5eURR5RX5 g)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)rrra)rold_output_namenew_output_names rO rename_outputIrOpNode.rename_output!s>yy||~) < ) %%oGrNcURR5cS5eURR5RU5$)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. r)rrr;rs rOr;IrOpNode.input.sAyy||~) < )yy||~##D))rNcURR5cS5eURR5RU5$)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. r)rrrrs rOrIrOpNode.output=sAyy||~) < )yy||~$$T**rNcURR5cS5eURR5RU5$)z` Change the operator type into new type. Args: new_type(str): new operator type to be set. r)rrrz)rnew_types rOrzIrOpNode.set_typeLsAyy||~) < )yy||~&&x00rNc&URX5 g)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. Nr}rs rOset_attrIrOpNode.set_attrXs t)rNczURR5cS5eURR5n[U[5(aUR XR 5 g[U[ 5(aA[U[5(a,URXVs/sHoDR PM sn5 g[U[5(aURXR 5 g[U[ 5(aHU(aA[U[5(a,URXVs/sHoDR PM sn5 g[U[R[R45(a URXR!55 gUR#X5 gs snfs snf)zB Update the value of the op desc's attribute by attribute's name. Nr)rrrTrNryrvrdr:rzr{r|r}rr~rrrr)rrrrvr4s rOr~IrOpNode._update_desc_attrbs2yy||~) < )yy||~ c8 $ $   dHH - T " "|C'B'B   tc%:cffc%: ; U # #   hh / T " "s|C/G/G  '<1'< = dnnd.>.>? @ @  $ $T+B+B+D E NN4 %&;(=s 'F3 5F8 cURR5cS5eURR5R5$)zq Return input arguments' names of this op node. Returns: list(str): input arguments' names of this op node. r)rrrfrs rOrfIrOpNode.input_arg_namesws?yy||~) < )yy||~--//rNcURR5cS5eURR5R5$)zs Return output arguments' names of this op node. Returns: list(str): output arguments' names of this op node. r)rrrrs rOrIrOpNode.output_arg_namess?yy||~) < )yy||~..00rNclURRVs/sHn[U5PM sn$s snf)zZ Return the node inputs. Returns: list(IrVarNode): node inputs wrapped by IrVarNode. )rrrrs rOrIrOpNode.inputss,'+ii&6&67&6 ! &6777rclURRVs/sHn[U5PM sn$s snf)z\ Return the node outputs. Returns: list(IrVarNode): node outputs wrapped by IrVarNode. )rrrrs rOrIrOpNode.outputss,'+ii&7&78&7 ! &7888rr)rrrrrrrrr;rrzrr~rfrrrrrrrs@rOrrsd  E H * + 1*&* 0 18899rNrc\rSrSrSrS!SjrSrSrSrSr Sr S r S!S jr S!S jr S rS rSrSrSrSrSrSrSrSrSrSrSrSrSrS"SjrSrSrSr S r!g)#IrGraphiz 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. ch[U[R5(dS5eXlX lg)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)rTrGraphgraph _for_test)rrfor_tests rOrIrGraph.__init__s1%,, 7 , !rNc`URR5n[XR5$)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)rgs rOr IrGraph.clones% JJ   q..))rNcUR$)zX If the graph is used for testing, the function returns true. Otherwise, returns false. )rrs rOis_testIrGraph.is_tests~~rNctURR5Vs1sHn[U5iM sn$s snf)z2 Return all nodes included in the graph as a set. )rnodesrrs rO all_nodesIrGraph.all_nodess/*.)9)9);<);t );<<P,>D++- $,>PPP A A cZ[5nURR5HcnUR5(dMUR 5cM-UR 5R 5(dMRUR U5 Me UVs1sHn[U5iM sn$s snf)zG Return all persistable variable nodes included in the graph as a set. )rtrrrryr.rr)rpersistable_nodesrrs rOall_persistable_nodesIrGraph.all_persistable_nodess} EJJ$$&D HHJ*HHJ**,,!%%d+ ''88&7 ! &7888sB(cURR5Vs1sH$oR5(dM[U5iM& sn$s snf)z; Return all operator nodes included in the graph as a set. )rrrrrs rO all_op_nodesIrGraph.all_op_nodess7,0::+;+;+=N+=4+=NNNrc[URR55Vs/sH&n[URR U5US9PM( sn$s snf)z< Return all sub_graphs included in the main graph as a set. r)rrsub_graph_sizer get_sub_graph)rrrs rOall_sub_graphsIrGraph.all_sub_graphssQ4::4467 7 DJJ,,Q/( C7   s-AcH[URRU5US9$)z* Return i-th sub_graph in the main graph. r)rrr )rrrs rOr IrGraph.get_sub_graphs tzz//2XFFrNc[R"U5nURU5 URU5 UR U5 UR S5 [ URRU55$)a 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. var_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) rrrzr{r|rrrcreate_var_noderrr-r- var_dtypevar_descs rOcreate_persistable_nodeIrGraph.create_persistable_nodesd<<%(#5!9%  &33H=>>rNc[R"U5nURU5 URU5 UR U5 [ UR RU55$)az Create a variable node in the graph. The created variable node is not persistable. Args: name(str): the name of the variable node. var_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. )rrrzr{r|rrr&r's rOr&IrGraph.create_var_nodesV<<%(#5!9%33H=>>rNcH[URR55$)z create a control var )rrcreate_control_dep_varrs rOr/IrGraph.create_control_dep_var's::<==rNcJ[URRU55$)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&)rr)s rOcreate_var_node_from_desc!IrGraph.create_var_node_from_desc-s33H=>>rNc [R"5nURU5 UR5HupgUR XVU5 M UR5HLup[ U [ 5(dU /n URXV s/sHoR5PM sn 5 MN UR5HLup[ U [ 5(dU /n URXV s/sHoR5PM sn 5 MN [URRU55$s sn fs sn f)a/ Create a operator node in the graph. Args: op_type(str): the type of the operator node. attrs(dict): the attributes of the operator node. inputs(dict): the inputs of the operator node. outputs(dict): the outputs of the operator node. Returns: IrOpNode: the created operator node. ) rr.rzrWr~rTrdrrrrrcreate_op_node) rr+rMrrrMrTr` input_name var_nodesvar_node output_names rOr5IrGraph.create_op_node:s++-! ;;=KD  " "7% 8)%+\\^ !Ji..&K   YGY]]_YG &4 '.mmo "Ki..&K   iHi(mmoiH '6  11':;;H Is D6 .D; cJ[URRU55$)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. )rrr5)rrMs rOcreate_op_node_from_desc IrGraph.create_op_node_from_descYs 11':;;rNcURURR5;aPURURR5;a(URURR5;dS5eURU5 UR U5 UR U5 UR U5 URUR5UR55 g)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)rold_input_nodenew_input_nodeop_nodes rOupdate_input_linkIrGraph.update_input_linkes   4::#3#3#5 5##tzz'7'7'99  0 0 22 e   3 $$W-^,$$W-^,^002N4G4G4IJrNcURURR5;aPURURR5;a(URURR5;dS5eURU5 UR U5 UR U5 UR U5 URUR5UR55 g)a 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)rold_output_nodenew_output_noderAs rOupdate_output_linkIrGraph.update_output_link{s  DJJ$4$4$6 6$$ (8(8(::  0 0 22 i   3 $$W-o.$$W-o.o224o6J6J6LMrNctURURR5;d#SURR5S35eURURR5;d#SURR5S35eUR U5 UR U5 g)zg Connect two nodes. Args: node_in(IrNode): the input node. node_out(IrNode): the output node. znode_in(z) must be in the graph nodes.z node_out(N)rrrrrr)rnode_innode_outs rOlink_toIrGraph.link_tos||tzz//11 w||((*++H I 1}} 0 0 22  **,--J K 2 h'g&rNc[U[5(d$[U[5(a [U5nOU1nUVs1sHo"RiM nn[R "UR U5 gs snf)z Remove nodes safely since links connected to these removed nodes are also removed. Args: remove_nodes(set): the nodes prepared to be removed. N)rTrtrrrgraph_safe_remove_nodesr)r remove_nodesruoriginal_nodess rOsafe_remove_nodesIrGraph.safe_remove_nodess^,,,,11"<0 ,~ *67,Q&&,7 $$TZZ@8sA7cj[R"UR5n0nUHnUR5(dMUR 5cM-UR 5R 5H)nXB;dM UR URU5/X$'M+ UR 5R5HVnXB;a!UR URU5/X$'M)X$RUR URU55 MX M URRU5 grK) r topology_sortrrrrf_find_node_by_namerrrrresolve_hazard)r ordered_nodesr7r each_var_names rOrWIrGraph.resolve_hazards**4::6  !Dzz|| 5%)WWY%>%>%@M$5 33DKKO4 0&A &*WWY%?%?%AM$5 33DLL-P4 0"077 33DLL-P &B" !!),rNcB[R"UR5$)za Check if the graph has a circle. Returns: bool: True if the graph has a circle else False. )r has_circlerrs rOr\IrGraph.has_circlestzz**rNcB[R"UR5$)zl Count the number of unconnected graphs in this graph. Returns: int: the number of unconnected graphs. )r graph_numrrs rOr_IrGraph.graph_nums~~djj))rNc[R"UR5nUVs/sHn[U5PM sn$s snf)z Perform the topology sort operation on the graph. Notes: the `graph` can not contain a circle. Returns: list(IrNode): nodes in topology order. )rrUrr)rrXrus rOrUIrGraph.topology_sorts4**4::6 #01=aq =111s=c[R"UR5n0nUR5H-up4UVs1sHn[ U5iM snU[ U5'M/ U$s snf)zu Build an adjacency list of operations for the `graph`. Returns: dict{IrNode: set(IrNode)}: the adjacency list. )rbuild_adjacency_listrrWr)radj_listwrapped_adj_listrr4rus rOrdIrGraph.build_adjacency_lists_,,TZZ8NN$DA>?*@a6!9a*@ VAY '%+AsA&NcSn[5nU(aPUR5H+nUR5(dMURU5 M- UR U5 [ S[ UR55S35 Ub[U[5(d$[U[5(a [U5nOU1nUVs1sHoRiM nnUVs1sHoRiM nnX6- nURRS5(aURRS5 URRSU5 [RR!U5(d[R""U5 [RR%X5S-n [&R("S5n U RSU 5 U R+UR5 U"U 5 gs snfs snf) a Draw the graph. If `dot` command is installed, the drawn graph will be saved as pdf file type, otherwise dot file type is used. Args: save_path(str): the save path of drawn graph. name(str): the name of drawn graph. marked_nodes(set(IrNode)): nodes that are needed to be marked. Default value is None. remove_ctr_var(bool): If it is set True, all control variable nodes in the graph will be removed. Default value is True. c[RRU5SS-n[R"SSUSU/5nUS:wa[ S5 [ SUS35 gg) Nrz.pdfdotz-Tpdfz-oz1The dot command is needed for creating pdf files.zThe z is saved as the dot filetype.)r~pathsplitext subprocesscallprint) dot_file_path pdf_save_path exited_codes rO_convert_to_pdf%IrGraph.draw.._convert_to_pdfsfGG,,];A>GM$//mDKaIJ]O+IJK rNzTotal ops num = rN__graphviz__marked_node__z.dotgraph_viz_passgraph_viz_path)rtrrrrRror[rrTrrrhaseraser~rkexistsmakedirsrrget_passr) r save_pathr marked_nodesremove_ctr_varrsremove_ctr_varsrru viz_dot_pathviz_passs rOdraw IrGraph.draws L% **,##%%#''--  " "? 3  T%6%6%8!9 :!<=  #lC00lH55#&|#4L$0>L,89LqFFLL9/>?!vvO?'9Lzz~~9::   !<= JJNN6 Eww~~i(( KK "ww||I4v= ==!12 %|4tzz" %:?s H&Hc[R"S5n[R"5nURSU5 UR UR 5 [ RU5nU$)z 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. graph_to_program_passro)rr|r set_not_ownedrrrE_construct_from_desc)r convert_passrvros rO to_programIrGraph.to_program%sX}}%<= !""9d34::&..t4rNchSnUHnUR5U:XdMUnM Uc SUS35eU$)z2 Find a node in the giving nodes set by the name. NzCannot find the target node (z)in the giving set.r)rr node_name target_noderus rOrVIrGraph._find_node_by_name7sP Avvx9$ & +I;6I J &rNc[U[5(aURX#R5 g[U[5(aA[ U[5(a,UR X#Vs/sHoDRPM sn5 g[U[5(aURX#R5 g[U[5(aHU(aA[ U[5(a,URX#Vs/sHoDRPM sn5 g[U[R[R45(a URX#R55 gURX#5 gs snfs snf)z; Update the value of desc's attribute by attribute's name. N)rTrNryrvrdr:rzr{r|r}rr~rrrr)rrvrrr4s rOr~IrGraph._update_desc_attrDs c8 $ $   dHH - T " "|C'B'B   tc%:cffc%: ; U # #   hh / T " "s|C/G/G  '<1'< = dnnd.>.>? @ @  $ $T+B+B+D E NN4 %&;(=s +E7 9E< )rrrr)"rrrrrrrr rrrrr!r r*r&r/r2r5r<rBrGrLrRrWr\r_rUrdrrrVr~rrMrNrOrrs " * = Q 9O  G ?*?*> ?<> <K,N,'"A -*+* 2  1&f$ &rNrc\rSrSrSrSrSrSrS/Sjr\ S5r \ RS5r \ S 5r \ S 5r\ S 5r\ S0S j5rS rS1SjrS0SjrSrSrS0Sjr\ S5rSrSrS1SjrS1Sjr\S5r\S5r\ S5r\ S5r \RS5rSr!Sr"Sr#S r$S2S"jr%S#r&S$r'S%r(S&r)S'r*S2S(jr+S3S)jr,S*r-S+r.S4S,jr/S2S-jr0S.r1g!)5rEiVa 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_base_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_base_framework_default_startup_program` **and** :ref:`api_paddle_base_framework_default_main_program` **by default, a pair of them will shared the parameters. The** :ref:`api_paddle_base_framework_default_startup_program` **only run once to initialize parameters,** :ref:`api_paddle_base_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)) c[R"5Ul[US5/UlSUl[ Ul[RRRUl /Ul SUl SUlSUl/UlSUl/UlSUlSUlSUlSUlSUlSUlSUlSUlSUlSUlSUlSUlSUl[@RB"5Ul"URES5Ul#SUl$SUl%SUl&SUl'g)NrFr__auto_checkpoint_program__)(rrrvr{rcurrent_block_idxglobal_prog_seed_seedrrForward _current_role_Program__op_role_var_is_distributed _is_chief_parameters_on_pservers _endpoints _ps_endpoint_trainers_endpoints_distributed_lookup_table _enable_dgc _use_lamb_nccl_comm_num_use_hierarchical_allreduce$_hierarchical_allreduce_inter_nranks _fleet_opt_program_config _pass_applied _pipeline_opt _pass_opt_heter_pipeline_opt_appending_grad_timesrUniqueNameGeneratorrp_auto_checkpoint_name_graph_is_start_up_program_ _need_decomp_grad_var_to_varrs rOrProgram.__init__s>$$& T1~& !"% !<<CCKK %'+$ #% )-&!+0(451#!"$( &'" +>>@%)%9%9 )& "  %*" " $rNc SnURn/nUR5n[U5GHUnU[UR5S- :aUR 5 UR U5nUR/5 USnUR5GHn URURU R55(a-URURU R55n OSn U R5U R5U"U S[RRR [RRR"[RRR$/5U"U S[RRR [RRR"[RRR$/5U"U S[RRR [RRR$/5U b U R&OSU b U R(OSU b U R*OSU R-5U b U R.OSS. n [1U [25(aU R5U R6U R8U R:U R<U R>U R@U RBS .5 UR[2[DRF"U 5S .5 GMU RI5U S 'UR[J[DRF"U 5S .5 GM GMX U$) NcLUR5U;a[X5"5$grK)rr)r)rU allowed_typess rOget_var_desc_attr_or_noneAProgram._find_var_class_kwargs..get_var_desc_attr_or_nones!}}-/x355rNrrr-rr~F) rrr-rr~rurrrrt)rr)r*do_model_average need_clipis_distributedr)classrr.)&rv num_blocksrr[r _create_blockrnrrarrryrrrrr+rDENSE_TENSOR_ARRAYrurrrrtrTrirfrr)r*rrrrrLdeepcopyr.rN) rnew_descrold_desc all_new_vars block_numrnew_block_descblock_new_vars new_var_descold_varrs rO_find_var_class_kwargsProgram._find_var_class_kwargss  99 '') #Cc$++&*+""$%^^C0N    #)"-N . 7 7 9 ;;s#++L,=,=,?@@"kk#.22<3D3D3FGG"G)--/(--/6$ LL00== LL00>> LL00CC7$ LL00== LL00>> LL00CC";$# LL00== LL00CC"/6.A**t291D--%,3+>E'3'C'C'E#. 33"U,\gy11MM)0):):-4-B-B+2+>+>070H0H)0):):.5.D.D,3,@,@ #))%.&*mmF&;-9,D,D,FF=)"))%-&*mmF&;Q!: $jrNcURU5nUR5nU[U5:XdeX0RR5:Xde[ U5HFnUR UnUR R5 URR5 MH [ U5H>nUR URnURU5nURU5 M@ A[ U5H3nUR UnX$HnUSn USn XZS'U "S0U D6 M M5 [ U5HnUR UnURRU5n[ UR55H8n URU 5n [X\S9n URRU 5 M: M g)NrrrnrUrM)rrr[rvrrrclearrrn _move_fromrdrrr)rrvrrrrn block_descrrKclazzrrgrMrs rOr}Program._rebuild_from_desc,s2248 OO% C ----II002222#CKK$E JJ    IIOO $ #CS)..J!ZZ_N  ! !. 1$ #CKK$E',( *"'w -$#CKK$E-J 2 2 45$--/E8   $6$rNcUq[Ulg)a 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)rrrseeds rO global_seedProgram.global_seedQs6 % rNcUR$)aI 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. rrs rOrProgram._op_roleos!!!rNcXlgrKr)rroles rOrrs!rNcUR$)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. )rrs rOrProgram._op_role_vars!!!rNc## URn[RRnURUlSv Xlg!Xlf=f7frK)rrrrr)rtmp_rolers rO_backward_role_guardProgram._backward_role_guardsA%%0077#__ * !)  s8AAAAAc#R# URnURn[RRnUR UlUVs/sH&n[ U[5(a UROUPM( snUlSv X0lX lgs snf!X0lX lf=f7f)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.base as base >>> p, g = backward(...) >>> with program._optimized_guard([p,g]): >>> p = p - 0.001 * g N) rrrrrrrTrNr)rparam_and_gradsrtmp_varrrys rO_optimized_guardProgram._optimized_guards$%%$$0077#__' &#311CHHs :&  * !( !)  ") !) s*AB' -B7B'BB'B$$B'c#R# URnURn[RRnUR UlU(a0[ UR 5[ UR5-Ul/UlSv X0lX lg!X0lX lf=f7f)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.base as base >>> p, g = backward(...) >>> with program.lr_schedule_guard(): >>> lr = lr * decay N)rrrrrLRSchedrr)r is_with_optrrrs rO_lr_schedule_guardProgram._lr_schedule_guards,%%$$0077#^^ !$V^^!4s6??7K!KD  * !( !) ") !) sBB'B B'B$$B'c"UR5$)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. rrs rOrProgram.__str__s%%''rNc[U[5(dS[U535eSnURHnX#R U5- nUS- nM U$)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()) r1rr)rTrrrr)rrH program_strrns rOrProgram._to_readable_codesmB+T22 QRVWhRiQj k 2 [[E 223DE EK 4 K!rNc[U[5(dS[U5S35e[U[5(dS[U5S35eU(aSnURHnX4R X5- nM UR R 5n[RR[U55nUS[R"[URU5S5-S-- nUS[R"[URU5S5-S-- nU$UR R 5n[RR[U55n[Xa5nU$) 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)) zKThe type of throw_on_error parameter is wrong, expected bool, but received rzIThe type of with_details parameter is wrong, expected bool, but received rz version { z z} zop_version_map { )rTrrrrrvrrrrrtextwrapindentr&rop_version_map)rr$rrrnrr#s rOrProgram.to_stringsr@.$// YZ^_mZnYoop q /,-- WX\]iXjWkkl m - G??>HH%yy446H!--88xIE //"5==.A4  G &//"5#7#7H$  Gyy446H!--88xIE$U;GrNcUR$)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. )rvrs rO _get_descProgram._get_descWsyyrNc6URR5$rK)rv_versionrs rOrProgram._versionasyy!!##rNc<UR5 SnU(a[5n[R"UR5uUln[ URR 55Vs/sHn[X45PM snUlUR5 URSS9nGO[5nURUl URUl [R"UR5Ul[ URR 55Vs/sHn[XT5PM snUlURUl URUlURUl[!US5(aUR"Ul[!US5(aUR$Ul[!US5(aUR&Ul[!US5(aUR(Ul[!US5(aUR*UlUR5 UR-U5 UR/X5 UR1U5 UR3U5 UR4R75UlU$s snfs snf) a .. note::: 1. :code:`Program.clone()` method DOES NOT clone :ref:`api_paddle_io_DataLoader` . 2. Recommend you to use :code:`clone` before using :code:`Optimizer.minimize` . 3. This API has no effect in Dygraph Mode. Create a new Program with forward content of original one when ``for_test=True``. Create a new Program as same as the original one when ``for_test=False``. Some operators, e.g., :ref:`api_paddle_base_layers_batch_norm` , behave differently between training and testing. They have an attribute, :code:`is_test`, to control this behaviour. This method will change the :code:`is_test` attribute of them to :code:`True` when :code:`for_test=True`. * Set for_test to False when you want to clone the program for training. * Set for_test to True when you want to clone the program for testing. We will prune the backward and optimize part of the program when you use :code:`clone` after :code:`Optimizer.minimize`, but we still recommend you to use :code:`clone` before using :code:`Optimizer.minimize`. Examples: .. code-block:: python :name: code-example-1 >>> import paddle >>> import paddle.static as static >>> paddle.enable_static() >>> img = static.data(name='image', shape=[None, 784]) >>> pred = static.nn.fc(x=img, size=10, activation='relu') >>> loss = paddle.mean(pred) >>> # Here we use clone before Momentum >>> test_program = static.default_main_program().clone(for_test=True) >>> optimizer = paddle.optimizer.Momentum(learning_rate=0.01, momentum=0.9) >>> optimizer.minimize(loss) Args: for_test (bool): True if change the :code:`is_test` attribute of operators to :code:`True` and prune the backward and optimize part of the program. The default value is :code:`False` . Returns: Program: A new Program with forward content of original one when ``for_test=True``. A new Program as same as the original one when ``for_test=False`` Examples: .. note:: The Program's order maybe different after :code:`clone` and this will not affect your training or testing progress. In the following example we give you an simple method :code:`print_prog(program)` to print Program Descs inorder to make sure you have same print result after :code:`clone`: .. code-block:: python :name: code-example-2 >>> import paddle >>> def print_prog(prog): ... for name, value in sorted(prog.block(0).vars.items()): ... print(value) ... for op in prog.block(0).ops: ... print("op type is {}".format(op.type)) ... print("op inputs are {}".format(op.input_arg_names)) ... print("op outputs are {}".format(op.output_arg_names)) ... for key, value in sorted(op.all_attrs().items()): ... if key not in ['op_callstack', 'op_role_var']: ... print(" [ attrs: {}: {} ]".format(key, value)) 1. To clone a test program, the sample code is: .. code-block:: python :name: code-example-3 >>> import paddle >>> import paddle.static as static >>> import paddle.utils as utils >>> import paddle.nn.functional as F >>> paddle.enable_static() >>> def print_prog(prog): ... for name, value in sorted(prog.block(0).vars.items()): ... print(value) ... for op in prog.block(0).ops: ... print("op type is {}".format(op.type)) ... print("op inputs are {}".format(op.input_arg_names)) ... print("op outputs are {}".format(op.output_arg_names)) ... for key, value in sorted(op.all_attrs().items()): ... if key not in ['op_callstack', 'op_role_var']: ... print(" [ attrs: {}: {} ]".format(key, value)) >>> train_program = static.Program() >>> startup_program = static.Program() >>> # startup_program is used to do some parameter init work, >>> # and main program is used to hold the network >>> with static.program_guard(train_program, startup_program): ... with utils.unique_name.guard(): ... img = static.data(name='image', shape=[None, 784]) ... hidden = static.nn.fc(x=img, size=200, activation='relu') ... hidden = F.dropout(hidden, p=0.5) ... loss = F.cross_entropy( ... input=static.nn.fc(x=hidden, size=10, activation='softmax'), ... label=static.data(name='label', shape=[1], dtype='int64')) ... avg_loss = paddle.mean(loss) ... test_program = train_program.clone(for_test=True) >>> print_prog(test_program) >>> # Due to parameter sharing usage for train and test, so we need to use startup program of train >>> # instead of using test startup program, while nothing is in test's startup program >>> # In Paddle we will share weights by using the same Tensor name. In train and test program >>> # all parameters will have the same name and this can make train and test program sharing parameters, >>> # that's why we need to use startup program of train. And for startup program of test, it has nothing, >>> # since it is a new program. >>> with static.program_guard(train_program, startup_program): ... with utils.unique_name.guard(): ... sgd = paddle.optimizer.SGD(learning_rate=1e-3) ... sgd.minimize(avg_loss) 2. The clone method can be avoid if you create program for training and program for testing individually. .. code-block:: python :name: code-example-4 >>> import paddle >>> import paddle.static as static >>> import paddle.utils as utils >>> import paddle.nn.functional as F >>> paddle.enable_static() >>> def print_prog(prog): ... for name, value in sorted(prog.block(0).vars.items()): ... print(value) ... for op in prog.block(0).ops: ... print("op type is {}".format(op.type)) ... print("op inputs are {}".format(op.input_arg_names)) ... print("op outputs are {}".format(op.output_arg_names)) ... for key, value in sorted(op.all_attrs().items()): ... if key not in ['op_callstack', 'op_role_var']: ... print(" [ attrs: {}: {} ]".format(key, value)) >>> def network(): ... img = static.data(name='image', shape=[None, 784]) ... hidden = static.nn.fc(x=img, size=200, activation='relu') ... hidden = F.dropout(hidden, p=0.5) ... loss = F.cross_entropy( ... input=static.nn.fc(x=hidden, size=10, activation='softmax'), ... label=static.data(name='label', shape=[1], dtype='int64')) ... avg_loss = paddle.mean(loss) ... return avg_loss >>> train_program_2 = static.Program() >>> startup_program_2 = static.Program() >>> test_program_2 = static.Program() >>> with static.program_guard(train_program_2, startup_program_2): ... with utils.unique_name.guard(): ... avg_loss = network() ... sgd = paddle.optimizer.SGD(learning_rate=1e-3) ... sgd.minimize(avg_loss) >>> # the test startup program is not used. >>> with static.program_guard(test_program_2, startup_program_2): ... with utils.unique_name.guard(): ... avg_loss = network() >>> print_prog(test_program_2) The two code snippets above will generate and print same programs. NF) prune_read_op lr_schedulerrrrr)r,rErprune_backwardrvrrr{r_inference_optimizerrrrrrrrrrrrrr_copy_data_info_from_copy_dist_param_info_from_copy_operator_info_fromrpr)rrpruned_origin_block_id_map forward_progrrs rOr Program.clonedsb %)" "9L<@#>Al&>#L   ' ' )00u0EA A"&"8"8A jjAG%%dii0AF-24993G3G3I-JK-Ja -JKAH"00AO"00AO&*&@&@A #t^,,!%!2!2t_--"&"4"4t[))"nn t^,,!%!2!2t/00%)%:%:"     % t@ $$T* ""4( 00668G#Ls 1J%Jc#&# [U[5(a[R"U5nO9[U[5(a$[R"UR 55nUR nXlSv X lg!X lf=f7frK)rTr\rrrrrp)r new_generator old_generators rOswitch_name_generator_guard#Program.switch_name_generator_guardBsr mS ) )';;MJM  u - -';;$$&M,, , 1 #0 = sA8B;B?BBBc&UR/U5$)aj Prune operators and variables which are not needed to generate :code:`targets`. Notes: This is a very low level API. Users should not use this API directly. This API is in flux and not stable. Args: targets(list|Variable|Operator): A list of variables, operators, or variable names need to be pruned Returns: Program: A new, pruned program. )_prune_with_input)rtargetss rO_pruneProgram._pruneRs%%b'22rNcUR5 [U[5(dU/n[U[5(dU/nUH0n[U[5(aM[ S[ U5S35e [ 5n[UR5R5HupVSnURHqnUR5RU5(dM)UR5RU5R(aMYXRU5;dMoSn O U(dMURUR5nM /n UGHKn [U [ 5(Gd[U ["5(a U R$nO9[U [5(a [U 5nO[ S[ U 5S35eX;aX;aMSn UR5n [U R5H4upVXR;dMUR'5(aXb;aM2Un M6 U b4U R)U R*R,U R,/5 GMGMU R)U R*R,U R,/5 GMN [/5n [0R2"UR4[ U5U 5uU ln[7U R4R955Vs/sHn[;X5PM snU lU R5 U R?U5 U RAX5 U RCU5 U REU5 U $s snf)aA Prune operators and variables which are not needed to generate :code:`targets`. Prune operators and variables which are needed to generate feeded_var Notes: This is a very low level API. Users should not use this API directly. This API is in flux and not stable. Args: feeded_var_names(list|str): A list of variable names from where pruning start. If it is set as [], this API works just like _prune() targets(list|Variable|Operator): A list of variables, operators, or variable names need to be pruned Returns: Program: A new, pruned program. zRAll feeded_var_names of Program._prune_with_input() can only be str, but received rTFzZAll targets of Program._prune_with_input() can only be Variable or Operator, but received N)#r,rTrdr\r]rrtr1rrrfrryr.rrrrNrrrrnrrErprunervrrr{rrrrrr)rfeeded_var_namesrrygeneratable_varsrr runnable_opr targets_idxr` target_oprresrrs rOr Program._prune_with_inputcs* *D11 01 '4((iG#Cc3'' ))-c 16$5 !2!2!4!8!89GCK**((*22488$$&**40<<556FGG"'K+{#3#9#9":M:M#N : Aa**a**66D3''q6D$>>B1gYaI+3 ! #002 ()9)9:GC222--//B4E$(*I ;(&& (;(;Y]]'KL)""AGGKK#78QTi/3zz IIs+,k0 ,,.33883F3F3H-IJ-IeCm-IJ   !!$'   B &&t, $$T* Ks M=c[5n[R"UR5UlSnURR S5nU(aX4R 5:d#UR U5R5S:XaOUS- nM>X4R 5:aURSUS-5 UR5HhnUR5[RRR:XdM;URUR5R55 Mj [!URR#55HnURR U5n[!UR 55HcnUR U5n U R%S5(aU R'SS5 U R5S:XdMRU R)S5 Me M [!URR#55Vs/sHn[+X&5PM snUlUR/5 U$s snf)a6 This method will create a new program and do following adjustments on it: 1. Remove all reader variables and their creator ops if exist. 2. Remove the :code:`read_op` if exists. 3. change the :code:`is_test` attribute of operators to :code:`True`. All the :code:`Parameter` information will be lost. Args: prune_read_op(bool): remove the read ops that are added by py_reader for cpp inference library Notes: This API is a very low level API. Use :code:`Program.clone(for_test=True)` instead. Returns: Program: The new program. rTreadrr  batch_norm ReserveSpace)rErrrvrnrdrrrXrarrREADERr2rrxrrrrrr{rr,) rrr read_op_idx root_blockryrrnjrs rOrProgram._inference_optimizes*i##DII. XX^^A& #5#5#77!}}[1668FBq //11%%aq9!**,88:!5!5!?- sxx**,-AHHNN1%E5==?+XXa[;;y))%%i6779 ,$$^4 ,..33883F3F3H-IJ-IeCm-IJ   Ks!Ic P[5n[R"UR5Ul[ URR 55Vs/sHn[ X#5PM snUlUR5 SS/n[ URR 55GHsnURRU5nUR5H#nUR5 UR5 M% U(dM_[ SUR55GHnURU5nUR5[ R#5R$;aMG[R&"UR55n [ R#5R)UR55n /n UR+5Hhn Sn U R,H9nUR.U :waMUR0(aU R3U 5 Sn O U (aMWU R3U 5 Mj /nUR55Hhn Sn U R6H9nUR.U :waMUR0(aUR3U 5 Sn O U (aMWUR3U 5 Mj UHn UR9U 5 M [R:R=5nUUR?5;a[AURCU55OSnUSSSS S S /nU RE5HnURGU5 M /nUR?5Hn U(a U U;aMU RIS 5(aM*[KU 5S:aX;aURGU 5 MQSn U RLHnUR.U :waMSn O U (aMUR3U 5 M UHn URGU 5 M GM GMv U$s snf) a This method will create a new program and do following adjustments on it: 1. Remove all variable's `is_parameter` attribute if exist. 2. Remove all variable's `stop_gradient` attribute if exist. Notes: This API is a very low level API. Returns: Program: The new program. r5with_quant_attrrFTquantization_type skip_quantactivation_bits bit_lengthquantize_weight_bitsweight_quant_scale _threshold)'rErrrvrrr{rr,rnraclear_is_parameterclear_stop_gradientrdrrrr_rr rr:rrextrarr9rrrkOpWithQuantAttrNamerrrTrrrendswithr[rM)r clip_extrarrcommon_clipped_attrs_listrnryrgrr%r#remove_input_listrfind input_protoremove_output_list output_proto op_quant_namequant quant_attrsextra_attr_nameremove_attr_list attr_protos rO_remove_training_infoProgram._remove_training_infos~i##DII.-23883F3F3H-IJ-IeCm-IJ  &45F$G!sxx**,-AHHNN1%E~~'&&('')(5==?3XXf%779M$:$:$<$I$II"&"9"9"'')"D%..0==bggiH$&!NN,D D',|| &++t3$&,,-44T:# (4 4)006-&("OO-D D(- ',,4$'--.55d;# )6 4*11$7./D$$T*/33HHJ % 7/0 "' % *( (7';';'=ONN?3(>#% MMOD;.$==66$?+a/<NN40  D&+kk %??d2$# '2  4(//5#,$-DNN4(-]4.n }KsP#c[5n[R"U5Ul[ URR 55Vs/sHn[ X5PM snUlUR5 U$s snf)a .. note:: 1. All information about parameters will be lost after serialization; 2. This API has no effect in Dygraph mode. Deserialize a Program from `protobuf `_ binary string. This method always use to save and load model Args: binary_str_type (str): the binary protobuf string. Returns: Program: A deserialized Program. Examples: .. code-block:: python >>> import paddle >>> import paddle.static as static >>> paddle.enable_static() >>> startup_prog = static.Program() >>> main_prog = static.Program() >>> with static.program_guard(startup_prog, main_prog): ... x = static.data(name='X', shape=[1000, 784], dtype='float32') ... y = static.data(name='Y', shape=[784, 100], dtype='float32') ... z = paddle.matmul(x=x, y=y) ... binary_str = static.default_main_program().desc.serialize_to_string() ... prog_restored = static.default_main_program().parse_from_string(binary_str) ... print(static.default_main_program()) ... print(prog_restored) ) rErrrvrrr{rr,) binary_strrrs rOrFProgram.parse_from_stringuscH I!!*-).qvv/@/@/B)CD)CAE!K)CD Es A:c[5nXl[URR55Vs/sHn[ X5PM snUlUR 5 U$s snf)z Construct a program from program desc. Args: desc(core.ProgramDesc): The program desc for constructing. Returns: Program: A program. )rErvrrr{rr,)rvrrs rOrProgram._construct_from_descsU I).qvv/@/@/B)CD)CAE!K)CD EsA%cUR$)a The default random seed for random operators in Program. ``0`` means get the random seed from random device. .. note:: It must be set before the operators have been added. Returns: int64: Random seed in current Program Examples: .. code-block:: python >>> import paddle >>> import paddle.static as static >>> import paddle.nn.functional as F >>> paddle.enable_static() >>> prog = static.default_main_program() >>> random_seed = prog.random_seed >>> x_var = static.data(name="X", shape=[3,3], dtype="float32") >>> print(random_seed) 0 >>> ## the default random seed is 0 >>> # Here we need to set random seed before we use paddle.nn.functional.dropout >>> prog.random_seed = 1 >>> z_var = F.dropout(x_var, 0.7) >>> print(prog.random_seed) 1 >>> ## the random seed is change to 1 )rrs rO random_seedProgram.random_seedsJzzrNc6URR5$)a The number of :ref:`api_guide_Block_en` in this Program. .. note:: This API has no effect in Dygraph mode. Returns: int(Platform-dependent size): num of :ref:`api_guide_Block_en` in current Program Examples: .. code-block:: python >>> import paddle >>> import paddle.static as static >>> paddle.enable_static() >>> prog = static.default_main_program() >>> num_blocks = prog.num_blocks >>> print(num_blocks) 1 )rvrrs rOrProgram.num_blockss2yy##%%rNcj[U[5(d[S[U5S35eXlg)NzBProgram.random_seed's input seed must be an integer, but received r)rTrr]rrrs rOrFrGs8$$$TUYZ^U_T``ab  rNc"UR5$rK)rrs rOrProgram.__repr__s||~rNc URS$)a .. note:: This API has no effect in Dygraph mode. Get the first :ref:`api_guide_Block_en` of this Program. Returns: :ref:`api_guide_Block_en`: The first :ref:`api_guide_Block_en` of this Program. Examples: .. code-block:: python >>> import paddle >>> import paddle.static as static >>> paddle.enable_static() >>> prog = static.default_main_program() >>> gb_block = prog.global_block() >>> print(gb_block) rrrs rOrProgram.global_blocks0{{1~rNc URU$)a .. note:: This API has no effect in Dygraph mode. Get the :code:`index` :ref:`api_guide_Block_en` of this Program Args: index (int): The index of :ref:`api_guide_Block_en` to get Returns: :ref:`api_guide_Block_en`: The :code:`index` block Examples: .. code-block:: python >>> import paddle >>> import paddle.static as static >>> paddle.enable_static() >>> prog = static.default_main_program() >>> block_0 = prog.block(0) >>> print(block_0) rN)rrs rOrn Program.blocks2{{5!!rNc4URUR$)a3 .. note:: This API has no effect in Dygraph mode. Get the current :ref:`api_guide_Block_en` . The :code:`current` :ref:`api_guide_Block_en` is the :ref:`api_guide_Block_en` to append operators. Returns: :ref:`api_guide_Block_en`: The :code:`index` :ref:`api_guide_Block_en` Examples: .. code-block:: python >>> import paddle >>> import paddle.static as static >>> paddle.enable_static() >>> prog = static.default_main_program() >>> current_blk = prog.current_block() >>> print(current_blk) )rrrs rO current_blockProgram.current_block2s.{{41122rNNcF[UR5nUcUR5OURU5nURR UR5 X lURR[XR 55 UR5$)z Create a new block with the :code:`parent_idx` and change the current block to new block. Args: parent_idx(int): The parent block index. Returns: Block: The new block. ) r[rrSrnrv append_blockrrr{)rr new_block_idxrs rOrProgram._create_blockKsDKK( !    J'  v{{+!. 5'='=>?!!##rNcSUlg)Nr)rrs rO_roll_to_global_blockProgram._roll_to_global_blockbs !"rNcBUR5RUlg)zK Exit a code block, i.e., roll back to the parent block. Returns: None N)rSrrrs rO _rollbackProgram._rollbackes "&!3!3!5!@!@rNc[[UR5URR 55H'nURR [ X55 M) URHnUR5 M g)z Synchronize Python instance to its binding C++ object instance. If the program is modified in C++ space, this method should be invoked. Notes: This is a very low level API. Users should not invoke it directly. Returns: None N)rr[rrvrrr{r,)r block_idxrns rOr,Program._sync_with_cppms]s4;;/1E1E1GHI KK  uT5 6I[[E  "!rNc[U[5(d[S[U535eUR 5R UR 55 g)z Copy the information of parameters from other program. Notes: This is a very low level API. Users should not invoke it directly. Args: other(Program): Other program Returns: None YFunction Program._copy_param_info_from() needs to pass in a source Program, but received N)rTrErVrrrrrrps rOrrProgram._copy_param_info_from}sR%))klpqvlwkxy  11%2D2D2FGrNc([U[5(d[S[U535eURUlUR UlUR UlURUlURUlURUl g)z Copy the information of distributed information from other program. Args: other(Program): Other program Returns: None rcN) rTrErVrrrrrrrrds rOr"Program._copy_dist_param_info_froms%))klpqvlwkxy  %44','D'D$**!..).)H)H&rNc[U[5(d[S[U535eU(d3[ UR R 55Vs0sHo3U_M nn[UR5Hup4URX#n[URR55HnURUR5nUR(aSUlUR R5(aUR R!S5 UR"(dMSUlM M gs snf)a Copy the information of data variables from other program. Notes: This is a very low level API. Users should not invoke it directly. Args: other(Program): Other program pruned_origin_block_id_map(dict{int:int}): A dict which maps the block id in program self to the block id in program other. For example, {0:0, 1:1, 2:3} means block 0 in self is cloned from block 0 in other, etc. Default is None, which means default mapped, {0:0, 1:1,..., n:n}. Returns: None rcTN)rTrErVrrrvrr1rrdrrryrrrrr)rrprrrn other_blockry other_vars rOrProgram._copy_data_info_froms "%))klpqvlwkxy *#DII$8$8$:;*;1; '* "$++.HA,,'A'DEKEJJ--/0'OOCHH5 $$"&CK>>1133HH006***(,C%1/ *s EcX[U[5(d[S[U535e[ UR UR 5HZup#[ UR UR 5H1upEURUR5 URUl M3 M\ g)z~ Copy the information of Operator information from other program. Args: other(Program): Other program Returns: None z\Function Program._copy_operator_info_from() needs to pass in a source Program, but received N) rTrErVrziprrrrr)rrp dst_block src_blockdst_opsrc_ops rOr Program._copy_operator_info_froms%))nostyozn{| %( U\\$B I"%immY]]"C&&v'9'9:%+%7%7"#D%CrNc## URH.n[URR55ShvN M0 gN 7f)a0 Get all Tensors from this Program. A iterable object is returned. Returns: iterable Tensors: The Generator will yield every Tensor in this program. Examples: .. code-block:: python >>> # doctest: +SKIP("This has diff in xdoctest env") >>> import paddle >>> import paddle.static as static >>> paddle.enable_static() >>> prog = static.default_main_program() >>> img = static.data(name='img', shape=[None, 1,28,28], dtype='float32') >>> label = static.data(name='label', shape=[None,1], dtype='int64') >>> for var in prog.list_vars(): ... print(var) >>> # var img : DENSE_TENSOR.shape(-1, 1, 28, 28).dtype(float32).stop_gradient(True) >>> # var label : DENSE_TENSOR.shape(-1, 1).dtype(int64).stop_gradient(True) N)rrdrr)r each_blocks rO list_varsProgram.list_varss32++JJOO2245 5 5& 5s6AA Acn/nURH"nURUR55 M$ U$)aO Get all :ref:`api_guide_parameter_en` from this Program. A list object is returned. Returns: list[ :ref:`api_guide_parameter_en` ]: The list contains all parameters in this program. Examples: .. code-block:: python >>> # doctest: +SKIP("This has diff in xdoctest env") >>> import paddle >>> import paddle.static as static >>> paddle.enable_static() >>> program = static.default_main_program() >>> data = static.data(name='x', shape=[None, 13], dtype='float32') >>> hidden = static.nn.fc(x=data, size=10) >>> loss = paddle.mean(hidden) >>> paddle.optimizer.SGD(learning_rate=0.01).minimize(loss) >>> for param in program.all_parameters(): ... print(param) >>> # Here will print all parameters in current program, in this example, >>> # the result is like: >>> # >>> # persist trainable param fc_0.w_0 : DENSE_TENSOR.shape(13, 10).dtype(float32).stop_gradient(False) >>> # persist trainable param fc_0.b_0 : DENSE_TENSOR.shape(10,).dtype(float32).stop_gradient(False) >>> # >>> # Here print(param) will print out all the properties of a parameter, >>> # including name, type and persistable, you can access to specific >>> # property of a parameter, such as param.name, param.type )rextendr)r parametersrts rOrProgram.all_parameterss5F ++J   j779 :&rNc^^ ^ ^ SSKJn Ub7[U[R5(d[ S[ U5S35eUcU"5n[T[5(d[ S[ T5S35eSm Sm U 4Sjm U U U4S jn[X@R55n0nUHVnURUR5nUc[S URS 35eUR5XgR'MX U$) a Get parameters and persistable buffers of program as a dict. The key is the name of the parameter or the name of the buffer. The value is the tensor of this variable in the given scope. .. note:: This function MUST called after run start_up_program Args: mode(str, optional): Source of the obtained parameters and buffers. 'opt' : The return value only contains the variable in the optimizer. 'param' : The return value only contains the variable in the network, not the variable in the optimizer. 'all' : The return value contains the variable in the network and optimizer. Default: 'all' scope(Scope, optional) : If scope is None, state_dict will be set to global scope obtained through 'paddle.static.global_scope()'. Otherwise, value will be set to scope. Default: None Returns: dict: a dict contains the parameters and persistable buffers. Examples: .. code-block:: python >>> import paddle >>> import paddle.static as static >>> paddle.enable_static() >>> x = static.data(name="x", shape=[10, 10], dtype='float32') >>> y = static.nn.fc(x, 10) >>> z = static.nn.fc(y, 10) >>> place = paddle.CPUPlace() >>> exe = static.Executor(place) >>> exe.run(static.default_startup_program()) >>> prog = static.default_main_program() >>> path = "./temp/model.pdparams" >>> paddle.save(prog.state_dict(), path) rr\zD`scope` should be None or `paddle.static.Scope'` type, but received rz.Type of `mode` should be string, but received c"[U[5$rKr rys rOr(Program.state_dict..is_parameter`sc9- -rNcURR5[RRR :XdURR5[RRR :Xd@URR5[RRR:XagUR$NF) rvrrrrFEED_MINIBATCH FETCH_LISTrr.r}s rOis_persistable*Program.state_dict..is_persistablecsu 4<<#7#7#F#FF88==?dll&:&:&E&EE88==?dll&:&:&A&AA?? "rNc~>[U[5(d'URR5(dT"U5$gr)rTrirvr)ryrs rOis_belong_to_optimizer2Program.state_dict..is_belong_to_optimizerls0sI..#((2J2J2L2L%c**rNc>TS:XaT"U5$TS:XaT"U5$TS:XaT"U5=(d T"U5$[STS35e)Nroptr8z>`mode` string should be 'param', 'opt' or 'all', but received r)r])ryrrmodes rO condition%Program.state_dict..conditionqs`w#C((-c22#C(G,B3,GG TUYTZZ[\rNr_z+' in the scope. Make sure it is initialized)rar]rTrrbrVrr\filterrurwrr]rc) rrrr]rrrIryrdrrrs ` @@@rOrIProgram.state_dict%sX +  Zt{{%C%CVW[\aWbVccde  = NE$$$@d AN  . #  )^^%56 C~~chh/H -chhZ7bc$,#6#6#8Jxx rNc[U[5(d[S[U5S35eUR 5Vs0sHo3R U_M nnSU;aSOSnUR 5H\upgU(aUS:XaMXaS;aUSUnXd;aXFRXr5 M?[R"SUS US 35 M^ gs snf![a1n[R"SUS3[U5-5 SnAMSnAf[a1n[R"SUS3[U5-5 SnAMSnAff=f) a! Set parameters and persistable buffers in state_dict to program. An exception will throw if shape or dtype of the parameters is not match. .. note:: This function MUST called after run start_up_program Args: state_dict(dict): the dict store parameters and persistable buffers. The key is the name of the parameter or the name of the buffer. The value is the tensor of this variable in the given scope. scope(Scope, optional) : If scope is None, state_dict will be set to global scope obtained through 'paddle.static.global_scope()'. Otherwise, value will be set to scope. Default: None Returns: None Examples: .. code-block:: python >>> import paddle >>> import paddle.static as static >>> paddle.enable_static() >>> x = static.data(name="x", shape=[10, 10], dtype='float32') >>> y = static.nn.fc(x, 10) >>> z = static.nn.fc(y, 10) >>> place = paddle.CPUPlace() >>> exe = static.Executor(place) >>> exe.run(static.default_startup_program()) >>> prog = static.default_main_program() >>> path = "./temp/model.pdparams" >>> paddle.save(prog.state_dict(), path) >>> state_dict_load = paddle.load(path) >>> prog.set_state_dict(state_dict_load) z2Type of `state_dict` should be dict, but received rzStructuredToParameterName@@TFzSkip loading for 'z'. Nz '. Because 'z' not in the program.) rTrUrVrrurrWrvr]rrr\) rrIrry vars_dictrrr`errs rOset_state_dictProgram.set_state_dictsOT*d++DT*EUDVVWX /3nn.>?.>sXXs].> ?1Z?DU &++-KD88&CDD%&CDTJD MO--e;  (l4&@UV. @"MMM$6tfC"@3s8"KLL MMM$6tfC"@3s8"KLLMs*CC E "&D E &EE ) __op_role_varrrrrrrrrrrrrrrrprrrrrrrrrrrrrrrv)rrrrK)rprE)r8N)2rrrrrrrr}rrrrrrrrrrrrrrrr rr rr>rrFrrFrrrrnrSrrZr]r,rrrrrrurrIrrrMrNrOrErEVs,\B%HaF#%J&<"" __""""#*#*#*#*@#"*#"*H ((T?B$\|# 1# 13"jX5nm^''R $$L&&44"632$.#A# H(I*&-P8&68&PcJCrNrEct\rSrSrSr\R RR4Sjr Sr SSjr \ r Sr g) riiay Parameter is derived from Variable. A parameter is a persistable Variable, and will be updated by optimizers after each iteration. The training of a neural network is essentially the updating of its parameters. Relative to a general Variable, a Parameter has several its own member variables: Args: trainable(bool): True if the parameter need to be updated after iterations. optimize_attr(map): Parameter attributes related with optimizing. Currently, it only contains 'learning_rate'. Default: {'learning_rate': 1.0} regularizer(WeightDecayRegularizer): The Regularizer which will be applied on the parameter. Default: None do_model_average(bool): True if the model average strategy will be applied on this parameter. need_clip (bool): Whether the parameter gradient need to be clipped in optimizer. Default is True. c Uc [S5eUc [S5eUH nUS:dM [S[U535e [R"UU4SUUUS.UD6 UR SS5UlUR (+UlUR SS S 05UlUR S S5UlUR S S5Ul UR S S5Ul SUl SUl g)N)The shape of Parameter should not be None)The dtype of Parameter should not be NonerKEach dimension of shape for Parameter must be greater than 0, but received T)r.r-rrrr) learning_rate?r*rrF) r]rdrNrrrrr)r*rrrr)rrnr-rrreachs rOrParameter.__init__s  =HI I =HI IDax abfglbmano        K6!%/#ZZ/39OP!::mT: & +=t DK6# rNc"UR5$rKrrs rOrParameter.__str__rrNc[U[5(a[U[5(deU(a6[RXS5nSnUHnX5S[ X5S3- nM U$[RXS5nU$)a To debug string. Args: throw_on_error(bool): raise exception when self is not initialized when throw_on_error is True with_details(bool): more details about variables and parameters (e.g. trainable, optimize_attr, ...) will be printed when with_details is True Returns(str): The debug string. Examples: .. code-block:: python >>> import paddle >>> paddle.enable_static() >>> prog = paddle.static.default_main_program() >>> rlt = paddle.static.data("fake_data", shape=[-1,1,1], dtype='float32') >>> debug_str = prog.to_string(throw_on_error=True, with_details=False) >>> print(debug_str) T)rr)r*rrrrF)rTrrNrr)rr$rrrrUs rOrParameter.to_strings,.$//J $5 5    ((tDGO- [74+C*DBGG-((uEGrN)rrrrr)r*rrNr)rrrrrrrrr+rrrrrrMrNrOriris48\\ ! ! . . *!X(&PHrNric^\rSrSrSr\S5rU4SjrSSU4Sjjjr\ S5r Sr \S5r \ S 5r\RS 5rS rU4S jrS rSrU4Sjr\rSrU=r$)rhiBa EagerParamBase is derived from Tensor( Which is the concept in Eager-Dygraph Mode). A EagerParamBase is a persistable Tensor, and will be updated by optimizers after each iteration. The training of a neural network is essentially the updating of its EagerParamBase. Relative to a general Tensor, a EagerParamBase has several its own member variables: Args: trainable(bool): True if the EagerParamBase need to be updated after iterations. optimize_attr(map): EagerParamBase attributes related with optimizing. Currently, it only contains 'learning_rate'. Default: {'learning_rate': 1.0} regularizer(WeightDecayRegularizer): The Regularizer which will be applied on the EagerParamBase. Default: None do_model_average(bool): True if the model average strategy will be applied on this EagerParamBase. need_clip (bool): Whether the parameter gradient need to be clipped in optimizer. Default is True. c[U5S:a[US[5(dSU;aUR"U0UD6 gUR"U0UD6 g)Nrr-)r[rTrd__init_by_shape____init_by_tensor__)rrrs rOrEagerParamBase.__init__[sJ IMja$77GvUc [S5eUc [S5eUH nUS:dM [S[U535e Ub [U5nO$[RR R nURS[R"S55n[U[RR5(aUR5n[TU]=UU(a [U5O/U[RR R S5 UR#5 URSS5nU(+UlURS S S 05UlURS S5UlURS S5UlURSS5UlURSS5UlSUlSUlg)Nrrrrr_eager_param_baseTrr)rrr*rrrF)r]rdrrrrrrrgeneraterTr)r*rrrr+r,rr)r*rrr _init_func_init_op_creator)rr-rrrrrrs rOr EagerParamBase.__init_by_shape__bs =HI I =HI IDax abfglbmano  )%0ELL((--Ezz&+"6"67J"KL eTZZ.. / /KKME   DKb  LL - -    JJ{D1 !*]#ZZ/39OP!::mT: & +=t DK6$jj)95A $rNc >Uc[R"/5nURnURnUH nUS:dM [ S[ U535e [ U5nURS[R"S55n[TU]-UU(a [ U5O/U[RRRS5 UR!5 SUlU(+UlURSSS05UlURS S5UlURS S5UlURS S5UlURS S 5UlSUlSUlUR5U5 g)NrrrrTr)rrr*rrrF)rk to_tensorr-rr]rdrrrrrrrrrr+r, _is_paramrr)r*rrrrr _set_impl) rdata requires_gradrr-rrrrs rOr!EagerParamBase.__init_by_tensor__sX <##B'D  Dax abfglbmano &e,zz&+"6"67J"KL   DKb  LL - -    !..#ZZ/39OP!::mT: & +=t DK6$jj)95A $ trNc  U"URUR40UD6nURSS5nURSS5nUnUb5Ub2[RR XUS9nUR S-UlURU5 U$)N process_mesh placements)rrz.dist)r-rrrr)r*rr)r^tensorrrmeshr src_tensors rO from_tensorEagerParamBase.from_tensorsFLL&,,9&9zz.$/ZZ d3    6**j+J w.EJ  # rNcXlgrKr)robjs rO set_init_funcEagerParamBase.set_init_funcsrNc^URcS5eURUS5 SUlg)Nz8Required self._init_func is not None, but received None.rrs rO initializeEagerParamBase.initializes3* F * d#rNc$UR(+$rK)rrs rOrEagerParamBase.trainables%%%%rNct[U[5(a U(+Ulg[S[ U535e)Nz4The type of trainable MUST be bool, but the type is )rTrrr]r)rrs rOrrs5 i & &%.D FtIFWX rNcNURcS5eURX5 g)zI Call init_op_creator function to create initializer operation in block. Nz>Required self._init_op_creator is not None, but received None.)r)rrns rO_create_init_opEagerParamBase._create_init_ops0$$0 L 0 d*rNc&>S[TU]53$)a$ Convert a EagerParamBase object to a readable string. Returns(str): A readable string. Examples: .. code-block:: python >>> import paddle >>> linear = paddle.nn.Linear(3, 3) >>> print(linear.weight) >>> # doctest: +SKIP('it will be different') Parameter containing: Tensor(shape=[3, 3], dtype=float32, place=Place(cpu), stop_gradient=False, [[ 0.48948765, 0.05829060, -0.25524026], [-0.70368278, 0.52986908, -0.68742192], [-0.54217887, 0.48439729, 0.34082305]]) zParameter containing: )rr)rrs rOrEagerParamBase.__str__s&)):(;<>> import paddle >>> import copy >>> linear = paddle.nn.Linear(1, 3) >>> linear_copy = copy.deepcopy(linear) >>> print(linear.weight) >>> # doctest: +SKIP('it will be different') Parameter containing: Tensor(shape=[1, 3], dtype=float32, place=Place(cpu), stop_gradient=False, [[-0.30929261, -0.90929240, -1.07851017]]) >>> # doctest: -SKIP >>> print(linear_copy.weight) >>> # doctest: +SKIP('it will be different') Parameter containing: Tensor(shape=[1, 3], dtype=float32, place=Place(cpu), stop_gradient=False, [[-0.30929261, -0.90929240, -1.07851017]]) _deepcopyrT) rLrrrrrrhr-rrcopy_rr)rmemostate new_params rO __deepcopy__EagerParamBase.__deepcopy__s4 dmmT2 K$8$8$EEf "4::tzzCUC "RXd## %)%:%: "rNc[R"UR5n[URUR 40UD6n[ RRXX5 U$rK) rLrrrhr-rrr) tensor_copy)rdeviceblockingrrs rO_copy_toEagerParamBase._copy_to(sG dmm,"4::tzzCUC  tArNc>US:Xa7[US5(a&URb[SURS35e[TU]X5 g)Ncolorz Parameter 'zm' already has a 'color' attribute (used for distributed sharding parallel grouping) and cannot be reassigned.)rrAttributeErrorrrr)rrr`rs rOrEagerParamBase.__setattr__.sR GOg&& & dii[),-  D(rN) rrrrrrr)r*rr)rzpaddle.Tensor | Nonerr)rrrrr dygraph_onlyrrrrdrrrrrrrrrrrrrrrs@rOrhrhBs055 -%b&*"&"&&&P(&&+=*!F )HrNrhc[$)a Get default/global startup program. The :code:`paddle.nn` function will append the initialization operators into startup program. The :code:`startup_program` will initialize the parameters by the OPs. This method will return the default or the current startup program. Users can use :ref:`api_paddle_base_framework_program_guard` to switch :ref:`api_paddle_base_framework_Program` . Returns: Program: current default startup program. Returns type: Examples: .. code-block:: python >>> import paddle >>> paddle.enable_static() >>> x = paddle.static.data(name="x", shape=[-1, 784], dtype='float32') >>> out = paddle.static.nn.fc(name="fc", x=x, size=10, activation="relu") >>> print("main program is: {}".format(paddle.static.default_main_program())) >>> print("start up program is: {}".format(paddle.static.default_startup_program())) _startup_program_rMrNrOdefault_startup_programrCs 4 rNc[$)a This API can be used to get ``default main program`` which store the descriptions of Ops and tensors. For example ``z = paddle.add(x, y)`` will create a new ``add`` Op and a new ``z`` tensor, and they will be recorded in ``default main program`` . The ``default main program`` is the default value for ``Program`` parameter in a lot of APIs. For example, the :code:`Executor.run()` will execute the :code:`default_main_program` when the program is not specified. If you want to switch the ``default main program``, you can use :ref:`api_paddle_base_framework_program_guard` . Returns: Program: A ``Program`` which holding the descriptions of OPs and tensors in the network. Examples: .. code-block:: python >>> import paddle >>> paddle.enable_static() >>> # Sample Network: >>> x = paddle.static.data(name='x', shape=[100, 100], dtype='float32') >>> y = paddle.static.data(name='y', shape=[100, 100], dtype='float32') >>> out = paddle.add(x, y) >>> # print the number of blocks in the program, 1 in this case >>> print(paddle.static.default_main_program().num_blocks) 1 >>> # print the default_main_program >>> print(paddle.static.default_main_program()) _main_program_rMrNrOrr`s D rNc[nUqU$)z Switch the main program to a new program. Args: program(Program): The new main program Returns: Program: The previous main program rro prev_programs rOswitch_main_programrs"LN rNc[nUqU$)z Switch the startup program to a new program Args: program(Program): The new startup program Returns: Program: The previous startup program rrs rOswitch_startup_programrs%L rNc## SSKJn U"US[S5 [U5nUb!U"US[S5 SUl[ U5nSv [U5 Ub [ U5 gg![U5 Ub [ U5 ff=f7f)a :api_attr: Static Graph Change the global main program and startup program with ``with`` statement. Layer functions in the Python ``with`` block will append operators and Tensors to the new main programs. Args: main_program(Program): New main program inside ``with`` statement. startup_program(Program, optional): New startup program inside ``with`` statement. :code:`None` means not changing startup program, default_startup_program is still used. Default: None. Examples: .. code-block:: python :name: code-example-1 >>> import paddle >>> paddle.enable_static() >>> main_program = paddle.static.Program() >>> startup_program = paddle.static.Program() >>> with paddle.static.program_guard(main_program, startup_program): ... data = paddle.static.data(name='image', shape=[None, 784, 784], dtype='float32') ... hidden = paddle.static.nn.fc(x=data, size=10, activation='relu') Notes: The temporary :code:`Program` can be used if the user does not need to construct either of startup program or main program. Examples: .. code-block:: python :name: code-example-2 >>> import paddle >>> paddle.enable_static() >>> main_program = paddle.static.Program() >>> # does not care about startup program. Just pass a temporary value. >>> with paddle.static.program_guard(main_program, paddle.static.Program()): ... data = paddle.static.data(name='image', shape=[None, 784, 784], dtype='float32') r) check_typer~zpaddle.static.program_guardNrT) data_feederrrErrr)r~rrs rO program_guardrs^(ng/L'|4L"    )  15-0A4 L)  & "? 3 ' L)  & "? 3 'sABA' B'BBcUc [5n[U[5(de[U[5(deUR 5R U5$)z Get a variable by name from the global block of a program. Args: name(str): name of the variable program(Program|None): program object. If None, default_global_program() will be used. Returns: Variable )rrTr\rErry)rros rO_get_varrsQ&( dC  gw ' '' '    ! % %d ++rNc## SSKJn SSKJn U"5(a[ U"5S9 Sv SSS5 gSv g!,(df  g=f7f)Nr)Tracerr4)tracer)dygraphrr6r5_dygraph_guard)rr5s rOdygraph_guard_if_declarativers6/ 68 , - , - ,s'A <A  A A c## [RnU[lSv U[lg!U[lf=f7frKr)r tmp_tracers rOrr s0,,J"(J1 &0 #j #s?/ ? <?c## [nUq[U5 Sv Uq[[5 g!Uq[[5 f=f7frKrn)rk tmp_places rO_dygraph_place_guardr sD(I#&u-D "+*+BC#,*+BCsA-AAAc[nUqU$rK)r)r pre_devices rO switch_devicer% s JO rNc#T# SnU(a*SU;a$URS5upUS:Xa [S5eUS;a'U[R"5;a[SU35eU(aSR X/5n[ U5nSv [ U5 g![ U5 f=f7f)ab Note: The API only supports static graph mode. A context manager that specifies the device on which the OP will be placed. Args: device(str|None): Specify the device to use in the context. It should be ``cpu``, ``gpu`` or ``gpu:x``, where ``x`` is the index of the GPUs. When it is set to 'cpu' or 'gpu', all OPs created in the context will be placed on CPUPlace or CUDAPlace. When 'gpu' is set and the program runs on single-card, the device index will be the same as the device on which the executor runs. Default: None, OPs in this context will be automatically assigned devices. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> paddle.device.set_device('gpu') >>> paddle.enable_static() >>> support_gpu = paddle.is_compiled_with_cuda() >>> place = paddle.CPUPlace() >>> if support_gpu: ... place = paddle.CUDAPlace(0) # type: ignore >>> # if GPU is supported, the three OPs below will be automatically assigned to CUDAPlace(0) >>> data1 = paddle.full(shape=[1, 3, 8, 8], fill_value=0.5, dtype='float32') >>> data2 = paddle.full(shape=[1, 3, 64], fill_value=0.5, dtype='float32') >>> shape = paddle.shape(data2) >>> with paddle.static.device_guard("cpu"): ... # Ops created here will be placed on CPUPlace ... shape = paddle.slice(shape, axes=[0], starts=[0], ends=[4]) >>> with paddle.static.device_guard('gpu'): ... # if GPU is supported, OPs created here will be placed on CUDAPlace(0), otherwise on CPUPlace ... out = paddle.reshape(data1, shape=shape) >>> exe = paddle.static.Executor(place) >>> exe.run(paddle.static.default_startup_program()) >>> result = exe.run(fetch_list=[out]) N:cpuz!Should not set device id for cpu.)rgpudcuxpurNzThe Attr(device) should be 'cpu', 'xpu', 'dcu', 'gpu' or custom device, and it can also be empty string or None when there is no need to specify device. But received )rr]rr^rr)rrrs rO device_guardr, s` E #- S)  U?@A A<< $99; ; EEKH N   6/*v&J" j! j!sBB(B B( B%%B(cUcU$[U[R5(aU$[U[5(d[ SU35eUR 5nUR S5(aURSS5nUS:Xa[R"5$US:Xa[R"5$[R"SU5nUS:XdUS:Xd US:XdU(a[R"5(d[ S UR5S 35eUS:Xa[R"5$US:XdUS:Xa[R"S 5$URS S 5nUS n[!U5n[R"U5$[R"SU5nU(d US:XdUS:Xa[R""5(d[ S UR5S35eUS:Xa[R$"S 5$US:Xa[R&"5$URS S 5nUS n[!U5n[R$"U5$[R"SU5nU(ao[R("5(d[ S UR5S35eURS S 5nUS n[!U5n[R*"U5$URS S 5nUS nU[R,"5;aL[/U5S :Xa[R0"US 5$US n[!U5n[R0"Xc5$[ SUS35e)z5 Convert given place to standard paddle Place object z>place only support string which is 'Place' and so on, but got cudarrrzgpu:\d+ gpu_pinnedrzThe device should not be z., since PaddlePaddle is not compiled with CUDArrrzxpu:\d+r xpu_pinnedz-, since PaddlePaddle is not compiled with XPUzipu:\d+z-, since PaddlePaddle is not compiled with IPUzwPaddle supports CPUPlace, CUDAPlace, CUDAPinnedPlace, XPUPlace, XPUPinnedPlace, IPUPlace and CustomPlace, but received r)rTrrTr\r]rrYreplacerYr r rUrrrWrrrZr\rrIPUPlacer^r[r`)rkavailable_gpu_placeplace_info_list device_idavailable_xpu_placeavailable_ipu_placers rO_get_paddle_placerr sF } %$$ eS ! !LUG T   KKME  fe, ~}} zz|((:u5  E> E> ))+++,?,E,E,G+HI))  L '') ) e^u~>>!$ $#kk#q1O'*III>>), ,((:u5eun0E((**+,?,E,E,G+HI((  E>==# # l "&&( (#kk#q1O'*III==+ +((:u5((**+,?,E,E,G+HI((  ++c1-#A&  N }}Y''kk#q)O!!$Kd5577  1 $##K3 3'*III##K; ;  BCHBIIJ K rNc[U[[45(d [S5e/nUHn[ U5nUR U5 M! U$)Nzplaces must to be List or Tuple)rTrdrerVrr)placesretrs rO_get_paddle_place_listr sJ ftUm , ,9:: C  a  1  JrNclU[R:XagU[R:XagU[R:XagU[R:XagU[ R RR:XagU[ R RR:Xag[SUS35e) Nfp16bf16fp32fp64rrz)got unsupported data type for promotion: r) rkrrrrrrrrrrV)in_dtypes rO dtype_to_strr s6>>! V__ $ V^^ # V^^ # T\\))33 3 T\\))44 4CH:QOPPrNc URS5nURS-[U5-nURUUSURS9nUR S5(d-[ [RRR5OURS5nURUSSU0SU0URURUUS .S 9 URRURUR5 g) Nrz.cast_F)rrr.rrcastrr)r out_dtyperrr)rTrrrrrrrrrrrQrrvr\) rrnrrr r cast_nameout_varrs rOadd_cast_for_type_promotionr# s $I (< +BBI ,, G{{9%% D + + 2 2 : :; WWY   !! X   "  " GG(--6rNcUS;agURS:wagURRURS5S5RnURRURS5S5RnU[ R :Xa%U[ R[ R4;agg)N)GPUXPUFrrrr T) rrnrqr;rrkrrr)rr input_x_dtype input_y_dtypes rOcan_skip_promoter) !s ^# ww##HH00#q1ABHHMHH00#q1ABHHM&&..&//:: rNc Sn[R"5(a*[[5[R5(aSnOC[R "5(a)[[5[R 5(aSnUnUc [5n[U[5(dU$UR5nUR5nURGHnURnSnU[U5:dM#XgnSn /n /n [RUR S5n U b[#X5(aUS- nMU[%[UR&55Hln UR(U U ;dMUR&U nU R+UR,R/U5R05 U R+U5 Mn [U 5S:Xa[R2"UR /U Q76(ak[R4"UR /U Q76nU HDnUR,R/U5n U R0U:wdM0[7UUUU U5 US- nMF US- nU[U5:aGMGM U$)Nr%r&rrr )rrUrTrgrWrZr\rrErrrrr[#SUPPORT_PROMOTION_OPS_AND_INPUTNAMErrr)rrfr:rrnrrneed_type_promotion_old_irget_promote_dtype_old_irr#)ror org_programr all_paramsrnrrrr all_dtypesall_input_name_need_castneed_transed_var_names input_idxinput_arg_name common_dtypeinput_name_need_casts rOprocess_type_promotionr7!sT F !!## !4>>)) " " $ $!4==**K&( gw ' ''')L,,.JiiCHnBHJ') $%H%L%L& "&-1A"1M1Mq#3r'9'9#:; >>),0FF%'%7%7 %BN%%//?EE-33NC <:!#(G(G)$)) $<<GG (  -E(!xx667KLH~~53!$( q-E 1HCUCHnn \ NrNc#^# SnSnU4SjmUR5n[RR5(a"U"U5(aUS:wdS5eU"U5 Sv [RR5(aU"U5(a/SQnT"XAU5 ggg![RR5(aU"U5(a/SQnT"XAU5 fff=f7f)Nc:[SUR55$)Nc3<# UHoRSLv M g7frK)r)r3rs rOr6?auto_complete_op_role..is_dist_block..a!s@i<.is_dist_block`!s@eii@@@rNcURH0nURS:XdM[SUR5S35e g)Nrz?All ops' op_role should be set before the completion. However, z's op_role is -1)rrr]r)rnrs rOvalidate_op_roles0auto_complete_op_role..validate_op_rolesc!sA))BzzR UVXV]V]V_U``pqrNc>URH|nUR5U;aUO,[[RR R 5nURS:XaXClUR5H nT"XQU5 M M~ gr ) rrrrrrrrr)rnralways_forward_opsr set_op_role sub_block set_op_roless rOrE+auto_complete_op_role..set_op_rolesj!st))B779$6688??GGH  zzR( YY[ Y1CD)rNrz)Can't set op_role to -1 for new added ops)z pd_op.datazbuiltin.parameterzcf.stack_createz cf.tuple_push)rrk frameworkr)rorr<r?rnrBrEs @rOauto_complete_op_rolerH^!sAE"  "E ##%%-*>*>"}III}%  =    ' ' ) )mE.B.B"  ); </C )6   ' ' ) )mE.B.B"  ); </C )s A"C.&B**AC.*AC++C.c## [RR5(a+[R"5n[R "U5 Sv [RR5(a[R "W5 gg![RR5(a[R "W5 ff=f7frK)rkrGrr get_op_rolerC)roriginal_op_ropes rOpir_op_role_guardrL!s ##%%??,  .    ' ' ) ) OO, - *6   ' ' ) ) OO, - *ACB;C>Cc#2# [U[[45(d![S[ U5R 35e[ RRRU5 Sv [U[5(a*[ RRRS5 g[U[5(a>[ RRR[RUS55 gg![U[5(a*[ RRRS5 f[U[5(a>[ RRR[RUS55 ff=f7f)Nz4The input of vlog_guard must be int or dict but got r) rTrrUrVrrrkr[rset_vlog_levelfromkeys) module_levelss rO vlog_guardrd!s mc4[ 1 1B4 CVC_C_B` a   KK##M2M  mS ) ) KK   + +A .  t , , KK   + +DMM-,K L- mS ) ) KK   + +A .  t , , KK   + +DMM-,K L-s A&F)D-BFBFF)r^dict[str, bool | str | float]rNone)r^zstr | Sequence[str]rre)rr)rr)rrrrrGenerator[None, None, None])..)rrrrrrrr)rpaddle.nn.LayerrrrrrrhrK)rr\r str | Nonerrfr)rrf)rSequence[int] | Nonerzlist[core.CUDAPlace])rrjrzlist[core.XPUPlace])rb int | Nonerzlist[core.CPUPlace])rbrkrzlist[core.CUDAPinnedPlace])rbrkrzlist[core.XPUPinnedPlace])rarirrg)rznp.dtype | strrzcore.VarDesc.VarType)rz5np.dtype | str | core.VarDesc.VarType | core.DataTyperz$core.VarDesc.VarType | core.DataTyper)rrE)rorErrE)r~rErzProgram | Nonerrg)rrirrg)rint - 1rrg)rQrlrrg)rWr\rrg)r^rrrg)rcz int | dictrrg) __future__rrrLrMrsr~r rmrur threadingrrcollections.abcr contextlibrtypesrrtypingrr r r rrtyping_extensionsr rkrrrr libpaddlerr#rrvariable_indexrrwrapped_decoratorrrrrrrrr__all__ kEmptyVarNameEMPTY_VAR_NAME kTempVarName TEMP_VAR_NAMEkGradVarSuffixrkZeroVarSuffixZERO_VAR_SUFFIXkControlDepVarNamerglobalsrLr+ stride_opsrPrbrirolocalrqr}rrSrrr>rrr r r rrFLOAT16rUINT16rBFLOAT16FLOAT32rrrr r rr r rr FLOAT8_E4M3FNr FLOAT8_E5M2rrrrrrrrrrrrrrrr"r*r0r8r<r?rErOdygraph_not_supportr static_onlyrrrQrergrlroryrXr]rarZrrrUrrrrrrrrrrrrrrrrrrrrr r&r+r0r:rArHrJrXrrZrfrNrrrrrrr{rrrrrrErir)r*rhrrrrrrrrrrrrrrrrrr#r)r7rHrLrSrYr_rdrMrNrOrsW #   $%*==' =L I 37 ##%!!# %%'%%'002''Sz''S#J''Sz''S#J '' Sz '' S#J ''Sz''S#J''S#J'' #s''Sz''S#J'' c3Z''3*'' c3Z'' #s!''"#s#''$3*%''&S#J'''(c3Z)''*C:+'',3*-''.C:/''0c 1''2c3Z3''4c 5''6c3Z7''8Sz9'':S#J;''<Sz=''>S#J?''@SzA''BS#JC''D3*E''FSzsD\,M''#R ,<+\11)" )"X  &+# ~ ~ ~ ~   ~   ~  ~ ~fb\N62,FB<.fb\Nvrl^ vrl^62,  lE " #!" lE " ##$5 ! "$e,-'( %() %()!5)*!5)* %()3:m-.12]X'(./|m  MM4<<'',, dll**// OOT\\)).. t||++00 dll**// dll**// MM4<<'',, NNDLL((.. NNDLL((.. NNDLL((.. NNDLL((..  ,,66 --88 DLL00;; $,,..77&3B>2$O8 ! < H!!"$3* 3*3* 3*3*l HK#'#03#BE## #  ?B'*9<  :zod  "    "  $  "  & ""%%:;n- ]+ $%:; !23'0#f& < .  '"4 ( ( . ("(,/=$/=/=d$