ёio SSKJr SSKrSSKrSSKrSSKrSSKrSSKJrJ r SSK r SSK r SSK J r SSKJrJr SSKJr SSKJrJrJrJr SSKJr S S KJrJrJrJr S S KJ r J!r! S S K"J#r# S S K$J%r%J&r&J'r'J(r(J)r)J*r*J+r+J,r,J-r-J.r. \(a$SSK/J0r0 SSKJ1r1 SSK2J3r3 SSK4J5r5J6r6J7r7J8r8J9r9J:r:J;r; /rSeSjr?SfSgSjjr@ShSiSjjrASjSkSjjrB\"SS/SS/5SlSSSS.SmSjjj5rCSnSoS jjrDSpSqS!jjrESrSsS"jjrFStSuS#jjrGSpSvS$jjrHSwS%jrISSSSS&.SxS'jjrJ"S(S)\ RRTR5rL\"S*S+/5SlSSSS,.SyS-jjj5rMSzS{S.jjrN\SlSSSSS/.S|S0jjj5rO\"S*S+/05SlSSSS,.S}S1jjj5rP\SlSSSSS/.S|S2jjj5rQ\"S*S+/05SlSSSS,.S}S3jjj5rR\"S4S5/S6S7/5S~SSSSS/.SS8jjj5rS\"SS9/05SlSSSSS/.SS:jjj5rTSSSSSSS<.SS=jjjrU\"S>S;S?9SSSSSS@.SSAjjj5rVSSBjrW\SSSCjj5rX\SSSDjj5rY\ SlSSEjj5rZ\ SSSF.SSGjj5rZSHrZSSSIjjr[SSSJjjr\SSSKjjr]SSSLjjr^\SlSSSSS/.S|SMjjj5r_\"S*S+/05SlSSSS,.S}SNjjj5r`SSSOjjraSSSPjjrbSlSSQjjrcSSSR.SSSjjjrdSSSUjjreSSSVjjrfSSSR.SSWjjjrg\+SSSXjj5rh\+SSSYjj5ri\SSSZjj5rj\SSS[jj5rkS\rl\l"S]5rm\l"S^5rn\l"S_5ro\l"S`5rp\l"Sa5rq\l"Sb5rr\l"Sc5rs\l"Sd5rt\l"ST5ru\l"S5rvg)) annotationsN) TYPE_CHECKINGoverload)_C_ops)triltriu) deprecated)ParamAliasDecoratorparam_one_aliasparam_two_aliassize_args_decorator)inplace_apis_in_dygraph_only) check_dtype check_typecheck_variable_and_dtype convert_dtype)Variable device_guard) ParamAttr) LayerHelper_current_expected_place_current_expected_place__get_paddle_placeconvert_np_dtype_to_dtype_core dygraph_onlyin_dynamic_modein_dynamic_or_pir_mode in_pir_mode)Sequence)Any)NDArray) DTypeLikeNestedNumericSequenceNumeric ParamAttrLike PlaceLike ShapeLike TensorLikeFcU[RRR:Xa$[RRR$U[RRR :Xa$[RRR $U[RRRR:Xa.[RRRR$U[RRRR :Xa.[RRRR$U$N) rVarDescVarType COMPLEX64FP32 COMPLEX128FP64paddlepirDataTypeFLOAT32FLOAT64dtypes V/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/paddle/tensor/creation.py_complex_to_real_dtyper;Ps  $$...||##((( $,,&&11 1||##((( &**//**44 4zz''/// &**//**55 5zz''/// cU[RRR:Xa$[RRR$U[RRR :Xa$[RRR $U[RRRR:Xa.[RRRR$U[RRRR:Xa.[RRRR $U$r,) rr-r.r0r/r2r1r3r4r5r6r7r8s r:_real_to_complex_dtyper>]s  $$)))||##--- $,,&&++ +||##... &**//**22 2zz''111 &**//**22 2zz''222 r<shapeboolc  [US[[[R4S5 UHan[US[ [R [R[R[R[R4S5 Mc [US/SQS5 [S 0[5D6nURUUUUSS9nURU[ R"R$R'[)U5US9S 9 U$) a This function creates a new tensor variable with value in the global block(block 0). Args: shape (list[int]|tuple[int]): Shape of the variable value (float): The value of the variable. The new created variable will be filled with it. dtype (str): Data type of the variable persistable (bool, optional): If this variable is persistable. Default: False force_cpu (bool, optional): Force this variable to be on CPU. Default: False name (str|None, optional): For detailed information, please refer to :ref:`api_guide_Name` . Usually name is no need to set and None by default. Returns: Variable: The created Variable Examples: .. code-block:: python >>> import paddle >>> paddle.enable_static() >>> var = paddle.static.create_global_var(shape=[2,3], value=1.0, dtype='float32', ... persistable=True, force_cpu=True, name='new_var') r?create_global_var item of shaper9) r@float16float32float64int8int16int32int64uint8uint16T)r9r? persistablename stop_gradient)value force_cpu) initializer) global_var)rlisttuplenpndarrayintrKrGrHrIrJrrlocalscreate_global_variableset_variable_initializerr3nnrRConstantInitializerfloat) r?rPr9rMrQrNitemhelpervars r:rBrBjsDugeRZZ8:MN         $ 2 2F  ' '  ( C ## II))==,)> $ Jr<c d[US[[[R4S5 UHan[US[ [R [R[R[R[R4S5 Mc [US/SQS5 [US[S5[4S5 [US[S5[RR R"4S5 [%S 0['5D6nUc [US 9nUR)X0[+U5XE5$) a: This function creates a parameter. The parameter is a learnable variable, which can have gradient, and can be optimized. Note: This is a very low-level API. This API is useful when you create operator by your self, instead of using layers. Args: shape (list of int): Shape of the parameter dtype (str): Data type of the parameter. It can be set as 'float16', 'float32', 'float64'. name(str|None, optional): For detailed information, please refer to :ref:`api_guide_Name` . Usually name is no need to set and None by default. attr (ParamAttr|None, optional): Attribute object of the specified argument. For detailed information, please refer to :ref:`api_paddle_ParamAttr` None by default, which means that ParamAttr will be initialized as it is. is_bias (bool, optional): This can affect which default initializer is chosen when default_initializer is None. If is_bias, initializer.Constant(0.0) will be used. Otherwise, Xavier() will be used. default_initializer (Initializer|None, optional): Initializer for the parameter Returns: The created parameter. Examples: .. code-block:: python >>> import paddle >>> paddle.enable_static() >>> W = paddle.create_parameter(shape=[784, 200], dtype='float32') r?create_parameterrCr9) r@rDrLrErFrGrHrIrJrKattrNdefault_initializer)rN)rc)rrTrUrVrWrXrKrGrHrIrJrtyperr3r\rR InitializerrrYrcr)r?r9rNrdis_biasrer_r`s r:rcrcsLugeRZZ8:LM         "tVd4j)46HI dVYY**667  8vx 8F |d#  " " ]5)7 r<c|[US/SQS5 [S0[5D6nURURXS9$)a Create a variable, which will hold a Tensor with data type dtype. Args: dtype(str|paddle.dtype|np.dtype, optional): the data type of Tensor to be created, the data type is bool, float16, float32, float64, int8, int16, int32 and int64. name(string, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` persistable(bool): Set the persistable flag of the create tensor. default value is False. Returns: Variable: The tensor to be created according to dtype. Examples: .. code-block:: python >>> import paddle >>> tensor = paddle.tensor.create_tensor(dtype='float32') r9)r@rDrErFrGrIrIrJ create_tensorrNr9rM)rj)rrrYcreate_variablerN)r9rNrMr`s r:rjrjsN.    5FH 5F  ! ! [[ " r<stopendnumsteps)outdevice requires_gradc  Uc[R"5nUb [U5O [5nUnUn Un [ U[ [R R45(d[US[S5 [ U[RR[R RR45(d [U5n[ U[ [R R45(d [S5 [!S/X0SS9n SSS5 [ U[ [R R45(d [S5 [!S/X1SS9n SSS5 [ U[ [R R45(d![S5 [!S/SUSS9nSSS5 [#5(a)[$R&"U U UUUUS 9n U(aS U lU $[+5(Ga[-S0[/5D6n [1U R25n [1U R25n[1U5n[ U[R R5(aR2S /S QS5 O[US [[64S5 [ U[R R5(aR2S /S QS5 O[US [[64S5 [ U[R R5(a[5UR2SSS/S5 [5US/S QS5 US:XdU S:XaUS;dUS:XdU S:XaUS:Xa[9SU SUSUS35e[ U[R:RRR5(a'[R RR<Un[$R&"U U UUUUS 9n U(aS U lU $[-S0[/5D6n [1U R25n [1U R25n[1U5n[ U[ 5(aR2S /S QS5 O[US [[64S5 [ U[ 5(aR2S /S QS5 O[US [[64S5 [ U[ 5(a[5UR2SS/S5 [5US/S QS5 US:XdU S:XaUS;dUS:XdU S:XaUS:Xa[9SU SUSUS35eU R?US9nU RASU U US.SU0SU/0S9 [ U[5(aURBREU45 U$!,(df  GN=f!,(df  GN~=f!,(df  GN@=f)a< Return fixed number of evenly spaced values within a given interval. Note: no gradient calculation is performed. Args: start(int|float|Tensor): The input :attr:`start` is start of range. It is a int, float, \ or a 0-D Tensor with data type int32, int64, float32 or float64. stop(int|float|Tensor): The input :attr:`stop` is end of range. It is a int, float, \ or a 0-D Tensor with data type int32, int64, float32 or float64. num(int|Tensor): The input :attr:`num` is given num of the sequence. It is an int, \ or a 0-D Tensor with data type int32. dtype(str|paddle.dtype|np.dtype|None, optional): The data type of output tensor, it could be int32, int64, float32 and float64. Default: if None, the data type is float32. name(str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. out(Tensor|None, optional): Optional output tensor. If provided, the result will be stored in this tensor. \ The tensor must have the correct shape and dtype. Default: None. device(str|paddle.CUDAPlace|paddle.CPUPlace|None, optional): The device where the output tensor will be placed. \ It can be a string (e.g., 'cpu', 'gpu:0'), a paddle.CUDAPlace, or a paddle.CPUPlace object. \ If None, the current device context will be used. Default: None. requires_grad(bool, optional): Whether the output tensor should have gradient computation enabled. \ If True, the output tensor's ``stop_gradient`` attribute will be set to False. Default: False. Returns: Tensor: the output data type will be float32, float64. The 1-D tensor with fixed number of evenly spaced values, \ the data shape of this tensor is :math:`[num]` . If the :attr:`num` is set 1, the output tensor just has \ the value with input :attr:`start`. .. note:: **Alias Support:** - The parameter name ``end`` can be used as an alias for ``stop``. \ For example, ``linspace(start=0, end=10, ...)`` is equivalent to ``linspace(start=0, stop=10, ...)``. - The parameter name ``steps`` can be used as an alias for ``num``. \ For example, ``linspace(start=0, stop=10, steps=5)`` is equivalent to ``linspace(start=0, stop=10, num=5)``. Examples: .. code-block:: python >>> import paddle >>> data = paddle.linspace(0, 10, 5, 'float32') >>> print(data.numpy()) [0. 2.5 5. 7.5 10.] >>> data = paddle.linspace(0, 10, 1, 'float32') >>> print(data.numpy()) [0.] >>> # Using device parameter >>> data = paddle.linspace(0, 10, 5, device='cpu') >>> print(data.numpy()) [0. 2.5 5. 7.5 10.] >>> # Using requires_grad parameter >>> data = paddle.linspace(0, 10, 5, requires_grad=True) >>> print(data.stop_gradient) False NrolinspacecpuTrQrIrqFstart)rDrLrErFrIrJrmrJr9rFrErIzThe dtype of start/stop is /z$ but the attr(dtype) of linspace is zL, which may cause data type overflows. Please reset attr(dtype) of linspace.r8)StartStopNumOutrfinputsattrsoutputs)ru)#r3get_default_dtyperr isinstancerr4ValuerrXrr-r.r5rr fill_constantrrrurOr rrYrr9rr^ ValueErrorbasevartype_to_datatype"create_variable_for_type_inference append_opdesc set_shape)rzrmror9rNrqrrrs tensor_num tensor_start tensor_stop out_tensorr` start_dtype stop_dtype out_dtypes r:ruruCs7H }((*   &! $ & JLK cHfjj&6&67 8 83j1 edll22FJJOO4L4LM N N*51 eh (8(89 : : % (!edKL! dXvzz'7'78 9 9 % 'UDIK! cHfjj&6&67 8 8 % &sGSDIJ!__        ',J $ 4684#L$6$67 ";#4#45 !%( eVZZ-- . .  M   ugU|Z @ dFJJ,, - -  M   tVc5\: > c6::++ , ,  57G* >JJOO77>E__        ',J $4684#L$6$67 ";#4#45 !%( eX & &  M   ugU|Z @ dH % %  M   tVc5\: > c8 $ $  57)Z @   I   9 $ y(@11 7 "kW&<W$-k]!Jc  Uc[R"5nUnUnUnUn [U[[RR 45(d[ US[S5 [U[RR[R45(d [U5n[U[[RR 45(d![S5 [S/X@5nSSS5 [U[[RR 45(d![S5 [S/XA5nSSS5 [U[[RR 45(d"[S5 [S/SU5nSSS5 [U[[RR 45(d![S5 [S/XC5n SSS5 [5(a#[ R""UUUU U[%55$['5(a[)UR*5n [)UR*5n [)U R*5n [)U5n U S:Xd U S:XdU S:XaU S;dU S :Xd U S :XdU S :XaU S:Xa[-S U S U S U S US 3 5e[U[RR 5(a[/UR*SS/S5 [ R""UUUU U[%55$[1S0[35D6n[)UR*5n [)UR*5n [)U R*5n [)U5n [U[5(a[/UR*S/SQS5 O[ US[[44S5 [U[5(a[/UR*S/SQS5 O[ US[[44S5 [U[5(a[/UR*SS/S5 [U[5(a[/UR*S/SQS5 O[ US[[44S5 [/US/SQS5 U S:Xd U S:XdU S:XaU S;dU S :Xd U S :XdU S :XaU S:Xa[-S U S U S U S US 3 5eUR7US9nUR9SUUUU S.SU0SU/0S9 [U[5(aUR:R=U45 U$!,(df  GNQ=f!,(df  GN=f!,(df  GN=f!,(df  GN=f)a Return fixed number of logarithmically-evenly spaced values within the interval \ :math:`[base^{start}, base^{stop}]`. Notes: This API does not compute the gradient. Args: start(int|float|Tensor): The input :attr:`start` is exponent of first entry in \ the sequence. It is a scalar, or a 0-D Tensor of shape [] with input data \ type int32, int64, float32 or float64. stop(int|float|Tensor): The input :attr:`stop` is exponent of last entry in the \ sequence. It is a scalar, or a 0-D Tensor of shape [] with input data \ type int32, int64, float32 or float64. num(int|Tensor): The input :attr:`num` is given number of items in the sequence. \ It is an int scalar, or a 0-D Tensor of shape [] with data type int32. base(int|float|Tensor): The input :attr:`base` is base of the logarithm function. \ It is a scalar, or a 0-D Tensor of shape [] with input data type int32, int64, \ float32 or float64. dtype(str|paddle.dtype|np.dtype, optional): The data type of output tensor, it could be \ int32, int64, float32 or float64. Default: if None, the data type is float32. \ name(str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: The output data type will be float32, float64. The 1-D tensor with \ fixed number of logarithmically-evenly spaced values, the data shape of this \ tensor is :math:`[num]`. If the :attr:`num` is set 1, the output tensor \ just has the value with exponential of :attr:`start` with base :attr:`base`. Examples: .. code-block:: python >>> import paddle >>> data = paddle.logspace(0, 10, 5, 2, 'float32') >>> print(data.numpy()) [1.0000000e+00 5.6568542e+00 3.2000000e+01 1.8101933e+02 1.0240000e+03] >>> data = paddle.logspace(0, 10, 1, 2, 'float32') >>> print(data.numpy()) [1.] NrologspacervrwrIrFr{rJz The dtype of start/stop/base is r|z$ but the attr(dtype) of logspace is zL, which may cause data type overflows. Please reset attr(dtype) of logspace.rz)rErFrIrJrmrr9)rIrJrErFr8)r}r~rBaserr)r)r3rrrr4rrrXrr-r.r5rrrrrrrr rr9rrrrYr^rrrr)rzrmrorr9rNrrr tensor_baserr base_dtyperr`rqs r:rr"s` }((*JLKK cHfjj&6&67 8 83j1 edll22DMMB C C*51 eh (8(89 : : % (!e;L! dXvzz'7'78 9 9 % 'U9K! cHfjj&6&67 8 8 % &sGS9J! dXvzz'7'78 9 9 % 'U9K!      # %    #L$6$67 ";#4#45 ";#4#45 !%( i')+*11g%')(W$2;-q Aj\Y}D~EE]]  c6::++ , ,  57)Z @      # %   4684#L$6$67 ";#4#45 ";#4#45 !%( eX & &  8   ugU|Z @ dH % %  8   tVc5\: > c8 $ $  57)Z @ dH % %  8   tVc5\: > 7Dj i')+*11g%')(W$2;-q Aj\Y}D~EE]]  77e7D%#!#  E"SEN   c3   HH  v & K! ! ! ! s0 T80U UU.8 U U U+. U=c  SSjn[U[R5(a[R"U5n[U[R5(Gd[R "U5(a-[U[ 5(d[R"U5nGO[U[[45(GaSnUH&n[U[R5(dM$Sn O U(a[U5S:Xal[US[R5(aJUSR[R:Xa)[R"USR5/5nO[R"U5nU(d URnO[R"U5nUR[R:Xa [!S5eO[U[R5(a"UR#US5nU"X5nX0lU$[U[&R(5(a$[R"XS9nU"X5nX0lU$[+S[-U5S 35eU(dURS ;a^[R."5n[R0"U5(a US ;aS OS n[3U5[3UR5:waUnURS;aUR5S5nU(a[3U5[3UR5:wad[3U5S:Xa;[&R6RUUSSSSS9nUR5U5nX8lU$UR5[3U55n[U[R5(Ga6UR[R8[R:[R<[R>[R@[RB4;aURDS:Xa[U[&RF5(d4[U[&RH5(a\URK5(aG[RL"URNURQS/5SUR5n X9lU $[&R6RUUSSSUS9$[R"UUSSUS9$)NcU(a<[U5[UR5:waUR[U55$U$r,)rr9astype)tensorr9s r:_handle_tensor_dtype3_to_tensor_non_static.._handle_tensor_dtypes6 U#}V\\'BB}}]5%9:: r<FTrwrz Failed to convert input data to a regular ndarray : - Usually this means the input data contains nested lists with different lengths. )placez2Can't constructs a 'paddle.Tensor' with data type z>, data type must be scalar|list|tuple|np.ndarray|paddle.Tensor)rDrErF complex64 complex128)rDrErrrIrJrL)rPrrM zero_copyrNrO)rPrrMrrO)r paddle.Tensorr9r$returnr))rrVnumberarrayrWisscalarstrrTrUr3Tensorlenr9bfloat16numpyobject_r_copy_torOr DenseTensor TypeErrorrfr iscomplexobjrreagerrErFrIrJrrsize CUDAPlacePlace is_gpu_placefullr?reshape) datar9rrOr has_tensord default_typerrets r:_to_tensor_non_staticrs &/ $ ""xx~ dBJJ ' ' ;;t  Zc%:%:88D>D tUm , ,Ja//!%JIN"47FMM::Q 888T!W]]_$56D88D>D JJExx~zzRZZ' _( fmm , ,==.D'4D!. K d.. / /==3D'4D!. KDT$ZLQOP zz &779 ??4(((+AA$)! !.- 2KK(EzzY&{{7+ u%tzz)BB  8 +ZZ&&!" 'F]]5)F#0 M;;}U34D$ ## JJ      Q5$..11udjj11e6H6H6J6J++djj$,,s*;A*> KC - J::$$!+ % }}'   r<c[U[[RR45(a,UnUb%XR :wa[R "X15nGO[U[R5(a[R"U5n[U[R5(Gd[R"U5(a,[U[5(d[R"U5nOi[U[[45(a6[R"U5nUR S:Xa [S5eUnO[S[)U5S35eUR S;a%UR+[R,"55nO!UR S;aUR+S5nU(aUnOC[/US5(aUR S:wa UR nO[R,"5n[1U5nUR S :XaUR+S 5n[3U5n[1UR 5U:wa[R "X85nX#lU$! S/[!U5-n[#U5Hupg[%XqU5XV'M [R&"U5nGN]=f) NobjectzNumpy get dtype `object`.zDo not support transform type `z ` to tensor)rDrErFrrJr9rHrI)rrr3r4rr9castrVrrrWrrrTrU RuntimeErrorr enumerate_to_tensor_staticstackrfrrhasattrrassignrO) rr9rOoutput array_data to_stack_listidxr target_dtypes r:rrns $6::#3#3455  **!4[[/F dBII & &88D>D$ ++{{4  D#)>)>xx~D4-007"$$J"''83*+FGG%D#5d4j\M zz>>{{6#;#;#=>y({{7+  L T7 # # h(>::L!335L$\2 :: ;;w'D  &, 6[[6F( MI7%)FSY$6M"+D/->m. *#2"<< 6Ds 4I22A J>cNU(+n[U5nUc [5nU(a[U[R[R 45(dy[U[R 5(a[R"5nOD[U[R5(a[R "5nO[SUS35e[5(a[R"U5nU(de[US5(aT[R"5(d [S5e[R"U5nU(aUR5nU$U(a"[ (d["R$"SSS9 S q['XXe5nU$[(R*"S [(R,5n [(R."U [1U55S n [R2R5U 5 [7XU5nUsSSS5 $!,(df  g=f) u Constructs a ``paddle.Tensor`` from ``data`` , which can be scalar, tuple, list, numpy\.ndarray, paddle\.Tensor. If the ``data`` is already a Tensor, copy will be performed and return a new tensor. If you only want to change stop_gradient property, please call ``Tensor.stop_gradient = stop_gradient`` directly. .. code-block:: text We use the dtype conversion rules following this: Keep dtype np.number ───────────► paddle.Tensor (0-D Tensor) default_dtype Python Number ───────────────► paddle.Tensor (0-D Tensor) Keep dtype np.ndarray ───────────► paddle.Tensor Args: data(scalar|tuple|list|ndarray|Tensor): Initial data for the tensor. Can be a scalar, list, tuple, numpy\.ndarray, paddle\.Tensor. dtype(str|np.dtype, optional): The desired data type of returned tensor. Can be 'bool' , 'float16' , 'float32' , 'float64' , 'int8' , 'int16' , 'int32' , 'int64' , 'uint8', 'complex64' , 'complex128'. Default: None, infers dtype from ``data`` except for python float number which gets dtype from ``get_default_type`` . device(CPUPlace|CUDAPinnedPlace|CUDAPlace|str, optional): The place to allocate Tensor. Can be CPUPlace, CUDAPinnedPlace, CUDAPlace. Default: None, means global place. If ``device`` is string, It can be ``cpu``, ``gpu:x`` and ``gpu_pinned``, where ``x`` is the index of the GPUs. requires_grad(bool, optional): Whether to block the gradient propagation of Autograd. Default: False. pin_memory(bool, optional): If set, return tensor would be allocated in the pinned memory. Works only for CPU tensors. Default: False Returns: Tensor: A Tensor constructed from ``data`` . Examples: .. code-block:: python >>> # type: ignore >>> import paddle >>> type(paddle.tensor(1)) >>> paddle.tensor(1) Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, 1) >>> x = paddle.tensor(1, requires_grad=True) >>> print(x) Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=False, 1) >>> paddle.tensor(x) # A new tensor will be created with default stop_gradient=True Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, 1) >>> paddle.tensor([[0.1, 0.2], [0.3, 0.4]], device=paddle.CPUPlace(), requires_grad=True) Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=False, [[0.10000000, 0.20000000], [0.30000001, 0.40000001]]) >>> type(paddle.tensor([[1+1j, 2], [3+2j, 4]], dtype='complex64')) >>> paddle.tensor([[1+1j, 2], [3+2j, 4]], dtype='complex64') Tensor(shape=[2, 2], dtype=complex64, place=Place(cpu), stop_gradient=True, [[(1+1j), (2+0j)], [(3+2j), (4+0j)]]) N$Pinning memory is not supported for .__cuda_array_interface__zXPaddlePaddle is not compiled with CUDA, but trying to create a Tensor from a CUDA array.zTo copy construct from a tensor, it is recommended to use sourceTensor.clone().detach(), rather than paddle.to_tensor(sourceTensor).r) stacklevelTz [(](.+?)[)]r)rrrrCUDAPinnedPlaceXPUPinnedPlacerXPUPlacerrr3 is_tensorris_compiled_with_cuda tensor_from_cuda_array_interface pin_memory_warned_in_tensorwarningswarnrrecompileDOTALLfindallrstaticrr) rr9rrrsrrOrrrre_exp place_strs r:rrsZ&%M f %E }(** $$d&9&9: eT^^ , ,((*E t}} - -'')E!EeWANO O$$T* WT+EFF--//"n::4@F**, ((MMF#$ )-%*4MF NBII6JJvs5z215 ]] ' ' 2&tMBF3 2 2s >H H$c [XX#(+S9$)ul Constructs a ``paddle.Tensor`` from ``data`` , which can be scalar, tuple, list, numpy\.ndarray, paddle\.Tensor. If the ``data`` is already a Tensor, copy will be performed and return a new tensor. If you only want to change stop_gradient property, please call ``Tensor.stop_gradient = stop_gradient`` directly. .. note:: Alias Support: The parameter name ``device`` can be used as an alias for ``place``. For example, ``device=paddle.CUDAPlace(0)`` is equivalent to ``place=paddle.CUDAPlace(0)``. .. code-block:: text We use the dtype conversion rules following this: Keep dtype np.number ───────────► paddle.Tensor (0-D Tensor) default_dtype Python Number ───────────────► paddle.Tensor (0-D Tensor) Keep dtype np.ndarray ───────────► paddle.Tensor Args: data(scalar|tuple|list|ndarray|Tensor): Initial data for the tensor. Can be a scalar, list, tuple, numpy\.ndarray, paddle\.Tensor. dtype(str|paddle.dtype|np.dtype, optional): The desired data type of returned tensor. Can be 'bool' , 'float16' , 'float32' , 'float64' , 'int8' , 'int16' , 'int32' , 'int64' , 'uint8', 'complex64' , 'complex128'. Default: None, infers dtype from ``data`` except for python float number which gets dtype from ``get_default_type`` . place(CPUPlace|CUDAPinnedPlace|CUDAPlace|str, optional): The place to allocate Tensor. Can be CPUPlace, CUDAPinnedPlace, CUDAPlace. Default: None, means global place. If ``place`` is string, It can be ``cpu``, ``gpu:x`` and ``gpu_pinned``, where ``x`` is the index of the GPUs. device: An alias for ``place`` , with identical behavior. stop_gradient(bool, optional): Whether to block the gradient propagation of Autograd. Default: True. Returns: Tensor: A Tensor constructed from ``data`` . Examples: .. code-block:: python >>> import paddle >>> type(paddle.to_tensor(1)) >>> paddle.to_tensor(1) Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, 1) >>> x = paddle.to_tensor(1, stop_gradient=False) >>> print(x) Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=False, 1) >>> paddle.to_tensor(x) # A new tensor will be created with default stop_gradient=True Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, 1) >>> paddle.to_tensor([[0.1, 0.2], [0.3, 0.4]], place=paddle.CPUPlace(), stop_gradient=False) Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=False, [[0.10000000, 0.20000000], [0.30000001, 0.40000001]]) >>> type(paddle.to_tensor([[1+1j, 2], [3+2j, 4]], dtype='complex64')) >>> paddle.to_tensor([[1+1j, 2], [3+2j, 4]], dtype='complex64') Tensor(shape=[2, 2], dtype=complex64, place=Place(cpu), stop_gradient=True, [[(1+1j), (2+0j)], [(3+2j), (4+0j)]]) )r9rrrsr)rr9rrOs r: to_tensorr1s^  %7H r<c[U[R5(d[S[ U5S35e[ U5$)a Creates a ``paddle.Tensor`` from a ``numpy.ndarray``. The returned Tensor and the input ``ndarray`` share the same underlying memory. Changes to the Tensor will be reflected in the ``ndarray`` and vice versa. Args: ndarray(numpy.ndarray): The numpy ndarray to be converted to a Tensor. Returns: Tensor: A Tensor that shares the same memory with the input ``ndarray``. Examples: .. code-block:: python >>> import paddle >>> import numpy as np >>> np_data = np.array([1, 2, 3]).astype('int64') >>> tensor = paddle.from_numpy(np_data) >>> print(tensor) Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True, [1, 2, 3]) zCThe input type of from_numpy() must be numpy.ndarray, but received zG. To convert other types to tensor, please use paddle.tensor() instead.)rrVrWrrfr)rWs r: from_numpyrsJ2 grzz * *QRVW^R_Q`aT T   '?r<)r9rrcopyrsc[XX$S9$)u Constructs a ``paddle.Tensor`` from ``obj`` , which can be scalar, tuple, list, numpy\.ndarray, paddle\.Tensor. If the ``obj`` is already a tensor, copy will be performed and return a new tensor. .. note:: The parameter ``copy`` will not affect this api's behavior. Copy will always be performed if ``obj`` is a tensor. .. code-block:: text We use the dtype conversion rules following this: Keep dtype np.number ───────────► paddle.Tensor (0-D Tensor) default_dtype Python Number ───────────────► paddle.Tensor (0-D Tensor) Keep dtype np.ndarray ───────────► paddle.Tensor Args: obj(scalar|tuple|list|ndarray|Tensor): Initial data for the tensor. Can be a scalar, list, tuple, numpy\.ndarray, paddle\.Tensor. dtype(str|np.dtype, optional): The desired data type of returned tensor. Can be 'bool' , 'float16' , 'float32' , 'float64' , 'int8' , 'int16' , 'int32' , 'int64' , 'uint8', 'complex64' , 'complex128'. Default: None, infers dtype from ``data`` except for python float number which gets dtype from ``get_default_type`` . device(CPUPlace|CUDAPinnedPlace|CUDAPlace|str, optional): The place to allocate Tensor. Can be CPUPlace, CUDAPinnedPlace, CUDAPlace. Default: None, means global place. If ``place`` is string, It can be ``cpu``, ``gpu:x`` and ``gpu_pinned``, where ``x`` is the index of the GPUs. copy(bool, optional): This param is ignored and has no effect. requires_grad(bool, optional): Whether to block the gradient propagation of autograd. Default: False. Returns: Tensor: A Tensor constructed from ``data`` . Examples: .. code-block:: python >>> import paddle >>> type(paddle.asarray(1)) >>> paddle.asarray(1) Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, 1) >>> x = paddle.asarray(1, requires_grad=True) >>> print(x) Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=False, 1) >>> paddle.asarray(x) # A new tensor will be created with default stop_gradient=True Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, 1) >>> paddle.asarray([[0.1, 0.2], [0.3, 0.4]], device=paddle.CPUPlace(), requires_grad=True) Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=False, [[0.10000000, 0.20000000], [0.30000001, 0.40000001]]) >>> type(paddle.asarray([[1+1j, 2], [3+2j, 4]], dtype='complex64')) >>> paddle.asarray([[1+1j, 2], [3+2j, 4]], dtype='complex64') Tensor(shape=[2, 2], dtype=complex64, place=Place(cpu), stop_gradient=True, [[(1+1j), (2+0j)], [(3+2j), (4+0j)]]) )rr9rrrsr)objr9rrrrss r:asarrayrs^  f r<c^^\rSrSrSrSU4SjjrSSU4SjjjrSrU=r$) MmapStorageia/ This class will use mmap to load a file. Args: filename(str): the name of .safetensors file. nbytes(int): number of bytes to map into memory. Examples: .. code-block:: python >>> import paddle >>> shape = [4,5] >>> dtype = paddle.float32 >>> a = paddle.arange(4*5).reshape(shape).astype(dtype) >>> a.numpy().tofile("test.pp") >>> size = a.size * a.element_size() >>> t = paddle.MmapStorage("test.pp", size) >>> t.get_slice(dtype = dtype, start = 0, stop = a.size).reshape(shape) Tensor(shape=[4, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[0. , 1. , 2. , 3. , 4. ], [5. , 6. , 7. , 8. , 9. ], [10., 11., 12., 13., 14.], [15., 16., 17., 18., 19.]]) c$>[TU]X5 gr,)super__init__)selffilenamenbytes __class__s r:rMmapStorage.__init__s *r<cz>[RRRU5n[TU]XRX45nU$)aW Slice the tensor from the mmapped file. Args: dtype (DTypeLike | None): The data type of the output tensor. Default: "uint8". start (int): The start index of the slice. Default: 0. stop (int): The end index of the slice. Default: -1. step (int): The step size of the slice. Default: 1. Returns: Tensor: The sliced tensor. )r3r frameworkconvert_to_proto_typer get_slice)rr9rzrmstep proto_dtyperqrs r:rMmapStorage.get_slices:"kk++AA%H 161B 2  r<)rrrrX)rKrrw) r9DTypeLike | NonerzrXrmrXrrXrr) __name__ __module__ __qualname____firstlineno____doc__rr__static_attributes__ __classcell__)rs@r:rrsU4+ #*      r<rxinput)rrrsrc[U[R[[R R [[RR45(d[S[U5S35eUc URnOD[U[RR[R 45(d [#U5nUc UR$n['5(GaUb [)U5O [+5nU(Ga#[-5(GaUGb[U[R.[R045(d[U[R25(d4[U[R45(a+UR75(a[R."5nOw[U[R85(d4[U[R45(a+UR;5(a[R0"5nO[=SU35e[>R@"XX$5nUSLaSUl!U(a[-5(aURE5nU$[GS0[I5D6n[KUS/SQS5 [MUS /SQS 5 UROUS 9n URQS S U/0XS.SU /0S9 SU l!U $)a This function creates a tensor filled with ``fill_value`` which has identical shape of ``x`` and ``dtype``. If the ``dtype`` is None, the data type of Tensor is same with ``x``. .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``. For example, ``full_like(input=tensor_x, ...)`` is equivalent to ``full_like(x=tensor_x, ...)``. Args: x(Tensor): The input tensor which specifies shape and data type. The data type can be bool, float16, float32, float64, int32, int64. fill_value(bool|float|int): The value to fill the tensor with. Note: this value shouldn't exceed the range of the output data type. dtype(str|paddle.dtype|np.dtype, optional): The data type of output. The data type can be one of bool, float16, float32, float64, int32, int64. The default value is None, which means the output data type is the same as input. name(str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. device(PlaceLike|None, optional): The desired device of returned tensor. if None, uses the current device for the default tensor type (see paddle.device.set_device()). device will be the CPU for CPU tensor types and the current CUDA device for CUDA tensor types. Default: None. requires_grad(bool, optional): If autograd should record operations on the returned tensor. Default: False. pin_memory(bool, optional): If set, return tensor would be allocated in the pinned memory. Works only for CPU tensors. Default: False Returns: Tensor: Tensor which is created according to ``x``, ``fill_value`` and ``dtype``. Examples: .. code-block:: python >>> import paddle >>> input = paddle.full(shape=[2, 3], fill_value=0.0, dtype='float32', name='input') >>> output = paddle.full_like(input, 2.0) >>> print(output.numpy()) [[2. 2. 2.] [2. 2. 2.]] zlThe fill_value should be int, float, bool, complex, np.number, string numeric value or Tensor, but received rrTF full_liker )r@rDrErFrHrIrJrLr9zfull_like/zeros_like/ones_liker8 fill_any_likeX)rPr9rrr))rnumbersNumberrrrrrr3r4rrrfr9r-r.r5rrrrrrrrrrrr is_xpu_placerrrrOrrrYrrrr) r  fill_valuer9rNrrrsrrr`rqs r:rr0sb  djj//6::;K;KL  z{AK|L{MMN O   }%$,,"6"6 !FGG.u5E ~! f %(*  !!"--t/B/BC&$..1164::..63F3F3H3H--/FDMM2264::..63F3F3H3H,,.":6(C!!!? D #(F /++&&(F 5FH5         - 77e7D !:&7SEN  ! r<c[U[5(aU/OUn[5(Ga4Uc [5nO [ U5nU(a[ R "5n[U[ RR[ R45(d [U5n[5(aP[U[ RR5(a'[RR RUn[5(a;[U[ ["45(a[R$R'U5nO[R$R)U5 [U[ ["45(aD[R$R+U5(a[R$R-U5nO5[U[RR.5(aO [1S5eUc [2R4"XX5nSUlU$UR8U:wa [1S5e[2R:"X@X!U5nSUlU$SU0n[=U5n[U[>5(dQUS;a&[A[U55US'[U5US'O%[A[CU55US'[CU5US'[ES0[G5D6n0n [U[>5(a3[=UR85U:wa[RH"X!5nX)S '[R$R)U5 [KUS /S QS5 [MUS [>[ ["4S5 Ub[OUS [=U5/S5 [ES0[G5D6n[R$RQXUSS9 UcURSUS9nUR8US 'URUSU SU/0USS9 SUlU$)N-Shape only supports Value, or list, or tuple.TzTRequired out.dtype == dtype if specifying out, but received f{out.dtype} != f{dtype}rQ)rGrKrHrIrJ str_valuerPr ValueTensorr9)r@rDrErFrGrKrHrIrJrrrL float8_e4m3fn float8_e5m2r?rqrrr?op_typer8rrfrrrrO)r)+rrXrrrrCPUPlacer-r.r5rr r3r4rrrTrUutilsconvert_shape_to_list check_shape _contain_varget_int_tensor_listrrrrrOr9full_rrrr^rrYrrrrget_shape_tensor_inputsrr) r?r9rPrQrqrrNrr`rs r:rrsF"%--UG5E =+-E%e,E MMOE%$,,"6"6 !FGG.u5E ==Zt||/C/CDDJJOO77>E   %$// ::5A LL $ $U +%$//<<,,U33"LL<>> import paddle >>> # shape is a list/tuple >>> data1 = paddle.ones(shape=[3, 2]) >>> print(data1.numpy()) [[1. 1.] [1. 1.] [1. 1.]] >>> # shape is a Tensor >>> shape = paddle.to_tensor([3, 2]) >>> data2 = paddle.ones(shape=shape) >>> print(data2.numpy()) [[1. 1.] [1. 1.] [1. 1.]] >>> # shape is a Tensor List >>> shape = [paddle.to_tensor(3), paddle.to_tensor(2)] >>> data3 = paddle.ones(shape=shape) >>> print(data3.numpy()) [[1. 1.] [1. 1.] [1. 1.]] rwrqrrrsrrNrr?r9rNrqrrrsrs r:onesr+3s*v    #   r<c  [USUUUUUS9$)a< Returns a Tensor filled with the value 1, with the same shape and data type (use ``dtype`` if ``dtype`` is not None) as ``x``. .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``. For example, ``ones_like(input=tensor_x, ...)`` is equivalent to ``ones_like(x=tensor_x, ...)``. Args: x(Tensor): The input tensor which specifies shape and dtype. The dtype of ``x`` can be bool, float16, float32, float64, int32, int64. dtype(str|paddle.dtype|np.dtype, optional): The data type of the output tensor. Supported data types: bool, float16, float32, float64, int32, int64. If ``dtype`` is None, the data type is the same as ``x``. Default is None. name(str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. device(PlaceLike|None, optional): The desired device of returned tensor. if None, uses the current device for the default tensor type (see paddle.device.set_device()). device will be the CPU for CPU tensor types and the current CUDA device for CUDA tensor types. Default: None. requires_grad(bool, optional): If autograd should record operations on the returned tensor. Default: False. pin_memory(bool, optional): If set, return tensor would be allocated in the pinned memory. Works only for CPU tensors. Default: False Returns: Tensor: A Tensor filled with the value 1, with the same shape and data type (use ``dtype`` if ``dtype`` is not None) as ``x``. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([1,2,3]) >>> out1 = paddle.ones_like(x) >>> print(out1.numpy()) [1 1 1] >>> out2 = paddle.ones_like(x, dtype='int32') >>> print(out2.numpy()) [1 1 1] rw)r rr9rNrrrrsrr r9rNrrrsrs r: ones_liker.zs'd   # r<c "[USUUUUUUS9$)a Creates a tensor of specified :attr:`shape` and :attr:`dtype`, and fills it with 0. .. note:: Alias Support: The parameter name ``size`` can be used as an alias for ``shape``. ``shape`` can be a variable number of arguments. For example: ``paddle.ones(1, 2, 3, dtype=paddle.float32)`` ``paddle.ones(size=[1, 2, 3], dtype=paddle.float32)`` Args: shape (tuple|list|Tensor|variable number of arguments): Shape of the Tensor to be created. The data type is ``int32`` or ``int64`` . alias: ``size``. If ``shape`` is a list or tuple, each element of it should be integer or 0-D Tensor with shape []. If ``shape`` is an Tensor, it should be an 1-D Tensor which represents a list. dtype(str|paddle.dtype|np.dtype, optional): Data type of output Tensor, it supports bool, float16, float32, float64, int32 and int64. Default: if None, the data type is float32. property. For more information, please refer to :ref:`api_guide_Name`. out(Tensor, optional): The output tensor. device(PlaceLike|None, optional): The desired device of returned tensor. if None, uses the current device for the default tensor type (see paddle.device.set_device()). device will be the CPU for CPU tensor types and the current CUDA device for CUDA tensor types. Default: None. requires_grad(bool, optional): If autograd should record operations on the returned tensor. Default: False. name(str|None, optional): The default value is None. Normally there is no need for user to set this pin_memory(bool, optional): If set, return tensor would be allocated in the pinned memory. Works only for CPU tensors. Default: False Returns: Tensor: A tensor of data type :attr:`dtype` with shape :attr:`shape` and all elements set to 0. Examples: .. code-block:: python >>> import paddle >>> # shape is a list/tuple >>> data1 = paddle.zeros(shape=[3, 2]) >>> print(data1.numpy()) [[0. 0.] [0. 0.] [0. 0.]] >>> # shape is a Tensor >>> shape = paddle.to_tensor([3, 2]) >>> data2 = paddle.zeros(shape=shape) >>> print(data2.numpy()) [[0. 0.] [0. 0.] [0. 0.]] >>> # shape is a Tensor List >>> shape = [paddle.to_tensor(3), paddle.to_tensor(2)] >>> data3 = paddle.zeros(shape=shape) >>> print(data3.numpy()) [[0. 0.] [0. 0.] [0. 0.]] rr(r)r*s r:zerosr0s*H    #   r<c  [USUUUUUS9$)a5 Returns a Tensor filled with the value 0, with the same shape and data type (use ``dtype`` if ``dtype`` is not None) as ``x``. .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``. For example, ``zeros_like(input=x, ...)`` is equivalent to ``zeros_like(x=x, ...)``. Args: x(Tensor): The input tensor which specifies shape and dtype. The dtype of ``x`` can be bool, float16, float32, float64, int32, int64. dtype(str|paddle.dtype|np.dtype, optional): The data type of the output tensor. Supported data types: bool, float16, float32, float64, int32, int64. If ``dtype`` is None, the data type is the same as ``x``. Default is None. name(str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. device(PlaceLike|None, optional): The desired device of returned tensor. if None, uses the current device for the default tensor type (see paddle.device.set_device()). device will be the CPU for CPU tensor types and the current CUDA device for CUDA tensor types. Default: None. requires_grad(bool, optional): If autograd should record operations on the returned tensor. Default: False. pin_memory(bool, optional): If set, return tensor would be allocated in the pinned memory. Works only for CPU tensors. Default: False Returns: Tensor: A Tensor filled with the value 0, with the same shape and data type (use ``dtype`` if ``dtype`` is not None) as ``x``. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([1, 2, 3]) >>> out1 = paddle.zeros_like(x) >>> print(out1.numpy()) [0 0 0] >>> out2 = paddle.zeros_like(x, dtype='int32') >>> print(out2.numpy()) [0 0 0] r)r rr9rNrrrsrrr-s r: zeros_liker2s'f   # r<num_rowsn num_columnsmc SnU"US5 Uc[R"5n[U[RR [R RR45(d [U5nUb U"US5 OUn[5(GaUb [U5O [5nU(Ga#[5(GaUGb[U[R[R45(d[U[R5(d4[U[R 5(a+UR#5(a[R"5nOw[U[R$5(d4[U[R 5(a+UR'5(a[R"5nO[)SU35e[*R,"UUUUUS9n USLaSU lUbSUlU(a[5(aU R15n U $[3S0[55D6n [7US /S QS5 U R9US 9nU R;S0S U/0UUUS .SS9 SUlU$)a This function constructs 2-D Tensor with ones on the diagonal and zeros elsewhere. .. note:: Alias Support: The parameter name ``n`` can be used as an alias for ``num_rows``, and ``m`` can be used as an alias for ``num_columns``. For example, ``eye(n=tensor_x, m=tensor_y, ...)`` is equivalent to ``eye(num_rows=tensor_x, num_columns=tensor_y, ...)``. Args: num_rows(int | paddle.Tensor): the number of rows in each batch Tensor. Alias: ``n``. num_columns(int | paddle.Tensor | None, optional): the number of columns in each batch Tensor. If None, default: num_rows. dtype(str|paddle.dtype|np.dtype, optional): The data type of the returned Tensor. It should be int32, int64, float16, float32, float64, complex64, complex128. Default: if None, the data type is float32. name(str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. out(Tensor, optional): The output tensor. device(PlaceLike|None, optional): The desired device of returned tensor. if None, uses the current device for the default tensor type (see paddle.device.set_device()). device will be the CPU for CPU tensor types and the current CUDA device for CUDA tensor types. Default: None. requires_grad(bool, optional): If autograd should record operations on the returned tensor. Default: False. pin_memory(bool, optional): If set, return tensor would be allocated in the pinned memory. Works only for CPU tensors. Default: False Returns: Tensor: An identity Tensor or DenseTensor of shape [num_rows, num_columns]. Examples: .. code-block:: python >>> import paddle >>> data = paddle.eye(3, dtype='int32') >>> print(data.numpy()) [[1 0 0] [0 1 0] [0 0 1]] >>> data = paddle.eye(2, 3, dtype='int32') >>> print(data.numpy()) [[1 0 0] [0 1 0]] c[U[[RR[ R R45(aI[UR5S:Xd/[UR5S:XaURSS;degg[U[[R45(aUS:a[US35eg)Nrrw)rwrz should be a non-negative int.)rrrrrr3r4rrr?rXrVintegerr)rdmessages r: _check_attreye.._check_attr|s dh (9(96::;K;KL N Ntzz?a'DJJ1$A')A )A(D3 "344qwi'EFG G9Ar<r3r5rryTFeyer9)rDrErFrLrIrJrrr8r)r3r5r9r)r=)r3rrrr-r.r4r5rrrrrrrrrrrrrrr=rOrrrYrrr) r3r5r9rNrqrrrsrr;rr`s r:r=r=Es?nH*% }((* edll22FJJOO4L4LM N N*51K/ ! f %(*  !!"--t/B/BC&$..1164::..63F3F3H3H--/FDMM2264::..63F3F3H3H,,.":6(C       D #(F $)! /++&&(F /fh/     77e7DSEN$*   C Jr<rc [U[R[[R R [[RR45(d[S[U5S35eUcO[U[5(aSnO7[U[R5(aSnO[R "5n[#5(GaCUb [%U5O ['5nU(Ga#[)5(GaUGb[U[R*[R,45(d[U[R.5(d4[U[R05(a+UR35(a[R*"5nOw[U[R45(d4[U[R05(a+UR75(a[R,"5nO[9SU35e[;UUUUUUS9nUSLaSUlUbSUlU(a[)5(aUR?5nU$) u Return a Tensor with the ``fill_value`` which size is same as ``shape``. .. note:: Alias Support: The parameter name ``size`` can be used as an alias for ``shape``. For example, ``full(size=[2, 3], …)`` is equivalent to ``full(shape=[2, 3], …)``. Args: shape (tuple|list|Tensor): Shape of the Tensor to be created. The data type is ``int32`` or ``int64`` . If ``shape`` is a list or tuple, each element of it should be integer or 0-D Tensor with shape []. If ``shape`` is an Tensor, it should be an 1-D Tensor which represents a list. Alias: ``size``. fill_value(Scalar|Tensor): The constant value used to initialize the Tensor to be created. If ``fill_value`` is an Tensor, it should be an 0-D Tensor which represents a scalar. dtype(str|paddle.dtype|np.dtype, optional): Data type of the output Tensor which can be float16, float32, float64, int32, int64, if dtype is `None`, the data type of created Tensor is `float32`. name(str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. out(Tensor, optional): The output tensor. device(PlaceLike|None, optional): The desired device of returned tensor. if None, uses the current device for the default tensor type (see paddle.device.set_device()). device will be the CPU for CPU tensor types and the current CUDA device for CUDA tensor types. Default: None. requires_grad(bool, optional): If autograd should record operations on the returned tensor. Default: False. pin_memory(bool, optional): If set, return tensor would be allocated in the pinned memory. Works only for CPU tensors. Default: False Returns: Tensor: Tensor which is created according to ``shape``, ``fill_value`` and ``dtype``. Examples: .. code-block:: python >>> import paddle >>> # shape is a list/tuple >>> data1 = paddle.full(shape=[3, 2], fill_value=1.) >>> print(data1.numpy()) [[1. 1.] [1. 1.] [1. 1.]] >>> # shape is a Tensor >>> shape = paddle.to_tensor([3, 2]) >>> data2 = paddle.full(shape=shape, fill_value=2.) >>> print(data2.numpy()) [[2. 2.] [2. 2.] [2. 2.]] >>> # shape is a Tensor List >>> shape = [paddle.to_tensor(3), paddle.to_tensor(2)] >>> data3 = paddle.full(shape=shape, fill_value=3.) >>> print(data3.numpy()) [[3. 3.] [3. 3.] [3. 3.]] >>> # fill_value is a Tensor. >>> val = paddle.full([], 2.0, "float32") >>> data5 = paddle.full(shape=[3, 2], fill_value=val) >>> print(data5.numpy()) [[2. 2.] [2. 2.] [2. 2.]] zmThe fill_value should be int, float, bool, complex, np.number, string numeric values or Tensor, but received rr@rr)r?r9rPrqrrNTF) rrrrrrrrr3r4rrrfr@builtinscomplexrrrrrrrrrrrrrrrOr) r?rr9rNrqrrrsrrs r:rrs^  djj//6::;K;KL  {}ABL}M|NNO P   } j4 ) )E  X%5%5 7 7 E,,.E! f %(*  !!"--t/B/BC&$..1164::..63F3F3H3H--/FDMM2264::..63F3F3H3H,,.":6(C   F$ ? %C o''""$ Mr<rwr(c  UcUnSnUcXU4Hn [U [[RR45(a6[R "U 5(d[R "5n OUSnMh[U [R5(d,[U [5(d[R "5n OSnM Sn [U[[RR45(+=(ae [U[[RR45(+=(a/ [U[[RR45(+n [5(d,U (a%[[R"X- U- 55/n [U[RR[R 45(d [#U5n[%5(GaCUb ['U5O [)5nU(Ga#[5(GaUGb[U[R*[R,45(d[U[R.5(d4[U[R05(a+UR35(a[R*"5nOw[U[R45(d4[U[R05(a+UR75(a[R,"5nO[9SU35eU (ak[;5(a\[<R>"UUUUUUS9n U(+U l Ub U(+Ul U(a[5(aU RC5n U $[U[[RR45(dK[ES5 [RF"U5(d[ISUS35e[KS /X0S S 9nSSS5 O_URLU:waO[5(a*[RF"U5(d[ISUS35e[RN"X5n[U[[RR45(dK[ES5 [RF"U5(d[IS US35e[KS /X1S S 9nSSS5 O_URLU:waO[5(a*[RF"U5(d[IS US35e[RN"X5n[U[[RR45(d![ES5 [KS /X2S S 9nSSS5 O&URLU:wa[RN"X#5n[%5(ar[<R>"UUUUUb ['U5O [)5US9n U(+U l Ub U(+Ul U(a[5(aU RC5n U $[QUS /SQS5 [SS0[U5D6n U RWX:S9nU RYSXUS.SU0S9 S Ul U bURZR]U 5 U$!,(df  GNN=f!,(df  GN=f!,(df  GN#=f)a Returns a 1-D Tensor with spaced values within a given interval. Values are generated into the half-open interval [``start``, ``end``) with the ``step``. (the interval including ``start`` but excluding ``end``). If ``dtype`` is float32 or float64, we advise adding a small epsilon to ``end`` to avoid floating point rounding errors when comparing against ``end``. Parameters: start(float|int|Tensor): Start of interval. The interval includes this value. If ``end`` is None, the half-open interval is [0, ``start``). If ``start`` is a Tensor, it is a 0-D Tensor which represents a scalar and data type is int32, int64, float32, float64. Default is 0. end(float|int|Tensor, optional): End of interval. The interval does not include this value. If ``end`` is a Tensor, it is a 0-D Tensor which represents a scalar and data type is int32, int64, float32, float64. If ``end`` is None, the half-open interval is [0, ``start``). Default is None. step(float|int|Tensor, optional): Spacing between values. For any out, it is the instance between two adjacent values, out[i+1] - out[i]. If ``step`` is a Tensor, it is a 0-D Tensor which represents a scalar and data type is int32, int64, float32, float64. . Default is 1. dtype(str|paddle.dtype|np.dtype, optional): The data type of the output tensor. Supported data types: int32, int64, float32, float64. If ``dtype`` is None, the data type is float32. Default is None. out(Tensor, optional): The output tensor. device(PlaceLike|None, optional): The desired device of returned tensor. if None, uses the current device for the default tensor type (see paddle.device.set_device()). device will be the CPU for CPU tensor types and the current CUDA device for CUDA tensor types. Default: None. requires_grad(bool, optional): If autograd should record operations on the returned tensor. Default: False. pin_memory(bool, optional): If set, return tensor would be allocated in the pinned memory. Works only for CPU tensors. Default: False name(str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: A 1-D Tensor with values from the interval [``start``, ``end``) taken with common difference ``step`` beginning from ``start``. Its data type is set by ``dtype``. Examples: .. code-block:: python >>> import paddle >>> out1 = paddle.arange(5) >>> print(out1.numpy()) [0 1 2 3 4] >>> out2 = paddle.arange(3, 9, 2.0) >>> print(out2.numpy()) [3. 5. 7.] >>> # use 4.999 instead of 5.0 to avoid floating point rounding errors >>> out3 = paddle.arange(4.999, dtype='float32') >>> print(out3.numpy()) [0. 1. 2. 3. 4.] >>> start_var = paddle.to_tensor(3) >>> out4 = paddle.arange(start_var, 7) >>> print(out4.numpy()) [3 4 5 6] NrrJrryrvz1The value of start must be finite, but received: rrwTrxz/The value of end must be finite, but received: r9)rErFrIrJrDrLz range/arangerange)r?)r}EndSteprrfrr)rB)/rrr3r4r is_integerrrVr9rXrmathceilrr-r.r5rrrrrrrrrrrrr rarangerOrrisfiniterrr9rrrrYrrrr)rzrnrr9rqrrrsrrNval out_shapeis_value_inputrr`s r:rIrIcsV { }%C#&***:*:;<<((--"446E#E!#rzz22:c3;O;O"446E#E&I ux)9)9: ;; ?36::+;+; <= = ?4(FJJ,<, >   CK4#789: edll22DMMB C C*51! f %(*  !!"--t/B/BC&$..1164::..63F3F3H3H--/FDMM2264::..63F3F3H3H,,.":6(C+--       $10 ?$1 1C  /++&&(F eh (8(89 : : % ;;u%% GwaP"1#utDE !     V__U%;%;CE7!L  E) cHfjj&6&67 8 8 % ;;s## EcU!L U4@C ! e    V__S%9%9A#aH kk#% dXvzz'7'78 9 9 %  !eTBD! u {{4'    %"&),.  $10 ?$1 1C  /++&&(F    I   11777O"=CL  !  HH  y ) K! ! ! s$#7[<7[ [% [ ["% [4zpaddle.range is deprecated and will be removed in a future release because its behavior is inconsistent with Python's range builtin.Instead, use paddle.arange, which produces values in [start, end))reasonlevel)rqrrrsrNc UcUnSnUc[R"5n[U[[RR 45(+=(ae [U[[RR 45(+=(a/ [U[[RR 45(+n[U[ RR[ R45(d [U5nU(a[[5(aL[R"UUUUUb [U5O [5US9n U(+U lUb U(+UlU $[U[[RR 45(d![#S5 [%S/X0SS9nSSS5 O&UR&U:wa[R("X5n[U[[RR 45(d![#S5 [%S/X1SS9nSSS5 O&UR&U:wa[R("X5n[U[[RR 45(d![#S5 [%S/X2SS9nSSS5 O&UR&U:wa[R("X#5n[R"UUUUUb [U5O [5US9n U(+U lUb U(+UlU $!,(df  GNG=f!,(df  N=f!,(df  N}=f)a Returns a 1-D Tensor of size $$ \lfloor \dfrac{end - start}{step} \rfloor + 1 $$ with values from ``start`` to ``end`` with ``step``. ``step`` is the gap between two values in the tensor. $$ out_{i+1} = out_{i} + step $$ Values are generated into the half-open interval [``start``, ``end``) with the ``step``. (the interval including ``start`` but excluding ``end``). If ``dtype`` is float32 or float64, we advise adding a small epsilon to ``end`` to avoid floating point rounding errors when comparing against ``end``. Parameters: start(float|int|Tensor): Start of interval. The interval includes this value. If ``end`` is None, the half-open interval is [0, ``start``). If ``start`` is a Tensor, it is a 0-D Tensor which represents a scalar and data type is int32, int64, float32, float64. Default is 0. end(float|int|Tensor, optional): End of interval. The interval does not include this value. If ``end`` is a Tensor, it is a 0-D Tensor which represents a scalar and data type is int32, int64, float32, float64. If ``end`` is None, the half-open interval is [0, ``start``). Default is None. step(float|int|Tensor, optional): Spacing between values. For any out, it is the instance between two adjacent values, out[i+1] - out[i]. If ``step`` is a Tensor, it is a 0-D Tensor which represents a scalar and data type is int32, int64, float32, float64. . Default is 1. dtype(str|np.dtype, optional): The data type of the output tensor. Supported data types: int32, int64, float32, float64. If ``dtype`` is None, the data type is float32. Default is None. out(Tensor, optional): The output tensor. device(PlaceLike|None, optional): The desired device of returned tensor. if None, uses the current device for the default tensor type (see paddle.device.set_device()). device will be the CPU for CPU tensor types and the current CUDA device for CUDA tensor types. Default: None. requires_grad(bool, optional): If autograd should record operations on the returned tensor. Default: False. name(str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: A 1-D Tensor with values from the interval [``start``, ``end``) taken with common difference ``step`` beginning from ``start``. Its data type is set by ``dtype``. Examples: .. code-block:: python >>> import paddle >>> out1 = paddle.range(5) >>> print(out1.numpy()) [0 1 2 3 4 5] >>> out2 = paddle.range(3, 9, 2.0) >>> print(out2.numpy()) [3. 5. 7. 9.] >>> # use 4.999 instead of 5.0 to avoid floating point rounding errors >>> out3 = paddle.range(4.999, dtype='float32') >>> print(out3.numpy()) [0. 1. 2. 3. 4.] >>> start_var = paddle.to_tensor(3) >>> out4 = paddle.range(start_var, 7) >>> print(out4.numpy()) [3 4 5 6 7] NrryrvrwTrx)r3rrrr4rrr-r.r5rr rrange_v2rrrOrrr9r) rzrnrr9rqrrrsrNrMrs r:rBrBB sj { }((* ux)9)9: ;; ?36::+;+; <= = ?4(FJJ,<, > edll22DMMB C C*51+--    %"&),.  $10 ?$1 1C  eh (8(89 : : % !1#utDE!   E) cHfjj&6&67 8 8 % U4@C! e kk#% dXvzz'7'78 9 9 %  !eTBD! u {{4' __    ! f %(*  F -,F  -- MA! ! ! s$ L L! L2 L! L/2 McJURnURRSS5nUc SU35e[US/SQU5 [ UR 5S:a[ SUS35eURRSS 5n[U[45(d[S US 35eURRS S5nUcURURS 9nOURXBRSS9nURSSU0UUS:XaSOSS.SU0S9 U$)zBase op of tril_op and triu_opr Nzx cannot be None in ) rDrLrErFrIrJr@rrrz x shape in z must be at least 2-Ddiagonalrz diagonal in z must be a python IntrNr8Frk tril_triurrT)rSlowerrr) layer_typekwargsgetrrr?rrrXrrr9rlr)r`rr rSrNrqs r: _tril_triu_oprY sFG #t$A =:0 ::=      177|a;wi/DEFF}}  Q/H h ' ',wi/DEFF ==  VT *D |77agg7F$$WW%%   Qx $.TE   Jr<cN[5(a[R"X5$g)z Inplace version of ``tril`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_tril`. N)rrtril_r rSrNs r:r[r[ !||A((r<cN[5(a[R"X5$g)z Inplace version of ``triu`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_triu`. N)rrtriu_r\s r:r_r_ r]r<cgr,r)argsrNindexings r:meshgridrc( s r<)rNrbcgr,r)rNrbras r:rcrc0 sr<c|URSS5nURSS5nUcSn[U5S:Xa#[US[[ 45(aUSnUS;a[ SU35eUS :H=(a [U5S :nU(aUSUS/US SQ7n[5(a [R"[ U55nO[S0[5D6n[U[[ 45(d [S 5e[U5Hupx[URS /SQS 5 M! [U5n [ R""U 5V s/sHn UR%X RS9PM nn UR'S S[ U50SU0S9 U(aUSUSsUS'US'U$s sn f)u Takes a list of N tensors as input :attr:`*args`, each of which is 1-dimensional vector, and creates N-dimensional grids. Args: *args(Tensor|list of Tensor) : tensors (tuple(list) of tensor): the shapes of input k tensors are (N1,), (N2,),..., (Nk,). Support data types: ``float64``, ``bfloat16``, ``float16``, ``float32``, ``int32``, ``int64``, ``complex64``, ``complex128``. **kwargs (optional): Currently, only accept name in **kwargs The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. indexing (Optional[str]) : the indexing mode, either “xy” or “ij”, defaults to “ij”.If “xy” is selected, the first dimension corresponds to the cardinality of the second input and the second dimension corresponds to the cardinality of the first input. If “ij” is selected, the dimensions are in the same order as the cardinality of the inputs. Returns: Tensor: k tensors. The shape of each tensor is (N1, N2, ..., Nk) Examples: .. code-block:: pycon >>> import paddle >>> x = paddle.randint(low=0, high=100, shape=[100]) >>> y = paddle.randint(low=0, high=100, shape=[200]) >>> grid_x, grid_y = paddle.meshgrid(x, y) >>> print(grid_x.shape) paddle.Size([100, 200]) >>> print(grid_y.shape) paddle.Size([100, 200]) rNNrbijrwr)rfxyz1meshgrid: indexing must be 'ij' or 'xy', but got rgrrcz2The type of input args in meshgrid should be list.zcreate data type)rLrDrErFrIrJrrr8rrrE)rc)rXpoprrrTrUrrrrcrrYrrrr9r?rBrr) rarWrNrbswap_xyrqr`idinput_rois r:rcrc6 sB ::fd #Dzz*d+H 4yA~*T!WtUm<<Aw|#?z J  $13t9>GQa,48,ood4j)4684$u ..D $D/JB  "  *"$i^^C( (  5 5DGMM 5 J(   S$t*$5s|  QQAA J s%F9c*UHnUS:dM [S5e [U5nX@RU:wa[SUSURU35e/nSnUH3nXc-n[R"X/U/U/S9nUR U5 UnM5 U$)a~ Splits the input tensor into multiple sub tensors according to given split sizes. Args: self (Tensor): The input tensor to be split. split_sizes (list[int]): A list of non negative integers specifying the sizes of each split along dimension ``dim``. The sum of all elements in this list must equal the size of ``self`` along ``dim``. dim (int, optional): The dimension along which to split the tensor. Defaults to 0. Returns: list[Tensor]: A list of sub tensors resulting from splitting ``self`` along the specified dimension. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]) >>> # Split into two parts along the first dimension, of sizes 1 and 2 >>> splits = paddle.Tensor.split_with_sizes(x, [1, 2], dim=0) >>> print(splits) rzCsplit_with_sizes expects split_sizes have only non-negative entrieszSplit sizes add up to z but got the tensor's size of )axesstartsends)rsumr?r3sliceappend) r split_sizesdimrtotaloutsrzrnrqs r:split_with_sizesrx s6 !8U   E 3$UG+I$**UX/IZ [   D Elll4eUG3%H C  Kr<cZ[U[5(d [U5n[5(a[R "XX#5$SU/0nXUS.nSnU"XX#5 [ S 0[5D6nURURS9nURSSU/0XUS.SU/0S9 SUl U$) ax Creates a tensor whose diagonals of certain 2D planes (specified by dim1 and dim2) are filled by ``input``. By default, a 2D plane formed by the last two dimensions of the returned tensor will be selected. The argument ``offset`` determines which diagonal is generated: - If offset = 0, it is the main diagonal. - If offset > 0, it is above the main diagonal. - If offset < 0, it is below the main diagonal. Args: input(Tensor|numpy.ndarray): The input tensor. Must be at least 1-dimensional. The input data type should be float32, float64, int32, int64. offset(int, optional): Which diagonal to consider. Default: 0 (main diagonal). dim1(int, optional): The first dimension with respect to which to take diagonal. Default: -2. dim2(int, optional): The second dimension with respect to which to take diagonal. Default: -1. Returns: Tensor, the output data type is the same as input data type. Examples: .. code-block:: python >>> import paddle >>> diag_embed_input = paddle.arange(6) >>> diag_embed_output1 = paddle.diag_embed(diag_embed_input) >>> print(diag_embed_output1) Tensor(shape=[6, 6], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [0, 0, 2, 0, 0, 0], [0, 0, 0, 3, 0, 0], [0, 0, 0, 0, 4, 0], [0, 0, 0, 0, 0, 5]]) >>> diag_embed_output2 = paddle.diag_embed(diag_embed_input, offset=-1, dim1=0,dim2=1 ) >>> print(diag_embed_output2) Tensor(shape=[7, 7], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0], [0, 0, 2, 0, 0, 0, 0], [0, 0, 0, 3, 0, 0, 0], [0, 0, 0, 0, 4, 0, 0], [0, 0, 0, 0, 0, 5, 0]]) >>> diag_embed_input_2dim = paddle.reshape(diag_embed_input,[2,3]) >>> print(diag_embed_input_2dim) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 1, 2], [3, 4, 5]]) >>> diag_embed_output3 = paddle.diag_embed(diag_embed_input_2dim,offset= 0, dim1=0, dim2=2 ) >>> print(diag_embed_output3) Tensor(shape=[3, 2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[[0, 0, 0], [3, 0, 0]], [[0, 1, 0], [0, 4, 0]], [[0, 0, 2], [0, 0, 5]]]) Input)offsetdim1dim2cZ[URS/SQS5 [UR5n[ U5S:dS[ U5S35e[ R "U5[ U5::d'S[ U5S-*S[ U5S US 35e[ R "U5[ U5::d'S [ U5S-*S[ U5S US 35eUS :aUO[ U5U-S-nUS :aUO[ U5U-S-nXV:wdS USUS35eg)Nrz)rIrJrDrErF diag_embedrwzHInput must be at least 1-dimensional, But received Input's dimensional: z. z2Dim1 is out of range (expected to be in range of [z, z ], but got z). z2Dim2 is out of range (expected to be in range of [rz?dim1 and dim2 cannot be the same dimension.But received dim1 = z , dim2 =  )rr9rTr?rrVabs)r r{r|r} input_shapedim1_dim2_s r: __check_input!diag_embed..__check_input s| KK  ?   5;;' ;1$  114[1A0B# G $ vvd|s;// @3{CSVWCWAX@YY[\_`k\l[mmxy}x~C D /vvd|s;// @3{CSVWCWAX@YY[\_`k\l[mmxy}x~C D / s;'7$'>'B s;'7$'>'B~  ##'& $r ; ~r<rr8rrT)r) rrrrrrrrYrr9rrO) r r{r|r}rrrr`rqs r:rr sD eX & &u   ;;w FT :E :%,  2 2F  3 3%++ 3 FC  %!t<  C Jr<c[5(a_[UR5S::a[R"XS5$[R "USS5n[R"X1S5$Sn[ US[S5 [URS/SQS5 [ US[S5 [S0[5D6nURURS9nURUR5nURURS9n[UR5S::aURS S U0S U0XS .S 9 O8URSS U0XgS.SSS.S 9 SUlURS S U0S U0XS .S 9 SUlU$)a If ``x`` is a vector (1-D tensor), a 2-D square tensor with the elements of ``x`` as the diagonal is returned. If ``x`` is a tensor (more than 1-D), a 2-D square tensor with the elements of flattened ``x`` as the diagonal is returned. The argument ``offset`` controls the diagonal offset. If ``offset`` = 0, it is the main diagonal. If ``offset`` > 0, it is superdiagonal. If ``offset`` < 0, it is subdiagonal. Args: x (Tensor): The input tensor. It can be any shape. Its data type should be float16, float32, float64, int32, int64. offset (int, optional): The diagonal offset. A positive value represents superdiagonal, 0 represents the main diagonal, and a negative value represents subdiagonal. Default: 0 (main diagonal). name(str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor, a square matrix. The output data type is the same as input data type. Examples: .. code-block:: python :name: diagflat-example-1 >>> import paddle >>> x = paddle.to_tensor([1, 2, 3]) >>> y = paddle.diagflat(x) >>> print(y) Tensor(shape=[3, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[1, 0, 0], [0, 2, 0], [0, 0, 3]]) >>> y = paddle.diagflat(x, offset=1) >>> print(y) Tensor(shape=[4, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 1, 0, 0], [0, 0, 2, 0], [0, 0, 0, 3], [0, 0, 0, 0]]) >>> y = paddle.diagflat(x, offset=-1) >>> print(y) Tensor(shape=[4, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 0, 0, 0], [1, 0, 0, 0], [0, 2, 0, 0], [0, 0, 3, 0]]) .. code-block:: python :name: diagflat-example-2 >>> import paddle >>> x = paddle.to_tensor([[1, 2], [3, 4]]) >>> y = paddle.diagflat(x) >>> print(y) Tensor(shape=[4, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[1, 0, 0, 0], [0, 2, 0, 0], [0, 0, 3, 0], [0, 0, 0, 4]]) >>> y = paddle.diagflat(x, offset=1) >>> print(y) Tensor(shape=[5, 5], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 1, 0, 0, 0], [0, 0, 2, 0, 0], [0, 0, 0, 3, 0], [0, 0, 0, 0, 4], [0, 0, 0, 0, 0]]) >>> y = paddle.diagflat(x, offset=-1) >>> print(y) Tensor(shape=[5, 5], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 0, 0, 0, 0], [1, 0, 0, 0, 0], [0, 2, 0, 0, 0], [0, 0, 3, 0, 0], [0, 0, 0, 4, 0]]) rwrrr diagflat)rDrErFrIrJrLr{r8diag_v2rrr{ padding_valuerfrrrflatten_contiguous_range)rXShape) start_axis stop_axisT)r)rrr?rdiagflattenrrrr9rXrrYrrrO) r r{rNyrr`out1 out1_shapeout2s r:rr: sp qww<1 ;;q!, ,q!R(A;;q!, , 1cHz2 GG  I   68cJ7468488qww8G>>qwwG 88qww8G qww<1    Qx !'H     /Qx $;%&R8   "&D    T{ !'H   " r<c:[5(a[R"XU5$[US[S5 [ UR S/SQS5 [US[S5 [US[[4S5 [UR5S:wa:[UR5S:wa![S[UR535e[S0[5D6nURUR S 9nURSS U0S U0XS .S 9 SUlU$)a If ``x`` is a vector (1-D tensor), a 2-D square tensor with the elements of ``x`` as the diagonal is returned. If ``x`` is a matrix (2-D tensor), a 1-D tensor with the diagonal elements of ``x`` is returned. The argument ``offset`` controls the diagonal offset: If ``offset`` = 0, it is the main diagonal. If ``offset`` > 0, it is superdiagonal. If ``offset`` < 0, it is subdiagonal. Args: x (Tensor): The input tensor. Its shape is either 1-D or 2-D. Its data type should be float16, float32, float64, int32, int64, complex64, complex128. offset (int, optional): The diagonal offset. A positive value represents superdiagonal, 0 represents the main diagonal, and a negative value represents subdiagonal. padding_value (int|float, optional): Use this value to fill the area outside the specified diagonal band. Only takes effect when the input is a 1-D Tensor. The default value is 0. name(str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor, a square matrix or a vector. The output data type is the same as input data type. Examples: .. code-block:: python :name: diag-example-1 >>> import paddle >>> paddle.disable_static() >>> x = paddle.to_tensor([1, 2, 3]) >>> y = paddle.diag(x) >>> print(y) Tensor(shape=[3, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[1, 0, 0], [0, 2, 0], [0, 0, 3]]) >>> y = paddle.diag(x, offset=1) >>> print(y) Tensor(shape=[4, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 1, 0, 0], [0, 0, 2, 0], [0, 0, 0, 3], [0, 0, 0, 0]]) >>> y = paddle.diag(x, padding_value=6) >>> print(y) Tensor(shape=[3, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[1, 6, 6], [6, 2, 6], [6, 6, 3]]) .. code-block:: python :name: diag-example-2 >>> import paddle >>> paddle.disable_static() >>> x = paddle.to_tensor([[1, 2, 3], [4, 5, 6]]) >>> y = paddle.diag(x) >>> print(y) Tensor(shape=[2], dtype=int64, place=Place(cpu), stop_gradient=True, [1, 5]) >>> y = paddle.diag(x, offset=1) >>> print(y) Tensor(shape=[2], dtype=int64, place=Place(cpu), stop_gradient=True, [2, 6]) >>> y = paddle.diag(x, offset=-1) >>> print(y) Tensor(shape=[1], dtype=int64, place=Place(cpu), stop_gradient=True, [4]) r r) rDrLrErFrLrIrJrrr{rrwrz=The dimension of input x must be either 1 or 2, but received r8rrrrT)r)rrrrrrr9rXr^rr?rrrYrrrO)r r{rrNr`rqs r:rr s`{{1m441cHy1 GG    68cI6=/C<K qww<1 QWW!2OPSTUT[T[P\~^ 3&(377agg7F8CL#D  ! r<cUc[R"5n[U5n[5(Ga[ 5(a [R R U5nO[US/SQS5 [R RU5 [U[R5(aUR5n[U[[45(aD[R RU5(a[R R!U5nO5[U[R"R$5(aO ['S5eUb [)U5O [+5nU(Ga#[ 5(GaUGb[U[,R.[,R045(d[U[,R25(d4[U[,R45(a+UR75(a[,R."5nOw[U[,R85(d4[U[,R45(a+UR;5(a[,R0"5nO[=SU35e[>R@"U[CU5UUS9nU(a[ 5(aURE5nUSLaSUl#UbSUl#U$[IS0[K5D6n0n [US/SQS5 [MUS [N[[4S5 [U[N5(a[URPS S S /S5 0n [R RSXUSS 9 URUUS 9n[CU5U S'URWSU SU/0U SS9 SUl#U$)a& Returns a Tensor with uninitialized data which size is same as ``shape``. Args: shape (tuple|list|Tensor): Shape of the Tensor to be created. The data type is ``int32`` or ``int64`` . If ``shape`` is a list or tuple, each element of it should be integer or 0-D Tensor with shape []. If ``shape`` is an Tensor, it should be an 1-D Tensor which represents a list. dtype(str|paddle.dtype|np.dtype, optional): Data type of the output Tensor which can be bool, float16, float32, float64, int32, int64, complex64, complex128 if dtype is `None`, the data type of created Tensor use global default dtype (see ``get_default_dtype`` for details). name(str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. out(Tensor, optional): The output tensor. device(PlaceLike|None, optional): The desired device of returned tensor. if None, uses the current device for the default tensor type (see paddle.device.set_device()). device will be the CPU for CPU tensor types and the current CUDA device for CUDA tensor types. Default: None. requires_grad(bool, optional): If autograd should record operations on the returned tensor. Default: False. pin_memory(bool, optional): If set, return tensor would be allocated in the pinned memory. Works only for CPU tensors. Default: False Returns: Tensor: Tensor which is created according to ``shape`` and ``dtype``, and is uninitialized. Examples: .. code-block:: python >>> import paddle >>> # shape is a list/tuple >>> data1 = paddle.empty(shape=[3, 2]) >>> print(data1.numpy()) >>> # doctest: +SKIP('change everytime') [[1. 1.] [1. 1.] [1. 1.]] >>> # shape is a Tensor >>> shape = paddle.to_tensor([3, 2]) >>> data2 = paddle.empty(shape=shape) >>> print(data2.numpy()) >>> # doctest: +SKIP('change everytime') [[1. 1.] [1. 1.] [1. 1.]] >>> # shape is a Tensor List >>> shape = [paddle.to_tensor(3), paddle.to_tensor(2)] >>> data3 = paddle.empty(shape=shape) >>> print(data3.numpy()) >>> # doctest: +SKIP('change everytime') [[1. 1.] [1. 1.] [1. 1.]] r9) r@rDrErFrLrGrHrIrJrrremptyrrryTFr?rIrJrr8rr)r),r3rrrrr r!rr"rrVrWtolistrTrUr#r$r4rrrrrrrrrrrrrrrrrrOrrYrrr9r&rr) r?r9rNrqrrrsrrr`rrs r:rr< sB }((* % E   LL66u=E  # ( LL $ $U +%,, %$//<<,,U33"LL<>> import paddle >>> paddle.set_device("cpu") # and use cpu device >>> x = paddle.randn([2, 3], 'float32') >>> output = paddle.empty_like(x) >>> print(output) >>> # doctest: +SKIP('change everytime') [[1.8491974e+20 1.8037303e+28 1.7443726e+28] [4.9640171e+28 3.0186127e+32 5.6715899e-11]] rTF empty_liker ) r@rDrErFrGrHrIrJrLrrr9r8rrrr)r) r9rrrrrrrrrrrrrrrrr?r3rrrrOrrrYrrrr r&r) r r9rNrrrsrx_shaperr`rqrrr?s r:rr s^^ } ~ % E! f %(*  !!"--t/B/BC&$..1164::..63F3F3H3H--/FDMM2264::..63F3F3H3H,,.":6(C   ggGll1oG  &u -   D #(F /++&&(F 6VX6   ! $     ! $77e7D3E:g Q ,,e\ -  SEN  ! r<c XLa1[U[[RR45(aU$Un[ S0[ 5D6n[US[[RR[R[[[[[4S5 [R"U5(a-[U[ 5(d[R""U/5nO1[U[[45(a[R""U5n[U[[$R&R([RR45(a[+5(a4Uc[,R."U5nU$[,R0"X!5nU$[3UR4S/SQSS5 UcUR7UR4S9nUR9SSU/0SU/0S9 U$[U[R5(Ga-[;UR<5S :a[?S U55(ah[AS U55(d [CS 5eS n[[EXB55n[RF"U5n[RH"US5nU$UR4S:Xa [CS5e[KUR45n[3US/SQSS5 SnURM5RO5n Sn URPU :a*S SK)J*n U "SS9n [WS5n U RYU 5 U e[+5(aUc[[[UR<5U5n[]5(a7[,R^"U[UR<5UU [a55 U$[,R^"U[UR<5UU [a55nU$UcUR7UR4S9nUR9SSU/0SUS[UR<5X0S9 U$)a Copy value of the :attr:`x` to the :attr:`output`. Parameters: x (Tensor|np.ndarray|list|tuple|scalar): A Tensor, numpy ndarray, tuple/list of scalar, or scalar. Its data type can be float16, float32, float64, int32, int64 or bool. Note: the float64 data will be converted to float32 because of current platform protobuf data limitation. output (Tensor|None, optional): A Tensor. If :attr:`output` is None, a new Tensor will be created as :attr:`output`. Default: None. Returns: Tensor: A Tensor with the same shape, data type and value as :attr:`x`. Examples: .. code-block:: python >>> import paddle >>> import numpy as np >>> data = paddle.full(shape=[3, 2], fill_value=2.5, dtype='float64') >>> print(data.numpy()) [[2.5 2.5] [2.5 2.5] [2.5 2.5]] >>> array = np.array([[1, 1], [3, 4], [1, 3]]).astype( ... np.int64 ... ) >>> result1 = paddle.zeros(shape=[3, 3], dtype='float32') >>> paddle.assign(array, result1) >>> print(result1.numpy()) [[1 1] [3 4] [1 3]] >>> result2 = paddle.assign(data) >>> print(result2.numpy()) [[2.5 2.5] [2.5 2.5] [2.5 2.5]] >>> result3 = paddle.assign(np.array([[2.5, 2.5], [2.5, 2.5], [2.5, 2.5]], dtype='float32')) >>> print(result3.numpy()) [[2.5 2.5] [2.5 2.5] [2.5 2.5]] rr ) rDrLrErFrHrIrJrKrGr@rrz/(When the type of input in assign is Variable.)r8rrrErc3v# UH/n[U[[RR45v M1 g7fr,)rrr3r4r.0r s r: assign..s,( AFAJq8VZZ%5%56 7 7s79c3# UH^n[U[[RR[ R R45(dMMURS:Hv M` g7f))rwN) rrrrrr3r4rr?rs r:rrsIA$**"3"3VZZ5E5EF 4s A A(A(zLUnsupported paddle.assign([Variable, Variable...]) with non-scalar variable.c[U[[RR[ R R45(d [U5$U$r,) rrrrrr3r4rr)r s r:convert_scalarassign..convert_scalars@!$**"3"3VZZ5E5EF"!9$r<rrzrThe type of received input == `object`, it is not supported to convert to tensor, such as [[Var], [Var], [3], [4]])rErFrIrJr@rrz2(When the type of input in assign is numpy array.)valuesl) SotExtraInfoT)need_breakgraphzXThe size of input is too big. Please consider saving it to file and 'load_op' to load it assign_valuer9r?)rfrr)r)1rrr3r4rrrYrrVrWrTrUr^rXr@rrrrrrrrr assign_out_rr9rrrr?anyallrmaprsqueezerravelrrpaddle.jit.sot.utils.exceptionsrrattachr0r assign_value_r)r rr r`rrrr9 value_namermax_element_numrsot_extra_infoerrs r:rr sZ {z!h 0@0@%ABB E  .VX .F   JJ   JJ         {{5*UC"8"8%! ED%= ) ) %(DJJ$5$5vzz7G7GHII ! # #~u-B M ++E:~ M{   A% (~BB++C   sUGnuvh>O  J ME E2:: & & u{{ a C( AF( % %  b !^!;>> import paddle >>> import numpy as np >>> x = paddle.ones([2]) >>> x.stop_gradient = False >>> x.retain_grads() >>> clone_x = paddle.clone(x) >>> clone_x.retain_grads() >>> y = clone_x**3 >>> y.backward() >>> print(clone_x.grad.numpy()) # type: ignore [3. 3.] >>> print(x.grad.numpy()) # type: ignore [3. 3.] )clone)r rNs r:rrfs@ 779r<cSnUcSnO[R"5nURU5 UR5(aSnO_UR 5(aSnOGUR 5(aSnO/UR 5(aSnOUR5(aSn[5(a[R"X5$[S0[5D6n[US[S5 [U[[R R"45(a[%UR&S/S QSS 5 UcUR)UR&S 9nS U0nUR+SS U/0SU/0US9 U$)a The OP copies the :attr:`input` to the :attr:`output`. NOTE: currently, only support CUDAPlace <-> CUDAPinnedPlace. Parameters: input (Tensor): A tensor. Its data type supports float16, float32, float64, int32, int64, and bool. device (Place): Target place for the output. output (Tensor, optional): A tensor. If :attr:`output` is None, a new tensor will be created as :attr:`output`. Default: None. Returns: Tensor, A tensor with the same shape, data type and value as :attr:`input`. Examples: .. code-block:: python >>> import paddle >>> data = paddle.full(shape=[3, 2], fill_value=2.5, dtype='float64') >>> print(data.numpy()) [[2.5 2.5] [2.5 2.5] [2.5 2.5]] >>> # doctest: +SKIP('NOTE(zhiqiu): not public') >>> result = paddle._memcpy(data, place=paddle.CPUPlace()) >>> print(result2) [[2.5 2.5] [2.5 2.5] [2.5 2.5]] rrrwrmemcpyr ) rDrLrErFrIrJrKrGr@z/(When the type of input in memcpy is Variable.)r8dst_place_typerrr)r)rr set_place is_cpu_placeris_cuda_pinned_placeris_custom_placer rrrrYrrrrrrr9rr)r rrrpr`rs r:_memcpyrsR@N } JJL E >>  N ^^  N  # # % %N ^^  N    N}}}}U33  .VX .Fug84%(DJJ$5$5677 KK    = "~:::M ~ .E  eW~!  Mr<ryc2[5(a[R"XUS9$[USSS/S5 [USSS/S5 Sn[ U40[ 5D6nXS.nUR [UR5S9nS U0n0nURXFXS 9 U$) aReturn a complex tensor given the real and image component. Args: real (Tensor): The real component. The data type should be 'float32' or 'float64'. imag (Tensor): The image component. The data type should be the same as ``real``. name(str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. out(Tensor|None, optional): The output tensor. Default: None. Returns: Tensor, The output tensor. The data type is 'complex64' or 'complex128', with the same precision as ``real`` and ``imag``. Note: ``paddle.complex`` supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor Examples: .. code-block:: python >>> import paddle >>> x = paddle.arange(2, dtype=paddle.float32).unsqueeze(-1) >>> y = paddle.arange(3, dtype=paddle.float32) >>> z = paddle.complex(x, y) >>> print(z) Tensor(shape=[2, 3], dtype=complex64, place=Place(cpu), stop_gradient=True, [[0j , 1j , 2j ], [(1+0j), (1+1j), (1+2j)]]) ryrealrErFr@imag)rYr8rr) rrr@rrrYrr>r9r) rrrNrqrr`rrrs r:r@r@sF~~dc22 &9i0)  ! &9i0) W11'77(48 #,u   r<rJc R[U[RR[R45(d [ U5n[U[ 5(aUS:a [S5eUb'[U[ 5(aUS:a [S5eOUn[5(a'UcUn[R"XX#[55nU$[U[ 5(d [S5e[S 0[5D6nURUS9nURS0SU/0XX#S.S 9 U$) a Return the indices of the lower triangular part of the 2-D matrix whose row and col is known. Indices are ordered based on row and then columns. The lower triangular part of the matrix is defined as the elements on and below the diagonal. Args: row (int): The input x which is a int number describe the number of row of the matrix. col (int): The input x which is a int number describe the number of col of the matrix. offset (int, optional): The offset to consider, default value is 0. - If offset = 0, all elements on and below the main diagonal are retained. - If offset > 0, include just as many diagonals above the main diagonal. - If offset < 0, excludes just as many diagonals below the main diagonal. dtype (str|core.VarDesc.VarType|core.DataType, optional): the data type of the output tensor, can be int32, int64. Returns: Tensor: Results of the indices of lower triangular part of a row * col matrix, where the first row contains row coordinates of and the second row contains column coordinates. Examples: .. code-block:: python >>> import paddle >>> # example 1, default offset value >>> data1 = paddle.tril_indices(4,4,0) >>> print(data1) Tensor(shape=[2, 10], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 1, 1, 2, 2, 2, 3, 3, 3, 3], [0, 0, 1, 0, 1, 2, 0, 1, 2, 3]]) >>> # example 2, positive offset value >>> data2 = paddle.tril_indices(4,4,2) >>> print(data2) Tensor(shape=[2, 15], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3], [0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]]) >>> # example 3, negative offset value >>> data3 = paddle.tril_indices(4,4,-1) >>> print(data3) Tensor(shape=[2, 6], dtype=int64, place=Place(cpu), stop_gradient=True, [[1, 2, 2, 3, 3, 3], [0, 0, 1, 0, 1, 2]]) r row should be a non-negative int col should be a non-negative intzoffset should be a int tril_indicesr8rq)rowscolsr{r9r)r)rrr-r.r5rrXrrrrrrrYrrrowcolr{r9rqr`s r:rrsd edll22DMMB C C*51 c3  37:;; #s##sQw>? ?(/ ;C!! f%<%>  &#&&56 68vx877e7DSENvN  Jr<c R[U[RR[R45(d [ U5n[U[ 5(aUS:a [S5eUb'[U[ 5(aUS:a [S5eOUn[5(a'UcUn[R"XX#[55nU$[U[ 5(d [S5e[S 0[5D6nURUS9nURS0SU/0XX#S.S 9 U$) a) Return the indices of the upper triangular part of the 2-D matrix whose row and col is known. Indices are ordered based on row and then columns. The upper triangular part of the matrix is defined as the elements on and above the diagonal. Args: row (int): The input x which is a int number describe the number of row of the matrix. col (int|None, optional): The input x which is a int number describe the number of col of the matrix. default value for col is None, then it will be set equal to row, indicting a square matrix. offset (int, optional): The offset to consider, default value is 0. - If offset = 0, all elements on and above the main diagonal are retained. - If offset > 0, include just as few diagonals above the main diagonal. - If offset < 0, excludes just as few diagonals below the main diagonal. dtype (str|np.dtype|core.VarDesc.VarType|core.DataType, optional): the data type of the output tensor, can be int32, int64, default value is int64. Returns: Tensor: Results of the indices of upper triangular part of a row * col matrix, where the first row contains row coordinates of and the second row contains column coordinates. Examples: .. code-block:: python >>> import paddle >>> # example 1, default offset value >>> data1 = paddle.triu_indices(4,4,0) >>> print(data1.numpy()) [[0 0 0 0 1 1 1 2 2 3] [0 1 2 3 1 2 3 2 3 3]] >>> # example 2, positive offset value >>> data2 = paddle.triu_indices(4,4,2) >>> print(data2.numpy()) [[0 0 1] [2 3 3]] >>> # example 3, negative offset value >>> data3 = paddle.triu_indices(4,4,-1) >>> print(data3.numpy()) [[0 0 0 0 1 1 1 1 2 2 2 3 3] [0 1 2 3 0 1 2 3 1 2 3 2 3]] rrrzoffset should be a int triu_indicesr8rq)rrr{r9r)r)rrr-r.r5rrXrrrrrrrYrrrs r:rrps\ edll22DMMB C C*51 c3  37:;; #s##sQw>? ?(/ ;C!! f%<%>  &#&&45 58vx877e7DSENVL  Jr<c[USSS/S5 [USSS/S5 [R"U[R"U5-U[R"U5-X2S9$)aReturn a Cartesian coordinates corresponding to the polar coordinates complex tensor given the ``abs`` and ``angle`` component. Args: abs (Tensor): The abs component. The data type should be 'float32' or 'float64'. angle (Tensor): The angle component. The data type should be the same as ``abs``. name (str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. out (Tensor, optional): The output tensor. If set, the result will be stored in this tensor. Default is None. Returns: Tensor, The output tensor. The data type is 'complex64' or 'complex128', with the same precision as ``abs`` and ``angle``. Note: ``paddle.polar`` supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor Examples: .. code-block:: python >>> import paddle >>> import numpy as np >>> abs = paddle.to_tensor([1, 2], dtype=paddle.float64) >>> angle = paddle.to_tensor([np.pi / 2, 5 * np.pi / 4], dtype=paddle.float64) >>> out = paddle.polar(abs, angle) >>> print(out) Tensor(shape=[2], dtype=complex128, place=Place(cpu), stop_gradient=True, [ (6.123233995736766e-17+1j) , (-1.4142135623730954-1.414213562373095j)]) rrErFz paddle.polarangle)rqrN)rr3r@cossin)rrrNrqs r:polarrsdJS%)Y)?P wI. >> fjjvzz%'8!8c r<cUR5 [R"U5RUR5n[R"S5RUR5nUR U5R [R5R5R U5RU5 U$)a5Fills the tensor with numbers drawn from the Cauchy distribution. Args: x (Tensor): the tensor will be filled, The data type is float32 or float64. loc (scalar, optional): Location of the peak of the distribution. The data type is float32 or float64. scale (scalar, optional): The half-width at half-maximum (HWHM). The data type is float32 or float64. Must be positive values. name(str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: input tensor with numbers drawn from the Cauchy distribution. Examples: .. code-block:: python >>> import paddle >>> x = paddle.randn([3, 4]) >>> x.cauchy_(1, 2) >>> # doctest: +SKIP('random check') >>> print(x) Tensor(shape=[3, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 3.80087137, 2.25415039, 2.77960515, 7.64125967], [ 0.76541221, 2.74023032, 1.99383152, -0.12685823], [ 1.45228469, 1.76275957, -4.30458832, 34.74880219]]) g?) normal_r3rrr9 subtract_scale_rVpitan_add_)r locscalerNhalfs r:cauchy_rs@IIK   3  & &qww /C   C ' ' 0DKKRUU#((*11%8==cB Hr<cr[R"[UR5S9Rn[ R "U5RUR5nUR[U5[S5S9 UR5R[ R"U*55 U$)aFills the tensor with numbers drawn from the Geometric distribution. Args: x (Tensor): the tensor will be filled, The data type is float32 or float64. probs (float|Tensor): Probability parameter. The value of probs must be positive. When the parameter is a tensor, probs is probability of success for each trial. name(str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: input tensor with numbers drawn from the Geometric distribution. Examples: .. code-block:: python >>> import paddle >>> x = paddle.randn([3, 4]) >>> x.geometric_(0.3) >>> # doctest: +SKIP('random check') >>> print(x) Tensor(shape=[3, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[2.42739224, 4.78268528, 1.23302543, 3.76555204], [1.38877118, 0.16075331, 0.16401523, 2.47349310], [1.72872102, 2.76533413, 0.33410925, 1.63351011]]) r8rw)minmax) rVfinforr9tinyr3rruniform_r^log_divide_log1p)r probsrNrs r: geometric_rs|> 88-0 1 6 6D   U # * *177 3EJJ5;E!HJ-FFHV\\E(+, Hr<cb[5(GaUR(a*UR(d[SURS35eUc'[ R "S/URS9nS/nS/nO`[U[[RR45(d[S[U535e[URS/SQS 5 Uc0Uc URnO [ R "U5RnUc UR n["R$"XX#U5$g) a> set x with specified source Tensor's underlying storage, shape, stride and offset. Note that the ``x`` will share the same data with ``source`` Tensor. Args: x (Tensor): An arbitrary Tensor. The data type supports ``bfloat16``, ``float16``, ``float32``, ``float64``, ``bool``, ``int8``, ``int16``, ``int32``, ``int64``, ``uint8``, ``complex64`` or ``complex128``. source (Tensor|None, optional): Define the target Tensor to use. The data type supports `bfloat16`, ``float16``, ``float32``, ``float64``, ``bool``, ``int8``, ``int16``, ``int32``, ``int64``, ``uint8``, ``complex64`` or ``complex128``. Default: None, which means to set ``x`` with an empty source tensor. shape (list|tuple|None, optional): Define the target shape. Each element of it should be integer. Default: None, which means it will use the specified ``source``'s shape as default value. stride (list|tuple|None, optional): Define the target stride. Each element of it should be integer. Default: None, and when ``shape`` is also None, it will use the specified ``source``'s stride as default value; when ``shape`` is specified, it will use the default stride corresponding to the specified ``shape``. offset (int, optional): Define the target offset from x's holder. Default: 0. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, the Tensor with the same data type as ``x``. Examples: .. code-block:: python >>> import paddle >>> src = paddle.to_tensor([[11., 22., 33.]]) >>> src2 = paddle.to_tensor([11., 22., 33., 44., 55., 66.]) >>> x = paddle.to_tensor([1., 2., 3., 4., 5.]) >>> x.set_() >>> print(x) Tensor(shape=[0], dtype=float32, place=Place(cpu), stop_gradient=True, []) >>> x = paddle.to_tensor([1., 2., 3., 4., 5.]) >>> x.set_(src) >>> print(x) Tensor(shape=[1, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[11., 22., 33.]]) >>> print(x._is_shared_buffer_with(src)) True >>> x = paddle.to_tensor([1., 2., 3., 4., 5.]) >>> x.set_(src, shape=[2, 1]) >>> print(x) Tensor(shape=[2, 1], dtype=float32, place=Place(cpu), stop_gradient=True, [[11.], [22.]]) >>> x = paddle.to_tensor([1., 2., 3., 4., 5.]) >>> x.set_(src2, shape=[3], stride=[2]) >>> print(x) Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [11., 33., 55.]) >>> x = paddle.to_tensor([1., 2., 3., 4., 5.]) >>> x.set_(src2, shape=[5], offset=4) >>> print(x) Tensor(shape=[5], dtype=float32, place=Place(cpu), stop_gradient=True, [22., 33., 44., 55., 66.]) z(InvalidArgument) Leaf Tensor z7 that doesn't stop gradient can't use inplace strategy.Nrr8z4Input (source) should be paddle.Tensor but received source r@rDrLrErFrGrHrIrJrKrrset)ris_leafrOrrNr3rr9rrrrrrfrstridesr?rset_)r rr?strider{rNs r:rr>sT 99Q__09$$  >\\1#QWW5FCESFfx1B1B&CDD J4PV<.Y   # & >}e,44 =LLE{{1eV<<[r<c [5(a[URS/SQS5 [U[[ 45(d[ S[U535e[R"U5n[R"UR5nXE:agU(a`U*U-*nUR5n[R"U4[R"U54US- --5SUnURX5$URX5$g)a& Resize ``x`` with specified ``shape``. Args: x (Tensor): An arbitrary Tensor. The data type supports ``bfloat16``, ``float16``, ``float32``, ``float64``, ``bool``, ``int8``, ``int16``, ``int32``, ``int64``, ``uint8``, ``complex64`` or ``complex128``. shape (list|tuple): Define the target shape. Each element of it should be integer. fill_zero (bool, optional): If the size of specified ``shape`` is greater than the original Tensor size, the new Tensor will be filled with zero if ``fill_zero`` is True. Default: False, which means the filled value will be undetermined. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, the resized Tensor. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([1., 2., 3.]) >>> x.resize_([2, 1]) >>> print(x) Tensor(shape=[2, 1], dtype=float32, place=Place(cpu), stop_gradient=True, [[1.], [2.]]) >>> x = paddle.to_tensor([1., 2., 3.]) >>> x.resize_([2, 3], fill_zero=True) >>> print(x) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[1., 2., 3.], [0., 0., 0.]]) r rresizez3Input (shape) should be list or tuple but received rwN)rrr9rrTrUrrfrGprodr?rr3concatr2r) r r? fill_zerorNnew_sizeold_sizerepeats flatten_xtmps r:resize_rsT GG   # &%$//Ed5k]S 99U#99QWW%  Y! X-.G I--  1 1) <>'A+NNxC66#% %vvaEr<c"^"U4SjS5nU$)Nc">\rSrSrU4SjrSrg)1dtype_tensor_factory.._DtypeTensorFactoryic>[U5S:Xa[R"S/TS9$[U5S:Xa6[US[[ 45(a[R "USTS9$[SU55(a[R"[ U5TS9$URST5 [R"U0UD6$)Nr)r?r9rwr8c3B# UHn[U[5v M g7fr,)rrX)rargs r:rLdtype_tensor_factory.._DtypeTensorFactory.__new__..s:TcZS))Tsr9) rr3rrrTrUrr setdefaultr)clsrarWr9s r:__new__9dtype_tensor_factory.._DtypeTensorFactory.__new__ s4yA~||1#U;;TaJtAwu $F$F}}T!WE:::T:::||$t*EBB!!'51}}d5f55r<rN)rrrrr r r8sr:_DtypeTensorFactoryrs  6 6r<rr)r9rs` r:dtype_tensor_factoryrs 6 6 r<rErFrDrrKrGrHrI)r9r$rr$)FFN)r?r)rPr^r9r$rMr@rQr@rN str | Nonerr)NNFN)r?r)r9r$rNrrdzParamAttrLike | Nonerhr@rez(paddle.nn.initializer.Initializer | Nonerr)NF)r9r$rNrrMr@rr)NN)rzfloat | paddle.Tensorrmrroint | paddle.Tensorr9rrNrrqpaddle.Tensor | NonerrPlaceLike | Nonersr@rr)g$@NN)rzrrmrrorrrr9rrNrrr)NNT) rr*r9rrrrOr@rr)NT)rr*r9rrOr@rr)NNFF) r"TensorLike | NestedNumericSequencer9rrrrrsr@rr@rr) rrr9rrrrOr@rr)rWz NDArray[Any]rr) rrr9rrrrrz bool | Nonersr@)r rr Numeric | strr9rrNrrrrrsr@rr@rr)FNNN)r?r)r9r$rPzbool | float | paddle.TensorrQr@rqrrrrNrrr)r?r)r9rrNrrqrrrrrsr@rr@rr)r rr9rrNrrrrrsr@rr@rr)NNN)r3rr5zint | paddle.Tensor | Noner9rrNrrqrrrrrsr@rr@rr)r?r)rrr9rrNrrqrrrrrsr@rr@rr)rNrwN)rzrrnfloat | paddle.Tensor | Nonerrr9rrqrrrrrsr@rr@rNrrr)rzrrnrrrr9r$rqrrrrrsr@rNr)r`rrr)rN)r rrSrXrNrrr)razSequence[paddle.Tensor]rNrrbrrlist[paddle.Tensor])rarrNrrbrrr)r)rrrtz list[int]rurXrr)rr) r r*r{rXr|rXr}rXrr)r rr{rXrNrrr)rrN) r rr{rXrrXrNrrrr,)r r*rrrr)r rrNrrr)rr) rrrrrNrrqrrr)rrJ)rrXrrXr{rXrr)NrrJ)rrXrz int | Noner{rXrr) rrrrrNrrqrrr)rrwN) r rrr&rr&rNrrr)r rrrrNrrr)NNNrN)r rrrr?Sequence[int] | Nonerrr{rXrNrrr)FN) r rr?z Sequence[int]rr@rNrrr)w __future__rr?rGrrrtypingrrrrVr3r paddle._C_opsrr paddle.utilsr paddle.utils.decorator_utilsr r r r paddle.utils.inplace_utilsrbase.data_feederrrrrbase.frameworkrrbase.param_attrrrrrrrrrrrrr collections.abcr!r" numpy.typingr#paddle._typingr$r%r&r'r(r)r*__all__rr;r>rBrcrjrurrrrrrrrrrrr+r.r0r2r=rrIrBrYr[r_rcrxrrrrrrrrr@rrrrrrrr FloatTensor DoubleTensor HalfTensorBFloat16Tensor ByteTensor CharTensor ShortTensor IntTensor LongTensor BoolTensorrr<r:r2s#  * $# D 4'   ($   " S S S S S  S  SSr!%DH T T T T  T  T B TTpDI) )&)<@))X&%5'"23 # [!%#[ [ [ [  [  [ [ [[[4[D#'" @ @ @ @ @  @  @@J#" F F F  F  F  F V#F F FF FV## w ,w w w w  w  wx#" Q ,Q Q Q Q  QhH## Q +Q Q  Q  Q  Qh3&++""..3l#w # J $JJJ J  J  JJJJ!Jb $"r r r (r r  r  r rrj#C !%#C C C C  C  CCCCCLcG9%&#9 $99 9 9  9  999'9x#L !%#L L L L  L  LLLLL^cG9%&#: $:: : :  :  :::':z*c"]C$89/3" P !%#P!P+P P  P  P PPPP:Pfgx()# F !%#F FF F  F  F FFFF*FT$%(,"#" \ !%#\ \ %\ \  \  \ \\\ \\~  L $%(,"# Q !%#Q Q %Q Q  Q  Q QQ QQh.b<@ ) ) # )/9 ) ) )<@ ) ) # )/9 ) ) )  !    -1$  *=G  Xx=>/ /&//69//fEGt t"t.1t>Attp;?EE!E-7EET ww ww  w  wt#y !%#y y y y  y  yyyyyxcG9%&#W $WW W W  W  WWW'WtOd HSr8 !% 8 8 8 8  8  8x07R RR #RRl>EO OO.1OOj, !% , , , ,  ,  ,^ # # #  #   #  # # L" " "  "  " " J$("&#' v=v= v= v= ! v=  v=  v=v=v=r K K K K   K  K K \  #9- #I. !) , %j1 !' * !& ) "7+  ) !' * !& ) r<