ёiC%SSKJr SSKrSSKrSSKrSSKJrJrJr SSK r SSK J r SSK r SSK Jr SSKJrJrJr SSKJr SSKJrJrJrJrJrJrJrJrJr SS KJ r S S K!J"r"J#r#J$r$J%r% S S K&J'r'J(r( S S K)J*r*J+r+J,r,J-r-J.r.J/r/J0r0 SSK1J2r2J3r3J4r4 \(a$SSK5J6r6J7r7 SSK8J9r9 SSK J:r: SSK;Jr>J?r?J@r@JArA SSKJBrB SSKJCrC /rDSSSjjrESSjrF\ SSj5rGSSjrHSSjrISSSjjrJSSS jjrKSSS!jjrLSSS"jjrM\-SS#j5rN\-SS$j5rO\-SSS%jj5rPSSS&jjrQSSS'jjrRSSS(jjrS\-SS)j5rT\"S*/S/S+.5SSS,.SS-jjj5rUSSS.jjrVSSS/jjrWSSS/S4SS0jjrX\"S/S1/S2/S3.5SSS4jj5rYSS5jrZ\ SSS6jj5r[\"S*/S/S+.5SSS,.SS7jjj5r\SSS8jjr]SSS9jjr^SSS:jjr_SSS;jjr`SSS<jjra\C"1S=kS>S?S@SA9SSSBjj5rb\SSSCjj5rcSSSDjjrdSSSEjjreSSSFjjrf\"SS/SS/5SSSGjj5rg\ SSSHjj5rh\"SS/SS/5SSSIjj5ri\ SSSKjj5rj\ SSSLjj5rj\ SSSMjj5rj\ SSSNjj5rj\ SSSOjj5rj\ SSSPjj5rj\ SSSQjj5rj\ SSSRjj5rj\ SSSSjj5rjSSUjrj\"SS/SS/5SSSVjj5rk\ SSSWjj5rlSSSXjjrmSSSYjjrn\ SSSZjj5ro\ SSS[jj5roSS\jro\R"\n5\olq\"SS/5SSS]jj5rrSSS^jjrsSSS_jjrt\ SSS`jj5ru\ SSSajj5ru\ SSbj5ru\R"\t5\ulpSSScjjrvSSSdjjrw\ SSSejj5rx\ SSSfjj5rxSSgjrx\R"\v5\xlqSSShjjrySSSijjrz\"S/S/S+.5SSSjjj5r{\"S/Sk/Sl.5SSSmjj5r|\"Sn5SSoj5r}\"S/Sp/Sq.5SSSrjj5r~\"5SSSsjj5r\"5SSStjj5rSSSujjr\ SSSvjj5r\ SSSwjj5r\ SSSxjj5r\ SJSy.SSzjj5rSSy.S{jr\ SSS|jj5r\ SJSy.SS}jj5rSSy.S~jr\ SSSjj5r\ SJSy.SSjj5rSSy.SjrSSSjjrSSSjjrSSSjjrSSSjjrSSSjjrSSjrSSjr\"SS/SS/5SSS.SSjjj5rSSSjjrSGSSjjr\ SGSSjj5r\ GSSj5r\ GSSj5rSrGSSjrGSSjrGSSjr\"S/S/S.5GSSS,.GSSjjj5rSTS.GSSjjrGS GS Sjjr\ GS GS Sjj5rGSSjr\"5GS SS,.GS Sjjj5r\"5\ GS GSSjj55r\"S/S/S/S.5SGSSjj5r\-SGSSjj5r\-\"5SGSSjj55r\-SGSSjj5r\-\"SS/5SGSSjj55r\N\O\P\R\S\TS.rS\S'\GRI5H%urr\"\,GRPRt\\5 M' GSSjrSGSSjjr\ SGSSjj5rSGSSjjrSGSSjjrSGSSjjrSGSSjjrg() annotationsN) TYPE_CHECKINGAnyLiteral)overload)_C_ops) index_put index_put_roll) fill_constant) ParamAliasDecoratorVariableArgsDecoratorexpand_decoratorindex_add_decoratorparam_one_aliasparam_two_aliasreshape_decoratortensor_split_decoratorview_decorator)inplace_apis_in_dygraph_only) check_dtype check_typecheck_variable_and_dtype convert_dtype)Variabledefault_main_program) LayerHelperconvert_np_dtype_to_dtype_core dygraph_onlyin_dynamic_modein_dynamic_or_pir_mode in_pir_mode)_complex_to_real_dtype_real_to_complex_dtypezeros)CallableSequence)Number)Tensor) DTypeLike NestedListNestedSequenceNumeric ShapeLikeTensorOrTensors) expand_as)ForbidKeywordsDecoratorinputaxisc [5(a[U[5(dS5eSSKJnJn U(aUOUnU"XS9n[R "[R"UVs/sHn[URU5PM sn55n Xy4$[5(a[US[[RR4S5 [U[5(aj[U5HZup[U S[!U 5-S-[RRS5 U R#5(aMQ[%S 5e O UR#5(d [%S 5e[R&R)XU5$[US[[*4S5 [U[5(a5[U5H&up[U S[!U 5-S-[*S5 M( [-S0[/5D6n U R1U R35S 9n U R1S S 9nU R5SS U0U /U/S .XS.S9 X4$s snf)a This function concatenates or stacks all tensors in the input DenseTensorArray along the axis mentioned and returns that as the output. For Example: .. code-block:: text Case 1: Given: input.data = {[[0.6, 0.1, 0.3], [0.5, 0.3, 0.2]], [[1.3], [1.8]], [[2.3, 2.1], [2.5, 2.4]]} axis = 1, use_stack = False Then: output.data = [[0.6, 0.1, 0.3, 1.3, 2.3, 2.1], [0.5, 0.3, 0.2, 1.8, 2.5, 2.4]] output_index.data = [3, 1, 2] Case 2: Given: input.data = {[[0.6, 0.1], [0.5, 0.3]], [[0.3, 1.3], [0.2, 1.8]], [[2.3, 2.1], [2.5, 2.4]]} axis = 1, use_stack = True Then: output.data = [[[0.6, 0.1] [0.3, 1.3] [2.3, 2.1], [[0.5, 0.3] [0.2, 1.8] [2.5, 2.4]]] output_index.data = [2, 2, 2] Args: input(Tensor|list[Tensor]): A TensorArray variable. axis(int, optional): The axis along which the tensors in attr::`input` will be concatenated or stacked. use_stack(bool, optional): Act as concat_op or stack_op. For stack mode, all tensors in the tensor array must have the same shape. name(str|None, optional): A name for this layer(optional). If set None, the layer will be named automatically. Returns: Tensor: The concatenated or stacked tensor variable. Tensor: A 1-D tensor variable with int32 data type. The data in this \ tensor contains all input including tensors' sizes along the axis. Examples: .. code-block:: python >>> import numpy >>> import paddle >>> x0 = paddle.assign(numpy.random.rand(2, 2).astype("float32")) >>> x1 = paddle.assign(numpy.random.rand(2, 2).astype("float32")) >>> i = paddle.full(shape=[1], dtype="int64", fill_value=0) >>> array = paddle.tensor.array.create_array(dtype='float32') >>> paddle.tensor.array.array_write(x0, i, array) >>> paddle.tensor.array.array_write(x1, i + 1, array) >>> output, output_index = paddle.tensor.manipulation.tensor_array_to_tensor(input=array) z2The 'input' in tensor_array_to_tensor must be listr)concatstackr6r5tensor_array_to_tensorinput[]z%input should be tensor array variabledtypeint32XOutOutIndexr6 use_stacktypeinputsoutputsattrs)r;)r" isinstancelistpaddler8r9 to_tensornparrayintshaper$rpirValue enumeratestris_dense_tensor_array_type TypeError_pir_opsarray_to_tensorrrlocals"create_variable_for_type_inference input_dtype append_op)r5r6rFnamer8r9opresxsizesiinput_xhelperout out_indexs Z/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/paddle/tensor/manipulation.pyr;r;Os"j%&& @ & )UV"  u*Mu!3qwwt}+=u*M!NOz    6::## $ $  eT " "'. s1v%+JJ$$,  99;;#$KLL/3355 GHH..uIFF5'D(#35MN eT " "'. s1v%+, /BB77$$&8 ==G=L )< E {;8  ~Y+Ns)"I rcc[U[RR[R45(d [ U5n[ 5(a[R"X5$[US/SQS5 [US/SQS5 [S 0[5D6nURXRS9nURSSU/0SU/0UR UR S .S 9 U$) a Take in the Tensor :attr:`x` with :attr:`x.dtype` and cast it to the output with :attr:`dtype`. It's meaningless if the output dtype equals the input dtype, but it's fine if you do so. The following picture shows an example where a tensor of type float64 is cast to a tensor of type uint8. .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/cast.png :width: 800 :alt: legend of reshape API :align: center Args: x (Tensor): An input N-D Tensor with data type bool, float16, float32, float64, int32, int64, uint8. dtype (paddle.dtype|np.dtype|str): Data type of the output: bool, float16, float32, float64, int8, int32, int64, uint8. Returns: Tensor, A Tensor with the same shape as input's. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([2, 3, 4], 'float64') >>> y = paddle.cast(x, 'uint8') rc) boolfloat16float32float64int16r@int64uint8uint16 float8_e4m3fn float8_e5m2castr?) rlrmrnroint8rpr@rqrrrsrtrur? stop_gradientrArC)in_dtype out_dtyperG)rv)rLr VarDescVarTypeDataTyperr#rrvrrrr\r]ryr_r?)rcr?rgrhs rjrvrvs> edll22DMMB C C*51{{1$$   ! $     # (0vx0778  !:SEN wwSYY?   c[5(aZ[U[RR[R 45(d [ U5n[R"X5$g)z Inplace version of ``cast`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_cast`. N) r"rLr r|r}r~rrcast_)rcr?s rjrr2sK %$,,"6"6 !FGG.u5E||A%%rc[U[[45(a[U5n[U5S:Xa [ S5e[ [U55HYnXS:a([ SX[UR5-5X'M3[[UR5S- X5X'M[ O[ S[U535e[5(GaSnSnSn[ [U55Vs/sHnSPM nn[U[[45(aMUV s/sH?n [U [RR5(aU RS5OU PMA nn Oi[U[RR5(a@URS5n [U 5n[ [U55Vs/sHnSPM nn[U[[45(aMUV s/sH?n [U [RR5(aU RS5OU PMA nn Oi[U[RR5(a@URS5n [U 5n[ [U55Vs/sHnSPM nn[ R""XX#U/5$[%5(Ga[U[[[&R(R*45(d [ S 5e[U[[[&R(R*45(d [ S 5e[ [U55Vs/sHnSPM nn[U[&R(R*5(a,S Ul[ [U55Vs/sHnSPM nnO[U[[45(a[&R.R1U5(ab[3U5H4upK[U [&R(R*5(dM0SX'M6 [&R.R5U5n[U[&R(R*5(a,S Ul[ [U55Vs/sHnSPM nnO[U[[45(a[&R.R1U5(ab[3U5H4upK[U [&R(R*5(dM0SX'M6 [&R.R5U5n[ R""XX#U/5$[U[[[645(d [ S 5e[U[[[645(d [ S 5e[9S0[;5D6n SU0n SU0n[ [U55Vs/sHnSPM nn[U[65(a0S UlX-S'[ [U55Vs/sHnSPM nnO[U[[45(a/US'[&R.R1U5(az[&R.R=U5U S'[3U5HHupK[U [65(aUSR?S5 SX'M4USR?U 5 MJ OX%S'[U[65(a0S UlX=S'[ [U55Vs/sHnSPM nnO[U[[45(a/US'[&R.R1U5(az[&R.R=U5U S'[3U5HHupK[U [65(aUSR?S5 SX'M4USR?U 5 MJ OX5S'XS'U RAU RCS5S9nU RESXSU0S9 U$s snfs sn fs snfs sn fs snfs snfs snfs snfs snfs snfs snf)a This operator produces a slice of ``input`` along multiple axes. Similar to numpy: https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html Slice uses ``axes``, ``starts`` and ``ends`` attributes to specify the start and end dimension for each axis in the list of axes and Slice uses this information to slice the input data tensor. If a negative value is passed to ``starts`` or ``ends`` such as :math:`-i`, it represents the reverse position of the axis :math:`i-1` (here 0 is the initial position). If the value passed to ``starts`` or ``ends`` is greater than n (the number of elements in this dimension), it represents n. For slicing to the end of a dimension with unknown size, it is recommended to pass in INT_MAX. The size of ``axes`` must be equal to ``starts`` and ``ends``. Following examples will explain how slice works: .. code-block:: text Case1: Given: data = [ [1, 2, 3, 4], [5, 6, 7, 8], ] axes = [0, 1] starts = [1, 0] ends = [2, 3] Then: result = [ [5, 6, 7], ] Case2: Given: data = [ [1, 2, 3, 4], [5, 6, 7, 8], ] axes = [0, 1] starts = [0, 1] ends = [-1, 1000] # -1 denotes the reverse 0th position of dimension 0. Then: result = [ [2, 3, 4], ] # result = data[0:1, 1:4] The following figure illustrates the first case -- a 2D tensor of shape [2, 4] is transformed into a 2D tensor of shape [1, 3] through a slicing operation. .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/slice.png :width: 500 :alt: legend of slice API :align: center Args: input (Tensor): A ``Tensor`` . The data type is ``float16``, ``float32``, ``float64``, ``int32`` or ``int64``. axes (list|tuple): The data type is ``int32`` . Axes that `starts` and `ends` apply to . starts (list|tuple|Tensor): The data type is ``int32`` . If ``starts`` is a list or tuple, each element of it should be integer or 0-D int Tensor with shape []. If ``starts`` is an Tensor, it should be an 1-D Tensor. It represents starting indices of corresponding axis in ``axes``. ends (list|tuple|Tensor): The data type is ``int32`` . If ``ends`` is a list or tuple, each element of it should be integer or 0-D int Tensor with shape []. If ``ends`` is an Tensor, it should be an 1-D Tensor . It represents ending indices of corresponding axis in ``axes``. Returns: Tensor, A ``Tensor``. The data type is same as ``input``. Examples: .. code-block:: python >>> import paddle >>> input = paddle.rand(shape=[4, 5, 6], dtype='float32') >>> # example 1: >>> # attr starts is a list which doesn't contain tensor. >>> axes = [0, 1, 2] >>> starts = [-3, 0, 2] >>> ends = [3, 2, 4] >>> sliced_1 = paddle.slice(input, axes=axes, starts=starts, ends=ends) >>> # sliced_1 is input[1:3, 0:2, 2:4]. >>> # example 2: >>> # attr starts is a list which contain tensor. >>> minus_3 = paddle.full([1], -3, "int32") >>> sliced_2 = paddle.slice(input, axes=axes, starts=[minus_3, 0, 2], ends=ends) >>> # sliced_2 is input[1:3, 0:2, 2:4]. rz-Input axes should not be an empty list/tuple.r%z8Input axes must be a python list or tuple, but received NFz4Input starts must be an Value, python list or tuple.z2Input ends must be an Value, python list or tuple.Tz7Input starts must be an Variable, python list or tuple.z5Input ends must be an Variable, python list or tuple.sliceInputaxes StartsTensorstartsStartsTensorList EndsTensorendsEndsTensorList infer_flagsr5r>rCrHrIrKrJ)r)#rLrMtuplelen ValueErrorrangemaxrSminrHr"r eagerr,itemnumpyrrr$rNrTrUryutils _contain_varrVget_int_tensor_listrrr\_convert_to_tensor_listappendr]r^r_)r5rrrrerK starts_tensor ends_tensorrrtensor_tdimrgrIrhs rjrr>s`$u &&Dz t9>LM Ms4y!Aw{a3u{{+;!;<c%++.2DG< "FtDzl S    "'D "23"2Qq"2 3 ftUm , ,#"D!+41B1B C C ! M" F 1 1 2 2||E*H(^F',SY'78'7!2'7K8 dT5M * *! D!+41B1B C C ! M  Ddjj// 0 0zz%(H>D',SY'78'7!2'7K8||E{BGG &4 0@0@"ABBF $ufjj.>.> ?@@D #(D "23"2Qq"2 3 ffjj.. / /#'F ',SY'78'7!2'7K8K u . .||((00'/FA!#vzz'7'788)+ 0 99&A dFJJ,, - -!%D ',SY'78'7!2'7K8K tUm , ,||((..'oFA!#vzz'7'788)+ .||77=||E{BGG&4"9::I $uh 788G 115!"'D "23"2Qq"2 3 fh ' '#'F %+> "',SY'78'7!2'7K8K u . . E(O||((00LL88@)*(/FA!#x00h..r2)+ h..s3 0#)h dH % %!%D #'< ',SY'78'7!2'7K8K tUm , ,E&M||((..+1<<+O+O,'((oFA!#x00f ,,R0)+ f ,,S1 .!%f  +m77$$W-8  ucl   q499499,4 9(9sD6 a#Aa a4Aa a$# a)7 a.- a3= a8 a= brc r[U[R5(aUURS:Xa.UR[R [R 4;dS5eUR5nURS:dS5eUS:dS5eURnURS:XaSnSUs=::aU:d4O US:aX-OUnUS:dXT:a[SU*SUS- SUS 35eUnURUnU*Us=::aU::dO S U*SUSUS 35eUS:aX&-nX&U- ::dS US US US35e[UR5nX7U'URnX(U-n U [RRUR5-n [R"XXS9$)ag Returns a narrowed slice of input along a single axis. This operator selects the index range [start, start + length) on dimension dim and keeps all the dimensions unchanged. Args: input (Tensor): Input tensor. dim (int): Dimension to narrow. Supports negative indexing. start (int|Tensor): Start index on ``dim``. Can be a Python int or a 0-D int Tensor (int32 or int64). Negative values are supported. length (int): Number of elements to select from ``start``. Must be non-negative. Returns: Tensor: A tensor that is a narrowed view of ``input``. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1, 2, 3, 4],[5, 6, 7, 8]], dtype='int64') >>> y1 = paddle.narrow(x, dim=1, start=1, length=2) >>> print(y1) Tensor(shape=[2, 2], dtype=int64, place=Place(cpu), stop_gradient=True, [[2, 3], [6, 7]]) >>> y2 = paddle.narrow(x, dim=-1, start=-3, length=3) >>> print(y2) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[2, 3, 4], [6, 7, 8]]) >>> s = paddle.to_tensor(0, dtype='int64') >>> y3 = paddle.narrow(x, dim=1, start=s, length=2) >>> print(y3) Tensor(shape=[2, 2], dtype=int64, place=Place(cpu), stop_gradient=True, [[1, 2], [5, 6]]) rz'start must be an 0-dim integral Tensor.z-narrow() cannot be applied to a 0-dim tensor.z&narrow(): length must be non-negative.r%z4Dimension out of range (expected to be in range of [, z ], but got )z0start out of range (expected to be in range of [zstart (z ) + length (z) exceeds dimension size ().)rSstrideoffset)rLrNr,ndimr?r@rqr IndexErrorrSrMstridesr size_of_dtype as_strided) r5rstartlengthrank_dim dim_length new_shaperrs rjnarrowrsb%''zzQ5;; LL LL3 $  5 5 5   ::>JJJ> Q;@@@; ::D zzQ OtO 1Wsz# !8t|FugRPTWXPXzYdehdiijk S!J ;% -: - :J;-r*U`af`gghi - qy" ' ' % VH,FzlRTU 'U[[!IcN ]]F C[ F fkk'' 44F    v rc [5(a[R"X5$[US/SQS5 [ US[ [ 4S5 [U[ 5(a [ U5n[U5[UR5:wa.[S[UR5S[U5S35e[U5HHup4U[UR5:dM [SUS XS [UR5S35e [S0[5D6nURUR5nURUR5nUR!S S U/0U/U/S .SU0S9 U$)aE Permute the data dimensions of `input` according to `perm`. The `i`-th dimension of the returned tensor will correspond to the perm[i]-th dimension of `input`. The image illustrates the second example of the transpose operation. .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/transpose.png :width: 500 :alt: legend of transpose API Args: x (Tensor): The input Tensor. It is a N-D Tensor of data types bool, float32, float64, int32. perm (list|tuple): Permute the input according to the data of perm. name (str|None, optional): The name of this layer. It is optional. Returns: Tensor, A transposed n-D Tensor, with data type being bool, float32, float64, int32, int64. For Example: .. code-block:: text x = [[[ 1 2 3 4] [ 5 6 7 8] [ 9 10 11 12]] [[13 14 15 16] [17 18 19 20] [21 22 23 24]]] shape(x) = [2,3,4] # Example 1 perm0 = [1,0,2] y_perm0 = [[[ 1 2 3 4] [13 14 15 16]] [[ 5 6 7 8] [17 18 19 20]] [[ 9 10 11 12] [21 22 23 24]]] shape(y_perm0) = [3,2,4] # Example 2 perm1 = [2,1,0] y_perm1 = [[[ 1 13] [ 5 17] [ 9 21]] [[ 2 14] [ 6 18] [10 22]] [[ 3 15] [ 7 19] [11 23]] [[ 4 16] [ 8 20] [12 24]]] shape(y_perm1) = [4,3,2] Examples: .. code-block:: pycon >>> import paddle >>> x = paddle.randn([2, 3, 4]) >>> x_transposed = paddle.transpose(x, perm=[1, 0, 2]) >>> print(x_transposed.shape) paddle.Size([3, 2, 4]) rc rlrmrnror@rqrs complex64 complex128 transposepermzInput(perm) is the permutation of dimensions of Input(x), its length should be equal to dimensions of Input(x), but received dimension of Input(x) is z, the length of Input(perm) is .zJEach element in Input(perm) should be less than Input(x)'s dimension, but z-th element in Input(perm) is z$ which exceeds Input(x)'s dimension transpose2rArCXShaper6rG)r)r#rrrrrMrrLrrSrrVrr\r]r?r_)rcrr`idxrrgrhx_shapes rjrrvsxt((    4$ < dE " ":D t9AGG $99>> import paddle >>> x = paddle.ones(name='x', shape=[2, 3, 5], dtype='float32') # create a tensor with shape=[2, 3, 5] >>> y = paddle.unstack(x, axis=1) # unstack with second axis, which results 3 tensors with shape=[2, 5] z`axis` must be in the range [-rrrz`num` must be in the range [0, unstackzunknown unstack numberrAY)r6numrG)r) rrrSr#rrrr\rrr]r?r_)rcr6rrgouts_s rjrrsO2VVGt $aff $9!&&AFF81MNN C!GsWWT]'::1774=/KLL ;''$-C !8I~~as++3&(3 ;|qwwt}1 !9::ggdmsA KKAA!''J K !:$K,   rc F[5(a[R"XX#U5$[USSS/S5 Sn[ U40[ 5D6nUS:dX2:a[ SUSUS35eURURS 9nURUS U/0S U0UUUUS .S S9 U$)a Reset the values of `input` according to the shard it belongs to. Every value in `input` must be a non-negative integer, and the parameter `index_num` represents the integer above the maximum value of `input`. Thus, all values in `input` must be in the range [0, index_num) and each value can be regarded as the offset to the beginning of the range. The range is further split into multiple shards. Specifically, we first compute the `shard_size` according to the following formula, which represents the number of integers each shard can hold. So for the i'th shard, it can hold values in the range [i*shard_size, (i+1)*shard_size). :: shard_size = (index_num + nshards - 1) // nshards For each value `v` in `input`, we reset it to a new value according to the following formula: :: v = v - shard_id * shard_size if shard_id * shard_size <= v < (shard_id + 1) * shard_size else ignore_value That is, the value `v` is set to the new offset within the range represented by the shard `shard_id` if it in the range. Otherwise, we reset it to be `ignore_value`. As shown below, a ``[2, 1]`` 2D tensor is updated with the ``shard_index`` operation. Given ``index_num = 20``, ``nshards = 2``, and ``shard_id = 0``, the shard size is ``shard_size = (20 + 2 - 1) // 2 = 10``. For each label element: if its value is in [0, 10), it's adjusted to its offset; e.g., 1 becomes 1 - 0 * 10 = 1. Otherwise, it's set to the default ignore_value of -1, like 16 becoming -1. .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/shard_index.png :width: 500 :alt: Illustration of Case 2 :align: center Args: input (Tensor): Input tensor with data type int64 or int32. It's last dimension must be 1. index_num (int): An integer represents the integer above the maximum value of `input`. nshards (int): The number of shards. shard_id (int): The index of the current shard. ignore_value (int, optional): An integer value out of sharded index range. The default value is -1. Returns: Tensor. Examples: .. code-block:: python >>> import paddle >>> label = paddle.to_tensor([[16], [1]], "int64") >>> shard_label = paddle.shard_index(input=label, ... index_num=20, ... nshards=2, ... shard_id=0) >>> print(shard_label.numpy()) [[-1] [ 1]] r5rqr@ shard_indexrz The shard_id(z) should be in [0, rr>rArC) index_numnshardsshard_id ignore_valueT)rHrIrJrKry) r#rrrrr\rr]r?r_)r5rrrrop_typergrhs rjrrs~!! g  UGgw-?OG  -FH -F!|x*H:%8  C    3 3%++ 3 FC  eW~ " (    Jrc h [S0[5D6n[US/SQS5 [US[[ [ [S5[RR4S5 [US[[ [ [S5[RR4S5 UcS/[UR5-nUc URn[5(a[R"XU5$SnS n[!5(Ga[#U[RR5(aS UlO[R&R)U5(aw/nUHln[#U[RR5(aS UlUR+U5 MFU"U5 [-S /S US S 9n UR+U 5 Mn UnOUH n U"U 5 M [#U[RR5(aS UlO[R&R)U5(aw/n UHln [#U [RR5(aS U lU R+U 5 MFU"U 5 [-S /S U S S 9n U R+U 5 Mn U nOUH n U"U 5 M [R"XU5$UR/UR05n SU0n0n[#U[ 5(a(S UlX.S'S/[UR5-US'O[R&R)U5(a/n/nUHn[#U[ 5(a+S UlUR+U5 UR+S5 MCU"U5 UR/S 5n [-S /S US U S9 UR+U 5 UR+U5 M X~S'UUS'OUH n U"U 5 M X/S'[#U[ 5(a S UlXS'O[R&R)U5(a/n /nUHn [#U [ 5(a+S U lU R+U 5 UR+S5 MCU"U 5 UR/S 5n [-S /S U S U S9 U R+U 5 UR+U 5 M XS'UUS'OUH n U"U 5 M XS'UR3SUSU 0[U5S:XaSOUS9 U $)a Crop input into output, as specified by offsets and shape. .. code-block:: text * Case 1 (input is a 2-D Tensor): Input: X.shape = [3, 5] X.data = [[0, 1, 2, 0, 0], [0, 3, 4, 0, 0], [0, 0, 0, 0, 0]] Parameters: shape = [2, 2] offsets = [0, 1] Output: Out.shape = [2, 2] Out.data = [[1, 2], [3, 4]] * Case 2 (input is a 3-D Tensor): Input: X.shape = [2, 3, 4] X.data = [[[0, 1, 2, 3], [0, 5, 6, 7], [0, 0, 0, 0]], [[0, 3, 4, 5], [0, 6, 7, 8], [0, 0, 0, 0]]] Parameters: shape = [2, 2, -1] offsets = [0, 0, 1] Output: Out.shape = [2, 2, 3] Out.data = [[[1, 2, 3], [5, 6, 7]], [[3, 4, 5], [6, 7, 8]]] The image below demonstrates the Case 2 that a 3D tensor with shape [2,3,4] is cropped into a 3D tensor with shape [2,2,3] .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/crop.png :width: 500 :alt: Illustration of Case 2 :align: center Parameters: x (Tensor): 1-D to 6-D Tensor, the data type is float32, float64, int32 or int64. shape (list|tuple|Tensor, optional): The output shape is specified by `shape`. Its data type is int32. If a list/tuple, it's length must be the same as the dimension size of `x`. If a Tensor, it should be a 1-D Tensor. When it is a list, each element can be an integer or a Tensor of shape: [1]. If Variable contained, it is suitable for the case that the shape may be changed each iteration. offsets (list|tuple|Tensor, optional): Specifies the cropping offsets at each dimension. Its data type is int32. If a list/tuple, it's length must be the same as the dimension size of `x`. If a Tensor, it should be a 1-D Tensor. When it is a list, each element can be an integer or a Tensor of shape: [1]. If Variable contained, it is suitable for the case that the offsets may be changed each iteration. Default: None, the offsets are 0 at each dimension. 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 cropped Tensor has same data type with `x`. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> # x.shape = [3, 3] >>> # x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> # shape can be a 1-D Tensor or list or tuple. >>> shape = paddle.to_tensor([2, 2], dtype='int32') >>> # shape = [2, 2] >>> # shape = (2, 2) >>> out = paddle.crop(x, shape) >>> # out.shape = [2, 2] >>> # out = [[1,2], [4,5]] >>> # offsets can be a 1-D Tensor or list or tuple. >>> offsets = paddle.to_tensor([0, 1], dtype='int32') >>> # offsets = [1, 0] >>> # offsets = (1, 1) >>> out = paddle.crop(x, shape, offsets) >>> # out.shape = [2, 2] >>> # if offsets = [0, 0], out = [[1,2], [4,5]] >>> # if offsets = [0, 1], out = [[2,3], [5,6]] >>> # if offsets = [1, 0], out = [[4,5], [7,8]] >>> # if offsets = [1, 1], out = [[5,6], [8,9]] crop_tensorrcrnror@rqrSNoffsetsrc[U[5(d[S[U5S35eUS:a[ SUS35eg)NzFAttr(shape)'s dtype of Op(crop_tensor) should be int32, but received: rrzdWhen the element in Attr(shape) of Op(crop_tensor) is negative, only -1 is supported, but received: rLrRrYrHr) shape_vals rj_attr_shape_checkcrop.._attr_shape_checksj)S))XY]^gYhXiijk  r>vxAwBBCD  rc[U[5(d[S[U5S35eUS:a[ SUS35eg)NzHAttr(offsets)'s dtype of Op(crop_tensor) should be int32, but received: rrzSAttr(offsets) of Op(crop_tensor) should be greater or equal to zero, but received: r) offset_vals rj_attr_offsets_check!crop.._attr_offsets_checks[*c**Z[_`j[kZllmn  >efpeqqrs  rTr%r@) force_cpurAOffsetsrrrh OffsetsTensorShape ShapeTensorrCrG)r)rr\rrrMrrrHrNrTrUrrSr"rcropr$rLryrrrr r]r?r_)rcrSrr`rgrrnew_offsets_tensorrtemp_outrnew_shape_tensordim_sizerhrIrK offsets_attr shape_attrs rjrrusF 3&( 3F 38-  uhT FJJ,<,<=   uhT FJJ,<,<= #AGG $ }{{1W--}} gvzz// 0 0$(G ! \\ & &w / /!# c6::#3#344(,C%&--c2',,aS'3$OH&--h7)G!#F+" eVZZ-- . ."&E  \\ & &u - -! !h (8(899-1H*$++H5%h/,Wh$ H%++H5"%E!!(+"{{1W--  3 3AGG >> import paddle >>> tensor = paddle.to_tensor([0, 1, 2, 3, 4]) >>> tensor.fill_(0) >>> print(tensor.tolist()) [0, 0, 0, 0, 0] z8The type of 'value' must be int or float, but received r)rLfloatrRrYrHrfill_)rcvalues rjrrlsD6 eeS\ * *FtE{mST U   << !!rc0[R"US5$)a **Notes**: **This API is ONLY available in Dygraph mode** This function fill the Tensor with zero inplace. Args: x (Tensor): ``x`` is the Tensor we want to filled with zero inplace Returns: x (Tensor), Tensor x filled with zero inplace Examples: .. code-block:: python >>> import paddle >>> tensor = paddle.to_tensor([0, 1, 2, 3, 4]) >>> tensor.zero_() >>> print(tensor.tolist()) [0, 0, 0, 0, 0] g)rrrcs rjzero_rs4 <<3 rc[5(aH[UR5S:Xa[R"XX#5$[R"XUS5$g)a Note: This API is ONLY available in Dygraph mode. This function fill the value into the x Tensor's diagonal inplace. Args: x(Tensor): ``x`` is the original Tensor value(int|float): ``value`` is the value to filled in x offset(int,optional): the offset to the main diagonal. Default: 0 (main diagonal). wrap(bool,optional): the diagonal 'wrapped' after N columns for tall matrices. name(str|None,optional): Name for the operation (optional, default is None) Returns: Tensor, Tensor with diagonal filled with value. Examples: .. code-block:: python >>> import paddle >>> x = paddle.ones((4, 3)) * 2 >>> x.fill_diagonal_(1.0) >>> print(x.tolist()) [[1.0, 2.0, 2.0], [2.0, 1.0, 2.0], [2.0, 2.0, 1.0], [2.0, 2.0, 2.0]] rTN)r"rrSrfill_diagonal_)rcrrwrapr`s rjrrsKB qww<1 ((6@ @$$Qvt<<rc URnU[U5:aU[U5*:dS5eU[U5:aU[U5*:dS5e[U5S:dS5eU[U5-nU[U5-n/n[[U55H$nX:wdM X:wdMURXh5 M& [ XcXcU-XdXdU- 5n URU 5 [ U5[ UR5:Xd SU35e[UR5S:XaUR SS/5n[5(a7U(a[R"XX#U5$[R"XX#U5$[US/S QS 5 [US /S QS 5 [S0[5D6n U RUR5n U R!S UUS .SU 0UUUS.S9 U $)Nz9dim1 should between [-rank,rank) in fill_diagonal_tensor_z9dim2 should between [-rank,rank) in fill_diagonal_tensor_rz0Tensor dims should >= 2 in fill_diagonal_tensor_zthe y shape should be r%rrA) rmrnrorsrrrwrpr@rqrlrrz/paddle.tensor.manipulation.fill_diagonal_tensorrfill_diagonal_tensor)rArrC)rdim1dim2rGr)rSrrrrrreshaper#rfill_diagonal_tensor_rrrr\r]r?r_) rcyrrrinplaceinshape predshaperediaglenrgrhs rj_fill_diagonal_tensor_implrsggG #g, 4CL=#8C 8 #g, 4CL=#8C 8 w<1 PPP CLDCLDI 3w<  9   WZ (!     G W  uQWW~ -  , - 177|q IIq"g  //fDI I..qV4H H   ># & !   ># &@vx@77@'CL    rc [XX#USS9$)a Note: This API is ONLY available in Dygraph mode. This function fill the source Tensor y into the x Tensor's diagonal inplace. Args: x (Tensor): ``x`` is the original Tensor y (Tensor): ``y`` is the Tensor to filled in x dim1 (int,optional): first dimension with respect to which to fill diagonal. Default: 0. dim2 (int,optional): second dimension with respect to which to fill diagonal. Default: 1. offset (int,optional): the offset to the main diagonal. Default: 0 (main diagonal). name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, Tensor with diagonal filled with y. Examples: .. code-block:: python >>> import paddle >>> x = paddle.ones((4, 3)) * 2 >>> y = paddle.ones((3,)) >>> x.fill_diagonal_tensor_(y) >>> print(x.tolist()) [[1.0, 2.0, 2.0], [2.0, 1.0, 2.0], [2.0, 2.0, 1.0], [2.0, 2.0, 2.0]] Trrrrrrcrrrrr`s rjrr4sJ & VT4 rc [XX#USS9$)a This function fill the source Tensor y into the x Tensor's diagonal. Args: x (Tensor): ``x`` is the original Tensor y (Tensor): ``y`` is the Tensor to filled in x dim1 (int,optional): first dimension with respect to which to fill diagonal. Default: 0. dim2 (int,optional): second dimension with respect to which to fill diagonal. Default: 1. offset (int,optional): the offset to the main diagonal. Default: 0 (main diagonal). name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, Tensor with diagonal filled with y. Examples: .. code-block:: python >>> import paddle >>> x = paddle.ones((4, 3)) * 2 >>> y = paddle.ones((3,)) >>> nx = x.fill_diagonal_tensor(y) >>> print(nx.tolist()) [[1.0, 2.0, 2.0], [2.0, 1.0, 2.0], [2.0, 2.0, 1.0], [2.0, 2.0, 2.0]] Frrrs rjrr^sD & VT5 rc@URS5R5$)a2 Note: This API is ONLY available in Dygraph mode. This function translate the paddle.Tensor to python list. Args: x (Tensor): ``x`` is the Tensor we want to translate to list. Returns: list, A list that contain the same value of current Tensor. Examples: .. code-block:: python >>> import paddle >>> t = paddle.to_tensor([0,1,2,3,4]) >>> expectlist = t.tolist() >>> print(expectlist) [0, 1, 2, 3, 4] >>> expectlist = paddle.tolist(t) >>> print(expectlist) [0, 1, 2, 3, 4] F)rtolistrs rjrrs> 775> ""rtensors)rcr6rhcUn[5(a;[U[5(aURS5n[R "XAUS9$[ 5(Ga;SnU"5n[US[[[RR4S5 [U[RR5(de[U5HUupp[US[U5-S-/SQS5 U(aM-UR USR :wdML[#S 5e O\[U[RR5(a0UR%5(a[R&"XAS 5up8U$U/n[R "XA5$[US[[[4S5 [U[5(d\[U5HLupp[US[U5-S-/SQS5 UR USR :wdMC[#S 5e OU/n[US [([4S5 [U[5(a[+UR S S S /SS5 [-S0[/5D6n U R1U R35S9nUSR4R75[8R:R<R>:XaS[AU5S:XdS[AU5S35eU R1S S9n U RCSSUS0U/U /S.US S.S9 U$SU0n 0n [U[5(a SUl"XS'OXS 'U RCSU SU/0U S9 U$)a Concatenates the input along the axis. It doesn't support 0-D Tensor because it requires a certain axis, and 0-D Tensor doesn't have any axis. The image illustrates a typical case of the concat operation. Two three-dimensional tensors with shapes [2, 3, 4] are concatenated along different axes, resulting in tensors of different shapes. The effects of concatenation along various dimensions are clearly visible. .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/concat.png :width: 500 :alt: legend of concat API :align: center .. note:: Alias Support: The parameter name ``tensors`` can be used as an alias for ``x``, and ``dim`` can be used as an alias for ``axis``. For example, ``concat(tensors=tensor_x, dim=1, ...)`` is equivalent to ``concat(x=tensor_x, axis=1, ...)``. Args: x (list|tuple): ``x`` is a Tensor list or Tensor tuple which is with data type bool, float16, bfloat16, float32, float64, int8, int16, int32, int64, uint8, uint16, complex64, complex128. All the Tensors in ``x`` must have same data type. alias: ``tensors``. axis (int|Tensor, optional): Specify the axis to operate on the input Tensors. Tt should be integer or 0-D int Tensor with shape []. The effective range is [-R, R), where R is Rank(x). When ``axis < 0``, it works the same way as ``axis+R``. Default is 0. alias: ``dim``. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. out (Tensor|None, optional): The output Tensor. If set, the result will be stored in this Tensor. Default is None. Returns: Tensor, A Tensor with the same data type as ``x``. Examples: .. code-block:: python >>> import paddle >>> x1 = paddle.to_tensor([[1, 2, 3], ... [4, 5, 6]]) >>> x2 = paddle.to_tensor([[11, 12, 13], ... [14, 15, 16]]) >>> x3 = paddle.to_tensor([[21, 22], ... [23, 24]]) >>> zero = paddle.full(shape=[1], dtype='int32', fill_value=0) >>> # When the axis is negative, the real axis is (axis + Rank(x)) >>> # As follow, axis is -1, Rank(x) is 2, the real axis is 1 >>> out1 = paddle.concat(x=[x1, x2, x3], axis=-1) >>> out2 = paddle.concat(x=[x1, x2], axis=0) >>> out3 = paddle.concat(x=[x1, x2], axis=zero) >>> print(out1) Tensor(shape=[2, 8], dtype=int64, place=Place(cpu), stop_gradient=True, [[1 , 2 , 3 , 11, 12, 13, 21, 22], [4 , 5 , 6 , 14, 15, 16, 23, 24]]) >>> print(out2) Tensor(shape=[4, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[1 , 2 , 3 ], [4 , 5 , 6 ], [11, 12, 13], [14, 15, 16]]) >>> print(out3) Tensor(shape=[4, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[1 , 2 , 3 ], [4 , 5 , 6 ], [11, 12, 13], [14, 15, 16]]) rrc[R"5nURn[RR[RR /nX;$N)r _get_amp_attrs _amp_levelAmpLevelO1O2) amp_attrs amp_levelapply_amp_level_lists rjis_in_amp_modeconcat..is_in_amp_modesH++-I!,,I      $ 4 4rr5r8r<r=) rlrmbfloat16rnrorpr@rqrwunit8rsrr:All the Tensors in the input must have the same data type.Fr6r@rqzBThe data type of axis must be int32 or int64 when axis is a Tensorr>r%ztIf the elements of 'input' in concat are Variable(DenseTensorArray), number of the elements must be 1, but received rr;rArBrErGT AxisTensorrC)r8)#r"rLrrrr8r$rrMrrNrTrUrVrrWr?rYrXr[rRrrr\r]r^descrHr r|r}DENSE_TENSOR_ARRAYrr_ry) rcr6r`rhr5r is_in_ampidrrgrirIrKs rjr8r8sGT E dH % %99Q Broadcast a list of tensors following broadcast semantics Note: 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 The following figure illustrates the process of broadcasting three tensors to the same dimensions. The dimensions of the three tensors are [4, 1, 3], [2, 3], and [4, 2, 1], respectively. During broadcasting, alignment starts from the last dimension, and for each dimension, either the sizes of the two tensors in that dimension are equal, or one of the tensors has a dimension of 1, or one of the tensors lacks that dimension. In the figure below, in the last dimension, Tensor3 has a size of 1, while Tensor1 and Tensor2 have sizes of 3; thus, this dimension is expanded to 3 for all tensors. In the second-to-last dimension, Tensor1 has a size of 2, and Tensor2 and Tensor3 both have sizes of 2; hence, this dimension is expanded to 2 for all tensors. In the third-to-last dimension, Tensor2 lacks this dimension, while Tensor1 and Tensor3 have sizes of 4; consequently, this dimension is expanded to 4 for all tensors. Ultimately, all tensors are expanded to [4, 2, 3]. .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/broadcast.png :width: 800 :alt: Illustration of BroadCast :align: center Args: input (list|tuple): ``input`` is a Tensor list or Tensor tuple which is with data type bool, float16, float32, float64, int32, int64, complex64, complex128. All the Tensors in ``input`` must have same data type. Currently we only support tensors with rank no greater than 5. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: list(Tensor), The list of broadcasted tensors following the same order as ``input``. Examples: .. code-block:: python >>> import paddle >>> x1 = paddle.rand([1, 2, 3, 4]).astype('float32') >>> x2 = paddle.rand([1, 2, 1, 4]).astype('float32') >>> x3 = paddle.rand([1, 1, 3, 1]).astype('float32') >>> out1, out2, out3 = paddle.broadcast_tensors(input=[x1, x2, x3]) >>> # out1, out2, out3: tensors broadcasted from x1, x2, x3 with shape [1,2,3,4] r5broadcast_tensorsr%z8At least 1 tensor is needed to perform broadcast_tensorsr<r=rrrzIInput tensors to broadcast_tensors does not follow bcast semanticsTensor z conflicts with Tensor z in reversed dimension r>rArCrG)r)rr#rrrrMrrYrVrrWr?reversedrSrrr\r]r^r_)r5r` num_inputsrrc output_shape_r_last_tensor_indexoutput_shape_rjtensorrSreinvalid last_indexrgrhrIs rjrrwsrZUJ''..5'D%=2EF >J  u%EB $3r7"S( $  ww%(..(P%&.,.( #e*nXF&,,/0EAc%j.~&!+"))%(34;;A>')UX5**-2*!HM %E%H '&&0\1HKbcdbeg&(EH4,1H)>?;Q'c%j.( FA3#e*n6=FH= n JJ99 ,,.:  FA nu$CL   rc[U[5(aU/n[5(a[R"X5$[ S 0[ 5D6n[US[S5 URS5n[US/SQS5 [US[[4S5 UcURU5nOURX$SS9nURSSU0SU0SU0S 9 U$) aI Reverse the order of a n-D tensor along given axis in axis. The image below illustrates how ``flip`` works. .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/flip.png :width: 500 :alt: legend of flip API :align: center Args: x (Tensor): A Tensor with shape :math:`[N_1, N_2,..., N_k]` . The data type of the input Tensor x should be float32, float64, int32, int64, bool. axis (list|tuple|int): The axis(axes) to flip on. Negative indices for indexing from the end are accepted. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, Tensor or DenseTensor calculated by flip layer. The data type is same with input x. Examples: .. code-block:: python >>> # doctest: +SKIP("This has diff in xdoctest env") >>> import paddle >>> image_shape=(3, 2, 2) >>> img = paddle.arange(image_shape[0] * image_shape[1] * image_shape[2]).reshape(image_shape) >>> tmp = paddle.flip(img, [0,1]) >>> print(tmp) Tensor(shape=[3, 2, 2], dtype=int64, place=Place(cpu), stop_gradient=True, [[[10, 11], [8 , 9 ]], [[6 , 7 ], [4 , 5 ]], [[2 , 3 ], [0 , 1 ]]]) >>> out = paddle.flip(tmp,-1) >>> print(out) Tensor(shape=[3, 2, 2], dtype=int64, place=Place(cpu), stop_gradient=True, [[[11, 10], [9 , 8 ]], [[7 , 6 ], [5 , 4 ]], [[3 , 2 ], [1 , 0 ]]]) fliprArcrmrnror@rqrlr6F)r`r? persistablerCrG)r')rLrRr#rr'rr\rrr^rrMrr]create_variabler_)rcr6r`rgr?rhs rjr'r'sd$v{{1##0vx01cHv.""3'   G   4$7 <;;EBC((E)C 8CL4.   rc[S0[5D6n[US[[R R 4S5 URS5n[US/SQS5 [US[[4S5 [UR5n[U5nUS:wa[SU35eUS:a[SU35eUS US :wa[US US - 5U:wd[S US S US 35eUS U:a US U*:d[S US 35eUS U:a US U*:d[SUS 35eUS-nUS :XaU$US:Xa[[XS 5US 5$[[!S U55nXS XS sXS 'XS 'US :Xa[#[XS 5U5$[[#X5US 5$)a] Rotate a n-D tensor by 90 degrees. The rotation direction and times are specified by axes and the absolute value of k. Rotation direction is from axes[0] towards axes[1] if k > 0, and from axes[1] towards axes[0] for k < 0. Args: x (Tensor): The input Tensor. The data type of the input Tensor x should be float16, float32, float64, int32, int64, bool. float16 is only supported on gpu. k (int, optional): Direction and number of times to rotate, default value: 1. axes (list|tuple, optional): Axes to rotate, dimension must be 2. default value: [0, 1]. name (str|None, 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` . Returns: Tensor, Tensor or DenseTensor calculated by rot90 layer. The data type is same with input x. Examples: .. code-block:: python >>> import paddle >>> data = paddle.arange(4) >>> data = paddle.reshape(data, (2, 2)) >>> print(data.numpy()) [[0 1] [2 3]] >>> y = paddle.rot90(data, 1, [0, 1]) >>> print(y.numpy()) [[1 3] [0 2]] >>> y= paddle.rot90(data, -1, [0, 1]) >>> print(y.numpy()) [[2 0] [3 1]] >>> data2 = paddle.arange(8) >>> data2 = paddle.reshape(data2, (2,2,2)) >>> print(data2.numpy()) [[[0 1] [2 3]] [[4 5] [6 7]]] >>> y = paddle.rot90(data2, 1, [1, 2]) >>> print(y.numpy()) [[[1 3] [0 2]] [[5 7] [4 6]]] rot90rArcr(rrz2expected total rotation axes == 2, but got axes = z/expected total dims >= 2, but got total dims = rr%z8expected rotation axes to be different, but got axis0 = z, and axis1 = z%Rotation axis0 out of range, axis0 = z%Rotation axis1 out of range, axis1 = )r,)rr\rrrNrTrUr^rrMrrrSrabsr'rr) rckrr`rgr?input_total_dimstotal_rot_dims axes_lists rjr,r,Ns*l -FH -Fq#&**"2"23W=   s #E  C  tVdE]G4177|YN@@P Q  !=>N=O P   GtAw 3tAwa'8#9=M#MFtAwi~^bcd^e]f g   G& &477G6G+G@a JKK G& &477G6G+G@a JKKFAAvAvDG$d1g..U1./0Iq'q'-YAw7+ Avaa)955Ia+T!W55r start_dimend_dim)rc start_axis stop_axiscx[U[[RR45(d [ S5e[ UR5nUS:XaM[U[5(aUS;a [ S5e[U[5(aUS;a [ S5eO[U[5(aXS- :dX*:a [ S5e[U[5(aX$S- :dX$*:a [ S5eUS:aX-nUS:aX$-nX:a [ S 5e[5(a[R"XU5$[US /S QS 5 [S0[5D6nURUR 5nURUR 5nUR#S SU0XgS.XS.S9 U$)aB Flattens a contiguous range of axes in a tensor according to start_axis and stop_axis. Note: The output Tensor will share data with origin Tensor and doesn't have a Tensor copy in ``dygraph`` mode. If you want to use the Tensor copy version, please use `Tensor.clone` like ``flatten_clone_x = x.flatten().clone()``. For Example: .. code-block:: text Case 1: Given X.shape = (3, 100, 100, 4) and start_axis = 1 end_axis = 2 We get: Out.shape = (3, 100 * 100, 4) Case 2: Given X.shape = (3, 100, 100, 4) and start_axis = 0 stop_axis = -1 We get: Out.shape = (3 * 100 * 100 * 4) .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``, the parameter name ``start_dim`` can be used as an alias for ``start_axis`` , and the parameter name ``end_dim`` can be used as an alias for ``stop_axis``. For example, ``flatten(input=tensor_x, start_dim=0, end_dim=-1)`` is equivalent to ``flatten(x=tensor_x, start_axis=0, stop_axis=-1)``. Args: x (Tensor): A tensor of number of dimensions >= axis. A tensor with data type float16, float32, float64, int8, int32, int64, uint8. alias: ``input``. start_axis (int): the start axis to flatten alias: ``start_dim``. stop_axis (int): the stop axis to flatten alias: ``end_dim``. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, A tensor with the contents of the input tensor, whose input axes are flattened by indicated :attr:`start_axis` and :attr:`end_axis`, and data type is the same as input :attr:`x`. Examples: .. code-block:: pycon >>> import paddle >>> image_shape = (2, 3, 4, 4) >>> x = paddle.arange(end=image_shape[0] * image_shape[1] * image_shape[2] * image_shape[3]) >>> img = paddle.reshape(x, image_shape) >>> out = paddle.flatten(img, start_axis=1, stop_axis=2) >>> print(out.shape) paddle.Size([2, 12, 4]) >>> # out shares data with img in dygraph mode >>> img[0, 0, 0, 0] = -1 >>> print(out[0, 0, 0]) Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, -1) The input x should be a Tensorr)rrzYThe start_axis should be int, and should be 0 or -1 when the input tensor is a 0-D-TensorzXThe stop_axis should be int, and should be 0 or -1 when the input tensor is a 0-D-Tensorr%@The start_axis should be a int, and in range [-rank(x), rank(x))?The stop_axis should be a int, and in range [-rank(x), rank(x))-The stop_axis should be larger than stat_axisrc) rmrnrorwrpr@rqrrrsflattenflatten_contiguous_rangerAr)r5r6rGr<)rLrrNrTrUrrrSrRr#rr<rrr\r]r?r_)rcr5r6r`x_dimrgrhrs rjr<r<s^ q8VZZ%5%56 7 79:: LE z:s++ '0Ik 9c**y/Gj 0H J,,QY&F"R Is++AI%6!Q  >#+J q=!)I  !LM M~~aY77    3&(377@;;AGGD+83!+D   rc[U5$)a Return a contiguous flattened tensor. A copy is made only if needed. Note: The output Tensor will share data with origin Tensor and doesn't have a Tensor copy in ``dygraph`` mode. If you want to use the Tensor copy version, please use `Tensor.clone` like ``ravel_clone_x = x.ravel().clone()``. For example: .. code-block:: text Case 1: Given X.shape = (3, 100, 100, 4) We get: Out.shape = (3 * 100 * 100 * 4) Args: x (Tensor): A tensor of number of dimensions >= axis. A tensor with data type float16, float32, float64, int8, int32, int64, uint8. Returns: Tensor: A tensor with the contents of the input tensor, whose input axes are flattened by indicated :attr:`start_axis` and :attr:`stop_axis`, and data type is the same as input :attr:`x`. Examples: .. code-block:: pycon >>> import paddle >>> image_shape = (2, 3, 4, 4) >>> x = paddle.arange(end=image_shape[0] * image_shape[1] * image_shape[2] * image_shape[3]) >>> img = paddle.reshape(x, image_shape) >>> out = paddle.ravel(img) >>> print(out.shape) paddle.Size([96]) r>r5s rjravelrBIsJ 5>rc[U[5(d [S5e[UR5n[U[ 5(aXS- :dX*:a [S5e[U[ 5(aX$S- :dX$*:a [S5eUS:aX-nUS:aX$-nX:a [S5e[ 5(a[R"XU5$g)z Inplace version of ``flatten`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_flatten`. r8r%r9r:rr;N) rLrrrrSrRr"rflatten_)rcr5r6r`r?s rjrDrDqs q( # #9:: LE  C ( (  "   N   3 ' '  ! v  M  A~' 1}% HIIqi88rc UcSOUn[5(a[R"XUS9$[U[5(d[U[ 5(d[U[ 5(a@URR5[RRR:Xd>[U[RR5(aUR!5(aU/nO&[#SR%SSS[U555e['5(alUSR!5(a>[)U5S:XdS[)U5S 35e[R*"XS 5up4U$[R"X5$[-S0[/5D6nUR1USR25nUSRR5[RRR:Xal[)U5S:XdS[)U5S 35eUR1S S 9nUHn[5US/S QS5 M UR7SSUS0U/U/S.US S.S9 U$UR7SSU0SU0SU0S9 U$)al Stacks all the input tensors ``x`` along ``axis`` dimension. All tensors must be of the same shape and same dtype. For example, given N tensors of shape [A, B], if ``axis == 0``, the shape of stacked tensor is [N, A, B]; if ``axis == 1``, the shape of stacked tensor is [A, N, B], etc. It also supports the operation with zero-size tensors which contain 0 in their shape. See the examples below. .. code-block:: text Case 1: Input: x[0].shape = [1, 2] x[0].data = [ [1.0 , 2.0 ] ] x[1].shape = [1, 2] x[1].data = [ [3.0 , 4.0 ] ] x[2].shape = [1, 2] x[2].data = [ [5.0 , 6.0 ] ] Attrs: axis = 0 Output: Out.dims = [3, 1, 2] Out.data =[ [ [1.0, 2.0] ], [ [3.0, 4.0] ], [ [5.0, 6.0] ] ] Case 2: Input: x[0].shape = [1, 2] x[0].data = [ [1.0 , 2.0 ] ] x[1].shape = [1, 2] x[1].data = [ [3.0 , 4.0 ] ] x[2].shape = [1, 2] x[2].data = [ [5.0 , 6.0 ] ] Attrs: axis = 1 or axis = -2 # If axis = -2, axis = axis+ndim(x[0])+1 = -2+2+1 = 1. Output: Out.shape = [1, 3, 2] Out.data =[ [ [1.0, 2.0] [3.0, 4.0] [5.0, 6.0] ] ] Case 3: Input: x[0].shape = [0, 1, 2] x[0].data = [] x[1].shape = [0, 1, 2] x[1].data = [] Attrs: axis = 0 Output: Out.shape = [2, 0, 1, 2] Out.data = [] Case 4: Input: x[0].shape = [0, 1, 2] x[0].data = [] x[1].shape = [0, 1, 2] x[1].data = [] Attrs: axis = 1 Output: Out.shape = [0, 2, 1, 2] Out.data = [] The image below demonstrates the Case 1: three 2-dimensional tensors with shape [1, 2] are stacked in the dimension of axis=0 to form a 3-dimensional tensor with shape [3, 1, 2] . .. figure:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/stack/stack-0.png :width: 1000 :alt: Legend 1 :align: center Args: x (list[Tensor]|tuple[Tensor]): Input ``x`` can be a ``list`` or ``tuple`` of tensors, the Tensors in ``x`` must be of the same shape and dtype. Supported data types: float32, float64, int32, int64. Alias: ``tensors``. axis (int, optional): The axis along which all inputs are stacked. ``axis`` range is ``[-(R+1), R+1)``, where ``R`` is the number of dimensions of the first input tensor ``x[0]``. If ``axis < 0``, ``axis = axis+R+1``. The default value of axis is 0. Alias: ``dim``. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. out (Tensor, optional): The output tensor. If set, the output will be written to this tensor. Returns: Tensor, The stacked tensor with same data type as input. Examples: .. code-block:: pycon >>> import paddle >>> x1 = paddle.to_tensor([[1.0, 2.0]]) >>> x2 = paddle.to_tensor([[3.0, 4.0]]) >>> x3 = paddle.to_tensor([[5.0, 6.0]]) >>> out = paddle.stack([x1, x2, x3], axis=0) >>> print(out.shape) paddle.Size([3, 1, 2]) >>> print(out) Tensor(shape=[3, 1, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[[1., 2.]], [[3., 4.]], [[5., 6.]]]) >>> out = paddle.stack([x1, x2, x3], axis=-2) >>> print(out.shape) paddle.Size([1, 3, 2]) >>> print(out) Tensor(shape=[1, 3, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[[1., 2.], [3., 4.], [5., 6.]]]) >>> # zero-size tensors >>> x1 = paddle.ones([0, 1, 2]) >>> x2 = paddle.ones([0, 1, 2]) >>> out = paddle.stack([x1, x2], axis=0) >>> print(out.shape) paddle.Size([2, 0, 1, 2]) >>> print(out) Tensor(shape=[2, 0, 1, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[], []]) >>> out = paddle.stack([x1, x2], axis=1) >>> print(out.shape) paddle.Size([0, 2, 1, 2]) >>> print(out) Tensor(shape=[0, 2, 1, 2], dtype=float32, place=Place(cpu), stop_gradient=True, []) rrz2The type of '{}' in {} must be {}, but received {}rcr9z*list[Tensor], tuple[Tensor] or TensorArrayr%zoIf the elements of 'x' in stack are Variable(DenseTensorArray), number of the elements must be 1, but received rTr@r>rmrnror@rqrsr;rArBrErGrr6)r9)r"rr9rLrMrrrrHr r|r}rrNrTrUrXrYformatr$rr[rr\r]r?rr_)rcr6r`rhrrgrires rjr9r9sc| 1$D||A-- a  z!U';'; q( # # !5!5!H!HH q&**** + +0L0L0N0NADKK@G  }} Q4 * * , ,q6Q; BBEa&L ;++AT:FCJ<<( (  -FH -F  3 3AaDJJ ?Ctyy~~4<<//BBB1v{  >>A!fXQ H {==G=L A $  )1; E {;d3   J 8#J4.   Jrc[R"U6n[U[5(dU/nU(a)USRS:Xa[R "USUS9$[R "USUS9$)a+ Stacks all the input tensors ``x`` along horizontal axis. All tensors must be of the same dtype. The image below illustrates how ``hstack`` works. .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/hstack.png :width: 500 :alt: legend of hstack API :align: center Args: x (list[Tensor]|tuple[Tensor]): Input ``x`` can be a ``list`` or ``tuple`` of tensors, the Tensors in ``x`` must be of the same shape and dtype. Supported data types: ``float16``, ``float32``, ``float64``, ``int8``, ``int32``, ``int64`` or ``bfloat16``. 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 stacked tensor with same data type as input. Examples: .. code-block:: python >>> import paddle >>> # hstack with 0-D tensors >>> x1 = paddle.to_tensor(1.0) >>> x2 = paddle.to_tensor(2.0) >>> out = paddle.hstack((x1, x2)) >>> print(out) Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [1., 2.]) >>> # hstack with 1-D tensors >>> x1 = paddle.to_tensor([1.0, 2.0]) >>> x2 = paddle.to_tensor([3.0, 4.0, 5.0]) >>> out = paddle.hstack((x1, x2)) >>> print(out) Tensor(shape=[5], dtype=float32, place=Place(cpu), stop_gradient=True, [1., 2., 3., 4., 5.]) >>> # hstack mix with 0-D & 1-D tensors >>> x1 = paddle.to_tensor(1.0) >>> x2 = paddle.to_tensor([3.0, 4.0, 5.0]) >>> out = paddle.hstack((x1, x2)) >>> print(out) Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [1., 3., 4., 5.]) >>> # hstack with 2-D tensors >>> x1 = paddle.to_tensor([[1.0, 2.0]]) >>> x2 = paddle.to_tensor([[3.0, 4.0, 5.0]]) >>> out = paddle.hstack((x1, x2)) >>> print(out) Tensor(shape=[1, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[1., 2., 3., 4., 5.]]) rr%r6r`)rN atleast_1drLrMrr8rcr`arrayss rjhstackrM sat   "F fd # # &)..A%}}V!$77}}V!$77rc[R"U6n[U[5(dU/n[R"USUS9$)a Stacks all the input tensors ``x`` along vertical axis. All tensors must be of the same dtype. The image below illustrates how ``vstack`` works. .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/vstack.png :width: 500 :alt: legend of vstack API :align: center Args: x (list[Tensor]|tuple[Tensor]): Input ``x`` can be a ``list`` or ``tuple`` of tensors, the Tensors in ``x`` must be of the same shape and dtype. Supported data types: ``float16``, ``float32``, ``float64``, ``int8``, ``int32``, ``int64`` or ``bfloat16``. 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 stacked tensor with same data type as input. Examples: .. code-block:: python >>> import paddle >>> # vstack with 0-D tensors >>> x1 = paddle.to_tensor(1.0) >>> x2 = paddle.to_tensor(2.0) >>> out = paddle.vstack((x1, x2)) >>> print(out) Tensor(shape=[2, 1], dtype=float32, place=Place(cpu), stop_gradient=True, [[1.], [2.]]) >>> # vstack with 1-D tensors >>> x1 = paddle.to_tensor([1.0, 2.0, 3.0]) >>> x2 = paddle.to_tensor([3.0, 4.0, 5.0]) >>> out = paddle.vstack((x1, x2)) >>> print(out) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[1., 2., 3.], [3., 4., 5.]]) >>> # vstack mix with 1-D & 2-D tensors >>> x1 = paddle.to_tensor([1.0, 2.0, 3.0]) >>> x2 = paddle.to_tensor([[3.0, 4.0, 5.0]]) >>> out = paddle.vstack((x1, x2)) >>> print(out) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[1., 2., 3.], [3., 4., 5.]]) >>> # vstack with 2-D tensors >>> x1 = paddle.to_tensor([[1.0, 2.0, 3.0]]) >>> x2 = paddle.to_tensor([[3.0, 4.0, 5.0]]) >>> out = paddle.vstack((x1, x2)) >>> print(out) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[1., 2., 3.], [3., 4., 5.]]) rrI)rN atleast_2drLrMr8rKs rjvstackrP s<|   "F fd # # ==ad 33rc[R"U6n[U[5(dU/n[R"USUS9$)a| Stacks all the input tensors ``x`` along depth axis. All tensors must be of the same dtype. Args: x (list[Tensor]|tuple[Tensor]): Input ``x`` can be a ``list`` or ``tuple`` of tensors, the Tensors in ``x`` must be of the same shape and dtype. Supported data types: ``float16``, ``float32``, ``float64``, ``int8``, ``int32``, ``int64`` or ``bfloat16``. 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 stacked tensor with same data type as input. Examples: .. code-block:: python >>> import paddle >>> # dstack with 0-D tensors >>> x1 = paddle.to_tensor(1.0) >>> x2 = paddle.to_tensor(2.0) >>> out = paddle.dstack((x1, x2)) >>> print(out) Tensor(shape=[1, 1, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[[1., 2.]]]) >>> # dstack with 1-D tensors >>> x1 = paddle.to_tensor([1.0, 2.0, 3.0]) >>> x2 = paddle.to_tensor([3.0, 4.0, 5.0]) >>> out = paddle.dstack((x1, x2)) >>> print(out) Tensor(shape=[1, 3, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[[1., 3.], [2., 4.], [3., 5.]]]) >>> # dstack with 3-D tensors >>> x1 = paddle.to_tensor([[[1.0, 2.0], [3.0, 4.0]]]) >>> x2 = paddle.to_tensor([[[3.0, 4.0], [5.0, 6.0]]]) >>> out = paddle.dstack((x1, x2)) >>> print(out) Tensor(shape=[1, 2, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[[1., 2., 3., 4.], [3., 4., 5., 6.]]]) rrI)rN atleast_3drLrMr8rKs rjdstackrS s<\   "F fd # # ==ad 33rc/nUHVnURS:a2URURUR5S455 MEURU5 MX [R "USUS9$)a- Stacks all the input tensors ``x`` along horizontal axis. Each tensor in ``x`` will be first reshaped into ``(tensor.numel(), 1)`` if ``tensor.ndim < 2`` before being stacked. All tensors must be of the same dtype. Args: x (list[Tensor]|tuple[Tensor]): Input ``x`` can be a ``list`` or ``tuple`` of tensors, the Tensors in ``x`` must be of the same shape and dtype. Supported data types: ``float16``, ``float32``, ``float64``, ``int32``, ``int64`` or ``bfloat16``. 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 stacked tensor with same data type as input. Examples: .. code-block:: python >>> import paddle >>> # column_stack with 0-D tensors >>> x1 = paddle.to_tensor(1.0) >>> x2 = paddle.to_tensor(2.0) >>> out = paddle.column_stack((x1, x2)) >>> print(out) Tensor(shape=[1, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[1., 2.]]) >>> # column_stack mix with 1-D & 2-D tensors >>> x1 = paddle.to_tensor([[1.0], [2.0], [3.0]]) >>> x2 = paddle.to_tensor([3.0, 4.0, 5.0]) >>> out = paddle.column_stack((x1, x2)) >>> print(out) Tensor(shape=[3, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[1., 3.], [2., 4.], [3., 5.]]) >>> # column_stack with 3-D tensors >>> x1 = paddle.to_tensor([[[1.0, 2.0], [3.0, 4.0]]]) >>> x2 = paddle.to_tensor([[[3.0, 4.0], [5.0, 6.0]]]) >>> out = paddle.column_stack((x1, x2)) >>> print(out) Tensor(shape=[1, 4, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[[1., 2.], [3., 4.], [3., 4.], [5., 6.]]]) rr%rI)rrrnumelrNr8)rcr`rLr#s rj column_stackrVB s`bF ;;? MM&..&,,.!)<= > MM& !  ==ad 33rc*[R"XS9$)a Alias of `paddle.vstack()`. Stacks all the input tensors ``x`` along vertical axis. All tensors must be of the same dtype. Args: x (list[Tensor]|tuple[Tensor]): Input ``x`` can be a ``list`` or ``tuple`` of tensors, the Tensors in ``x`` must be of the same shape and dtype. Supported data types: ``float16``, ``float32``, ``float64``, ``int8``, ``int32``, ``int64`` or ``bfloat16``. 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 stacked tensor with same data type as input. Examples: .. code-block:: python >>> import paddle >>> # row_stack with 0-D tensors >>> x1 = paddle.to_tensor(1.0) >>> x2 = paddle.to_tensor(2.0) >>> out = paddle.row_stack((x1, x2)) >>> print(out) Tensor(shape=[2, 1], dtype=float32, place=Place(cpu), stop_gradient=True, [[1.], [2.]]) >>> # row_stack with 1-D tensors >>> x1 = paddle.to_tensor([1.0, 2.0, 3.0]) >>> x2 = paddle.to_tensor([3.0, 4.0, 5.0]) >>> out = paddle.row_stack((x1, x2)) >>> print(out) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[1., 2., 3.], [3., 4., 5.]]) >>> # row_stack mix with 1-D & 2-D tensors >>> x1 = paddle.to_tensor([1.0, 2.0, 3.0]) >>> x2 = paddle.to_tensor([[3.0, 4.0, 5.0]]) >>> out = paddle.row_stack((x1, x2)) >>> print(out) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[1., 2., 3.], [3., 4., 5.]]) >>> # row_stack with 2-D tensors >>> x1 = paddle.to_tensor([[1.0, 2.0, 3.0]]) >>> x2 = paddle.to_tensor([[3.0, 4.0, 5.0]]) >>> out = paddle.row_stack((x1, x2)) >>> print(out) Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[1., 2., 3.], [3., 4., 5.]]) r`)rNrP)rcr`s rj row_stackrY~ sp == &&r>rr#split_size_or_sectionsz paddle.splitzpaddle.compat.splitz torch.split) illegal_keys func_name correct_name url_suffixc^ ^UnUn[5(GaX[U[5(aURS5nU[ UR 5-S:dS5eUS:aU[ UR 5-OUn[U[ [45(ad[RRU5(a?[U5H0upg[U[5(dMXR5X'M2 O-[U[5(d[S[U5S35e[U[5(a[R "XAU5$[R""XAU5$[%5(Ga[U[R&R(5(aSUl[U[5(aC[ UR 5U-S:dS5eUS:a[ UR 5U-OUnUR n[U[[ [45(d[S[U5S35e[U[5(a\US:dS5e[U[5(a#XS:aXU-S:XdSUSXS 35e[R "XAU5$[U[5(a XS:a[ U5X::dS 5e[RRU5(a[RR-U5n[R""XAU5$[/US /S QS 5 [1US[ [[4S 5 [1US[[4S 5 [U[5(a[3UR4SSS/S 5 [7S0[95D6mUR nSU0n S[U[5(aUOS0n U4Sjn [U[5(a SUlXYS'O=[ UR 5U-S:dS5eUS:a[ U5U-OUnXZS'[U[5(aHUS:dS5e[U[5(a#XS:aXU-S:XdSUSXS 35eUn O[U[5(a XS:a[ U5X::dS 5e[ U5n UV s/sHn [U [5(aSOU PM sn U S'[RRU5(a U "U5U S'[;U 5Vs/sH nTR=TR?5S9PM" nnTRAS U SU0U S9 U$s sn fs snf)a{ Split the input tensor into multiple sub-Tensors. Args: x (Tensor): A N-D Tensor. The data type is bool, bfloat16, float16, float32, float64, uint8, int8, int32 or int64. num_or_sections (int|list|tuple): If ``num_or_sections`` is an int, then ``num_or_sections`` indicates the number of equal sized sub-Tensors that the ``x`` will be divided into. If ``num_or_sections`` is a list or tuple, the length of it indicates the number of sub-Tensors and the elements in it indicate the sizes of sub-Tensors' dimension orderly. The length of the list must not be larger than the ``x`` 's size of specified ``axis``. axis (int|Tensor, optional): The axis along which to split, it can be a integer or a ``0-D Tensor`` with shape [] and data type ``int32`` or ``int64``. If :math::`axis < 0`, the axis to split along is :math:`rank(x) + axis`. Default is 0. name (str|None, 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` . Returns: list(Tensor), The list of segmented Tensors. Examples: .. code-block:: pycon >>> import paddle >>> # x is a Tensor of shape [3, 9, 5] >>> x = paddle.rand([3, 9, 5]) >>> out0, out1, out2 = paddle.split(x, num_or_sections=3, axis=1) >>> print(out0.shape) paddle.Size([3, 3, 5]) >>> print(out1.shape) paddle.Size([3, 3, 5]) >>> print(out2.shape) paddle.Size([3, 3, 5]) >>> out0, out1, out2 = paddle.split(x, num_or_sections=[2, 3, 4], axis=1) >>> print(out0.shape) paddle.Size([3, 2, 5]) >>> print(out1.shape) paddle.Size([3, 3, 5]) >>> print(out2.shape) paddle.Size([3, 4, 5]) >>> out0, out1, out2 = paddle.split(x, num_or_sections=[2, 3, -1], axis=1) >>> print(out0.shape) paddle.Size([3, 2, 5]) >>> print(out1.shape) paddle.Size([3, 3, 5]) >>> print(out2.shape) paddle.Size([3, 4, 5]) >>> # axis is negative, the real axis is (rank(x) + axis)=1 >>> out0, out1, out2 = paddle.split(x, num_or_sections=3, axis=-2) >>> print(out0.shape) paddle.Size([3, 3, 5]) >>> print(out1.shape) paddle.Size([3, 3, 5]) >>> print(out2.shape) paddle.Size([3, 3, 5]) rz(rank(x) + axis) must >= 0zcThe type of 'num_or_sections' in split must be int, list or tuple in imperative mode, but received rTznum_or_sections must be than 0.zbThe input's size along the split dimension must be evenly divisible by Attr(num_or_sections). But z is not evenly divisible by z. z/nSn[U5Hup4[U[5(aSUlUR U5 M4[U[ 5(deUS:XaUS:Xd SUS35eUnTR S5n[S/SUSUS9 UR U5 M U$)NrTzSOnly one value of 'num_or_section' in split can be -1. But received num_or_section[z ] is also -1.r@r%r)rVrLrryrrRr]r )one_list tensor_list unk_dim_idxrrrrgs rj_get_SectionsTensorList&split.._get_SectionsTensorList[ sKK!*8!4 h11-1H*&&x0%h44442~*b0BBEmU0'* %HH H"Wh$H &&x0%"5& rrr6rsectionsSectionsTensorListr>rCrG)r`)!r"rLrrrrSrMrrNrrrVrRrYrHrsplit_with_numr`r$rTrUryrrrrr?rr\rr]r^r_)rcrar6r`r5rindexr input_shaperIrKrfrelererrgs @rjr`r` sP E C c8 $ $((1+CS%%*H,HH**-'sS%%s oe} 5 5||((99#,_#=KE!$111@1G1L1L1N.$>OS11 12!5  os + +((E E<<< <  c6::++ , , $C  c3  u{{#c)Q. L0L L..1Ag3u{{#c)3Ckk /Cu+=>> 12!5  os + +"Q& I(I I&#s## (81(<"'/9Q>*++G HXGYY[]> ((E E#s## (81(<?+{/??R?||((99"(,,"B"B##<<< < !     "  .sE0BG  3X8 c8 $ $  57G**++G HXGYY[]> "C#s## (81(<?+{/??R?o&C+!*C!h//S8*!E* ||((99/F#0+,3Z     5 5((* 6   %e   %! s #V%&'V*cTURS::dURU::a[SUSUR35eURUnSnSn[U[5(a U"XX5$[U[ [ 45(a U"XX5$[S[U535e)aC Split the input tensor into multiple sub-Tensors along ``axis``, allowing not being of equal size. In the following figure, the shape of Tenser x is [6], and after paddle.tensor_split(x, num_or_indices=4) transformation, we get four sub-Tensors out0, out1, out2, and out3 : .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/tensor_split/tensor_split-1_en.png since the length of x in axis = 0 direction 6 is not divisible by num_or_indices = 4, the size of the first int(6 % 4) part after splitting will be int(6 / 4) + 1 and the size of the remaining parts will be int(6 / 4). .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``, ``indices_or_sections`` can be used as an alias for ``num_or_indices``, and ``dim`` can be used as an alias for ``axis``. For example, ``tensor_split(input=tensor_x, indices=[2,4], dim=1, ...)`` is equivalent to ``tensor_split(x=tensor_x, num_or_indices=[2,4], axis=1, ...)``. Args: x (Tensor): A Tensor whose dimension must be greater than 0. The data type is bool, bfloat16, float16, float32, float64, uint8, int32 or int64. alias: ``input`` num_or_indices (int|list|tuple): If ``num_or_indices`` is an int ``n``, ``x`` is split into ``n`` sections along ``axis``. If ``x`` is divisible by ``n``, each section will be ``x.shape[axis] / n``. If ``x`` is not divisible by ``n``, the first ``int(x.shape[axis] % n)`` sections will have size ``int(x.shape[axis] / n) + 1``, and the rest will be ``int(x.shape[axis] / n). If ``num_or_indices`` is a list or tuple of integer indices, ``x`` is split along ``axis`` at each of the indices. For instance, ``num_or_indices=[2, 4]`` with ``axis=0`` would split ``x`` into ``x[:2]``, ``x[2:4]`` and ``x[4:]`` along axis 0. alias: ``indices`` or ``sections`` axis (int|Tensor, optional): The axis along which to split, it can be a integer or a ``0-D Tensor`` with shape [] and data type ``int32`` or ``int64``. If :math::`axis < 0`, the axis to split along is :math:`rank(x) + axis`. Default is 0. alias: ``dim`` name (str|None, 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` . Returns: list[Tensor], The list of segmented Tensors. Examples: .. code-block:: pycon :name: tensor-split-example-1 >>> import paddle >>> # evenly split >>> # x is a Tensor of shape [8] >>> x = paddle.rand([8]) >>> out0, out1 = paddle.tensor_split(x, num_or_indices=2) >>> print(out0.shape) paddle.Size([4]) >>> print(out1.shape) paddle.Size([4]) .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/tensor_split/tensor_split-2.png .. code-block:: pycon :name: tensor-split-example-2 >>> import paddle >>> # not evenly split >>> # x is a Tensor of shape [8] >>> x = paddle.rand([8]) >>> out0, out1, out2 = paddle.tensor_split(x, num_or_indices=3) >>> print(out0.shape) paddle.Size([3]) >>> print(out1.shape) paddle.Size([3]) >>> print(out2.shape) paddle.Size([2]) .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/tensor_split/tensor_split-3_en.png .. code-block:: pycon :name: tensor-split-example-3 >>> import paddle >>> # split with indices >>> # x is a Tensor of shape [8] >>> x = paddle.rand([8]) >>> out0, out1, out2 = paddle.tensor_split(x, num_or_indices=[2, 3]) >>> print(out0.shape) paddle.Size([2]) >>> print(out1.shape) paddle.Size([1]) >>> print(out2.shape) paddle.Size([5]) .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/tensor_split/tensor_split-4.png .. code-block:: pycon :name: tensor-split-example-4 >>> import paddle >>> # split along axis >>> # x is a Tensor of shape [7, 8] >>> x = paddle.rand([7, 8]) >>> out0, out1 = paddle.tensor_split(x, num_or_indices=2, axis=1) >>> print(out0.shape) paddle.Size([7, 4]) >>> print(out1.shape) paddle.Size([7, 4]) .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/tensor_split/tensor_split-5.png .. code-block:: pycon :name: tensor-split-example-5 >>> import paddle >>> # split along axis with indices >>> # x is a Tensor of shape [7, 8] >>> x = paddle.rand([7, 8]) >>> out0, out1, out2 = paddle.tensor_split(x, num_or_indices=[2, 3], axis=1) >>> print(out0.shape) paddle.Size([7, 2]) >>> print(out1.shape) paddle.Size([7, 1]) >>> print(out2.shape) paddle.Size([7, 5]) .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/tensor_split/tensor_split-6.png rzEThe input tensor's dimension must be greater than 0 or axis which is z , but got c/nSnSn/[U5QUPHTnUnUS:aUOX-nUS:aUOX-n [X5n [R"X/U/U /S9n UR U 5 UnMV U$)Nr)rrr)rMrrNrr) rctotal_nindicesr6splitsrrr starts_index ends_index sub_arrays rj_tensor_split_indices+tensor_split.._tensor_split_indices' s,T'],G,CD%+q[6g6FL!%J\6J  ~ZLI MM) $F- rczUS::a [S5e[X5upEUS-/U-U/X%- --n[XU5$)Nrz%num_or_indices must be larger than 0.r%)rdivmodr`)rcrprhr6basemodras rj_tensor_split_sections,tensor_split.._tensor_split_sections< sL q=DE E7- !8*s*dVx~-FFQ..rzAThe num_or_indices should be int, list or tuple of ints, but got )rrrSrLrRrMrrH)rcnum_or_indicesr6r`rprvr|s rj tensor_splitr sB vv{affnSTXSYYcdedjdjck l  ggdmG*/.#&&%a.GG NT5M 2 2$QFFOPTUcPdOe f  rcURS:a[SUR35eURS:a [XSUS9$[XSUS9$)a ``hsplit`` Full name Horizontal Split, splits the input Tensor into multiple sub-Tensors along the horizontal axis, in the following two cases: 1. When the dimension of x is equal to 1, it is equivalent to ``paddle.tensor_split`` with ``axis=0``; .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/hsplit/hsplit-1.png 2. when the dimension of x is greater than 1, it is equivalent to ``paddle.tensor_split`` with ``axis=1``. .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/hsplit/hsplit-2.png Args: x (Tensor): A Tensor whose dimension must be greater than 0. The data type is bool, bfloat16, float16, float32, float64, uint8, int32 or int64. num_or_indices (int|list|tuple): If ``num_or_indices`` is an int ``n``, ``x`` is split into ``n`` sections. If ``num_or_indices`` is a list or tuple of integer indices, ``x`` is split at each of the indices. name (str|None, 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` . Returns: list[Tensor], The list of segmented Tensors. Examples: .. code-block:: pycon >>> import paddle >>> # x is a Tensor of shape [8] >>> x = paddle.rand([8]) >>> out0, out1 = paddle.hsplit(x, num_or_indices=2) >>> print(out0.shape) paddle.Size([4]) >>> print(out1.shape) paddle.Size([4]) >>> # x is a Tensor of shape [7, 8] >>> x = paddle.rand([7, 8]) >>> out0, out1 = paddle.hsplit(x, num_or_indices=2) >>> print(out0.shape) paddle.Size([7, 4]) >>> print(out1.shape) paddle.Size([7, 4]) >>> out0, out1, out2 = paddle.hsplit(x, num_or_indices=[1, 4]) >>> print(out0.shape) paddle.Size([7, 1]) >>> print(out1.shape) paddle.Size([7, 3]) >>> print(out2.shape) paddle.Size([7, 4]) r%z=The input tensor's dimension must be greater than 0, but got rIrrrrrcr~r`s rjhsplitrP sVn vvzKAFF8 T   vvzAADAAAADAArchURS:a[SUR35e[XSUS9$)a ``dsplit`` Full name Depth Split, splits the input Tensor into multiple sub-Tensors along the depth axis, which is equivalent to ``paddle.tensor_split`` with ``axis=2``. Note: Make sure that the number of Tensor dimensions transformed using ``paddle.dsplit`` must be no less than 3. In the following figure, Tenser ``x`` has shape [4, 4, 4], and after ``paddle.dsplit(x, num_or_indices=2)`` transformation, we get ``out0`` and ``out1`` sub-Tensors whose shapes are both [4, 4, 2] : .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/dsplit/dsplit.png Args: x (Tensor): A Tensor whose dimension must be greater than 2. The data type is bool, bfloat16, float16, float32, float64, uint8, int32 or int64. num_or_indices (int|list|tuple): If ``num_or_indices`` is an int ``n``, ``x`` is split into ``n`` sections. If ``num_or_indices`` is a list or tuple of integer indices, ``x`` is split at each of the indices. name (str|None, 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` . Returns: list[Tensor], The list of segmented Tensors. Examples: .. code-block:: pycon >>> import paddle >>> # x is a Tensor of shape [7, 6, 8] >>> x = paddle.rand([7, 6, 8]) >>> out0, out1 = paddle.dsplit(x, num_or_indices=2) >>> print(out0.shape) paddle.Size([7, 6, 4]) >>> print(out1.shape) paddle.Size([7, 6, 4]) >>> out0, out1, out2 = paddle.dsplit(x, num_or_indices=[1, 4]) >>> print(out0.shape) paddle.Size([7, 6, 1]) >>> print(out1.shape) paddle.Size([7, 6, 3]) >>> print(out2.shape) paddle.Size([7, 6, 4]) z=The input tensor's dimension must be greater than 2, but got rrIrrs rjdsplitr s<\ vvzKAFF8 T    ==rchURS:a[SUR35e[XSUS9$)a6 ``vsplit`` Full name Vertical Split, splits the input Tensor into multiple sub-Tensors along the vertical axis, which is equivalent to ``paddle.tensor_split`` with ``axis=0``. 1. When the number of Tensor dimensions is equal to 2: .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/vsplit/vsplit-1.png 2. When the number of Tensor dimensions is greater than 2: .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/vsplit/vsplit-2.png Note: Make sure that the number of Tensor dimensions transformed using ``paddle.vsplit`` must be not less than 2. Args: x (Tensor): A Tensor whose dimension must be greater than 1. The data type is bool, bfloat16, float16, float32, float64, uint8, int32 or int64. num_or_indices (int|list|tuple): If ``num_or_indices`` is an int ``n``, ``x`` is split into ``n`` sections. If ``num_or_indices`` is a list or tuple of integer indices, ``x`` is split at each of the indices. name (str, 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` . Returns: list[Tensor], The list of segmented Tensors. Examples: .. code-block:: pycon >>> import paddle >>> # x is a Tensor of shape [8, 6, 7] >>> x = paddle.rand([8, 6, 7]) >>> out0, out1 = paddle.vsplit(x, num_or_indices=2) >>> print(out0.shape) paddle.Size([4, 6, 7]) >>> print(out1.shape) paddle.Size([4, 6, 7]) >>> out0, out1, out2 = paddle.vsplit(x, num_or_indices=[1, 4]) >>> print(out0.shape) paddle.Size([1, 6, 7]) >>> print(out1.shape) paddle.Size([3, 6, 7]) >>> print(out2.shape) paddle.Size([4, 6, 7]) rz=The input tensor's dimension must be greater than 1, but got rrIrrs rjvsplitr s<f vvzKAFF8 T    ==rcUc/nOq[U[5(aU/nOX[U[5(a [U5nO7[U[R [ 45(aURS:XaU$UnUn[5(a[R"X45$[5(a[U[5(aU/n[U[RR5(aSUlO][U[[45(aB[RR!U5(a[RR#USS9n[R"X45$[%S0['5D6n[)US/SQS5 [+US[[[[ 4S5 0n[U[ 5(a SUlXFS 'Of[U[[45(aK[RR!U5(a#[RR-U5US 'OXFS 'UR/UR0S 9nUR/UR0S 9nUR3S S U0UXxS .S9 U$)a Squeeze the dimension(s) of size 1 of input tensor x's shape. Note that the output Tensor will share data with origin Tensor and doesn't have a Tensor copy in ``dygraph`` mode. If you want to use the Tensor copy version, please use `Tensor.clone` like ``squeeze_clone_x = x.squeeze().clone()``. If axis is provided, it will remove the dimension(s) by given axis that of size 1. If the dimension of given axis is not of size 1, the dimension remain unchanged. If axis is not provided, all dims equal of size 1 will be removed. .. code-block:: text Case1: Input: x.shape = [1, 3, 1, 5] # If axis is not provided, all dims equal of size 1 will be removed. axis = None Output: out.shape = [3, 5] Case2: Input: x.shape = [1, 3, 1, 5] # If axis is provided, it will remove the dimension(s) by given axis that of size 1. axis = 0 Output: out.shape = [3, 1, 5] Case4: Input: x.shape = [1, 3, 1, 5] # If the dimension of one given axis (3) is not of size 1, the dimension remain unchanged. axis = [0, 2, 3] Output: out.shape = [3, 5] Case4: Input: x.shape = [1, 3, 1, 5] # If axis is negative, axis = axis + ndim (number of dimensions in x). axis = [-2] Output: out.shape = [1, 3, 5] .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``, and ``dim`` can be used as an alias for ``axis``. For example, ``squeeze(input=tensor_x, dim=1)`` is equivalent to ``squeeze(x=tensor_x, axis=1)``. Args: x (Tensor): The input Tensor. Supported data type: float32, float64, bool, int8, int32, int64. alias: ``input``. axis (int|list|tuple, optional): An integer or list/tuple of integers, indicating the dimensions to be squeezed. Default is None. The range of axis is :math:`[-ndim(x), ndim(x))`. If axis is negative, :math:`axis = axis + ndim(x)`. If axis is None, all the dimensions of x of size 1 will be removed. alias: ``dim``. name (str|None, optional): Please refer to :ref:`api_guide_Name`, Default None. Returns: Tensor, Squeezed Tensor with the same data type as input Tensor. Examples: .. code-block:: pycon >>> import paddle >>> x = paddle.rand([5, 1, 10]) >>> output = paddle.squeeze(x, axis=1) >>> print(x.shape) paddle.Size([5, 1, 10]) >>> print(output.shape) paddle.Size([5, 10]) >>> # output shares data with x in dygraph mode >>> x[0, 0, 0] = 10.0 >>> print(output[0, 0]) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 10.) rTrq default_dtypesqueezer5) rmrsrnrorlrwr@rqrr axis/axesrr>squeeze2rArr)r)rLrRrrMrNr,rsizer"rrr$rTrUryrrrrr\rrrr]r?r_) rcr6r`r5rrgrKrhrs rjrr sl | D#  v D% Dz D6==(3 4 4 99>H E D~~e**  dC 6D dFJJ,, - -!%D  tUm , ,||((..||778~~e**3&(3     $ 4sD%&BIN dH % %!%D  &M tUm , ,||((.. & D DT Jf $f 77ekk7J;;%++;N<3   rcUc/nO9[U[5(aU/nO [U[5(a [U5nUnUn[ 5(a[ R "X45$g)z Inplace version of ``squeeze`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_tensor_squeeze`. N)rLrRrrMr"rsqueeze_)rcr6r`r5rs rjrr s_ | D#  v D% Dz E Du++rcFUc/nOU/nUn[U[RR[R RR 45(d [U5n[5(Ga [R"UR5S:XaU/:Xa![R"/URS9/nOUR5/nUS:XdU[R:Xa[RnO[R nU(a$UR#[R"/US95 U(a$UR#[R"/US95 [%U5S:XaUS$['U5$[)5(am[*R,"XX#U5upn U /nU(aUR#U 5 U(aUR#U 5 [%U5S:XaUS$['U5$[/US/SQS5 [1US[2S5 [1US [2S5 [5US SS /S5 [%U5S:wa[1USS [6S5 [9S0[;5D6n UUUUS .n U R=URSS9n U R=USS9n U R=USS9n XU S.nU /nU(aUR#U 5 U(aUR#U 5 U R?SSU0U US9 [%U5S:XaUS$['U5$)a2 Eliminates all but the first element from every consecutive group of equivalent elements. Note: This function is different from :ref:`api_paddle_unique` in the sense that this function only eliminates consecutive duplicate values. This semantics is similar to :ref:`api_paddle_unique` in C++. .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``, and ``dim`` can be used as an alias for ``axis``. For example, ``unique_consecutive(input=tensor_x, dim=1, ...)`` is equivalent to ``unique_consecutive(x=tensor_x, axis=1, ...)``. Args: x(Tensor): the input tensor, it's data type should be float32, float64, int32, int64. alias: ``input``. return_inverse(bool, optional): If True, also return the indices for where elements in the original input ended up in the returned unique consecutive tensor. Default is False. return_counts(bool, optional): If True, also return the counts for each unique consecutive element. Default is False. axis(int, optional): The axis to apply unique consecutive. If None, the input will be flattened. Default is None. dtype(str|paddle.dtype|np.dtype, optional):The data type `inverse` tensor: int32 or int64. Default: int64. name(str|None, optional): Name for the operation. For more information, please refer to :ref:`api_guide_Name`. Default is None. Returns: - out (Tensor), the unique consecutive tensor for x. - inverse (Tensor), the element of the input tensor corresponds to the index of the elements in the unique consecutive tensor for x. inverse is provided only if return_inverse is True. - counts (Tensor), the counts of the every unique consecutive element in the input tensor. counts is provided only if return_counts is True. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([1, 1, 2, 2, 3, 1, 1, 2]) >>> output = paddle.unique_consecutive(x) # >>> print(output) Tensor(shape=[5], dtype=int64, place=Place(cpu), stop_gradient=True, [1, 2, 3, 1, 2]) >>> _, inverse, counts = paddle.unique_consecutive(x, return_inverse=True, return_counts=True) >>> print(inverse) Tensor(shape=[8], dtype=int64, place=Place(cpu), stop_gradient=True, [0, 0, 1, 1, 2, 3, 3, 4]) >>> print(counts) Tensor(shape=[5], dtype=int64, place=Place(cpu), stop_gradient=True, [2, 2, 1, 2, 1]) >>> x = paddle.to_tensor([[2, 1, 3], [3, 0, 1], [2, 1, 3], [2, 1, 3]]) >>> output = paddle.unique_consecutive(x, axis=0) # >>> print(output) Tensor(shape=[3, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[2, 1, 3], [3, 0, 1], [2, 1, 3]]) >>> x = paddle.to_tensor([[2, 1, 3], [3, 0, 1], [2, 1, 3], [2, 1, 3]]) >>> output = paddle.unique_consecutive(x, axis=0) # >>> print(output) Tensor(shape=[3, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[2, 1, 3], [3, 0, 1], [2, 1, 3]]) rr>r@r%r5runique_consecutivereturn_inverse return_countsr?rqr6)r?rrr6Trx)rCIndexCountsrAr)r) rLr r|r}rNrTr~rr"mathprodrSrOr?cloner@rqrrrr#rrrrrlrrRrr\r]r_)rcrrr6r?r` attr_dtyper return_dtyperhinversecountsrgrKrJs rjrr s\ |vJ T\\))6::??+C+CD  06  99QWW  "rz((177;< {5FLL#8%|| %||  F,,R|DE F,,R|DE4yA~Aw; %88 }J fu  KK  KK  t9>7NT{  4  >#3T;OP=/49MNE7Wg$68LM t9> tAw-A B>VX>,*   77''8 ;;D< ::D; 6Bu  KK  KK %8  t9>7NT{r.cgr rrc return_indexrrr6r?sortedr`s rjuniquerSs-0rcgr rrs rjrr`%(rcgr rrs rjrrmrrcgr rrs rjrrzrrcgr rrs rjrr rcgr rrs rjrrrrcgr rrs rjrrrrcgr rrs rjrrsrcgr rrs rjrrs#&rTc nUc/nOU/n[U5n[5(Ga[R"UR5S:XaUR 5/n US:XdU[ R:Xa[ Rn O[ Rn U(a$U R[ R"/U S95 U(a$U R[ R"/U S95 U(a$U R[ R"/U S95 [U 5S:XaU S$[U 5$[R"XX#XH5uppU /n U(aU RU 5 U(aU RU 5 U(aU RU5 [U 5S:XaU S$[U 5$[5(a[R"UUUUUUS5uppU /n U(aU RU 5 U(aU RU 5 U(aU RU5 [U 5S:XaU S$[U 5$[!US/SQS5 [#US [$S5 [#US [$S5 [#US [$S5 ['US SS /S5 [U5S:wa[#USS[(S5 [+S0[-5D6nUUUUUSS.nUR/UR0SS9n UR/USS9n UR/USS9n UR/USS9nU U U US.nU /n U(aU RU 5 U(aU RU 5 U(aU RU5 UR3SSU0UUS9 [U 5S:XaU S$[U 5$)a Returns the unique elements of `x` in ascending order. Args: x(Tensor): The input tensor, it's data type should be float32, float64, int32, int64. return_index(bool, optional): If True, also return the indices of the input tensor that result in the unique Tensor. return_inverse(bool, optional): If True, also return the indices for where elements in the original input ended up in the returned unique tensor. return_counts(bool, optional): If True, also return the counts for each unique element. axis(int, optional): The axis to apply unique. If None, the input will be flattened. Default: None. dtype(str|paddle.dtype|np.dtype, optional): The date type of `indices` or `inverse` tensor: int32 or int64. Default: int64. sorted(bool, optional): Does not affect the return result, same as PyTorch. name(str|None, optional): Name for the operation. For more information, please refer to :ref:`api_guide_Name`. Default: None. Returns: tuple (out, indices, inverse, counts). `out` is the unique tensor for `x`. `indices` is \ provided only if `return_index` is True. `inverse` is provided only if `return_inverse` \ is True. `counts` is provided only if `return_counts` is True. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([2, 3, 3, 1, 5, 3]) >>> unique = paddle.unique(x) >>> print(unique) Tensor(shape=[4], dtype=int64, place=Place(cpu), stop_gradient=True, [1, 2, 3, 5]) >>> _, indices, inverse, counts = paddle.unique(x, return_index=True, return_inverse=True, return_counts=True) >>> print(indices) Tensor(shape=[4], dtype=int64, place=Place(cpu), stop_gradient=True, [3, 0, 1, 4]) >>> print(inverse) Tensor(shape=[6], dtype=int64, place=Place(cpu), stop_gradient=True, [1, 2, 2, 0, 3, 2]) >>> print(counts) Tensor(shape=[4], dtype=int64, place=Place(cpu), stop_gradient=True, [1, 1, 3, 1]) >>> x = paddle.to_tensor([[2, 1, 3], [3, 0, 1], [2, 1, 3]]) >>> unique = paddle.unique(x) >>> print(unique) Tensor(shape=[4], dtype=int64, place=Place(cpu), stop_gradient=True, [0, 1, 2, 3]) >>> unique = paddle.unique(x, axis=0) >>> print(unique) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[2, 1, 3], [3, 0, 1]]) rr@r>r%Tr5)rmrsrnror@rqrrrrr?rqr6)r?rrrr6 is_sortedrx)rCIndicesrrrAr)r)rr"rrrSrrNr@rqrrOrrrrr$rrrlrrRrr\r]r?r_)rcrrrr6r?rr`rrrrhrqrrrgrKrJs rjrrskF |v+E2J 99QWW  "GGI;D5FLL#8%|| %||  F,,R|DE F,,R|DE F,,R|DE4yA~Aw; (. ^D) %gu  KK  KK  KK  t9>7NT{ (.      ) %gu  KK  KK  KK  t9>7NT{  I   <x@>#3T8D=/4BE7Wg$6A t9> tAwX 622(,*  77''8 ;;D< ;;D< ::D;    u  KK  KK  KK 3(%   t9>7NT{rc|UnUn[5(a[U[5(aU/nOy[U[5(aUR 5nOS[U[ [ 45(a8UVs/sH+n[U[5(aURS5OUPM- nn[R"X45$[5(a[U[5(aU/n[U[RR5(aSUlO][U[ [ 45(aB[RR!U5(a[RR#USS9n[R"X45$[%US[[ [ [4S5 ['US/SQS5 [)S0[+5D6nS U0n0n[U[5(aU/n[U[5(a SUlXGS 'Of[U[ [ 45(aK[RR!U5(a#[RR-U5US 'OXHS 'UR/UR0S9n UR/UR0S9n UR3S UUXS.S9 U $s snf)a Insert single-dimensional entries to the shape of input Tensor ``x``. Takes one required argument axis, a dimension or list of dimensions that will be inserted. Dimension indices in axis are as seen in the output tensor. Note that the output Tensor will share data with origin Tensor and doesn't have a Tensor copy in ``dygraph`` mode. If you want to use the Tensor copy version, please use `Tensor.clone` like ``unsqueeze_clone_x = x.unsqueeze(-1).clone()``. .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``, and ``dim`` can be used as an alias for ``axis``. For example, ``unsqueeze(input=tensor_x, dim=1)`` is equivalent to ``unsqueeze(x=tensor_x, axis=1)``. Args: x (Tensor): The input Tensor to be unsqueezed. Supported data type: bfloat16, float16, float32, float64, bool, int8, int32, int64. alias: ``input``. axis (int|list|tuple|Tensor): Indicates the dimensions to be inserted. The data type is ``int32`` . If ``axis`` is a list or tuple, each element of it should be integer or 0-D Tensor with shape []. If ``axis`` is a Tensor, it should be an 1-D Tensor . If ``axis`` is negative, ``axis = axis + ndim(x) + 1``. alias: ``dim``. name (str|None, optional): Name for this layer. Please refer to :ref:`api_guide_Name`, Default None. Returns: Tensor, Unsqueezed Tensor with the same data type as input Tensor. Examples: .. code-block:: pycon >>> import paddle >>> x = paddle.rand([5, 10]) >>> print(x.shape) paddle.Size([5, 10]) >>> out1 = paddle.unsqueeze(x, axis=0) >>> print(out1.shape) paddle.Size([1, 5, 10]) >>> out2 = paddle.unsqueeze(x, axis=[0, 2]) >>> print(out2.shape) paddle.Size([1, 5, 1, 10]) >>> axis = paddle.to_tensor([0, 1, 2]) >>> out3 = paddle.unsqueeze(x, axis=axis) >>> print(out3.shape) paddle.Size([1, 1, 1, 5, 10]) >>> # out1, out2, out3 share data with x in dygraph mode >>> x[0, 0] = 10.0 >>> print(out1[0, 0, 0]) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 10.) >>> print(out2[0, 0, 0, 0]) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 10.) >>> print(out3[0, 0, 0, 0, 0]) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 10.) rTrqrr unsqueezer5) rsrmrsrnrorlrwrpr@rqrr unsqueeze2rA AxesTensorAxesTensorListrr>rr)r)r"rLrRrrrMrrrrr$rNrTrUryrrrrrrr\rr]r?r_) rcr6r`r5rrrgrIrKrhrs rjrrs\F E D dC 6D h ' ';;=D tUm , ,! D!+4 : : ! D  ,,  dC 6D dFJJ,, - -!%D  tUm , ,||((..||778,,4sD%&BKP    # &6VX6u dC 6D dH % %!%D #'< tUm , ,||((..+1<<+O+O,'(!%f 77ekk7J;;%++;N3   s22J9cdUnUn[U[5(aU/nOy[U[5(aUR5nOS[U[[ 45(a8UVs/sH+n[U[5(aUR S5OUPM- nn[R"X45$s snf)z Inplace version of ``unsqueeze`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_tensor_unsqueeze`. r) rLrRrrrMrrr unsqueeze_)rcr6r`r5rrs rjrrs E D$v D( # #{{} D4- ( ( 'tX66DIIaLD @     U ))  s#2B-cd[R"XUSS9nUb[R"XC5 U$)zWrapper for take_along_axisF broadcast)rNtake_along_axisassign)r5rrkrhrbs rj_take_along_axis_wrapperr$s.  se DC  c JrcUcSn[5(a[R"XU5nO[US/SQS5 [USSS/S5 [ U[ 5(a[USSS/S5 [ S0[5D6nURS5nURU5n[ U[ 5(dURSXS .US S .S U0S 9 OURSXUS.SS 0S U0S 9 UnUb[R"XT5 U$)zWrapper for original gatherrrc) rlrmrnrorpr@rqrrrsrrgatherrkr@rqr6rArF)r6 overwriterCr)rArAxisr)r) r#rrrrLrrr\r^r]r_rNr) rcrkr6r`rhrbrgr?outputs rj_gather_wrapperr1s' |mmAd+   ! $ !'71CXN dH % % $T6GW3Ex P22""3'::5A$))   /#%8     ="E*    c Jrcgr r)rcrkr6r`rhs rjrrnrcgr r)r5rrkrhs rjrrxs rc[U5nU[U5-S:a[SUS[U5S35eSnUS:aU[US[5-nOUSU;-nU(a [ U0UD6$[ U0UD6$)ax This function has two functionalities, depending on the parameters passed: 1. ``gather(Tensor input, int dim, Tensor index, Tensor out = None)``: PyTorch compatible gather, calls a non-broadcast `paddle.take_along_axis`. Check out :ref:`api_paddle_take_along_axis` and also `[torch has more parameters] torch.scatter `_ Note that ``sparse_grad`` param of PyTorch is currently not supported by Paddle, therefore do not pass this param (behavior is equivalent to ``sparse_grad = False``). Also, dim allows for Tensor input, the same as PyTorch. However, when the first 3 params are all of Tensor types, there will be ambiguity between these two functionalities. Currently, original gather pass is more actively selected. Try avoiding using Tensor dim as input therefore. 2. ``gather(Tensor x, Tensor index, int axis, str name = None, Tensor out = None)``: The original paddle.gather, see the following docs. Output is obtained by gathering entries of ``axis`` of ``x`` indexed by ``index`` and concatenate them together. .. code-block:: text Given: x = [[1, 2], [3, 4], [5, 6]] index = [1, 2] axis=[0] Then: out = [[3, 4], [5, 6]] Args: x (Tensor): The source input tensor with rank>=1. Supported data type is int32, int64, float32, float64, complex64, complex128 and uint8 (only for CPU), float16 (only for GPU). index (Tensor): The index input tensor with rank=0 or rank=1. Data type is int32 or int64. axis (Tensor|int|None, optional): The axis of input to be gathered, it's can be int or a Tensor with data type is int32 or int64. The default value is None, if None, the ``axis`` is 0. name (str|None, 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` . Returns: output (Tensor), If the index is a 1-D tensor, the output is a tensor with the same shape as ``x``. If the index is a 0-D tensor, the output will reduce the dimension where the axis pointing. Examples: .. code-block:: python >>> import paddle >>> input = paddle.to_tensor([[1,2],[3,4],[5,6]]) >>> index = paddle.to_tensor([0,1]) >>> output = paddle.gather(input, index, axis=0) >>> print(output) Tensor(shape=[2, 2], dtype=int64, place=Place(cpu), stop_gradient=True, [[1, 2], [3, 4]]) r(Too few arguments in the function call: rz. Expect one of: - (Tensor input, int dim, Tensor index, *, Tensor out = None) - (Tensor x, Tensor index, int axis, str name = None, Tensor out = None)Fr%r)rrYrLrRrr)argskwargslen_argsis_take_along_axiss rjrrsx4yH#f+!6xj3v;-PX X  1}ja#66evo-'888///rc([U[5(d[S[U5S35eU[ UR *UR 5;a'[ SUR *SUR S35e[5(a[R"X5$[U[R5(a[R"U5nURnUS:aUO [U5U-nX#n[S0[!5D6n[#US[$S5 UR'5n[)US/S QS5 [ U5Vs/sH nUR+UR'5S 9PM" nnUR-SS U0S U0S U0S9 U$s snf)a Removes a tensor dimension, then split the input tensor into multiple sub-Tensors. .. note:: Alias Support: The parameter name ``dim`` can be used as an alias for ``axis``. For example, ``unbind(input=tensor_x, dim=0)`` is equivalent to ``unbind(input=tensor_x, axis=0)``. Args: input (Tensor): The input variable which is an N-D Tensor, data type being bool, float16, float32, float64, int32, int64, complex64 or complex128. axis (int, optional): A 0-D Tensor with shape [] and type is ``int32|int64``. The dimension along which to unbind. If :math:`axis < 0`, the dimension to unbind along is :math:`rank(input) + axis`. Default is 0. alias: ``dim``. Returns: list(Tensor), The list of segmented Tensor variables. Examples: .. code-block:: python >>> import paddle >>> # input is a Tensor which shape is [3, 4, 5] >>> input = paddle.rand([3, 4, 5]) >>> [x0, x1, x2] = paddle.unbind(input, axis=0) >>> # x0.shape [4, 5] >>> # x1.shape [4, 5] >>> # x2.shape [4, 5] >>> [x0, x1, x2, x3] = paddle.unbind(input, axis=1) >>> # x0.shape [3, 5] >>> # x1.shape [3, 5] >>> # x2.shape [3, 5] >>> # x3.shape [3, 5] z.The type of 'axis' must be int, but received rzThe axis must in range(rrrunbindr5 rlrmrsrnror@rqrrr>rArCr6rG)r)rLrRrYrHrrrr#rrrPgenericasscalarrSrrr\rrr^rr]r_) r5r6rlaxis_rrgr?rers rjrrsJ dS " " 225'Hx8""$     (3Z     5 5((* 6   <DM4.    s 'Fc UcUnUc [S5eOUb [S5eUcSn[UR5[UR5:wa [S5e[ X5n[ U[ R[ RR45(a[UR5[UR5:wa [S5e[[UR55HnXv:wa URUURU:d"URUURU:dMJ[SUSURSURS US UR3 5e On[ R"U5RUR5nS nURHn X-nM US :Xa [ R"X2R5nURUn X*:R!5(d[S US U 35e[#UR5S;a![S[#UR535e[$R&"XX6US5$)zWrapper for inplace version of put_along_axis This API is not directly available for users. One can only call this API via torch.Tensor.scatter_ or torch.scatter_ a'paddle.Tensor.scatter_' expect one of the following input pattern: - (int dim, Tensor index, Tensor src (alias value), *, str reduce) - (Tensor index, Tensor updates, bool overwrite, str name = None) However, the input pattern does not match, please check.R`value` is useless when `src` is specified. Be careful for conflicting parameters.rz<`index` and `input` must have the same number of dimensions!z:`index` and `src` must have the same number of dimensions!!Size does not match at dimension  expected index  to be smaller than self  apart from dimension z! and to be smaller size than src r%z7one of element of index is out of bounds for dimension with size r@rqzDThe data type of index should be one of ['int32', 'int64'], but got T)rYrrSrnon_negative_axisrLrNr,rTrUr RuntimeErrorrOastyper? broadcast_toallrrput_along_axis_) r5rrksrcreducerr6reelementsr axis_max_sizes rj_put_along_axis_inplace_wrapperr.sy { ;K     `  ~ 5;;3u{{++ J   U (D# vzz'7'7899 u{{ s399~ -L s5;;'(A ekk!nu{{1~=%++C ! C#7s:J5;;-Wpqvq|q|p}~TUYTZZ{||E|E{FG )s#**5;;799C OH q=%%c;;7CKK%M  ! & & ( (EdV;WdVe f  U[[!);;RS`afalalSmRn o    ! !%64 HHrc0[R"XX#5$)z"Wrapper for inplace origin scatter)rscatter_rcrkupdatesrr`s rj_scatter_inplace_wrapperros ??1W 88rcgr rrs rjrrzrrcgr r)r5rrkrrrs rjrrrc[U5nU[U5-S:a[SUS[U5S35eSnUS:a[US[5nOSU;nU(a [ U0UD6$[ U0UD6$)z Inplace version of ``scatter`` API, the output Tensor will be inplaced with input. Please refer to :ref:`api_paddle_tensor_scatter`. rrrz. Expect one of: - (int dim, Tensor index, Tensor src, *, str reduce, Tensor out = None) - (Tensor index, Tensor updates, bool overwrite, str name = None)Fr%r)rrYrLrRrrrrris_put_along_axiss rjrrs 4yH#f+!6xj3v;-PQ Q  1}&tAw4!VO.???'888rc\[5(a[R"XX#5nOk[US/SQS5 [ US[ S5 [ S0[5D6nURUR5nURSXUS.SU0SU0S9 UnUb[R"Xe5 U$) zWrapper for original scatter This API is not directly available for users. One can only call this API via torch.Tensor.scatter or torch.scatter r?)rnrormr@rqrsscatterr)rAIdsUpdatesrCr)r) r#rrrrrlrr\r]r?r_rNr) rcrkrrr`rhrbrgrs rj_scatter_wrapperrsnnQw:  I   9k4;3&(3::177CW= *FO    c Jrc UcUnUc [S5eOUb [S5eUcSn[R"XX1USS9nUb[R"Xu5 U$)zA PyTorch Compatible wrapper for put_along_axis This API is not directly available for users. One can only call this API via torch.Tensor.scatter or torch.scatter a''paddle.scatter' expect one of the following input pattern: - (Tensor input, int dim, Tensor index, Tensor src (alias value), *, str reduce, Tensor out = None) - (Tensor x, Tensor index, Tensor updates, bool overwrite, str name = None) However, the input pattern does not match, please check.rrFr)rYrNput_along_axisr)r5rrkrrrhrrbs rj_put_along_axis_wrapperrs{ { ;K     `  ~   c% PC  c Jrcgr r)rcrkrrr`rhs rjrrrrcgr r)r5rrkrrrhrs rjrrsrc[U5nU[U5-S:a[SUS[U5S35eSnUS:a[US[5nOSU;nU(a [ U0UD6$[ U0UD6$)a This function has two functionalities, depending on the parameters passed: 1. ``scatter(Tensor input, int dim, Tensor index, Tensor src (alias value), *, str reduce = None, Tensor out = None)``: PyTorch compatible scatter, calls a non-broadcast `paddle.put_along_axis`. Check out :ref:`api_paddle_put_along_axis` and also `[torch has more parameters] torch.scatter `_ 2. ``scatter(Tensor x, Tensor index, Tensor updates, bool overwrite, str name = None)``: The original paddle.scatter, see the following docs. **Scatter Layer** Output is obtained by updating the input on selected indices based on updates. As shown in the figure, when ``overwrite`` is set to ``True``, the output for the same index is updated in overwrite mode, where ``x[index[i]]`` is directly replaced with ``update[i]`` sequentially; When ``overwrite`` is set to ``False``, the output for the same index is updated in accumulation mode. In this mode, ``x[index[i]]`` is first initialized with elements set to 0. Then, ``update[i]`` is sequentially added to ``x[index[i]]`` to produce the output. .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/scatter.png :alt: Legend - scatter behavior display .. code-block:: pycon :name: scatter-example-1 >>> import paddle >>> # input: >>> x = paddle.to_tensor([[1, 1], [2, 2], [3, 3]], dtype='float32') >>> index = paddle.to_tensor([2, 1, 0, 1], dtype='int64') >>> # shape of updates should be the same as x >>> # shape of updates with dim > 1 should be the same as input >>> updates = paddle.to_tensor([[1, 1], [2, 2], [3, 3], [4, 4]], dtype='float32') >>> overwrite = False >>> # calculation: >>> if not overwrite: ... for i in range(len(index)): ... x[index[i]] = paddle.zeros([2]) >>> for i in range(len(index)): ... if overwrite: ... x[index[i]] = updates[i] ... else: ... x[index[i]] += updates[i] >>> # output: >>> out = paddle.to_tensor([[3, 3], [6, 6], [1, 1]]) >>> print(out.shape) paddle.Size([3, 2]) **NOTICE**: The order in which updates are applied is nondeterministic, so the output will be nondeterministic if index contains duplicates. Args: x (Tensor): The input N-D Tensor with ndim>=1. Data type can be float32, float64. index (Tensor): The index is a 1-D or 0-D Tensor. Data type can be int32, int64. The length of index cannot exceed updates's length, and the value in index cannot exceed input's length. updates (Tensor): Update input with updates parameter based on index. When the index is a 1-D tensor, the updates shape should be the same as input, and dim value with dim > 1 should be the same as input. When the index is a 0-D tensor, the updates should be a (N-1)-D tensor, the ith dim of the updates should be equal with the (i+1)th dim of the input. overwrite (bool, optional): The mode that updating the output when there are same indices.If True, use the overwrite mode to update the output of the same index,if False, use the accumulate mode to update the output of the same index. Default value is True. name(str|None, 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` . Returns: Tensor, The output is a Tensor with the same shape as x. Examples: .. code-block:: python :name: scatter-example-2 >>> import paddle >>> x = paddle.to_tensor([[1, 1], [2, 2], [3, 3]], dtype='float32') >>> index = paddle.to_tensor([2, 1, 0, 1], dtype='int64') >>> updates = paddle.to_tensor([[1, 1], [2, 2], [3, 3], [4, 4]], dtype='float32') >>> output1 = paddle.scatter(x, index, updates, overwrite=False) >>> print(output1) Tensor(shape=[3, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[3., 3.], [6., 6.], [1., 1.]]) >>> output2 = paddle.scatter(x, index, updates, overwrite=True) >>> # CPU device: >>> # [[3., 3.], >>> # [4., 4.], >>> # [1., 1.]] >>> # GPU device maybe have two results because of the repeated numbers in index >>> # result 1: >>> # [[3., 3.], >>> # [4., 4.], >>> # [1., 1.]] >>> # result 2: >>> # [[3., 3.], >>> # [2., 2.], >>> # [1., 1.]] rrrz. Expect one of: - (Tensor input, int dim, Tensor index, Tensor src, *, str reduce, Tensor out = None) - (Tensor x, Tensor index, Tensor updates, bool overwrite, str name = None)Fr%r)rrYrLrRrrrs rjrrsv4yH#f+!6xj3v;-P[ [  1}&tAw4!VO&777000rcURUR:wa7[S[UR5S[UR535e[5(a#URS:XaUR 5U-$[ 5(a[R"XU5$[S 0[5D6nURSS9nURU5nURSXUS.SU0S 9 U$) aq Output is obtained by applying sparse addition to a single value or slice in a Tensor. :attr:`x` is a Tensor with ndim :math:`R` and :attr:`index` is a Tensor with ndim :math:`K` . Thus, :attr:`index` has shape :math:`[i_0, i_1, ..., i_{K-2}, Q]` where :math:`Q \leq R` . :attr:`updates` is a Tensor with ndim :math:`K - 1 + R - Q` and its shape is :math:`index.shape[:-1] + x.shape[index.shape[-1]:]` . According to the :math:`[i_0, i_1, ..., i_{K-2}]` of :attr:`index` , add the corresponding :attr:`updates` slice to the :attr:`x` slice which is obtained by the last one dimension of :attr:`index` . .. code-block:: text Given: * Case 1: x = [0, 1, 2, 3, 4, 5] index = [[1], [2], [3], [1]] updates = [9, 10, 11, 12] we get: output = [0, 22, 12, 14, 4, 5] * Case 2: x = [[65, 17], [-14, -25]] index = [[], []] updates = [[[-1, -2], [1, 2]], [[3, 4], [-3, -4]]] x.shape = (2, 2) index.shape = (2, 0) updates.shape = (2, 2, 2) we get: output = [[67, 19], [-16, -27]] Args: x (Tensor): The x input. Its dtype should be int32, int64, float32, float64. index (Tensor): The index input with ndim > 1 and index.shape[-1] <= x.ndim. Its dtype should be int32 or int64 as it is used as indexes. updates (Tensor): The updated value of scatter_nd_add op, and it must have the same dtype as x. It must have the shape index.shape[:-1] + x.shape[index.shape[-1]:]. name (str|None, optional): The output tensor name. If set None, the layer will be named automatically. Returns: output (Tensor), The output is a tensor with the same shape and dtype as x. Examples: .. code-block:: pycon >>> import paddle >>> x = paddle.rand(shape=[3, 5, 9, 10], dtype='float32') >>> updates = paddle.rand(shape=[3, 9, 10], dtype='float32') >>> index = paddle.to_tensor([[1, 1], [0, 1], [1, 3]], dtype='int64') >>> output = paddle.scatter_nd_add(x, index, updates) >>> print(output.shape) paddle.Size([3, 5, 9, 10]) z3x and updates must have same data type but x.dtype=z, updates.dtype=rscatter_nd_addrcinput_param_name)rArrrCrHrIrJ)r)r?rYrr"rrr#rrrr\r^r]r_)rcrkrr`rgr?rs rjrrwsJ ww'--A-PQPWPWBXAYYijwxyFyFkGjH I   ::?779w& &$$Qw77::""C"8::5A!w?FO   rcB[[X!R5XU5$)a **Scatter_nd Layer** Output is obtained by scattering the :attr:`updates` in a new tensor according to :attr:`index` . This op is similar to :code:`scatter_nd_add`, except the tensor of :attr:`shape` is zero-initialized. Correspondingly, :code:`scatter_nd(index, updates, shape)` is equal to :code:`scatter_nd_add(paddle.zeros(shape, updates.dtype), index, updates)` . If :attr:`index` has repeated elements, then the corresponding updates are accumulated. Because of the numerical approximation issues, the different order of repeated elements in :attr:`index` may cause different results. The specific calculation method can be seen :code:`scatter_nd_add` . This op is the inverse of the :code:`gather_nd` op. Args: index (Tensor): The index input with ndim >= 1 and index.shape[-1] <= len(shape). Its dtype should be int32 or int64 as it is used as indexes. updates (Tensor): The updated value of scatter_nd op. Its dtype should be float32, float64. It must have the shape index.shape[:-1] + shape[index.shape[-1]:] shape(tuple|list|Tensor): Shape of output tensor. name (str|None, optional): The output Tensor name. If set None, the layer will be named automatically. Returns: output (Tensor), The output is a tensor with the same type as :attr:`updates` . Examples: .. code-block:: python >>> import paddle >>> index = paddle.to_tensor([[1, 1], ... [0, 1], ... [1, 3]], dtype="int64") >>> updates = paddle.rand(shape=[3, 9, 10], dtype='float32') >>> shape = [3, 5, 9, 10] >>> output = paddle.scatter_nd(index, updates, shape) )rr(r?)rkrrSr`s rj scatter_ndrsP %}}5ut LLrc*[US[S5 US::dS[U[5(a]US:aWURUS:waDXRU:a2URUS:wa[ SUSURUS35e[ XX#S9$) am Split the input tensor into multiple sub-Tensors. Here are some examples to explain it. - 1. Given a 3-D tensor x with a shape [3, 3, 3], if we split the first dimension into three equal parts, it will output a list containing three 3-D tensors with a shape of [1, 3, 3]. - 2. Given a 3-D tensor x with a shape [3, 3, 3], if we split the second dimension into three equal parts, it will output a list containing three 3-D tensors with a shape of [3, 1, 3]. - 3. Given a 3-D tensor x with a shape [3, 3, 3], if we split the third dimension into three equal parts, it will output a list containing three 3-D tensors with a shape of [3, 3, 1]. The following figure illustrates the first example. .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/chunk.png :width: 800 :alt: legend of reshape API :align: center .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``, and the parameter name ``dim`` can be used as an alias for ``axis``. For example, ``chunk(input=tensor_x, dim=1)`` is equivalent to ``chunk(x=tensor_x, axis=1)``. Args: x (Tensor): A N-D Tensor. The data type is bool, float16, float32, float64, int32 or int64. alias: ``input``. chunks(int): The number of tensor to be split along the certain axis. axis (int|Tensor, optional): The axis along which to split, it can be a integer or a ``0-D Tensor`` with shape [] and data type ``int32`` or ``int64``. If :math::`axis < 0`, the axis to split along is :math:`rank(x) + axis`. Default is 0. alias: ``dim``. name (str|None, 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` . Returns: list(Tensor), The list of segmented Tensors. Examples: .. code-block:: python >>> import paddle >>> x = paddle.rand([3, 9, 5]) >>> out0, out1, out2 = paddle.chunk(x, chunks=3, axis=1) >>> # out0.shape [3, 3, 5] >>> # out1.shape [3, 3, 5] >>> # out2.shape [3, 3, 5] >>> # axis is negative, the real axis is (rank(x) + axis) which real >>> # value is 1. >>> out0, out1, out2 = paddle.chunk(x, chunks=3, axis=-2) >>> # out0.shape [3, 3, 5] >>> # out1.shape [3, 3, 5] >>> # out2.shape [3, 3, 5] chunkschunkrrzThe value of 'chunks' must be greater than 0 and less than or equal to the size of the dimension specified by 'axis', but received chunks=z and x.shape[axis]=r)rar6r`)rrRrLrSrr`)rcrr6r`s rjrrsrvx#0 {4 AI WWT]a FWWT]$: GGDMR YZ`Yaatuvu|u|}AuBtCCD E    AArdims)rc repeat_timescSn[5(af[U[RR5(a'UR S:XdS5eUR 5n[R"X5$[5(a|U"X5 [U[[45(aC[RRU5(a[RRU5n[R"X5$U"X5 Sn[!S0[#5D6nSU/0n0n[U[$5(aSUlXS'S /US 'Ol[U[[45(aQU"U5US '[RRU5(a"[RR)U5US 'UR+S S 9nUR-U5n UR/SUSU 0US9 U $)aT Construct a new Tensor by repeating ``x`` the number of times given by ``repeat_times``. After tiling, the value of the i'th dimension of the output is equal to ``x.shape[i]*repeat_times[i]``. Both the number of dimensions of ``x`` and the number of elements in ``repeat_times`` should be less than or equal to 6. .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``, and ``dims`` can be used as an alias for ``repeat_times``. For example, ``tile(input=x, dims=repeat_times)`` is equivalent to ``tile(x=x, repeat_times=repeat_times)``. Args: x (Tensor): The input tensor, its data type should be bool, float16, float32, float64, int32, int64, complex64 or complex128. alias: ``input``. repeat_times (list|tuple|Tensor): The number of repeating times. If repeat_times is a list or tuple, all its elements should be integers or 1-D Tensors with the data type int32. If repeat_times is a Tensor, it should be an 1-D Tensor with the data type int32. alias: ``dims``. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: N-D Tensor. The data type is the same as ``x``. The size of the i-th dimension is equal to ``x[i] * repeat_times[i]``. Examples: .. code-block:: python >>> import paddle >>> data = paddle.to_tensor([1, 2, 3], dtype='int32') >>> out = paddle.tile(data, repeat_times=[2, 1]) >>> print(out) Tensor(shape=[2, 3], dtype=int32, place=Place(cpu), stop_gradient=True, [[1, 2, 3], [1, 2, 3]]) >>> out = paddle.tile(data, repeat_times=(2, 2)) >>> print(out) Tensor(shape=[2, 6], dtype=int32, place=Place(cpu), stop_gradient=True, [[1, 2, 3, 1, 2, 3], [1, 2, 3, 1, 2, 3]]) >>> repeat_times = paddle.to_tensor([1, 2], dtype='int32') >>> out = paddle.tile(data, repeat_times=repeat_times) >>> print(out) Tensor(shape=[1, 6], dtype=int32, place=Place(cpu), stop_gradient=True, [[1, 2, 3, 1, 2, 3]]) c[US[[[[R R 4S5 [U[[R R 45(a![UR5S:XdS5eOUHn[U[[R R 45(a2[R"SURS5nUS:XdS5eMd[[R[R4n[X$5(aMS5e [!US/SQS5 [#UR$5S :XaUR&(d [)S 5egg) Nrtiler%z-repeat_times must be a Tensor with ndim == 1.c X-$r r)rcrs rj+tile..check_input..s!%rzEElements in repeat_times must be Tensor with one element or integers.rcrrlzWhen the date type is bool for the input 'x' of tile op, you must set its stop_gradient to be True by some_var.stop_gradient == True supporting some_var is the input.)rrMrrrNrTrUrLrrS functoolsrrRrPr@rqrrr?ryr)rcrelemrU type_tuples rj check_inputtile..check_inputxsA   5(FJJ$4$4 5   lXvzz/?/?$@ A A|))*a/ ? /%dXvzz/?/?$@AA%,,-?QOE A:_:#&rxx!:J%d77_7% !     !V +AOOS 5D +rr%z6Only support ndim == 1 while repeat_times is a Tensor.c/n[U5HKup#[U[5(aURS5 M-URU5 US:aMFS5e U$)Nrrz7All elements in repeat_times must be positive for tile.rVrLrr)list_repeat_timesattrs_repeat_timesrtimess rjget_attr_repeat_times#tile..get_attr_repeat_timessa!# '(9: eX..&--b1&--e4 19Q9 ;& %rr rAT RepeatTimesrrrepeat_times_tensorrcrrCrGr )r"rLr rr,rrrr r$rMrrNrrrrr\rryrr^r]r_) rcrr`rrrgrIrKr?rhs rjr r Dsh-^ lDJJ$5$5 6 6$$) H )(..0L{{1++ A$ lT5M 2 2||((66%||?? M {{1++A$ &0vx0s lH - -)-L &$0= !%'DE. !  tUm 4 4$9,$GE. !||((66LL88F,-""C"877> E   rrepeatsc[XS9$)a Repeat elements of a tensor along specified dimensions. Args: input (Tensor): The input tensor to be repeated. *repeats (int|list|tuple|Tensor): The number of times to repeat along each dimension. Can be a single integer (applies to the first dimension only), or multiple integers (one per dimension). Returns: Tensor: The repeated tensor with expanded dimensions. Note: When using a single integer, it only repeats along the first dimension. The total number of repeat values must match the number of dimensions in the tensor when using multiple values. Examples: .. code-block:: python >>> import paddle >>> # Example 1: 1D tensor - single repeat >>> x = paddle.to_tensor([1, 2, 3]) >>> out = x.repeat(2) >>> print(out) Tensor(shape=[6], dtype=int64, place=Place(cpu), stop_gradient=True, [1, 2, 3, 1, 2, 3]) >>> # Example 2: 2D tensor - single repeat value >>> x = paddle.to_tensor([[1, 2], [3, 4]]) >>> out = x.repeat(2) >>> print(out) Tensor(shape=[2, 4], dtype=int64, place=Place(gpu:0), stop_gradient=True, [[1, 2, 1, 2], [3, 4, 3, 4]]) >>> # Example 3: 2D tensor - multiple repeats >>> x = paddle.to_tensor([[1, 2], [3, 4]]) >>> out = x.repeat([2, 3]) >>> print(out) Tensor(shape=[4, 6], dtype=int64, place=Place(gpu:0), stop_gradient=True, [[1, 2, 1, 2, 1, 2], [3, 4, 3, 4, 3, 4], [1, 2, 1, 2, 1, 2], [3, 4, 3, 4, 3, 4]]) >>> # Example 4: 3D tensor - mixed repeats >>> x = paddle.to_tensor([[[1, 2], [3, 4]]]) >>> out = x.repeat([2, 1, 3]) >>> print(out) Tensor(shape=[2, 2, 6], dtype=int64, place=Place(gpu:0), stop_gradient=True, [[[1, 2, 1, 2, 1, 2], [3, 4, 3, 4, 3, 4]], [[1, 2, 1, 2, 1, 2], [3, 4, 3, 4, 3, 4]]]) )rr)r5rs rjrepeatr sx  ,,rr)rcrSc[XU5$)a Broadcast the input tensor to a given shape. Both the number of dimensions of ``x`` and the number of elements in ``shape`` should be less than or equal to 6. The dimension to broadcast to must have a value 0. The following figure shows the process of broadcasting a one-dimensional tensor of shape [3] to a two-dimensional tensor of shape [2,3] based on the shape specified by 'shape'. .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/broadcast_to.png :width: 500 :alt: broadcast_to API :align: center .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``, and ``size`` can be used as an alias for ``shape``. For example, ``broadcast_to(input=tensor_x, size=[2, 3], ...)`` is equivalent to ``broadcast_to(x=tensor_x, shape=[2, 3], ...)``. Args: x (Tensor): The input tensor, its data type is bool, float16, float32, float64, int32, int64, uint8 or uint16. alias: ``input``. shape (list|tuple|Tensor): The result shape after broadcasting. The data type is int32. If shape is a list or tuple, all its elements should be integers or 0-D or 1-D Tensors with the data type int32. If shape is a Tensor, it should be an 1-D Tensor with the data type int32. The value -1 in shape means keeping the corresponding dimension unchanged. alias: ``size``. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: N-D Tensor, A Tensor with the given shape. The data type is the same as ``x``. Examples: .. code-block:: python >>> import paddle >>> data = paddle.to_tensor([1, 2, 3], dtype='int32') >>> out = paddle.broadcast_to(data, shape=[2, 3]) >>> print(out) Tensor(shape=[2, 3], dtype=int32, place=Place(cpu), stop_gradient=True, [[1, 2, 3], [1, 2, 3]]) expand)rcrSr`s rjrrs\ !D !!rcl[U[[45(a[U5S:XaU$[ 5(a[ R "X5$[5(a[UR5S:XaUR(d [S5e[U[RR5(aSUl Oj[U[[45(aD[RR!U5(a[RR#U5nO [%S5e[ R "X5$[U[&5(a![UR(5S:XdS5eOwUHqn[U[&5(aUR+5S:XdS5eM5[,[.R0[.R24n[X45(aMlS5e [5US /S QS 5 [7US [[[&4S 5 [UR5S:XaUR(d [S5eS U/0n0n[9S0[;5D6nSn[U[&5(a SUl XS'Ol[U[[45(aQU"U5US '[RR!U5(a"[RR=U5US'UR?S S9n URAU 5n URCSUSU 0US9 U $)a Expand the input tensor to a given shape. Both the number of dimensions of ``x`` and the number of elements in ``shape`` should be less than or equal to 6. And the number of dimensions of ``x`` should be less than the number of elements in ``shape``. The dimension to expand must have a value 0. The image illustrates a typical case of the expand operation. The Original Tensor is a 1D tensor with shape ``[3]`` and values [1, 2, 3]. Using the ``paddle.expand`` method with the parameter ``shape = [2, 3]``, it is broadcasted and expanded into a 2D tensor with shape ``[2, 3]`` .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/expand.png :width: 500 :alt: legend of expand API :align: center .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x`` and ``size`` can be used as an alias for ``shape``. ``shape`` can be a variable number of arguments. For example: ``paddle.expand(tensor_x, shape=[3, 4], name=None)`` ``tensor_x.expand([3, 4]) -> paddle.expand(tensor_x, [3, 4])`` ``tensor_x.expand(3, 4) -> paddle.expand(tensor_x, 3, 4)`` ``tensor_x.expand(size=[3, 4]) -> paddle.expand(tensor_x, size=[3, 4])`` Args: x (Tensor): The input Tensor, its data type is bool, float16, float32, float64, int32, int64, uint8, uint16, complex64 or complex128. alias: ``input`` shape (list|tuple|Tensor|variable number of arguments): The result shape after expanding. The data type is int32. If shape is a list or tuple, all its elements should be integers or 0-D or 1-D Tensors with the data type int32. If shape is a Tensor, it should be an 1-D Tensor with the data type int32. The value -1 in shape means keeping the corresponding dimension unchanged. ``shape`` can be a variable number of arguments. alias: ``size``. name (str|None, 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` . Returns: N-D Tensor, A Tensor with the given shape. The data type is the same as ``x``. Examples: .. code-block:: python >>> import paddle >>> data = paddle.to_tensor([1, 2, 3], dtype='int32') >>> out = paddle.expand(data, shape=[2, 3]) >>> print(out) Tensor(shape=[2, 3], dtype=int32, place=Place(cpu), stop_gradient=True, [[1, 2, 3], [1, 2, 3]]) rrlzWhen the data type of input 'x' for expand is bool, you must set its stop_gradient to be False by some_var.stop_gradient = True, supporting some_var as the input.Tz-Shape only supports Value, or list, or tuple.r%zshape must be a 1-D Tensor.z>Elements in shape must be Tensor with one element or integers.rc) rlrmrnror@rqrrrsrrr#rSrAc/n[U5HSup#[U[5(aURS5 M-URU5 US:aMFUS:XaMNS5e U$)Nrrz7All elements in shape of expand must be positive or -1.r)list_expand_shapeattrs_expand_shaperrSs rjget_attr_expand_shape%expand..get_attr_expand_shapesh!# '(9: eX..&--b1&--e4 19 Q3 ;& %rrexpand_shapes_tensorr expand_v2rCrGr")"rLrMrrr"rr#r$rr?ryrrNrTrUrrrrYrrSrUrRrPr@rqrrrr\rr^r]r_) rcrSr`rrrIrKrgr)r?rhs rjr#r#Lsd%$''CJ!O}}Q&&   !V +AOO)  eVZZ-- . ."&E  e} - -||((// 88?KL L}}Q&& eX & &u{{#q( G*G G(dH--::<1,X,#&rxx!:J%d77X7 !    " 5'D%#:HE  !V +AOO) s22 & eX & &"&E #7O e} - -259E'N||((//LL88?-.""C"877>VeS\   rc^U4Sjn[5(Ga[U[[45(a/nUH^n[U[R R 5(a!URUR55 MMURU5 M` UTR:XaTnU$[R"TU5nU$[U[R R 5(a SUl [R"TU5nU$[S[U5S35e[5(Ga"[!TS/SQS5 [#US[[[$R&R(4S5 [U[[45(ae[$R*R-U5(a [$R*R/U5nOU"U5n[R"TU5nU$[U[$R&R(5(a SUl [R"TU5nU$[S [U5S35e[!TS/S QS5 [#US[[[04S5 S T0n0n[U[05(a SUl XS 'Ol[U[[45(aQU"U5US'[$R*R-U5(a"[$R*R3U5US '[5S0[75D6n U R9TR:S9nU R9TR:S9n U R=SUUXjS.S9 U$)aV Changes the shape of ``x`` without changing its data. Note that the output Tensor will share data with origin Tensor and doesn't have a Tensor copy in ``dygraph`` mode. If you want to use the Tensor copy version, please use `Tensor.clone` like ``reshape_clone_x = x.reshape([-1]).clone()``. Some tricks exist when specifying the target shape. - 1. -1 means the value of this dimension is inferred from the total element number of x and remaining dimensions. Thus one and only one dimension can be set -1. - 2. 0 means the actual dimension value is going to be copied from the corresponding dimension of x. The index of 0s in shape can not exceed the dimension of x. Here are some examples to explain it. - 1. Given a 3-D tensor x with a shape [2, 4, 6], and the target shape is [6, 8], the reshape operator will transform x into a 2-D tensor with shape [6, 8] and leaving x's data unchanged. - 2. Given a 3-D tensor x with a shape [2, 4, 6], and the target shape specified is [2, 3, -1, 2], the reshape operator will transform x into a 4-D tensor with shape [2, 3, 4, 2] and leaving x's data unchanged. In this case, one dimension of the target shape is set to -1, the value of this dimension is inferred from the total element number of x and remaining dimensions. - 3. Given a 3-D tensor x with a shape [2, 4, 6], and the target shape is [-1, 0, 3, 2], the reshape operator will transform x into a 4-D tensor with shape [2, 4, 3, 2] and leaving x's data unchanged. In this case, besides -1, 0 means the actual dimension value is going to be copied from the corresponding dimension of x. The following figure illustrates the first example -- a 3D tensor of shape [2, 4, 6] is transformed into a 2D tensor of shape [6, 8], during which the order and values of the elements in the tensor remain unchanged. The elements in the two subdiagrams correspond to each other, clearly demonstrating how the reshape API works. .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/reshape.png :width: 800 :alt: legend of reshape API :align: center Args: x (Tensor): An N-D Tensor. The data type is ``float16``, ``float32``, ``float64``, ``int16``, ``int32``, ``int64``, ``int8``, ``uint8``, ``complex64``, ``complex128``, ``bfloat16`` or ``bool``. shape (list|tuple|Tensor): Define the target shape. At most one dimension of the target shape can be -1. The data type is ``int32`` . If ``shape`` is a list or tuple, each element of it should be integer or Tensor with shape []. If ``shape`` is a Tensor, it should be an 1-D Tensor . name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, A reshaped Tensor with the same data type as ``x``. Examples: .. code-block:: pycon >>> import paddle >>> x = paddle.rand([2, 4, 6], dtype="float32") >>> positive_four = paddle.full([1], 4, "int32") >>> out = paddle.reshape(x, [-1, 0, 3, 2]) >>> print(out.shape) paddle.Size([2, 4, 3, 2]) >>> out = paddle.reshape(x, shape=[positive_four, 12]) >>> print(out.shape) paddle.Size([4, 12]) >>> shape_tensor = paddle.to_tensor([8, 6], dtype=paddle.int32) >>> out = paddle.reshape(x, shape=shape_tensor) >>> print(out.shape) paddle.Size([8, 6]) >>> # out shares data with x in dygraph mode >>> x[0, 0, 0] = 10.0 >>> print(out[0, 0]) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 10.) c>Sn/n[U5Hup4[U[[RR 45(aUR S5 MGUR U5 US:XaUS:Xd SUS35eUnMsUS:Xac[R"TR5(a<U[TR5:d!SUS[TR5S35eMMUS:aMSUS U<S35e U$) NrzMOnly one dimension value of 'shape' in reshape can be -1. But received shape[aO] is also -1. # N = x.shape()[2] # N is an int. (NOT recommend under @to_static) N = paddle.shape(x)[2] # N is a Tensor. (Recommend) z = paddle.reshape([N, -1, 4]) # z.shape is [-1, -1, 4] If your target shape in Reshape represents dynamic shape, please turn it into a Tensor under @to_static. See above example for details.rz`The index of 0 in `shape` must be less than the input tensor X's dimensions. But received shape[z] = 0, X's dimensions = rzqEach dimension value of 'shape' in reshape must not be negative except one unknown dimension. But received shape[z] = ) rVrLrrNrTrUrrrrSr) list_shapere attrs_shapedim_idxrrcs rjget_attr_shapereshape..get_attr_shape#s)  !*:!6 G(Xvzz/?/?$@AA""2&""8,r>&", 55hh ,#*K]yy))&QWW5229:RSVWXW^W^S_R``ac5*$a<..5Yd8,aI<3"7<rTz>shape must be an instance of `list`, `tuple` `Variable`, got '.'rc) rtrmrnrorwrrrpr@rqrlrsrrrrSzHshape must be an instance of `list`, `tuple` `Value(in pir mode)`, got ') rmrnrorpr@rqrlrsrwrrrrrArrreshape2r>rr)r5)r"rLrMrr rr,rrrSrrryrrHr$rrrNrTrUrrrrrrr\r]r?r_) rcrSr`r2rrmrhrIrKrgrs ` rjrrs J!F edE] + +Ic4::#4#455$$SXXZ0$$S)  AGG# nnQ 2 tzz00 1 1"&E ..E*C  e R)     % ( 5'D%1A1A#BIN edE] + +||((//"LL<>> import paddle >>> paddle.seed(2048) >>> x = paddle.randn([2, 2]) >>> print(x) Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[-1.24725831, 0.03843464], [-0.31660911, 0.04793844]]) >>> mask = paddle.to_tensor([[True, True], [False, False]]) >>> value = paddle.to_tensor([1, 2, 3, 4, 5,], dtype="float32") >>> out = paddle.masked_scatter(x, mask, value) >>> print(out) Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[1, 2], [-0.31660911, 0.04793844]]) 9x and value must have the same dtype, but got x dtype is , value dtype is r>rRr%rrr@mask true nums must be <= value size, but got mask true nums is , value size is )r?rNrl zeros_likerRaddrvclipcumsumr"rUrr<rrS logical_notrwhere)rcmaskrr` zeros_like_x mask_prefixs rjmasked_scatterrEsut 77ekk ! CAGG9L]^c^i^i]jk ! :: $$ $$$Qc2L ::fkk$e4l CD++dkkma/Q7K[..0A52%++-/ N{[]OcOcOeNffvw|xCxCxExJxJxLwM N / MMOK ( 0 0 rRr%rr9rr:r;)r?rNrlr<rRr=rvr>r?rUrr<rrSr@rwhere_)rcrBrr`rCrDrhs rjmasked_scatter_rHsW 77ekk ! CAGG9L]^c^i^i]jk ! :: $$ $$$Qc2L ::fkk$e4l CD++dkkma/Q7K r?ekkm + J;WY?K_K_KaJbbrsxs~s~tAtFtFtHsI J + MMOK ( 0 0 >> import paddle >>> # one input >>> x = paddle.to_tensor(123, dtype='int32') >>> out = paddle.atleast_1d(x) >>> print(out) Tensor(shape=[1], dtype=int32, place=Place(cpu), stop_gradient=True, [123]) >>> # more than one inputs >>> x = paddle.to_tensor(123, dtype='int32') >>> y = paddle.to_tensor([1.23], dtype='float32') >>> out = paddle.atleast_1d(x, y) >>> print(out) [Tensor(shape=[1], dtype=int32, place=Place(cpu), stop_gradient=True, [123]), Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=True, [1.23000002])] >>> # more than 1-D input >>> x = paddle.to_tensor(123, dtype='int32') >>> y = paddle.to_tensor([[1.23]], dtype='float32') >>> out = paddle.atleast_1d(x, y) >>> print(out) [Tensor(shape=[1], dtype=int32, place=Place(cpu), stop_gradient=True, [123]), Tensor(shape=[1, 1], dtype=float32, place=Place(cpu), stop_gradient=True, [[1.23000002]])] r%rc3# UHpn[U[R[RRR [RR RR45v Mr g7fr  rLrNr,rz frameworkr libpaddlerTrU.0rs rj atleast_1d..f`  " MMKK))22KK))--33  "A8A:)r%)rrLrMranyrNr,rzrUrrVrTrUrOrrrr`rIrhr5r#results rjrJrJ:sV 6{aJvay4-@@   q   AYF C   %%.. %%))//   %%e,FF ::<1 ^^D)FF 6#& 3x1}1v  rcgr rrMs rjrOrOrNrcgr rrPs rjrOrOrQrc[U5S:Xa=[US[[45(a[ SUS55(aUSn/nUHn[U[ R [ RRR[ RRRR45(d[ R"U5nOUnUR5S:XaURS5nO,UR5S:Xa[ R "USS9nOUnUR#U5 M [U5S:XaUS$U$)a Convert inputs to tensors and return the view with at least 2-dimension. Two or high-dimensional inputs are preserved. The following diagram illustrates the behavior of atleast_2d on different dimensional inputs for the following cases: 1. A 0-dim tensor input. 2. A 0-dim tensor and a 1-dim tensor input. 3. A 0-dim tensor and a 3-dim tensor input. .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/atleast_2d.png :width: 600 :alt: legend of atleast_2d API :align: center In each case, the function returns the tensors (or a list of tensors) in views with at least 2 dimensions. Args: inputs (Tensor|list(Tensor)): One or more tensors. The data type is ``float16``, ``float32``, ``float64``, ``int16``, ``int32``, ``int64``, ``int8``, ``uint8``, ``complex64``, ``complex128``, ``bfloat16`` or ``bool``. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: One Tensor, if there is only one input. List of Tensors, if there are more than one inputs. Examples: .. code-block:: python >>> import paddle >>> # one input >>> x = paddle.to_tensor(123, dtype='int32') >>> out = paddle.atleast_2d(x) >>> print(out) Tensor(shape=[1, 1], dtype=int32, place=Place(cpu), stop_gradient=True, [[123]]) >>> # more than one inputs >>> x = paddle.to_tensor(123, dtype='int32') >>> y = paddle.to_tensor([1.23], dtype='float32') >>> out = paddle.atleast_2d(x, y) >>> print(out) [Tensor(shape=[1, 1], dtype=int32, place=Place(cpu), stop_gradient=True, [[123]]), Tensor(shape=[1, 1], dtype=float32, place=Place(cpu), stop_gradient=True, [[1.23000002]])] >>> # more than 2-D input >>> x = paddle.to_tensor(123, dtype='int32') >>> y = paddle.to_tensor([[[1.23]]], dtype='float32') >>> out = paddle.atleast_2d(x, y) >>> print(out) [Tensor(shape=[1, 1], dtype=int32, place=Place(cpu), stop_gradient=True, [[123]]), Tensor(shape=[1, 1, 1], dtype=float32, place=Place(cpu), stop_gradient=True, [[[1.23000002]]])] r%rc3# UHpn[U[R[RRR [RR RR45v Mr g7fr rTrWs rjrYatleast_2d..r[r\)r%r%r:rrLrMrr]rNr,rzrUrrVrTrUrOrrrrr^s rjrOrOs&n 6{aJvay4-@@   q   AYF C   %%.. %%))//   %%e,FF ::<1 ^^F+F ZZ\Q %%f15FF 6'* 3x1}1v  rcgr rrMs rjrRrRrNrcgr rrPs rjrRrRrQrc[U5S:Xa=[US[[45(a[ SUS55(aUSn/nUGHn[U[ R [ RRR[ RRRR45(d[ R"U5nOUnUR5S:XaURS5nOXUR5S:Xa[ R "USS/S9nO,UR5S:Xa[ R "USS9nOUnUR#U5 GM [U5S:XaUS$U$)a Convert inputs to tensors and return the view with at least 3-dimension. Three or high-dimensional inputs are preserved. Args: inputs (Tensor|list(Tensor)): One or more tensors. The data type is ``float16``, ``float32``, ``float64``, ``int16``, ``int32``, ``int64``, ``int8``, ``uint8``, ``complex64``, ``complex128``, ``bfloat16`` or ``bool``. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: One Tensor, if there is only one input. List of Tensors, if there are more than one inputs. Examples: .. code-block:: python >>> import paddle >>> # one input >>> x = paddle.to_tensor(123, dtype='int32') >>> out = paddle.atleast_3d(x) >>> print(out) Tensor(shape=[1, 1, 1], dtype=int32, place=Place(cpu), stop_gradient=True, [[[123]]]) >>> # more than one inputs >>> x = paddle.to_tensor(123, dtype='int32') >>> y = paddle.to_tensor([1.23], dtype='float32') >>> out = paddle.atleast_3d(x, y) >>> print(out) [Tensor(shape=[1, 1, 1], dtype=int32, place=Place(cpu), stop_gradient=True, [[[123]]]), Tensor(shape=[1, 1, 1], dtype=float32, place=Place(cpu), stop_gradient=True, [[[1.23000002]]])] >>> # more than 3-D input >>> x = paddle.to_tensor(123, dtype='int32') >>> y = paddle.to_tensor([[[[1.23]]]], dtype='float32') >>> out = paddle.atleast_3d(x, y) >>> print(out) [Tensor(shape=[1, 1, 1], dtype=int32, place=Place(cpu), stop_gradient=True, [[[123]]]), Tensor(shape=[1, 1, 1, 1], dtype=float32, place=Place(cpu), stop_gradient=True, [[[[1.23000002]]]])] r%rc3# UHpn[U[R[RRR [RR RR45v Mr g7fr rTrWs rjrYatleast_3d..)r[r\)r%r%r%rr:rer^s rjrRrRsJT 6{aJvay4-@@   q   AYF C   %%.. %%))//   %%e,FF ::<1 ^^I.F ZZ\Q %%fAq6:F ZZ\Q %%f15FF 6+. 3x1}1v  rcV[5(a0[URSSS/S5 [R"X5$[ US/SQS5 [ USSS/S5 [ S 0[5D6nUR5nURU5nURSXS.SU0S 9 U$) a This function is actually a high-dimensional extension of :code:`gather` and supports for simultaneous indexing by multiple axes. :attr:`index` is a K-dimensional integer tensor, which is regarded as a (K-1)-dimensional tensor of :attr:`index` into :attr:`input`, where each element defines a slice of params: .. math:: output[(i_0, ..., i_{K-2})] = input[index[(i_0, ..., i_{K-2})]] Obviously, :code:`index.shape[-1] <= input.rank` . And, the output tensor has shape :code:`index.shape[:-1] + input.shape[index.shape[-1]:]` . .. code-block:: text Given: x = [[[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]], [[12, 13, 14, 15], [16, 17, 18, 19], [20, 21, 22, 23]]] x.shape = (2, 3, 4) * Case 1: index = [[1]] gather_nd(x, index) = [x[1, :, :]] = [[12, 13, 14, 15], [16, 17, 18, 19], [20, 21, 22, 23]] * Case 2: index = [[0,2]] gather_nd(x, index) = [x[0, 2, :]] = [8, 9, 10, 11] * Case 3: index = [[1, 2, 3]] gather_nd(x, index) = [x[1, 2, 3]] = [23] Args: x (Tensor): The input Tensor which it's data type should be bool, float16, float32, float64, int32, int64. index (Tensor): The index input with rank > 1, index.shape[-1] <= input.rank. Its dtype should be int32, int64. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: output (Tensor), A tensor with the shape index.shape[:-1] + input.shape[index.shape[-1]:] Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[[1, 2], [3, 4], [5, 6]], ... [[7, 8], [9, 10], [11, 12]]]) >>> index = paddle.to_tensor([[0, 1]]) >>> output = paddle.gather_nd(x, index) >>> print(output) Tensor(shape=[1, 2], dtype=int64, place=Place(cpu), stop_gradient=True, [[3, 4]]) rkr@rq gather_ndrc)rlrmrsrnrorpr@rqrrCr)rl) r#rr?rrlrrr\r^r]r_)rcrkr`rgr?rs rjrlrlTsVEKK7G*>> import paddle >>> x = paddle.zeros(shape=[3,4,5,6], dtype="float32") >>> # example 1: >>> # attr starts is a list which doesn't contain Tensor. >>> axes = [1, 2, 3] >>> starts = [-3, 0, 2] >>> ends = [3, 2, 4] >>> strides_1 = [1, 1, 1] >>> strides_2 = [1, 1, 2] >>> sliced_1 = paddle.strided_slice(x, axes=axes, starts=starts, ends=ends, strides=strides_1) >>> # sliced_1 is x[:, 1:3:1, 0:2:1, 2:4:1]. >>> # example 2: >>> # attr starts is a list which contain tensor Tensor. >>> minus_3 = paddle.full(shape=[1], fill_value=-3, dtype='int32') >>> sliced_2 = paddle.strided_slice(x, axes=axes, starts=[minus_3, 0, 2], ends=ends, strides=strides_2) >>> # sliced_2 is x[:, 1:3:1, 0:2:1, 2:4:2]. c&[U[RR5(a SUlU$[U[ [ 45(aC[RRU5(a[RRU5nU$)NT) rLrNrTrUryrMrrrrrAs rjr.strided_slice.._convert_to_tensor_list!si%!1!122&*#LED%=11<<,,U33"LL<.check_list_elements_dtypeDs}*h//$$g&# ( 3FA)C/#a&83>H!#x00#IIx'O4rc  >/nUHyn[U[5(aSUlURU5 M2[U[5(deTR S5n[ S/SUSUS9 URU5 M{ U$)NTr@r%r)rLrryrrRr]r )old_listnew_list_tensorrrrgs rjget_new_list_tensor*strided_slice..get_new_list_tensorYs Oc8,,(,C%#**3/%c3////%HH H"WcTx$**84 # "rrr%Trrrrr StridesTensorStridesTensorListrr>rCr)rp)r"rrpr$rr\rrrMrrrrrLryrNrrrVrr]r^r_)rcrrrrr`rrwr|rIrKrerrrhrgs @rjrprpsz##AV7CC  )0&t,)'2##AV7CC99     4$@68dE8%P  "$/!&(3!$/!'95 #"1"'D "23"2Qq"2 3 fh ' '#'F %+> " u . . E(O||((00-@-H)*'/FA!#x00h..r2)+ h..s3 0#)h dH % %!%D #'< tUm , ,E&M||((..+>t+D'('oFA!#x00f ,,R0)+ f ,,S1 .!%f  gx ( ($(G !&-? # $ / /!E) ||((11.A'.J*+'0FA!#x00i(//3)+ i(//4 1$+i *m77$$S)8   CL   }4s O2c ^Sm/SQn[USUT5 [USUT5 [US[[[[ [ RR4T5 U4Sjn/n/n[R"[U5[R5(aFUS:dST-S US 3-5e[URU- UR5n[U5nO[U[ 5(aU"U5nU(a6[R"[US5[R5(aUnOSUSn[!U5S :aUS n[U[ 5(aU"U5n[U[ 5(aU"U5n[ U5[ U5pv[!U5[!U5pX:aUR#XxS 5 OX:aUR#XiS 5 [ UR$5[ UR$5p[R&"UR[(S 9n [R&"UR[(S 9n S n[[!U55HnXoXnnU UU UnnUS :Xa/S U U'UR+UUR,S 9R/U 5nOUUS :Xa/S U U'UR+UUR,S 9R/U 5nO UU:XdST-SUSUSUSUS 3 -5eSU U'SU U'XU-nM /n/n/nS nS n[UR5H9nX(aMUR1U5 UR1X5 UX-nM; UR#U5 UR#U5 [UR5H9nX(aMUR1U5 UR1X5 UX-nM; UR3US9R/UU/5nUR3US9R/UU/5nUR5U5R/U5nU$)a This function computes a contraction, which sum the product of elements from two tensors along the given axes. Args: x (Tensor): The left tensor for contraction with data type ``float16`` or ``float32`` or ``float64``. y (Tensor): The right tensor for contraction with the same data type as ``x``. axes (int|tuple|list|Tensor, optional): The axes to contract for ``x`` and ``y``, defaulted to integer ``2``. 1. It could be a non-negative integer ``n``, in which the function will sum over the last ``n`` axes of ``x`` and the first ``n`` axes of ``y`` in order. 2. It could be a 1-d tuple or list with data type ``int``, in which ``x`` and ``y`` will be contracted along the same given axes. For example, ``axes`` =[0, 1] applies contraction along the first two axes for ``x`` and the first two axes for ``y``. 3. It could be a tuple or list containing one or two 1-d tuple|list|Tensor with data type ``int``. When containing one tuple|list|Tensor, the data in tuple|list|Tensor specified the same axes for ``x`` and ``y`` to contract. When containing two tuple|list|Tensor, the first will be applied to ``x`` and the second to ``y``. When containing more than two tuple|list|Tensor, only the first two axis sequences will be used while the others will be ignored. 4. It could be a tensor, in which the ``axes`` tensor will be translated to a python list and applied the same rules described above to determine the contraction axes. Note that the ``axes`` with Tensor type is ONLY available in Dygraph mode. name(str|None, 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` . Return: Output (Tensor), The contraction result with the same data type as ``x`` and ``y``. In general, :math:`output.ndim = x.ndim + y.ndim - 2 \times n_{axes}`, where :math:`n_{axes}` denotes the number of axes to be contracted. NOTES: 1. This function supports tensor broadcast, the size in the corresponding dimensions of ``x`` and ``y`` should be equal, or applies to the broadcast rules. 2. This function also supports axes expansion, when the two given axis sequences for ``x`` and ``y`` are of different lengths, the shorter sequence will expand the same axes as the longer one at the end. For example, if ``axes`` =[[0, 1, 2, 3], [1, 0]], the axis sequence for ``x`` is [0, 1, 2, 3], while the corresponding axis sequences for ``y`` will be expanded from [1, 0] to [1, 0, 2, 3]. Examples: .. code-block:: python >>> import paddle >>> from typing import Literal >>> data_type: Literal["float64"] = 'float64' >>> # For two 2-d tensor x and y, the case axes=0 is equivalent to outer product. >>> # Note that tensordot supports empty axis sequence, so all the axes=0, axes=[], axes=[[]], and axes=[[],[]] are equivalent cases. >>> x = paddle.arange(4, dtype=data_type).reshape([2, 2]) >>> y = paddle.arange(4, dtype=data_type).reshape([2, 2]) >>> z = paddle.tensordot(x, y, axes=0) >>> print(z) Tensor(shape=[2, 2, 2, 2], dtype=float64, place=Place(cpu), stop_gradient=True, [[[[0., 0.], [0., 0.]], [[0., 1.], [2., 3.]]], [[[0., 2.], [4., 6.]], [[0., 3.], [6., 9.]]]]) >>> # For two 1-d tensor x and y, the case axes=1 is equivalent to inner product. >>> x = paddle.arange(10, dtype=data_type) >>> y = paddle.arange(10, dtype=data_type) >>> z1 = paddle.tensordot(x, y, axes=1) >>> z2 = paddle.dot(x, y) >>> print(z1) Tensor(shape=[], dtype=float64, place=Place(cpu), stop_gradient=True, 285.) >>> print(z2) Tensor(shape=[], dtype=float64, place=Place(cpu), stop_gradient=True, 285.) >>> # For two 2-d tensor x and y, the case axes=1 is equivalent to matrix multiplication. >>> x = paddle.arange(6, dtype=data_type).reshape([2, 3]) >>> y = paddle.arange(12, dtype=data_type).reshape([3, 4]) >>> z1 = paddle.tensordot(x, y, axes=1) >>> z2 = paddle.matmul(x, y) >>> print(z1) Tensor(shape=[2, 4], dtype=float64, place=Place(cpu), stop_gradient=True, [[20., 23., 26., 29.], [56., 68., 80., 92.]]) >>> print(z2) Tensor(shape=[2, 4], dtype=float64, place=Place(cpu), stop_gradient=True, [[20., 23., 26., 29.], [56., 68., 80., 92.]]) >>> # When axes is a 1-d int list, x and y will be contracted along the same given axes. >>> # Note that axes=[1, 2] is equivalent to axes=[[1, 2]], axes=[[1, 2], []], axes=[[1, 2], [1]], and axes=[[1, 2], [1, 2]]. >>> x = paddle.arange(24, dtype=data_type).reshape([2, 3, 4]) >>> y = paddle.arange(36, dtype=data_type).reshape([3, 3, 4]) >>> z = paddle.tensordot(x, y, axes=[1, 2]) >>> print(z) Tensor(shape=[2, 3], dtype=float64, place=Place(cpu), stop_gradient=True, [[506. , 1298., 2090.], [1298., 3818., 6338.]]) >>> # When axes is a list containing two 1-d int list, the first will be applied to x and the second to y. >>> x = paddle.arange(60, dtype=data_type).reshape([3, 4, 5]) >>> y = paddle.arange(24, dtype=data_type).reshape([4, 3, 2]) >>> z = paddle.tensordot(x, y, axes=([1, 0], [0, 1])) >>> print(z) Tensor(shape=[5, 2], dtype=float64, place=Place(cpu), stop_gradient=True, [[4400., 4730.], [4532., 4874.], [4664., 5018.], [4796., 5162.], [4928., 5306.]]) >>> # Thanks to the support of axes expansion, axes=[[0, 1, 3, 4], [1, 0, 3, 4]] can be abbreviated as axes= [[0, 1, 3, 4], [1, 0]]. >>> x = paddle.arange(720, dtype=data_type).reshape([2, 3, 4, 5, 6]) >>> y = paddle.arange(720, dtype=data_type).reshape([3, 2, 4, 5, 6]) >>> z = paddle.tensordot(x, y, axes=[[0, 1, 3, 4], [1, 0]]) >>> print(z) Tensor(shape=[4, 4], dtype=float64, place=Place(cpu), stop_gradient=True, [[23217330., 24915630., 26613930., 28312230.], [24915630., 26775930., 28636230., 30496530.], [26613930., 28636230., 30658530., 32680830.], [28312230., 30496530., 32680830., 34865130.]]) tensordot)rmrnrorcrrcZ>[5(a [U5$[ST-S-5e)Nz!The 'axes' with type 'Tensor' in zm is not available in static graph mode, please convert its type to int|Tuple|List, or use dynamic graph mode.)r"rrY)rurs rj _var_to_listtensordot.._var_to_list7s:   #;  / T T  rrzThe 'axes' in z+ should not be negative, but received axes=rr%Nr>z(The dimensional size for 'x' and 'y' in z+ should match each other, but 'x' has size z in dim z while 'y' has size T)r)rrrRrrMrrNrTrUrP issubdtyperHintegerrrrLrextendrSr(rlsumr?rrrmatmul)rcrrr`r^raxes_xaxes_y len_axes_x len_axes_yshape_xshape_yneed_contracted_dim_xneed_contracted_dim_ycontraction_sizeredim_xdim_ysxsyperm_xperm_y shape_outnot_contraction_size_xnot_contraction_size_yrhrs @rjrrsBG3KQ[':Q[': fsE46::3C3CDg F F }}T$Z,,qy  ;D6C D y qvv}aff-t dH % %%Dr}}T$q']BJJ??F!WF4y1}a&(++%f-&(++%f-&\4>> import paddle >>> x = paddle.arange(12, dtype=paddle.float32).reshape([2, 3, 2]) >>> y = paddle.as_complex(x) >>> print(y) Tensor(shape=[2, 3], dtype=complex64, place=Place(cpu), stop_gradient=True, [[(0.00000000+1.00000000j) , (2.00000000+3.00000000j) , (4.00000000+5.00000000j) ], [(6.00000000+7.00000000j) , (8.00000000+9.00000000j) , (10.00000000+11.00000000j)]]) rcrnro as_complexrAr>rCr) r#rrrrr\r]r'r?r_)rcr`rrgrIrhrJrKs rjrrsF  ## C)Y)?NW11q77(18 #,u   rc[5(a[R"U5$[USSS/S5 Sn[ U40[ 5D6nSU0nUR [UR5S9nSU0nURX$US9 U$) aTransform a complex tensor to a real tensor. The data type of the input tensor is 'complex64' or 'complex128', and the data type of the returned tensor is 'float32' or 'float64', respectively. When the shape of the input tensor is ``(*, )``, (``*`` means arbitrary shape), the shape of the output tensor is ``(*, 2)``, i.e. the shape of the output is the shape of the input appended by an extra ``2``. Args: x (Tensor): The input tensor. Data type is 'complex64' or 'complex128'. 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 output. Data type is 'float32' or 'float64', with the same precision as the input. Examples: .. code-block:: python >>> import paddle >>> x = paddle.arange(12, dtype=paddle.float32).reshape([2, 3, 2]) >>> y = paddle.as_complex(x) >>> z = paddle.as_real(y) >>> print(z) Tensor(shape=[2, 3, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[[0. , 1. ], [2. , 3. ], [4. , 5. ]], [[6. , 7. ], [8. , 9. ], [10., 11.]]]) rcrras_realrAr>rCr) r#rrrrr\r]r&r?r_)rcr`rrgrIrhrJs rjrrsB~~a   C+|)DiPW11q77(18 #,ggF rc[US9$)aReturn a complex tensor that is a view of the input real tensor . The data type of the input tensor is 'float32' or 'float64', and the data type of the returned tensor is 'complex64' or 'complex128', respectively. The shape of the input tensor is ``(* ,2)``, (``*`` means arbitrary shape), i.e. the size of the last axis should be 2, which represent the real and imag part of a complex number. The shape of the returned tensor is ``(*,)``. The complex tensor is a view of the input real tensor, meaning that it shares the same memory with real tensor. The image below demonstrates the case that a real 3D-tensor with shape [2, 3, 2] is transformed into a complex 2D-tensor with shape [2, 3]. .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/as_complex.png :width: 500 :alt: Illustration of as_complex :align: center Args: input (Tensor): The input tensor. Data type is 'float32' or 'float64'. Returns: Tensor, The output. Data type is 'complex64' or 'complex128', sharing the same memory with input. Examples: .. code-block:: python >>> import paddle >>> x = paddle.arange(12, dtype=paddle.float32).reshape([2, 3, 2]) >>> y = paddle.as_complex(x) >>> print(y) Tensor(shape=[2, 3], dtype=complex64, place=Place(cpu), stop_gradient=True, [[1j , (2+3j) , (4+5j) ], [(6+7j) , (8+9j) , (10+11j)]]) r)rrAs rjview_as_complexrsJ  rc[US9$)aReturn a real tensor that is a view of the input complex tensor. The data type of the input tensor is 'complex64' or 'complex128', and the data type of the returned tensor is 'float32' or 'float64', respectively. When the shape of the input tensor is ``(*, )``, (``*`` means arbitrary shape), the shape of the output tensor is ``(*, 2)``, i.e. the shape of the output is the shape of the input appended by an extra ``2``. The real tensor is a view of the input complex tensor, meaning that it shares the same memory with complex tensor. Args: input (Tensor): The input tensor. Data type is 'complex64' or 'complex128'. Returns: Tensor, The output. Data type is 'float32' or 'float64', sharing the same memory with input. Examples: .. code-block:: python >>> import paddle >>> x = paddle.arange(12, dtype=paddle.float32).reshape([2, 3, 2]) >>> y = paddle.as_complex(x) >>> z = paddle.as_real(y) >>> print(z) Tensor(shape=[2, 3, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[[0. , 1. ], [2. , 3. ], [4. , 5. ]], [[6. , 7. ], [8. , 9. ], [10., 11.]]]) r)rrAs rj view_as_realr#sD U r) output_sizec  [U[[RR45(a)UR (d[R "US/5nUc(URS:wa[R"U5nSn[5(ao[U[[RR45(a [R"XX$bU5$S5$[R"XX$bU5$S5$[S 0[5D6n[US/SQS5 UR!UR"5nUR%SU[U[5(aUOSS .S U0U[U[&5(aUOSUbUOSS .S 9 U$)a Returns a new tensor which repeats the ``x`` tensor along dimension ``axis`` using the entries in ``repeats`` which is a int or a Tensor. The image illustrates a typical case of the repeat_interleave operation. Given a tensor ``[[1, 2, 3], [4, 5, 6]]``, with the repeat counts ``repeats = [3, 2, 1]`` and parameter ``axis = 1``, it means that the elements in the 1st column are repeated 3 times, the 2nd column is repeated 2 times, and the 3rd column is repeated 1 time. The final output is a 2D tensor: ``[[1, 1, 1, 2, 2, 3], [4, 4, 4, 5, 5, 6]]``. .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/repeat_interleave.png :width: 500 :alt: legend of repeat_interleave API :align: center .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``, and ``dim`` can be used as an alias for ``axis``. For example, ``repeat_interleave(input=tensor_x, dim=1, ...)`` is equivalent to ``repeat_interleave(x=tensor_x, axis=1, ...)``. Args: x (Tensor): The input Tensor to be operated. The data of ``x`` can be one of float32, float64, int32, int64. alias: ``input``. repeats (Tensor|int): The number of repetitions for each element. repeats is broadcasted to fit the shape of the given axis. axis (int|None, optional): The dimension in which we manipulate. Default: None, the output tensor is flatten. alias: ``dim``. name(str|None, 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`. output_size (int, optional): Total output size for the given axis (e.g. sum of repeats). If given, it will avoid stream synchronization needed to calculate output shape of the tensor. Returns: Tensor, A Tensor with same data type as ``x``. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1, 2, 3], [4, 5, 6]]) >>> repeats = paddle.to_tensor([3, 2, 1], dtype='int32') >>> out = paddle.repeat_interleave(x, repeats, 1) >>> print(out) Tensor(shape=[2, 6], dtype=int64, place=Place(cpu), stop_gradient=True, [[1, 1, 1, 2, 2, 3], [4, 4, 4, 5, 5, 6]]) >>> out = paddle.repeat_interleave(x, 2, 0) >>> print(out) Tensor(shape=[4, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[1, 2, 3], [1, 2, 3], [4, 5, 6], [4, 5, 6]]) >>> out = paddle.repeat_interleave(x, 2, None) >>> print(out) Tensor(shape=[12], dtype=int64, place=Place(cpu), stop_gradient=True, [1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6]) r%Nrrrepeat_interleavercrz,paddle.tensor.manipulation.repeat_interleave)rA RepeatsTensorrC)rRepeatsrrG)r)rLrrNrTrUrSrrr<r#r#repeat_interleave_with_tensor_indexrrr\rr]r?r_rR)rcrr6r`rrgrhs rjrrHstJ'Hfjj&6&6788..1#. | 66Q;q!A g&***:*:; < <==D1H+ NP '' -Dk  JL   9 9F  06   3 3AGG >> import paddle >>> x = paddle.ones([3, 2, 4]) >>> outshape = paddle.moveaxis(x, [0, 1], [1, 2]).shape >>> print(outshape) paddle.Size([4, 3, 2]) >>> x = paddle.ones([2, 3]) >>> outshape = paddle.moveaxis(x, 0, 1).shape # equivalent to paddle.t(x) >>> print(outshape) paddle.Size([3, 2]) z5'source' must have the same number with 'destination'z(Each element of 'source' must be unique!z-Each element of 'destination' must be unique!rz)Each element of 'source' must be integer.z#'source' must be in the range of [-rrr%rc)rlrmrnror@rqrrmoveaxisrrArr6rG)r)rLrRrrMrsetrrSrrVzipremover#rrrrr\r]r?r_)rcsource destinationr`rdstrrsrc_dimsdst_dimsrer6rhrgrs rjrrs(H!--6(6C%k377;-[C&%  6l+u%%; s8s3x ?  3x3s3x= CDD 3x3s3x= HII qww 5dV2dV1E >$q'3'' 7 ' 7Q;7te# 5dV2dV1E # FdNF7T> 5dV2dV1E >vV 9,<3x= !$Ka["q'     468477@;;AGGD!: EgY74.   rc[R"U5(a![R"/X R5nURS:wa[R "US5n[ 5(a[R"XU5nU$[US/SQS5 [USS/S5 [S 0[5D6nURURS9nURSUUUS.SU0S 9 U$) a Fills elements of self tensor with value where mask is True. The shape of mask must be broadcastable with the shape of the underlying tensor. The following figure shows an example: consider a 3x3 matrix `x`,where all elements have a value of 1, and a matrix `mask` of the same size, and `value` is 3. .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/masked_fill.png :width: 700 :align: center Args: x (Tensor) : The Destination Tensor. Supported data types are float, double, int, int64_t,float16 and bfloat16. mask (Tensor): The boolean tensor indicate the position to be filled. The data type of mask must be bool. value (Scalar or 0-D Tensor): The value used to fill the target tensor. Supported data types are float, double, int, int64_t,float16 and bfloat16. name(str|None, 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`. Returns: Tensor, same dimension and dtype with x. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> x = paddle.ones((3, 3), dtype="float32") >>> mask = paddle.to_tensor([[True, True, False]]) >>> print(mask) Tensor(shape=[1, 3], dtype=bool, place=Place(gpu:0), stop_gradient=True, [[True , True , False]]) >>> out = paddle.masked_fill(x, mask, 2) >>> print(out) Tensor(shape=[3, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True, [[2., 2., 1.], [2., 2., 1.], [2., 2., 1.]]) rlrc) rlrmrrnrorpr@rqrwrrr masked_fillrBr>)rcrBrrhr)r)rPisscalarrNfullr?rvr#rrrrr\r]r_)rcrBrr`rhrgs rjrr1sV {{5 Bww/ zzV{{4(  %0    # & !   H   7fh777agg7F CL   rc[R"U5(a![R"/X R5nURS:wa[R "US5n[ R"XU5nU$)z Inplace version of ``masked_fill`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_masked_fill`. rl)rPrrNrr?rvr masked_fill_)rcrBrr`s rjrrsZ {{5 Bww/ zzV{{4(AU+A Hrcgr rarrr6s rjrrs69rcgr rrs rjrrsD qy{P@baPP{ K u} 0ba @ }  KrcUS:Xa USSUSS/nO%X1S- :Xa USUUUS/nOUSUX#US-XS-S/n[R"U5$)aJ Find the broadcast shape for indices when `arr` has a dynamic shape. Args: arr_shape (Tensor): Shape tensor of arr. arr_shape_dim (int): Dimensions of arr. indices_shape (Tensor): Shape tensor of indices. axis (int): The axis to put 1d slices along. Returns: Tensor: The shape tensor for later broadcasting rNr%)rNr8) arr_shape arr_shape_dim indices_shaper6 new_shapess rjinfer_dynamic_broadcast_shapers qy   abM  " " et     et   * Qhj ! == $$rc[UR5n[UR5UX2'[U5n[[ UR55H%nURUURU:dM% g U$r )rMrSrrr)rrqr6broadcast_shape_listbroadcast_shaperes rjinfer_broadcast_shaperso  ?!%gmm!4T!:01O 3syy> " 99Q<'--* *# rc [XX1SSSS9$)aq Scatter the values of the source tensor to the target tensor according to the given indices, and perform a add operation along the designated axis. Args: input (Tensor) : The Input Tensor. Supported data types are bfloat16, float16, float32, float64, int32, int64, uint8. dim (int) : The axis to scatter 1d slices along. index (Tensor) : Indices to scatter along each 1d slice of input. This must match the dimension of input, Supported data type are int32 and int64. src (Tensor) : The value element(s) to scatter. The data types should be same as input. Returns: Tensor, The indexed element, same dtype with input Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[10, 20, 30], [40, 50, 60]]) >>> indices = paddle.zeros((2,3)).astype("int32") >>> values = paddle.to_tensor([[1, 2, 3],[4, 5, 6]]).astype(x.dtype) >>> result = paddle.scatter_add(x, 0, indices, values) >>> print(result) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[15, 27, 39], [40, 50, 60]]) r=TF include_selfrrr5rrkrs rj scatter_addrsH  cDE rrc [UR5[UR5:wa [S5e[X5nU(Ga[ UR5n[ [UR55HWnURUS:XdURUS:XaSXV'M/[ URUURU5XV'MY [ UR5UXR'[U5n[R"X5n[ U5n[ UR5UXR'[U5n[R"X5nO[ [UR55HjnXb:wdM URUS:wdMURUURU:dMA[SUSURSURSU35e [5(a[R"XX$S9$[US /S QS 5 [US S S/S 5 [S0[!5D6nUR#5n UR%U 5n UR'S XS.SU0SU 0S9 U $)a{ Take values from the input array by given indices matrix along the designated axis. .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``arr``, and ``dim`` can be used as an alias for ``axis``. For example, ``repeat_interleave(input=tensor_arr, dim=1, ...)`` is equivalent to ``repeat_interleave(arr=tensor_arr, axis=1, ...)``. Args: arr (Tensor) : The input Tensor. Supported data types are bfloat16, float16, float32, float64, int32, int64, uint8. alias: ``input``. indices (Tensor) : Indices to take along each 1d slice of arr. This must match the dimension of arr, and need to broadcast against arr. Supported data type are int32 and int64. axis (int) : The axis to take 1d slices along. alias: ``dim``. broadcast (bool, optional): whether the indices broadcast. out (Tensor, optional): The output Tensor. If set, the output will be written to this Tensor. Returns: Tensor, The indexed element, same dtype with arr. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1, 2, 3], [4, 5, 6], [7,8,9]]) >>> index = paddle.to_tensor([[0]]) >>> axis = 0 >>> result = paddle.take_along_axis(x, index, axis) >>> print(result) Tensor(shape=[1, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[1, 2, 3]]) <`indices` and `arr` must have the same number of dimensions!rrrrrrrrcrmrnror@rqrrrsrrkr@rq)rrrResultr)r)rrSrrrMrrrrNrrr#rrrrr\r^r]r_) rrqr6rrhrrerrgr?r_s rjrrsZV 399~W]]++ J   S 'D#CIIs399~&A}}Q1$ ! (9*+$'*-ciilGMM!" 45%%g?#O4%)#))_T%:" 45!!#7s399~&A IIaLB&IIaL7==#33"7s:J7==/Yrsvs|s|r}~TUYTZ[ '%%cDBB      ! Ww02C ;&(;""$::5A" 34.v&   r)rc :US:XaSnUS:XaSn[XX1XESS9$)aC Scatter the values of the source tensor to the target tensor according to the given indices, and perform a reduction operation along the designated axis. Args: input (Tensor) : The Input Tensor. Supported data types are bfloat16, float16, float32, float64, int32, int64, uint8. dim (int) : The axis to scatter 1d slices along. index (Tensor) : Indices to scatter along each 1d slice of input. This must match the dimension of input, Supported data type are int32 and int64. src (Tensor) : The value element(s) to scatter. The data types should be same as input. reduce (str): The reduce operation, support 'sum', 'prod', 'mean', 'amin', 'amax'. include_self (bool, optional): whether to reduce with the elements of input, default is 'True'. Returns: Tensor, The indexed element, same dtype with input Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[10, 20, 30], [40, 50, 60]]) >>> indices = paddle.zeros((2,3)).astype("int32") >>> values = paddle.to_tensor([[1, 2, 3],[4, 5, 6]]).astype(x.dtype) >>> result = paddle.scatter_reduce(x, 0, indices, values, "sum", include_self=True) >>> print(result) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[15, 27, 39], [40, 50, 60]]) >>> result = paddle.scatter_reduce(x, 0, indices, values, "prod", include_self=True) >>> print(result) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[40 , 200, 540], [40 , 50 , 60 ]]) >>> result = paddle.scatter_reduce(x, 0, indices, values, "mean", include_self=True) >>> print(result) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[5 , 9 , 13], [40, 50, 60]]) rr=rmultiplyFrr)r5rrkrrrs rjscatter_reducer{s4j   c rc L Sn[UR5[UR5:wa [S5e[X5nU(GaU"UR5(dU"UR5(a[R"U5n[R"U5n [ XR X5n [U[R[RR[45(d[R"U5OUn[R"X5n[R"X*5nGO[XU5n [U[R[RR[45(d[R"U5OUnU (a.[R"X5n[R"X*5nGO[R"X!R5nGO[U[R[RR45(a[UR5[UR5:wa [S5e[[UR55Hn X:wa URU URU :d"URU URU :dMJ[!SU SURSURSUSUR3 5e On[R"U5R#UR$5nS n URHn X-n M U S :Xa [R"X!R5nURUn['5(a(X:R)5(d[!S US U35e[+5(aR[-UR$5S ;a![/S [-UR$535e[0R2"XX#XE5$[5US/SQS5 [5USSS/S5 [7US[8S5 [;S0[=5D6nUR?5nURAU5nURCSXUS.UUUS.SU0S9 U$)a Put values into the destination array by given indices matrix along the designated axis. Args: arr (Tensor) : The Destination Tensor. Supported data types are bfloat16, float16, float32, float64, int32, int64, uint8. indices (Tensor) : Indices to put along each 1d slice of arr. This must match the dimension of arr, and need to broadcast against arr if broadcast is 'True'. Supported data type are int32 and int64. values (scalar|Tensor) : The value element(s) to put. The data types should be same as arr. axis (int) : The axis to put 1d slices along. reduce (str, optional): The reduce operation, default is 'assign', support 'add', 'assign', 'mul', 'multiply', 'mean', 'amin' and 'amax'. include_self (bool, optional): whether to reduce with the elements of arr, default is 'True'. broadcast (bool, optional): whether to broadcast indices, default is 'True'. Returns: Tensor, The indexed element, same dtype with arr Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[10, 30, 20], [60, 40, 50]]) >>> index = paddle.to_tensor([[0]]) >>> value = 99 >>> axis = 0 >>> result = paddle.put_along_axis(x, index, value, axis) >>> print(result) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[99, 99, 99], [60, 40, 50]]) >>> index = paddle.zeros((2,2)).astype("int32") >>> value=paddle.to_tensor([[1,2],[3,4]]).astype(x.dtype) >>> result = paddle.put_along_axis(x, index, value, 0, "add", True, False) >>> print(result) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[14, 36, 20], [60, 40, 50]]) >>> result = paddle.put_along_axis(x, index, value, 0, "mul", True, False) >>> print(result) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[30 , 240, 20 ], [60 , 40 , 50 ]]) >>> result = paddle.put_along_axis(x, index, value, 0, "mean", True, False) >>> print(result) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[4 , 12, 20], [60, 40, 50]]) >>> result = paddle.put_along_axis(x, index, value, 0, "amin", True, False) >>> print(result) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[1 , 2 , 20], [60, 40, 50]]) >>> result = paddle.put_along_axis(x, index, value, 0, "amax", True, False) >>> print(result) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[10, 30, 20], [60, 40, 50]]) >>> result = paddle.put_along_axis(x, index, value, 0, "add", False, False) >>> print(result) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[4 , 6 , 20], [60, 40, 50]]) c&[SU55$)Nc3*# UH oS:v M g7frNr)rXrSs rjrY.has_dynamic_shape.. s1&19&s)r])shapess rjhas_dynamic_shape)put_along_axis..has_dynamic_shape s1&111rr?`indices` and `values` must have the same number of dimensions!rrrr$ and to be smaller size than values r%9one of element of indices is out of bounds for dimension rrzFThe data type of indices should be one of ['int32', 'int64'], but got rcrrrkr@rqr)rrrU)rReduce Include_selfrrr)"rrSrrrNrrrLr,rTrUrrOrrrrrr?r"rr#rrYrrrrrlrr\r^r]r_)rrqvaluesr6rrrrrrrrerrrrgr?r_s rjrrs6f2 399~W]]++ J   S 'D SYY ' '+.>? @ @7==!S%66 U3syy>*I#))A,q1A"A]]1% Q7&;A3>Nw}}o]vwzxAxAwBBXY]X^^BCICOCOBPQ +%%f-44SYY?FH||$1},,V]]C $   g&=%B%B%D%DKD6Q\]j\kl   '/A AXYfgngtgtYuXvw $$ &   !      ! Ww02B  <7GH::""$::5A! VD , v&   rc 8[UR5[UR5:wa [S5e[X5nU(a[ XU5n[ U[ R5(d[ R"U5OUnU(a[ R"X5n[ R"X!R5nGO[ U[ R[ RR45(a[UR5[UR5:wa [S5e[[UR55HnX:wa URUURU:d"URUURU:dMJ[SUSURSURSUSUR3 5e On[ R"U5RUR5nSn URHn X-n M U S:Xa [ R"X!R5nURUn X:R!5(d[S US U 35e["R$"XX#XE5$) z Inplace version of ``put_along_axis`` API, the output Tensor will be inplaced with input ``arr``. Please refer to :ref:`api_paddle_put_along_axis`. rrrrrrrr%rr)rrSrrrrLrNr,rOrrTrUrrrr?rrr) rrqrr6rrrrrerrrs rjrrvs^  399~W]]++ J   S 'D/dCffmm44   V $  ))'CG$$V]]; fv}}fjj.>.>? @ @7==!S%66 U3syy>*I#))A,q1A"A]]1% Q7&;A3>Nw}}o]vwzxAxAwBBXY]X^^BCICOCOBPQ +%%f-44SYY?FH||$1},,V]]C $ ',,..KD6Q\]j\kl   ! ! fF rc [XX1SSSS9$)z Inplace version of ``scatter_add`` API, the output Tensor will be inplaced with input ``input``. Please refer to :ref:`api_paddle_scatter_add`. r=TFr)rrs rj scatter_add_rs  cDE rcX[5(a"US:waX4-OUn[R"XXrUS9$[S0[ 5D6n[ US/SQS5 [ USSS /S5 [ US /SQS5 UR UR5nURSUUUS .S U0S U0S9 U$)a Adds the elements of the input tensor with value tensor by selecting the indices in the order given in index. Args: x (Tensor) : The Destination Tensor. Supported data types are int32, int64, float16, float32, float64. alias: ``input``. index (Tensor): The 1-D Tensor containing the indices to index. The data type of ``index`` must be int32 or int64. axis (int): The dimension in which we index. alias: ``dim``. value (Tensor): The tensor used to add the elements along the target axis. alias: ``source``. alpha (Number, optional): Scaling factor for value. Default: 1. out (Tensor, optional): The output tensor. Default: None. name(str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor, same dimension and dtype with x. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> paddle.device.set_device('gpu') >>> input_tensor = paddle.to_tensor(paddle.ones((3, 3)), dtype="float32") >>> index = paddle.to_tensor([0, 2], dtype="int32") >>> value = paddle.to_tensor([[1, 1, 1], [1, 1, 1]], dtype="float32") >>> outplace_res = paddle.index_add(input_tensor, index, 0, value) >>> print(outplace_res) Tensor(shape=[3, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True, [[2., 2., 2.], [1., 1., 1.], [2., 2., 2.]]) r%r index_addrcrFz$paddle.tensor.manipulation.index_addrkr@rq add_value)rArAddValuerCr6rG)r) r#rrrr\rr]r?r_) rcrkr6ralphar`rh scaled_valuergs rjrrs^(- u} ,#FF  1 1F  E.    '.   E.   3 3AGG >> import paddle >>> x = paddle.randn(shape=[4, 6, 8]) >>> shape = [2, 3] >>> axis = 1 >>> res = paddle.unflatten(x, axis, shape) >>> print(res.shape) paddle.Size([4, 2, 3, 8]) >>> x = paddle.randn(shape=[4, 6, 8]) >>> shape = (-1, 2) >>> axis = -1 >>> res = paddle.unflatten(x, axis, shape) >>> print(res.shape) paddle.Size([4, 6, 4, 2]) >>> x = paddle.randn(shape=[4, 6, 8]) >>> shape = paddle.to_tensor([2, 2]) >>> axis = 0 >>> res = paddle.unflatten(x, axis, shape) >>> print(res.shape) paddle.Size([2, 2, 6, 8]) Nr%rqzIThe data type of x should be one of ['List', 'Tuple', 'Tensor'], but got )rrLrMrrSrrNrTrUr8rvrYrHr)rcr6rSr`rs rj unflattenr+s| Q %D%$'' $ 4; .aggdQhj6I1J J  EHfjj&6&67 8 8MM Q& E7+ Qq +  WX\]bXcWd e   )A Hrc0[R"XX#5$)ag View x with specified shape, stride and offset. Note that the output Tensor will share data with origin Tensor and doesn't have a Tensor copy in ``dygraph`` mode. The following image illustrates an example: transforming an input Tensor with shape [2,4,6] into a Tensor with ``shape [8,6]`` and ``stride [6,1]``. .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/as_strided.png :alt: Legend Args: x (Tensor): An N-D Tensor. The data type is ``float32``, ``float64``, ``int32``, ``int64`` or ``bool`` shape (list|tuple): Define the target shape. Each element of it should be integer. stride (list|tuple): Define the target stride. Each element of it should be integer. offset (int, optional): Define the target Tensor's 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, A as_strided Tensor with the same data type as ``x``. Examples: .. code-block:: pycon >>> import paddle >>> paddle.base.set_flags({"FLAGS_use_stride_kernel": True}) >>> x = paddle.rand([2, 4, 6], dtype="float32") >>> out = paddle.as_strided(x, [8, 6], [6, 1]) >>> print(out.shape) paddle.Size([8, 6]) >>> # the stride is [6, 1]. )rr)rcrSrrr`s rjrrsV   Qv 66rc<[U[[45(a[R"X5$[U[ R R[ R45(d [U5nURU:XaU$[R"X5$)a View x with specified shape or dtype. Note that the output Tensor will share data with origin Tensor and doesn't have a Tensor copy in ``dygraph`` mode. .. note:: Alias Support: The parameter name ``size`` and ``dtype`` can be used as an alias for ``shape_or_dtype``. ``shape_or_dtype`` can be a variable number of arguments. For example: ``tensor_x.view(dtype=paddle.float32)`` ``tensor_x.view(size=[-1, 1, 3])`` ``tensor_x.view(-1, 1, 3)`` Args: x (Tensor): An N-D Tensor. The data type is ``float32``, ``float64``, ``int32``, ``int64`` or ``bool`` shape_or_dtype (list|tuple|np.dtype|str|VarType|variable number of arguments): Define the target shape or dtype. If list or tuple, shape_or_dtype represents shape, each element of it should be integer. If np.dtype or str or VarType, shape_or_dtype represents dtype, it can be bool, float16, float32, float64, int8, int32, int64, uint8. ``shape_or_dtype`` can be a variable number of arguments. alias: ``size`` or ``dtype``. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, A viewed Tensor with the same data as ``x``. Examples: .. code-block:: pycon >>> import paddle >>> paddle.base.set_flags({"FLAGS_use_stride_kernel": True}) >>> x = paddle.rand([2, 4, 6], dtype="float32") >>> out = paddle.view(x, [8, 6]) >>> print(out.shape) paddle.Size([8, 6]) >>> import paddle >>> paddle.base.set_flags({"FLAGS_use_stride_kernel": True}) >>> x = paddle.rand([2, 4, 6], dtype="float32") >>> out = paddle.view(x, "uint8") >>> print(out.shape) paddle.Size([2, 4, 24]) >>> import paddle >>> paddle.base.set_flags({"FLAGS_use_stride_kernel": True}) >>> x = paddle.rand([2, 4, 6], dtype="float32") >>> out = paddle.view(x, [8, -1]) >>> print(out.shape) paddle.Size([8, 6]) >>> import paddle >>> paddle.base.set_flags({"FLAGS_use_stride_kernel": True}) >>> x = paddle.rand([2, 4, 6], dtype="float32") >>> out = paddle.view(x, paddle.uint8) >>> print(out.shape) paddle.Size([2, 4, 24]) ) rLrMrr view_shaper r|r}r~rr? view_dtype)rcshape_or_dtyper`s rjviewrszN.4-00  33 T\\114==A  8GN 77n $H  33rcB[R"XR5$)aS View x with other's shape. Note that the output Tensor will share data with origin Tensor and doesn't have a Tensor copy in ``dygraph`` mode. The following figure shows a view_as operation - a three-dimensional tensor with a shape of [2, 4, 6] is transformed into a two-dimensional tensor with a shape of [8, 6] through the view_as operation. We can clearly see the corresponding relationship between the elements before and after the transformation. .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/view_as.png :width: 800 :alt: legend of view_as API :align: center Args: x (Tensor): An N-D Tensor. The data type is ``float32``, ``float64``, ``int32``, ``int64`` or ``bool`` other (Tensor): The result tensor has the same size as other. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, A viewed Tensor with the same shape as ``other``. Examples: .. code-block:: pycon >>> import paddle >>> paddle.base.set_flags({"FLAGS_use_stride_kernel": True}) >>> x = paddle.rand([2, 4, 6], dtype="float32") >>> y = paddle.rand([8, 6], dtype="float32") >>> out = paddle.view_as(x, y) >>> print(out.shape) paddle.Size([8, 6]) )rrrS)rcotherr`s rjview_asrsL   Q ,,r dimensionc0[R"XX#5$)a] View x with specified shape, stride and offset, which contains all slices of size from x in the dimension axis. Note that the output Tensor will share data with origin Tensor and doesn't have a Tensor copy in ``dygraph`` mode. Args: x (Tensor): An N-D Tensor. The data type is ``float32``, ``float64``, ``int32``, ``int64`` or ``bool`` axis (int): The axis along which the input is unfolded. Alias: ``dimension``. size (int): The size of each slice that is unfolded. step (int): The step between each slice. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, A unfold Tensor with the same data type as ``x``. Examples: .. code-block:: python >>> import paddle >>> paddle.base.set_flags({"FLAGS_use_stride_kernel": True}) >>> x = paddle.arange(9, dtype="float64") >>> out = paddle.unfold(x, 0, 2, 4) >>> print(out) Tensor(shape=[2, 2], dtype=float64, place=Place(cpu), stop_gradient=True, [[0., 1.], [4., 5.]]) )r tensor_unfold)rcr6rstepr`s rjunfoldr)sF    44r)rrrrrrzdict[str, Callable[..., Any]] __METHODSc[U[[RR45(d [ S5e[U[5(d[R "X0RS9nO$[UR5S:a [ S5e[UR5n[U[5(aX%S- :dX%*:a [ S5eUS:aX%-n[[[UR555nX&S'SXb'U(ag[5(aURS:XaU$[R"X5 [R "X4U5 [R"X5 U$[5(a URS:XaUR#5$[R$"X5n[R&"Xq4U5n[R$"Xv5nU$)Nzindex must be Tensorr>rz"value must be scalar or 0-D tensorr%z8The axis should be int, and in range [-rank(x), rank(x)))rLrrNrTrUrrOr?rrSrRrMrr"r transpose_r rrr )rcrkr6rrr?rrhs rj_index_fill_implr\s~ eh (8(89 : :/00 eX & &  gg6 u{{ a AB B LE tS ! !tai'7D6M F   ax| c!''l# $DGDJ   qH!"!Xu-!"   q779 q'sHe4s) rc[XX#S5$)a Fill the elements of the input tensor with value by the specific axis and index. As shown below, a ``[3, 3]`` 2D tensor is updated via the index_fill operation. With ``axis=0``, ``index=[0, 2]`` and ``value=-1``, the 1st and 3rd row elements become ``-1``. The resulting tensor, still [3, 3], has updated values. .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/index_fill.png :width: 500 :alt: Illustration of Case 2 :align: center Args: x (Tensor) : The Destination Tensor. Supported data types are int32, int64, float16, float32, float64. index (Tensor): The 1-D Tensor containing the indices to index. The data type of ``index`` must be int32 or int64. axis (int): The dimension along which to index. value (int|float): The tensor used to fill with. name(str|None, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor, same dimension and dtype with x. Examples: .. code-block:: python >>> import paddle >>> input_tensor = paddle.to_tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype='int64') >>> index = paddle.to_tensor([0, 2], dtype="int32") >>> value = -1 >>> res = paddle.index_fill(input_tensor, index, 0, value) >>> print(input_tensor) Tensor(shape=[3, 3], dtype=int64, place=Place(gpu:0), stop_gradient=True, [[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> print(res) Tensor(shape=[3, 3], dtype=int64, place=Place(gpu:0), stop_gradient=True, [[-1, -1, -1], [ 4, 5, 6], [-1, -1, -1]]) Frrcrkr6rr`s rj index_fillrsZ Ad5 99rc[XX#S5$)z Inplace version of ``index_fill`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_index_fill`. Trrs rj index_fill_rs Ad4 88rc[XX#XE5$)aB Embed the values of Tensor ``y`` into Tensor ``x`` along the diagonal elements of Tensor ``x``, with respect to ``axis1`` and ``axis2``. This function returns a tensor with fresh storage. The argument ``offset`` controls which diagonal to consider: - 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. Note: ``y`` should have the same shape as :ref:`paddle.diagonal `. The image below demonstrates the example: A 2D tensor with a shape of [2, 3] is ``diagonal_scatter`` along its main diagonal (``offset = 0``) within ``axis1 = 0`` and ``axis2 = 1`` using a 1D tensor filled with ones. .. image:: https://githubraw.cdn.bcebos.com/PaddlePaddle/docs/develop/docs/images/api_legend/diagonal_scatter.png :width: 500 :alt: legend of diagonal_scatter API Args: x (Tensor): ``x`` is the original Tensor. Must be at least 2-dimensional. y (Tensor): ``y`` is the Tensor to embed into ``x`` offset (int, optional): which diagonal to consider. Default: 0 (main diagonal). axis1 (int, optional): first axis with respect to which to take diagonal. Default: 0. axis2 (int, optional): second axis with respect to which to take diagonal. Default: 1. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, Tensor with diagonal embedded with ``y``. Examples: .. code-block:: python >>> import paddle >>> x = paddle.arange(6.0).reshape((2, 3)) >>> y = paddle.ones((2,)) >>> out = x.diagonal_scatter(y) >>> print(out) Tensor(shape=[2, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True, [[1., 1., 2.], [3., 1., 5.]]) r)rcrraxis1axis2r`s rjdiagonal_scatterr sj fU AArc pURnURn[U[5(d [U5nUS:aX5U- nUS:aU[U5- nXR [U5[U5:wa&[ S[ U5-S-[ U5-5e[ [U55H3nXWXg:wdM[ S[ U5-S-[ U5-5e SSKJn U/n US-/n S/n U/n /n U/nSU0nU U U U UU S.nURnUUS 'URU5nXS '[5(a[R"UUU U U U UU 5$[S0[5D6nUR!URS 9nU"5R#5nUR%S US U0USS 0S9 U$)a Embeds the values of the values tensor into x at the given index of axis. Args: x (Tensor) : The Destination Tensor. Supported data types are `bool`, `float16`, `float32`, `float64`, `uint8`, `int8`, `int16`, `int32`, `int64`, `bfloat16`, `complex64`, `complex128`. values (Tensor) : The tensor to embed into x. Supported data types are `bool`, `float16`, `float32`, `float64`, `uint8`, `int8`, `int16`, `int32`, `int64`, `bfloat16`, `complex64`, `complex128`. axis (int) : the dimension to insert the slice into. index (int) : the index to select with. name (str|None, optional): Name for the operation (optional, default is None). Returns: Tensor, same dtype and shape with x Examples: .. code-block:: python >>> import paddle >>> x = paddle.zeros((2,3,4)).astype("float32") >>> values = paddle.ones((2,4)).astype("float32") >>> res = paddle.select_scatter(x,values,1,1) >>> print(res) Tensor(shape=[2, 3, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[[0., 0., 0., 0.], [1., 1., 1., 1.], [0., 0., 0., 0.]], [[0., 0., 0., 0.], [1., 1., 1., 1.], [0., 0., 0., 0.]]]) rzEexpected values to have a size equal to the slice of x. value size = z slice size = r)rr%r)rrrsteps decrease_axes none_axesr? ValueTensorr> set_valuerCrHrIrJrK inplace_map)select_scatter)rSrLrMrrrWrbase.frameworkrr?rr#rset_value_with_tensorrr\r] current_blockr_)rcrr6rkr`r value_shapererrrrrrrrIrKr?rgr cur_blocks rjrrsDggG,,K gt $ $w- qy  ax G   7|s;'' S+  'l   3w<  : 'Wk"#"#g, !6WF AI;D CE 6DIFMq\F&  E GGEE'N ]]5 !F"=++         :::::I(*88: FO %(   rc t/n/nURn URU 5n[5(a[R"UUUUUUUU5$UUUUUUU S.n UUS.n [ S0[ 5D6n U RURS9n [5R5nURSU SU 0U SS0S9 U $) a Embeds the `value` tensor into `x` along multiple axes. Returns a new tensor instead of a view. The size of `axes` must be equal to `starts` , `ends` and `strides`. Args: x (Tensor) : The input Tensor. Supported data types are `bool`, `float16`, `float32`, `float64`, `uint8`, `int8`, `int16`, `int32`, `int64`, `bfloat16`, `complex64`, `complex128`. value (Tensor) : The tensor to embed into x. Supported data types are `bool`, `float16`, `float32`, `float64`, `uint8`, `int8`, `int16`, `int32`, `int64`, `bfloat16`, `complex64`, `complex128`. axes (list|tuple) : the dimensions to insert the value. starts (list|tuple) : the start indices of where to insert. ends (list|tuple) : the stop indices of where to insert. strides (list|tuple) : the steps for each insert. name (str|None, optional): Name for the operation (optional, default is None). Returns: Tensor, same dtype and shape with x Examples: .. code-block:: python >>> import paddle >>> x = paddle.zeros((3, 9)) >>> value = paddle.ones((3, 2)) >>> res = paddle.slice_scatter(x, value, axes=[1], starts=[2], ends=[6], strides=[2]) >>> print(res) Tensor(shape=[3, 9], dtype=float32, place=Place(cpu), stop_gradient=True, [[0., 0., 1., 0., 1., 0., 0., 0., 0.], [0., 0., 1., 0., 1., 0., 0., 0., 0.], [0., 0., 1., 0., 1., 0., 0., 0., 0.]]) >>> # broadcast `value` got the same result >>> x = paddle.zeros((3, 9)) >>> value = paddle.ones((3, 1)) >>> res = paddle.slice_scatter(x, value, axes=[1], starts=[2], ends=[6], strides=[2]) >>> print(res) Tensor(shape=[3, 9], dtype=float32, place=Place(cpu), stop_gradient=True, [[0., 0., 1., 0., 1., 0., 0., 0., 0.], [0., 0., 1., 0., 1., 0., 0., 0., 0.], [0., 0., 1., 0., 1., 0., 0., 0., 0.]]) >>> # broadcast `value` along multiple axes >>> x = paddle.zeros((3, 3, 5)) >>> value = paddle.ones((1, 3, 1)) >>> res = paddle.slice_scatter(x, value, axes=[0, 2], starts=[1, 0], ends=[3, 4], strides=[1, 2]) >>> print(res) Tensor(shape=[3, 3, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[[0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.], [0., 0., 0., 0., 0.]], [[1., 0., 1., 0., 0.], [1., 0., 1., 0., 0.], [1., 0., 1., 0., 0.]], [[1., 0., 1., 0., 0.], [1., 0., 1., 0., 0.], [1., 0., 1., 0., 0.]]]) )rrrrrrr?)rrr>rrCrr) slice_scatter) r?rr#rrrr\r]rrr_)rcrrrrrr`rrr?rKrIrgrrs rjrrd sDIM GGE LL E++         *"    99:::I(*88: FO %(   rc SnSnUVs/sH oC"U5PM nn[U5VVs/sH!upd[R"U"XVU5SS9PM# nnn[R"USS9$s snfs snnf)aP Create a block diagonal matrix from provided tensors. Args: inputs (list|tuple): ``inputs`` is a Tensor list or Tensor tuple, one or more tensors with 0, 1, or 2 dimensions. The data type: ``bool``, ``float16``, ``float32``, ``float64``, ``uint8``, ``int8``, ``int16``, ``int32``, ``int64``, ``bfloat16``, ``complex64``, ``complex128``. name (str|None, optional): Name for the operation (optional, default is None). Returns: Tensor, A ``Tensor``. The data type is same as ``inputs``. Examples: .. code-block:: python >>> import paddle >>> A = paddle.to_tensor([[4], [3], [2]]) >>> B = paddle.to_tensor([7, 6, 5]) >>> C = paddle.to_tensor(1) >>> D = paddle.to_tensor([[5, 4, 3], [2, 1, 0]]) >>> E = paddle.to_tensor([[8, 7], [7, 8]]) >>> out = paddle.block_diag([A, B, C, D, E]) >>> print(out) Tensor(shape=[9, 10], dtype=int64, place=Place(gpu:0), stop_gradient=True, [[4, 0, 0, 0, 0, 0, 0, 0, 0, 0], [3, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 7, 6, 5, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 5, 4, 3, 0, 0], [0, 0, 0, 0, 0, 2, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 8, 7], [0, 0, 0, 0, 0, 0, 0, 0, 7, 8]]) c [U5VVs/sHGup4X1:XaUO:[R"URSURS/URS9PMI snn$s snnf)Nrr%r>)rVrNr(rSr?)arysreararys rj to_col_block block_diag..to_col_block sg&dO  ,8\\399Q<".to_2d!sv 88q===a=(222: : 88q===a=( ( 88q=J gxxj   rrr:r%)rVrNr8)rIr`r"r%r!rrmatrixs rj block_diagr( s~F   #) )&3E#J&D )"$'HC  l4c2;'  ==a (( *s A,(A1)r%FN) r5zTensor | list[Tensor]r6rRrFrlr` str | Nonereturntuple[Tensor, Tensor])rcr,r?r-r*r,) r5r,rSequence[int | Tensor]rSequence[int | Tensor] | Tensorrr-r*r,) r5r,rrRr int | TensorrrRr*r,r )rcr,r Sequence[int]r`r)r*r,r)rcr,r6rRr int | Noner* list[Tensor])r) r5r,rrRrrRrrRrrRr*r,)NNN) rcr,rSzShapeLike | NonerzSequence[int] | Tensor | Noner`r)r*r,)rcr,rrr*r,)rcr,r*r,)rFN) rcr,rrrrRrrlr`r)r*r,)rrr%F)rcr,rr,rrRrrRrrRrrlr*r,)rrr%N)rcr,rr,rrRrrRrrRr`r)r*r,)rcr,r*z!NestedList[int | float | complex]) rcSequence[Tensor]r6r.r`r)rh Tensor | Noner*r,)r5r2r`r)r*r1)rcr,r6zSequence[int] | intr`r)r*r,) rcr,r/rRrr/r`r)r*r,)rrN) rcr,r5rRr6rRr`r)r*r,)r5r,r*r,) rcr2r6rRr`r)rhr3r*r,)rcr2r`r)r*r,) rcr,raint | Sequence[int]r6r.r`r)r*r1) rcr,r~r4r6r.r`r)r*r1)rcr,r~r4r`r)r*r1)NN)rcr,r6zint | Sequence[int] | Noner`r)r*r,)FFNrqN)rcr,rrlrrlr6r0r?r-r`r)r*tuple[Tensor, Tensor, Tensor]).......)rcr,r Literal[True]rr6rr6r6r0r?r-rrlr`r)r*z%tuple[Tensor, Tensor, Tensor, Tensor])rcr,rLiteral[False]rr6rr6r6r0r?r-rrlr`r)r*r5)rcr,rr6rr7rr6r6r0r?r-rrlr`r)r*r5)rcr,rr6rr6rr7r6r0r?r-rrlr`r)r*r5)rcr,rr7rr7rr6r6r0r?r-rrlr`r)r*r+)rcr,rr7rr6rr7r6r0r?r-rrlr`r)r*r+)rcr,rr6rr7rr7r6r0r?r-rrlr`r)r*r+)rcr,rr7rr7rr7r6r0r?r-rrlr`r)r*r,)FFF....)rcr,rrlrrlrrlr6r0r?r-rrlr`r)r*zTensor | tuple[Tensor, ...])FFFNrqTN)rcr,r6z%int | Sequence[Tensor | int] | Tensorr`r)r*r,)rcr,r6int | Sequence[int] | Tensorr`r)r*r,) r5r,rrRrkr,rhr3r*r,) rcr,rkr,r6zTensor | int | Noner`r)rhr3r*r,)rrrrr*r,)r)r5r,r6rRr*r1)r5r,rrRrkr,rr3rr)rr3r*r,)TN) rcr,rkr,rr,rrlr`r)r*r,)TNN)rcr,rkr,rr,rrlr`r)rhr3r*r,)NNNN)r5r,rrRrkr,rr3rr)rhr3rr3r*r,) rcr,rkr,rr,r`r)r*r,) rkr,rr,rSr1r`r)r*r,) rcr,rrRr6r.r`r)r*r1)rcr,rzTensorOrTensors | Sequence[int]r`r)r*r,)r5r,rr8r*r,)rcr,rSr1r`r)r*r,) rcr,rBr,rr,r`r)r*r,).)rIr,r`r)r*r,)rIr,r`r)r*r1)rcr,rkr,r`r)r*r,)rcr,rr,rr-rr-rr-r`r)r*r,)rN) rcr,rr,rz"int | NestedSequence[int] | Tensorr`r)r*r,)rcr,r`r)r*r,) rcr,rr.r6r0r`r)rr0r*r,) rcr,rr4rr4r`r)r*r,)rBr,rr0r`r)r*r,)rr,r6rRr*rR)rr,r6r,r*r,) rr,rrRrr,r6rRr*r,)rr,rqr,r6r.r*ztuple[int] | None) r5r,rrRrkr,rr,r*r,)T) rr,rqr,r6rRrrlrhr3r*r,)r5r,rrRrkr,rr,rz.Literal['sum', 'prod', 'mean', 'amin', 'amax']rrlr*r,)rTT)rr,rqr,rfloat | Tensorr6rRrCLiteral['assign', 'add', 'mul', 'multiply', 'mean', 'amin', 'amax']rrlrrlr*r,)rr,rqr,rr9r6rRrr:rrlrrl)r%N)rcr,rkr,r6rRrr,rr+r`r)rhr3r*r,)rcr,rkr,r6rRrr,rrRr`r)r*r,) rcr,r6rRrSr1r`r)r*r,) rcr,rSr/rr/rrRr`r)r*r,)rcr,rzSequence[int] | DTypeLiker`r)r*r,)rcr,rr,r`r)r*r,) rcr,r6rRrrRrrRr`r)r*r,) rcr,rkr,r6rRrr,rrlr*r,) rcr,rkr,r6rRrrr`r))rcr,rr,rrRr rRr rRr`r)r*r,) rcr,rr,r6rRrkrRr`r)r*r,)rcr,rr,rr/rr/rr/rr/r`r)r*r,)rIr2r`r)r*r,) __future__rrinspectrtypingrrrrrPtyping_extensionsrrNr paddle._C_opsr r r paddle.tensorr paddle.utils.decorator_utilsr rrrrrrrrpaddle.utils.inplace_utilsrbase.data_feederrrrrrrrrUrrr r!r"r#r$creationr&r'r(collections.abcr)r*numbersr+r,paddle._typingr-r.r/r0r1r2r3r4__all__r;rvrrrrrrrrrrrrrrr8rr'r,r<rBrDr9rMrPrSrVrYr`rrrrrrrrrrrrr signature __signature__rrrrrrrrrrr r rr#rrErHrJrJrOrRrlrprrrrrrrrrrrrrrrrrrrrrrrrrr__annotations__itemsr`funcsetattrrrrrr rrr(rrrjrOsu# ..& 55'   D <LK2$@   I I II  I  IXTn&&\ \ \ ,\ * \  \~V V V V  V  Vt8<h h"h*4h hV5z Y YYY Y  Y  Y|#-1 t t t+t  t  tn""B  8 #= #= #= #=  #=  #=  #=#=R _ _ _ _  _  _  _ _J ' ' ' '  '  '  ' 'Z $ $ $ $  $  $  $ $N##BI;89L  LL L L  L  L:L`15B B#-BBL>BO O(O0:O Of!QDe6 e6e6!.e6?Ie6 e6P )K= {KMQM MM/2M?IM MM`%PLP#9 #9#9/2#9?I#9 #9#9LI;89h  hh h h  h  h:hVA8HB4J24j94x8'v<&  ] ](] ]  ]  ]  ]@ m  m 'm  m   m  m m bHL>B >B2>B:D>B>BDHL2> 2>22>:D2>2>lHL7> 7>27>:D7>7>t#w&%1KOV V/V>HV V2VrKO, ,/,>H, ,,(#w&%1! ` ```  `  `  `#`2`F #&$'#& 0  0 0" 0! 0  0  0  0  0+ 0  0 $'$'#& (  (  (" (! (  (  (  (  (# (  ( #&%(#& (  ( (# (! (  (  (  (  (# (  ( #&$'$' (  ( (" (" (  (  (  (  (# (  ( $'%(#&        #  !                  $'$'$'        "  "                  #&%($'       #  "                  $'%($'     # "                &  & & & &  &  &  &  &! &  &   vr#w&%1I I /I I I2IXFJ* *1*9C* **2            !% : : : :  :  :  :z !%                     N0b((9&%!U"Ux >I >I >I >I  >I  >I  >I >IJ 9 9 99 9  9  9                       990&&'?@             N           B                        k1\ ))*:;CGX XX'-X5?X XxJN(M (M"(M+4(M