ΑiwXSSKJr SSKrSSKrSSKrSSKrSSKJrJrJ r J r J r SSK J r SSKrSSKJrJr SSKJq SSKJr SSKJr SS KJr S S KJr S S KJrJrJr S SKJ r \(a,SSK!J"r" SSK#J$r$J%r% SSK&J'r' SSK(J)r) SSK J*r* SSKJ+r+ SSK,J-r- /r.\ "S5r/\ "S5r0Sr1S6Sjr2S6Sjr3\2r4Sr5S7Sjr6\"\65r7\S8S9Sjj5r8\S:Sj5r9S r:S6S!jr;S;SS$jj5r>\ S?S@S%jj5r?\ S7S&j5r?\"SS'/05S;S(j5r?"S)S*5r@S6S+jrASAS,jrB"S-S.\@5rC"S/S0\@5rD"S1S2\@5rE\S;SBS3jj5rF\RSCSS4.SDS5jjj5rHg)E) annotationsN) TYPE_CHECKINGAnyCallableTypeVaroverload) ParamSpec)core framework) global_var)CleanupFuncRegistrar)ParamAliasDecorator)check_and_create_dir)_get_paddle_place)copy_signaturesignature_safe_contextmanagerwrap_decorator)Tracer) OrderedDict) GeneratorSequence)AbstractContextManager) TracebackType)Self)Tensor) PlaceLike_InputT_RetT__non_persistablec"[R$)zM Return a bool value that indicates whether running code under `@to_static` r _in_to_static_mode_X/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/paddle/base/dygraph/base.pyin_to_static_moder(As  ) ))r&cg)a Returns whether the code is running under the SOT simulation context. NOTE: Always returns False because if this function is called directly from native Python, it is not within the SOT simulation process. In that case, returning False is correct. If the code is running within the SOT simulation process, the function will be represented by UserDefinedFunctionVariable, which is specially handled in its `call_function` method to return True when this function is called. This design avoids introducing `global_var` into the guard logic. Fr%r%r&r'in_sot_simulation_moder*Is r&c|[XU5H,upEnXV:wdM [R"US3US3-5 M. g)z Warning if inputs do not elementwisely equals to support_values. It's a utility function for dy2static when dygraph interface have more inputs than static interface such as paddle.grad. z# has unsupported parameter in jit: z, jit will discard itN)zipwarningswarn) func_name input_namesinputssupport_valuesnameinpsups r'&to_static_unsupported_argument_warningr6\sFk>B3 : MM+@AF/01 Cr&funcc^SU4SjjnU$)Ncv>[R"S5 T"U0UD6sSSS5 $!,(df  g=fN)r _dygraph_guardargskwargsr7s r'__impl__*_switch_to_static_graph_..__impl__ps*  % %d +((, + +s* 8r=z _InputT.argsr>z_InputT.kwargsreturnr r%r7r?s` r'_switch_to_static_graph_rDms) Or&c## [RnU[lSv U[lg!U[lf=f7fr:r#) is_to_static original_vals r'to_static_mode_guardrHzs2 11L%1J"6 )5 & &s?/ ? <?c## [5(a[R"5(dU(aUR5nUR 5HEup#[ U[ 5(aUVs/sHn[U5PM nnO [U5nXPU'MG Sv URU5 gSv gs snf!URW5 f=f7fr:) r(paddlein_dynamic_modecopyitems isinstancelist_convert_into_variableupdate) parametersorigin_parametersr3var_basevarnew_vars r' param_guardrWs 6#9#9#;#;  1 * 1 ","2"2"4h--FNOhs5c:hGOG4X>G#*4 #5    / 0 P   / 0s.1C>B=2B8B=!C8B==CCc[RR5(a)[RRR U5$[ U[R5(aURRUR5nUb"[ U[R5(deOW[ U[R5(aURSS9nO(Sn[UR;aSnURSUS9nURSLaDSSKJn UR%5R&R)URR*U5 U$U$)z Convert Tensor into Variable. T) to_parameterF)rY persistabler)ProgramTranslator)rJr use_pir_apipirr _convert_into_valuerNrblock_find_var_recursiver3VariableEagerParamBase_to_static_varNON_PERSISTABLE_VAR_NAME_SUFFIXrZ'paddle.jit.dy2static.program_translatorr[ get_instance_params_recorderaddprogram)tensorrVis_persistabler[s r'rPrPs###%%zz226::&&--((,,226;;?  gy'9'9:: ::  8 8 9 9+++>G"N/&++=!&++",G   $ &   * * , = = A A $$f  r&c,[R"5$)a This function checks whether the program runs in dynamic graph mode or not. You can enable dynamic graph mode with :ref:`api_paddle_disable_static` api, or disable dynamic graph mode with :ref:`api_paddle_enable_static` . **Note**: ``base.dygraph.enabled`` is the alias of ``base.in_dygraph_mode``, and ``base.in_dygraph_mode`` is recommended to use for now. Returns: bool: Whether the program is running in dynamic graph mode. Examples: .. code-block:: python >>> import paddle.base as base >>> base.enable_dygraph() # Now we are in dygragh mode >>> print(base.dygraph.enabled()) True >>> base.disable_dygraph() >>> print(base.dygraph.enabled()) False )r in_dygraph_moder%r&r'enabledrns4  $ $ &&r&c[RcT[[U5S9[l[RR 5 [ R "[5 gg)aT .. note:: Dynamic graph mode is turn ON by default since paddle 2.0.0 This API turn OFF static graph mode. You can turn ON static graph mode by `enable_static <./disable_dygraph_en.html>`_ . Parameters: place(paddle.CPUPlace|paddle.CUDAPlace|str, optional): Place to run dynamic graph. Default: None. Which means that the running place will be determined according to the way of paddle compilation. If ``place`` is string, It can be ``cpu``, and ``gpu:x``, where ``x`` is the index of the GPUs. return: None Examples: .. code-block:: python >>> import paddle >>> print(paddle.in_dynamic_mode()) True >>> paddle.enable_static() >>> print(paddle.in_dynamic_mode()) False >>> paddle.disable_static() >>> print(paddle.in_dynamic_mode()) True Nplace)r #_functional_dygraph_context_managerguardr __enter__r registerdisable_dygraphrps r'enable_dygraphrwsOB55=9>#E*: 6 66@@B %%o6>r&c[Rb<[RR"[R"56 S[lgg)a .. note:: Dynamic graph mode is turn ON by default since paddle 2.0.0 This API turn ON static graph mode. You can turn ON static graph mode by `disable_static <./enable_dygraph_en.html>`_ . return: None Examples: .. code-block:: python >>> import paddle >>> print(paddle.in_dynamic_mode()) True >>> paddle.enable_static() >>> print(paddle.in_dynamic_mode()) False >>> paddle.disable_static() >>> print(paddle.in_dynamic_mode()) True N)r rr__exit__sysexc_infor%r&r'rvrvs8855A66??P9= 6Br&c## [R"5n[R"U5 Sv [R"U5 g![R"U5 f=f7fr:)r _has_grad _set_has_grad)is_trainhas_grads r'_switch_tracer_mode_guard_r4sE~~Hx %  8$8$s,A%A A% A""A%cgr:r%r7s r'no_gradr@s9>> import numpy as np >>> import paddle.base as base >>> # use as generator >>> data = np.array([[2, 3], [4, 5]]).astype('float32') >>> with base.dygraph.guard(): ... l0 = paddle.nn.Linear(2, 2) # l0.weight.gradient() is None ... l1 = paddle.nn.Linear(2, 2) ... with base.dygraph.no_grad(): ... # l1.weight.stop_gradient is False ... tmp = l1.weight * 2 # tmp.stop_gradient is True ... x = base.dygraph.to_variable(data) ... y = l0(x) + tmp ... o = l1(y) ... o.backward() ... print(tmp.gradient() is None) ... print(l0.weight.gradient() is None) True False >>> @base.dygraph.no_grad >>> def test_layer(): ... with base.dygraph.guard(): ... inp = np.ones([3, 1024], dtype='float32') ... t = base.dygraph.base.to_variable(inp) ... linear1 = paddle.nn.Linear(1024, 4, bias_attr=False) ... linear2 = paddle.nn.Linear(4, 4) ... ret = linear1(t) ... dy_ret = linear2(ret) ... >>> test_layer() Frc\>[SS9 T"U0UD6sSSS5 $!,(df  g=f)NFr)rr<s r'r?no_grad..__impl__s& ,U;T,V,<;;s +rA)r functoolswrapsrrCs` r'rrHs^f |)599   - -$ - -  - tX&r&c\\rSrSrSrSrS SjrS SjrS SjrS Sjr Sr g )_DecoratorContextManageriz1Allow a context manager to be used as a decorator__decorated_by__c^^[R"T5UU4Sj5n[R"T5UU4Sj5n[R"T5(aUnOUn[ TU5 [ U[ RT5 U$)NcN>T T"U0UD6sSSS5 $!,(df  g=fr:r%)r=r>r7selfs r'_decorate_function=_DecoratorContextManager.__call__.._decorate_functionsT,V,s $c?n># T"U0UD6nT UShvN SSS5 gN !,(df  g=f7fr:r%)r=r>genr7rs r'_decorate_generator>_DecoratorContextManager.__call__.._decorate_generators0''Cs 5$"$ 5$ 25)rrinspectisgeneratorfunctionrsetattrrDECORATED_BY_MARKER_ATTR)rr7rr decorated_fns`` r'__call__!_DecoratorContextManager.__call__s   -  -       & &t , ,.L-Lt\*  $ = =  r&c[er:NotImplementedErrorrs r'rt"_DecoratorContextManager.__enter__s!!r&c[er:r)rexc_type exc_value tracebacks r'ry!_DecoratorContextManager.__exit__s "!r&c"UR5$r:) __class__rs r'clone_DecoratorContextManager.clones~~r&r%Nr7Callable[_InputT, _RetT]rBr)rBr)rztype[BaseException] | NonerzBaseException | NonerzTracebackType | NonerBboolrBr) __name__ __module__ __qualname____firstlineno____doc__rrrtryr__static_attributes__r%r&r'rrsU;1, !8"","("( "  " r&rc,[R"5$)a  Returns whether current gradient calculation mode is enabled. Returns: bool: True if current gradient calculation mode is enabled, otherwise false. Examples: .. code-block:: pycon >>> import paddle >>> # Gradient calculation mode is enabled by default. >>> paddle.is_grad_enabled() True >>> with paddle.set_grad_enabled(False): ... paddle.is_grad_enabled() False >>> paddle.enable_static() >>> paddle.is_grad_enabled() True )r r}r%r&r'is_grad_enabledrs0 >> r&c0[R"U5 gr:)r r~)modes r'_set_grad_enabledrstr&c@\rSrSrSrS SjrS SjrS SjrS SjrSr g) set_grad_enabledia Create a context which enables or disables dygraph gradient calculation. Args: mode(bool): whether to enable (`True`), or disable (`False`) grad. Returns: None. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([1.], stop_gradient=False) >>> is_train = False >>> with paddle.set_grad_enabled(is_train): ... y = x * 2 >>> print(y.stop_gradient) True >>> paddle.set_grad_enabled(True) >>> y = x * 2 >>> print(y.stop_gradient) False >>> paddle.set_grad_enabled(False) >>> y = x * 2 >>> print(y.stop_gradient) True cD[5Ul[U5 Xlgr:)rprevrr)rrs r'__init__set_grad_enabled.__init__s#% $ r&cgr:r%rs r'rtset_grad_enabled.__enter__sr&c.[UR5 gr:rrrr=s r'ryset_grad_enabled.__exit__$))$r&c8URUR5$r:)rrrs r'rset_grad_enabled.clones~~dii((r&)rrNrBNoner=objectrBrr) rrrrrrrtryrrr%r&r'rrs> %%)r&rc,\rSrSrSrSSjrSSjrSrg) no_grad_i a@ :api_attr: imperative Create a context which disables dygraph gradient calculation. In this mode, the result of every computation will have `stop_gradient` set to `True`. Also functions as a decorator. (Make sure to use an instance.) Examples: .. code-block:: python >>> import numpy as np >>> import paddle >>> # use as generator >>> data = np.array([[2, 3], [4, 5]]).astype('float32') >>> l0 = paddle.nn.Linear(2, 2) # l0.weight.gradient() is None >>> l1 = paddle.nn.Linear(2, 2) >>> with paddle.no_grad(): ... # l1.weight.stop_gradient is False ... tmp = l1.weight * 2 # tmp.stop_gradient is True >>> x = paddle.to_tensor(data) >>> y = l0(x) + tmp >>> o = l1(y) >>> o.backward() >>> print(tmp.gradient() is None) True >>> print(l0.weight.gradient() is None) False >>> # use as decorator >>> @paddle.no_grad() >>> def test_layer(): ... inp = np.ones([3, 1024], dtype='float32') ... t = paddle.to_tensor(inp) ... linear1 = paddle.nn.Linear(1024, 4, bias_attr=False) ... linear2 = paddle.nn.Linear(4, 4) ... ret = linear1(t) ... dy_ret = linear2(ret) ... >>> test_layer() c8[5Ul[S5 g)NFrrrrs r'rtno_grad_.__enter__9s#% % r&c.[UR5 gr:rrs r'ryno_grad_.__exit__=rr&rNrrrrrrrrtryrr%r&r'rr s-^!%r&rc,\rSrSrSrSSjrSSjrSrg) enable_gradiAa :api_attr: imperative Create a context which enable dygraph gradient calculation, if it has been disabled by `no_grad` or `set_grad_enabled`. In this mode, the result of every computation will have `stop_gradient` set to `False`. Also functions as a decorator. (Make sure to use an instance.) Examples: .. code-block:: python >>> import paddle >>> # use as generator >>> x = paddle.to_tensor([1.], stop_gradient=False) >>> with paddle.no_grad(): ... with paddle.enable_grad(): ... y = x * 2 >>> assert(y.stop_gradient == False) >>> y.backward() >>> assert(x.grad is not None) >>> # use as decorator >>> @paddle.enable_grad() >>> def double(x): ... return x * 2 ... >>> with paddle.no_grad(): ... z = double(x) ... >>> assert(z.stop_gradient == False) c8[5Ul[S5 g)NTrrs r'rtenable_grad.__enter__is#% $r&c.[UR5 gr:rrs r'ryenable_grad.__exit__mrr&rNrrrr%r&r'rrAs%N %r&rc #T# [R"5n[R"5n[5nUb [U5nO[R"5n[R "X5 [R R5 [R"U5 [R"U5 Sv SSS5 SSS5 SSS5 SSS5 g!,(df  N'=f!,(df  N0=f!,(df  N9=f!,(df  g=f7f)a :api_attr: imperative This context will create a dygraph context for dygraph to run, using python ``with`` statement. Parameters: place(base.CPUPlace| base.CUDAPlace|str, optional): Place to execute dygraph. If None, the running place will be determined according to the way of paddle compilation. If ``place`` is string, It can be ``cpu``, ``gpu:x`` and ``xpu:x``, where ``x`` is the index of the GPUs or XPUs. Default: None return: None Examples: .. code-block:: python >>> import numpy as np >>> import paddle.base as base >>> with base.dygraph.guard(): ... inp = np.ones([3, 1024], dtype='float32') ... t = base.dygraph.base.to_variable(inp) ... linear1 = paddle.nn.Linear(1024, 4, bias_attr=False) ... linear2 = paddle.nn.Linear(4, 4) ... ret = linear1(t) ... dy_ret = linear2(ret) ... N) r Programrr_current_expected_place_ program_guard unique_namersr;_dygraph_place_guard)rqtrainstartuptracerexpected_places r'rsrsqs@    E!G XF *51";;= /##%  (&&~6  7 ) & 0/ 76 )( &% 0/sfA/D(1DD'C5>C$ C5 DD D($ C2 .C55 D ?D D D D%!D()dump_backward_graph_pathc `[5(a#SSKJn [S/SQX4XV//SQ5 U "XX'5$Sn U "US5nU "US5nUb][ U[ [ 45(dU/nUH8n U cM[ U [RR5(aM3S 5e O/n[U5S:a[U5[U5:XdS 5eUc/nO[ U[RR5(aU/nOp[ U[ [ [45(aE[ U5nUH3n [ U [RR5(aM.S 5e O [S 5e[ U[5(dS 5eUcUn[ U[5(dS5e[ U[5(dS5e[ U[5(dS5eU(dS5e[U5 [RRUUUUUUUUU5 $)a .. note:: **This API is ONLY available in imperative mode.** This API computes the sum of gradients of `outputs` with respect to each `inputs` . Parameters: outputs (Tensor|list[Tensor]|tuple[Tensor]): the output Tensor or Tensor list/tuple of the graph to compute gradients. inputs (Tensor|list[Tensor]|tuple[Tensor]): the input Tensor or Tensor list/tuple of the graph to compute gradients. The returned values of this API are the gradients of `inputs` . grad_outputs (Tensor|list[Tensor|None]|tuple[Tensor|None], optional): initial gradient values of `outputs` . If `grad_outputs` is None, the initial gradient values of `outputs` would be Tensors filled with 1; if `grad_outputs` is not None, it must have the same length as `outputs` , and in this case, the initial gradient value of the i-th `outputs` would be: (1) a Tensor filled with 1 when the i-th element of `grad_outputs` is None; (2) the i-th element of `grad_outputs` when the i-th element of `grad_outputs` is a Tensor. Default None. retain_graph (bool|None, optional): whether to retain the forward graph which is used to calculate the gradient. When it is True, the graph would be retained, in which way users can calculate backward twice for the same graph. When it is False, the graph would be freed. Default None, which means it is equal to `create_graph` . create_graph (bool, optional): whether to create the gradient graphs of the computing process. When it is True, higher order derivatives are supported to compute; when it is False, the gradient graphs of the computing process would be discarded. Default False. only_inputs (bool, optional): whether to only compute the gradients of `inputs` . If it is False, the gradients of all remaining leaf Tensors in the graph would be also computed and accumulated. If it is True, only the gradients of `inputs` would be computed. Default True. only_inputs=False is under development, and it is not supported yet. allow_unused (bool, optional): whether to raise error or return None if some Tensors of `inputs` are unreachable in the graph. If some Tensors of `inputs` are unreachable in the graph (i.e., their gradients are None), error would be raised if allow_unused=False, or None would be returned as their gradients if allow_unused=True. Default False. no_grad_vars (Tensor|list[Tensor]|tuple[Tensor]|set[Tensor], optional): the Tensors whose gradients are not needed to compute. Default None. dump_backward_graph_path (str, optional): specifies the directory path for storing the debug file. If this parameter is specified, the backward-related graph (in dot format) and the debugging call stack information will be generated in this directory. Returns: list: a list of Tensors, whose length is the same as the Tensor number inside `inputs`, and the i-th returned Tensor is the sum of gradients of `outputs` with respect to the i-th `inputs`. Examples: .. code-block:: python :name: code-example-1 >>> import paddle >>> def test_dygraph_grad(create_graph): ... x = paddle.ones(shape=[1], dtype='float32') ... x.stop_gradient = False ... y = x * x ... ... # Since y = x * x, dx = 2 * x ... dx = paddle.grad( ... outputs=[y], ... inputs=[x], ... create_graph=create_graph, ... retain_graph=True ... )[0] ... ... z = y + dx ... ... # If create_graph = False, the gradient of dx ... # would not be backpropagated. Therefore, ... # z = x * x + dx, and x.gradient() = 2 * x = 2.0 ... ... # If create_graph = True, the gradient of dx ... # would be backpropagated. Therefore, ... # z = x * x + dx = x * x + 2 * x, and ... # x.gradient() = 2 * x + 2 = 4.0 ... ... z.backward() ... return x.gradient() ... >>> print(test_dygraph_grad(create_graph=False)) [2.] >>> print(test_dygraph_grad(create_graph=True)) [4.] .. code-block:: python :name: code-example-2 >>> import paddle >>> def test_dygraph_grad(grad_outputs=None): ... x = paddle.to_tensor(2.0) ... x.stop_gradient = False ... ... y1 = x * x ... y2 = x * 3 ... ... # If grad_outputs=None, dy1 = [1], dy2 = [1]. ... # If grad_outputs=[g1, g2], then: ... # - dy1 = [1] if g1 is None else g1 ... # - dy2 = [1] if g2 is None else g2 ... ... # Since y1 = x * x, dx = 2 * x * dy1. ... # Since y2 = x * 3, dx = 3 * dy2. ... # Therefore, the final result would be: ... # dx = 2 * x * dy1 + 3 * dy2 = 4 * dy1 + 3 * dy2. ... ... dx = paddle.grad( ... outputs=[y1, y2], ... inputs=[x], ... grad_outputs=grad_outputs)[0] ... ... return dx.numpy() ... >>> grad_value = paddle.to_tensor(4.0) >>> # dy1 = [1], dy2 = [1] >>> print(test_dygraph_grad(None)) 7. >>> # dy1 = [1], dy2 = [4] >>> print(test_dygraph_grad([None, grad_value])) 16. >>> # dy1 = [4], dy2 = [1] >>> print(test_dygraph_grad([grad_value, None])) 19. >>> # dy1 = [3], dy2 = [4] >>> grad_y1 = paddle.to_tensor(3.0) >>> print(test_dygraph_grad([grad_y1, grad_value])) 24. r) gradientsz paddle.grad) retain_graph create_graph only_inputs allow_unused)NFTFcnUc US35e[U[[45(aX[U5S:d US35eUH7n[U[R R 5(aM.SUS35e U$[U[R R 5(d US35eU/$)Nz should not be Nonerz cannot be emptyz Elements of z must be Tensorz! must be Tensor or list of Tensor)rNrOtuplelenr eagerr) in_out_listr3each_vars r' check_in_outgrad..check_in_outDs&D4&0C(DD& kD%= 1 1{#a' BD61A)B B''!(DJJ,=,=>>"4&8>( k4::+<+<== &9: = = r&outputsr1zLgrad_outputs must be None, a Variable or a list containing None or Variablesz3The length of grad_outputs must be equal to outputsz%no_grad_vars can only contains Tensorz>no_grad_vars must be None, Tensor or list/tuple/set of Tensorsz"create_graph must be True or Falsez(retain_graph must be None, True or Falsez"allow_unused must be True or Falsez!only_inputs must be True or Falsez&only_inputs=False is not supported yet)r( paddle.staticrr6rNrOrr rrrsetAssertionErrorrrrun_partial_grad) rr1 grad_outputsrrrr no_grad_varsrrrrrUs r'gradrs0h ,.  K  C &  ,EE! 7I.G &( +F,u 66(>L$H#!(DJJ,=,=>>b>%   <1< CL0 A 0 L$**"3"3 4 4$~ L4"4 5 5L) Cc4::#4#455 7 5  L   lD ) )O+OO )# lD ) )2 ) lD ) )O+OO ) k4 ( (M*MM ( @@@;12 :: & &   r&)rBrr)T)rFrrBGenerator[None, None, None])rRzOrderedDict[str, Tensor]rBrr:)rqPlaceLike | NonerBrr)rrrBr).)r7rrBr)rrrBr)rqrrBr)NNFTFN)rTensor | Sequence[Tensor]r1rrz'Tensor | Sequence[Tensor | None] | Nonerz bool | Nonerrrrrrrz.Tensor | Sequence[Tensor] | set[Tensor] | Nonerz str | NonerBz list[Tensor])I __future__rrrrzr-typingrrrrrtyping_extensionsr rJ paddle.baser r paddle.base.frameworkr paddle.base.multiprocess_utilsr paddle.utils.decorator_utilsrpaddle.utils.downloadrrwrapped_decoratorrrrrr collectionsrcollections.abcrr contextlibrtypesrrrpaddle._typingr__all__rr rdr(r*in_declarative_moder6rDswitch_to_static_graphrHrWrPrnrwrvrrrrrrrrrsnon_static_onlyrr%r&r'rs# ( ',?<6) '31#&(  I "5*  (" "((@A 6 6  6 6( (,^':(7V>B%% %% < < L Lf{m,-?.?D. . b6+)/+)\5%'5%p-%*-%`..b =A $CGk,0k &k %k:k k  k  kkAk)kkkr&