ΑiSSKJr SSKJrJrJrJr SSKJr SSK r SSK J r SSK J r SSK Jr SSKJr SS KJr S S KJr S S KJrJrJrJrJr S S KJr \(a SSKJr SSK Jr /SQr Sr!\ RD\ RF\ RH\ RJ\ RL\ RN\ RP\ RR\ RT\ RV/ r,\,u r-r.r/r0r1r2r3r4r5r6\-\/\/\0\1\2\3\4\-\6/ \/\.\/\0\1\2\3\4\.\6/ \/\/\/\0\1\2\3\4\/\6/ \0\0\0\0\1\2\3\4\0\6/ \1\1\1\1\1\2\3\4\1\6/ \2\2\2\2\2\2\3\4\2\3/ \3\3\3\3\3\3\3\4\3\3/ \4\4\4\4\4\4\4\4\4\4/ \-\.\/\0\1\2\3\4\5\6/ \6\6\6\6\6\3\3\4\6\6/ / r7\8"\,5VVVVs0sH!up\8"\,5Hup#X4\7UU_M M# snnnnr9\"SS1SSS9SASj5r:"SS\5r;\"SS1SSS9SBSS.SCSjjj5r<\"SS1SS S9SBSS.SCS!jjj5r=SDS"jr>"S#S$\5r?SES%jr@SFS&jrASFS'jrB\"SS1S(S)S9SS.SGS*jj5rC\"SS1S+S,S9SS.SGS-jj5rD"S.S/\5rESHSIS0jjrF"S1S2\5rG\"SS1S3S4S9SJSKS5jj5rH\SLSMS6jj5rI\SLSNS7jj5rI\SLSOS8jj5rI\SLSPS9jj5rI\"SS1S:S;S9SQS<j5rI\"1S=kS>S?S9SRSSS@jj5rJgs snnnnf)T) annotations) TYPE_CHECKINGAnyLiteral NamedTuple)overloadN)_C_ops)core)Variable)in_dynamic_mode)ForbidKeywordsDecorator)nn)disable_torch_proxyenable_torch_proxy"extend_torch_proxy_blocked_modulespaddle_triton_funuse_torch_proxy_guard)_check_out_status)Sequence)Tensor) equalslogdetsortsplitminmaxuniquemedian nanmedianseedc$US:Xa [5$g)N paddle_triton)r)names V/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/paddle/compat/__init__.py __getattr__r&;s  ""xyzpaddle.compat.equalz paddle.equal) illegal_keys func_name correct_namecURUR:Xa$[R"X5R5$[R URUR5nURU:waUR U5nURU:waUR U5n[R"X5R5$)a` ``True`` if two tensors have the same size and elements, ``False`` otherwise. Note: Tensors containing NaNs are never equal to each other. Additionally, this function does not differentiate between the data types of the tensors during comparison. Args: input (Tensor): Tensor, data type is bool, float16, float32, float64, uint8, int8, int16, int32, int64, complex64, complex128. other (Tensor): Tensor, data type is bool, float16, float32, float64, uint8, int8, int16, int32, int64, complex64, complex128. Returns: Bool: ``True`` if two tensors have the same size and elements, ``False`` otherwise. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([1, 2, 3]) >>> y = paddle.to_tensor([1, 3, 2]) >>> result1 = paddle.compat.equal(x, y) >>> print(result1) False )dtypepaddle equal_allitem PROMOTE_DICTgetcast)inputother common_dtypes r%rrbsD {{ekk!-2244##EKK=L {{l" <( {{l" <(   E ) . . 00r'c*\rSrSr%S\S'S\S'Srg) MedianRetTypervaluesindicesN__name__ __module__ __qualname____firstlineno____annotations____static_attributes__r=r'r%r9r9 N Or'r9axiszpaddle.compat.medianz paddle.medianoutcUc?[US5 [R"XUSS9nUb[R"XC5 U$U$[US5 [R"XUSUS9upVUb[ USUSS9$[ XVS9$) a Returns the median of the values in input. Args: input (Tensor): The input tensor. dim (int|None, optional): The dimension to reduce. If None, computes the median over all elements. Default is None. keepdim (bool, optional): Whether the output tensor has dim retained or not. Default is False. out (Tensor|tuple[Tensor, Tensor], optional): If provided, the result will be written into this tensor. For global median (dim=None), out must be a single tensor. For median along a dimension (dim specified, including dim=-1), out must be a tuple of two tensors (values, indices). Returns: Tensor|MedianRetType: If dim is None, returns a single tensor. If dim is specified (including dim=-1), returns a named tuple MedianRetType(values: Tensor, indices: Tensor). Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> result = paddle.compat.median(x) >>> print(result) Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, 5) >>> ret = paddle.compat.median(x, dim=1) >>> print(ret.values) Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True, [2, 5, 8]) >>> print(ret.indices) Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True, [1, 1, 1]) >>> # Using out parameter >>> out_values = paddle.zeros([3], dtype='int64') >>> out_indices = paddle.zeros([3], dtype='int64') >>> paddle.compat.median(x, dim=1, out=(out_values, out_indices)) >>> print(out_values) Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True, [2, 5, 8]) FrrFkeepdimmodeT)rFrKrLrHrrr;r<)rr/rassignr9r5dimrKrHresultr;r<s r%rrsd {#u%ueL ? MM& &J #t$ -- W5c  ? AA? ?F<>> import paddle >>> import numpy as np >>> x = paddle.to_tensor([[1, float('nan'), 3], [4, 5, 6], [float('nan'), 8, 9]], dtype='float32') >>> result = paddle.compat.nanmedian(x) >>> print(result) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 5.0) >>> ret = paddle.compat.nanmedian(x, dim=1) >>> print(ret.values) Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [1.0, 5.0, 8.0]) >>> print(ret.indices) Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True, [0, 1, 1]) >>> # Using out parameter >>> out_values = paddle.zeros([3], dtype='float32') >>> out_indices = paddle.zeros([3], dtype='int64') >>> paddle.compat.nanmedian(x, dim=1, out=(out_values, out_indices)) >>> print(out_values) Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [1.0, 5.0, 8.0]) FrrJTrrrM)rr/r rNmaximum zeros_liker9rOs r%r r sf {#u%!!%7O ? MM& &J #t$ ** W5  ..&*;*;G*DE ? MM&a& ) MM'q6 * AA? ?F<>> import paddle >>> seed = paddle.compat.seed() )r default_cpu_generatorr!r/)r!s r%r!r!"s,  % % ' , , .D KK Kr'c*\rSrSr%S\S'S\S'Srg) MinMaxRetTypei2rr;r<r=Nr>r=r'r%rXrX2rEr'rXc^^^^S UUU4SjjmUU4SjnSnSn[T5nU[T5-nUS:aT"5eUS:XaiUS:XaTupEO$US:XaTSnU"S5nOU"S5nU"S5nUb/[U[[RR 45(aT"5eOjUS:XadU(aTSnOMST;aTSnOAS T;a;TS n[U[[RR 45(dT"5eUcT"5eUbY[U[[RR 45(d*[ U5[LaT"S TS [ U5S 35eXE4$)Nc X>TVs/sHn[U5RPM nnURTR5VVs/sHup1US[U5R3PM! snn5 SR U5nSTSUSUSTSTS3 n[ U5$s snfs snnf) N=, z%Invalid arguments for `paddle.compat.z`: zGot: (paddle.Tensor input, z;), but expect one of: - (input: paddle.Tensor) for reduce_zL on all dims. - (input: paddle.Tensor, other: paddle.Tensor) -> see paddle.zOimum - (input: paddle.Tensor, int dim (cannot be None), bool keepdim = False) )typer?extenditemsjoin TypeError) error_prefixv type_strsk signature error_msgargsr+kwargss r%invalid_arguments_exception;_min_max_param_checker..invalid_arguments_exception8s/34t!T!W%%t 4 OQCqa!1!1 23OPIIi( 4I;d<.))544=;?MMVKXZ [ ##5Os B!&B& cD>SnTUnU$![a T"5Sef=fN)KeyError)keyresrjris r% try_get_keys,_min_max_param_checker..try_get_keysFs9 :+C  :-/T 9 :s FrrrKrPr6zBThe second input must be int or Tensor or implicit None in compat.z, but received z. ))len isinstancer r/pirValuer]int) r+rhrirq dim_or_otherrKnum_args total_arg_numrjs ``` @r%_min_max_param_checkerr}7s $ $LG4yHs6{*Mq)++ !  q=$( !L' ]7L"9-G'.L"9-G  : 8VZZ%5%56$ $ ./ /$  !  7L%e} F"%g !,6::;K;K0LMM577  -/ /  <(FJJ4D4D)EFF  c ))PQZP[[jkop|k}j~B C     r'cURnU[R:Xd<U[R:Xd(U[R:XdU[R :Xa!UR (d[SUS35egg)z@Prevent integral input tensor type to have `stop_gradient=False`zTensors with integral type: 'z' should stop gradient.N)r.r/int32int64uint8int16 stop_gradientrar5in_dtypes r%_min_max_tensor_allow_gradr{sh{{HFLL v|| # v|| # v|| #""/z9PQ # $r'cURnU[R:Xd(U[R:XdU[R:Xa[ SUS35eg)zPpaddle.min/argmin(max/argmax), paddle.take_along_axis reject the following typesz*Non-CUDA GPU placed Tensor does not have 'zZ' op registered. Paddle support following DataTypes: int32, int64, float64, float32, uint8N)r.r/float16bfloat16rrars r%_min_max_allow_cpu_compositersU{{HFNN" v & v|| #8 CX X   $r'zpaddle.compat.minz paddle.minc [U[RR[R45(d"[ S[ U5RS35e[U5 [S/UQ70UD6upESnUc$[US5 [R"U5nGOP[U[5(Ga[US5 UR(a[5(aURR!5(dk[#U5 [R$"XSS9n[R&"XUS9nU(a [)XS 9nO[)UR+US9UR+US9S 9nO[,R."XUS5upSU l[)XS 9nOY[)U[R2"/[R4URS 9S 9nO"[US5 [,R6"X5nUbu[U[(5(aJ[R8"UR:US 5 [R8"UR<US 5 U$[R8"Xa5 U$) a Computes the minimum of tensor elements. There are mainly 3 cases (functionalities): 1. paddle.compat.min(input: Tensor): reduce min over all dims, return a single value Tensor 2. paddle.compat.min(input: Tensor, dim: int (cannot be None), keepdim=False): reduce min over the given dim, returns a named tuple MinMaxRetType(values: Tensor, indices: Tensor) 3. paddle.compat.min(input: Tensor, other: Tensor): see `paddle.minimum` Special warning: the gradient behavior is NOT well-documented by PyTorch, the actual behavior should be: 1. Case 1: the same as `min` 2. Case 2: NOT evenly distributing the gradient for equal minimum elements! PyTorch actually only propagates to the elements with indices, for example: Tensor([1, 1, 1]) -> min(..., dim=0) -> values=Tensor(0, ...), indices=Tensor(0), the gradient for input tensor won't be Tensor([1/3, 1/3, 1/3]) as stated in their documentation, but will be Tensor([1, 0, 0]). This API implements a similar backward kernel. 3. Case 3: the same as `minimum` Args: input (Tensor): A tensor, the data type is bfloat16, float16, float32, float64, int32, int64 on GPU. uint8, int32, int64, float32, float64 are allowed on CPU. dim (int, optional): The dim along which the minimum is computed. If this is not specified: see case 1, note that: `None` cannot be passed to this (TypeError will be thrown) compute the minimum over all elements of `input` and return a Tensor with a single element, otherwise must be in the range :math:`[-input.ndim, input.ndim)`. If :math:`dim < 0`, the axis to reduce is :math:`input.ndim + dim`. Warning: if `dim` is specified, execute static graph will throw exceptions when not on a GPU device, since max_with_index is not implemented for non-GPU devices keepdim (bool, optional): Whether to reserve the reduced dimension in the output Tensor. The result tensor will have one fewer dimension than the `input` unless :attr:`keepdim` is true, default value is False. Note that if `dim` does not appear in neither (`*args`) or (`**kwargs`), this parameter cannot be passed alone other (Tensor, optional): the other tensor to perform `paddle.minimum` with. This Tensor should have the same or broadcast-able shape as the `input`. Note that (`dim` & `keepdim`) and `other` are mutually exclusive meaning that trying to composite both will result in TypeError out (Tensor|tuple[Tensor, Tensor], optional): the output Tensor or tuple of (Tensor, int64 Tensor) that can be optionally given to be used as output buffers. For case 1 and 3 out is just a Tensor, while for case 2 we expect a tuple Returns: - For case 1. A single value Tensor (0-dim) - For case 2. A named tuple MinMaxRetType(values: Tensor, indices: Tensor), `values` has the same data type as the `input`, while indices is always an int64 Tensor, with exactly the same shape as `values`. MinMaxRetType can be used (indexed, packed, unpacked) in the same way as a regular tuple - For case 3. See `paddle.minimum` (:ref:`api_paddle_minimum`) Examples: .. code-block:: python >>> import paddle >>> # data_x is a Tensor with shape [2, 4] >>> # the axis is a int element >>> x = paddle.to_tensor([[0.2, 0.3, 0.5, 0.9], ... [0.1, 0.2, 0.6, 0.7]], ... dtype='float64', stop_gradient=False) >>> # Case 1: reduce over all dims >>> result1 = paddle.compat.min(x) >>> result1 Tensor(shape=[], dtype=float64, place=Place(gpu:0), stop_gradient=False, 0.10000000) >>> # Case 2: reduce over specified dim >>> x.clear_grad() >>> result2 = paddle.compat.min(x, dim=1) >>> result2 MinMaxRetType(values=Tensor(shape=[2], dtype=float64, place=Place(gpu:0), stop_gradient=False, [0.20000000, 0.10000000]), indices=Tensor(shape=[2], dtype=int64, place=Place(gpu:0), stop_gradient=True, [0, 0])) >>> result2[0].backward() >>> x.grad Tensor(shape=[2, 4], dtype=float64, place=Place(gpu:0), stop_gradient=False, [[1., 0., 0., 0.], [1., 0., 0., 0.]]) >>> # Case 3: equivalent to `paddle.minimum` >>> x.clear_grad() >>> y = paddle.to_tensor([[0.5, 0.4, 0.1, 0.2], ... [0.3, 0.1, 0.6, 0.7]], ... dtype='float64', stop_gradient=False) >>> result3 = paddle.compat.min(x, y) >>> result3 Tensor(shape=[2, 4], dtype=float64, place=Place(gpu:0), stop_gradient=False, [[0.20000000, 0.30000000, 0.10000000, 0.20000000], [0.10000000, 0.10000000, 0.60000000, 0.70000000]]) 9input should be a tensor, but got an instance with type ''rNFTrFrKrFrMr.devicerr)rvr/rwrxrrar]r?rr}rrryndimr place is_gpu_placerargmintake_along_axisrXsqueeze_r min_with_indexrzerosrminimumrNr;r< r5rHrhrirzrKretr<r;valsindss r%rrsB efjj.. > ? ?GU H\H\G]]^ _  u%25J4J6JL C#u%jj L# & &#t$ ::  )A)A)C)C,U3!--$O//'vGC'%LA ' 0 0l 0 CC $22% &*"#4> fll5;;C #u%nnU1  c= ) ) MM#**c!f - MM#++s1v . J MM# # Jr'zpaddle.compat.maxz paddle.maxc [U[RR[R45(d"[ S[ U5RS35e[U5 [S/UQ70UD6upESnUc$[US5 [R"U5nGOP[U[5(Ga[US5 UR(a[5(aURR!5(dk[#U5 [R$"XSS9n[R&"XUS9nU(a [)XS 9nO[)UR+US9UR+US9S 9nO[,R."XUS5upSU l[)XS 9nOY[)U[R2"/[R4URS 9S 9nO"[US5 [,R6"X5nUbu[U[(5(aJ[R8"UR:US 5 [R8"UR<US 5 U$[R8"Xa5 U$) a Computes the maximum of tensor elements. There are mainly 3 cases (functionalities): 1. paddle.compat.max(input: Tensor): reduce max over all dims, return a single value Tensor 2. paddle.compat.max(input: Tensor, dim: int (cannot be None), keepdim=False): reduce max over the given dim, returns a named tuple MinMaxRetType(values: Tensor, indices: Tensor) 3. paddle.compat.max(input: Tensor, other: Tensor): see `paddle.maximum` Special warning: the gradient behavior is NOT well-documented by PyTorch, the actual behavior should be: 1. Case 1: the same as `max` 2. Case 2: NOT evenly distributing the gradient for equal maximum elements! PyTorch actually only propagates to the elements with indices, for example: Tensor([1, 1, 1]) -> max(..., dim=0) -> values=Tensor(0, ...), indices=Tensor(0), the gradient for input tensor won't be Tensor([1/3, 1/3, 1/3]) as stated in their documentation, but will be Tensor([1, 0, 0]). This API implements a similar backward kernel. 3. Case 3: the same as `maximum` Args: input (Tensor): A tensor, the data type is bfloat16, float16, float32, float64, int32, int64 on GPU. uint8, int32, int64, float32, float64 are allowed on CPU. dim (int, optional): The dim along which the maximum is computed. If this is not specified: see case 1, note that: `None` cannot be passed to this (TypeError will be thrown) compute the maximum over all elements of `input` and return a Tensor with a single element, otherwise must be in the range :math:`[-input.ndim, input.ndim)`. If :math:`dim < 0`, the axis to reduce is :math:`input.ndim + dim`. Warning: if `dim` is specified, execute static graph will throw exceptions when not on a GPU device, since max_with_index is not implemented for non-GPU devices keepdim (bool, optional): Whether to reserve the reduced dimension in the output Tensor. The result tensor will have one fewer dimension than the `input` unless :attr:`keepdim` is true, default value is False. Note that if `dim` does not appear in neither (`*args`) or (`**kwargs`), this parameter cannot be passed alone other (Tensor, optional): the other tensor to perform `paddle.maximum` with. This Tensor should have the same or broadcast-able shape as the `input`. Note that (`dim` & `keepdim`) and `other` are mutually exclusive meaning that trying to composite both will result in TypeError out (Tensor|tuple[Tensor, Tensor], optional): the output Tensor or tuple of (Tensor, int64 Tensor) that can be optionally given to be used as output buffers. For case 1 and 3 out is just a Tensor, while for case 2 we expect a tuple Returns: - For case 1. A single value Tensor (0-dim) - For case 2. A named tuple MinMaxRetType(values: Tensor, indices: Tensor), `values` has the same data type as the `input`, while indices is always an int64 Tensor, with exactly the same shape as `values`. MinMaxRetType can be used (indexed, packed, unpacked) in the same way as a regular tuple - For case 3. See `paddle.maximum` (:ref:`api_paddle_maximum`) Examples: .. code-block:: python >>> import paddle >>> # data_x is a Tensor with shape [2, 4] >>> # the axis is a int element >>> x = paddle.to_tensor([[0.2, 0.3, 0.5, 0.9], ... [0.1, 0.2, 0.6, 0.7]], ... dtype='float64', stop_gradient=False) >>> # Case 1: reduce over all dims >>> result1 = paddle.compat.max(x) >>> result1 Tensor(shape=[], dtype=float64, place=Place(gpu:0), stop_gradient=False, 0.90000000) >>> # Case 2: reduce over specified dim >>> x.clear_grad() >>> result2 = paddle.compat.max(x, dim=1) >>> result2 MinMaxRetType(values=Tensor(shape=[2], dtype=float64, place=Place(gpu:0), stop_gradient=False, [0.90000000, 0.70000000]), indices=Tensor(shape=[2], dtype=int64, place=Place(gpu:0), stop_gradient=True, [3, 3])) >>> result2[0].backward() >>> x.grad Tensor(shape=[2, 4], dtype=float64, place=Place(gpu:0), stop_gradient=False, [[0., 0., 0., 1.], [0., 0., 0., 1.]]) >>> # Case 3: equivalent to `paddle.maximum` >>> x.clear_grad() >>> y = paddle.to_tensor([[0.5, 0.4, 0.1, 0.2], ... [0.3, 0.1, 0.6, 0.7]], ... dtype='float64', stop_gradient=False) >>> result3 = paddle.compat.max(x, y) >>> result3 Tensor(shape=[2, 4], dtype=float64, place=Place(gpu:0), stop_gradient=False, [[0.50000000, 0.40000000, 0.50000000, 0.90000000], [0.30000000, 0.20000000, 0.60000000, 0.70000000]]) rrrNFTrrrMrrr)rvr/rwrxrrar]r?rr}rrryrr rrrargmaxrrXrr max_with_indexrrrrSrNr;r<rs r%rr2sB efjj.. > ? ?GU H\H\G]]^ _  u%25J4J6JL C#u%jj L# & &#t$ ::  )A)A)C)C,U3 --$O//'vGC'%LA ' 0 0l 0 CC $22% &*"#4> fll5;;C #u%nnU1  c= ) ) MM#**c!f - MM#++s1v . J MM# # Jr'c*\rSrSr%S\S'S\S'Srg) SlogdetResultirsign logabsdetr=Nr>r=r'r%rrs Lr'rc[R"XS9up#Ub2[R"X!S5 [R"X1S5 [ X#5$)a (PyTorch Compatible API) Calculates the sign and natural logarithm of the absolute value of a square matrix's or batches square matrices' determinant. The determinant can be computed with ``sign * exp`` (logabsdet). Supports input of float, double, complex64, complex128. Notes: 1. For matrices that have zero determinant, this returns ``(0, -inf)``. 2. For matrices with complex value, the :math:`abs(det)` is the modulus of the determinant, and therefore :math:`sign = det / abs(det)`. 3. The return structure of this API has been revised **from a single stacked Tensor of shape `[2, *]` (where index 0 was sign and index 1 was logabsdet) to a tuple of two independent Tensors `(sign, logabsdet)`** (see `PR #72505 `_). This modification may cause incompatibility with models previously exported for inference that relied on the old return structure. Args: x (Tensor): the batch of matrices of size :math:`(*, n, n)` where math:`*` is one or more batch dimensions. out(SlogdetResult, optional): The tuple of output tensor, contains ``abs`` and ``logabsdet``. Returns: SlogdetResult: A tuple containing two Tensors: (sign, logabsdet). The first Tensor represents the signs of the determinants and the second Tensor represents the natural logarithms of the absolute values of the determinants. Each output Tensor has a shape of :math:`(*)`, where :math:`*` matches the batch dimensions of the input `x`. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1., 0.], [0., 1.]]) >>> A = paddle.compat.slogdet(x) >>> print(A.sign) Tensor(shape=[], dtype=float32, place=Place(gpu:0), stop_gradient=True, 1.) >>> print(A.logabsdet) Tensor(shape=[], dtype=float32, place=Place(gpu:0), stop_gradient=True, 0.) rGrr)r slogdet_v2r/rNr)r(rHrrs r%rrsGR''3OD  dF# iQ(  ))r'c*\rSrSr%S\S'S\S'Srg) SortRetTypeirr;r<r=Nr>r=r'r%rrrEr'rzpaddle.compat.sortz paddle.sortc[USS9 [R"XX#5upVUb2[R"XTS5 [R"XdS5 [ XVS9$)a Sorts the input along the given dimension, and returns the sorted output and indices tensor. The default sort algorithm is ascending, if you want the sort algorithm to be descending, you must set the :attr:`descending` as True. Args: input (Tensor): An input N-D Tensor with type float32, float64, int16, int32, int64, uint8, float16, bfloat16 dim (int, optional): Dimension to compute indices along. The effective range is [-R, R), where R is Rank(x). when dim<0, it works the same way as dim+R. Default is -1. descending (bool, optional) : Descending is a flag, if set to true, algorithm will sort by descending order, else sort by ascending order. Default is false. stable (bool, optional): Whether to use stable sorting algorithm or not. When using stable sorting algorithm, the order of equivalent elements will be preserved. Default is False. out (tuple, optional) : the output tuple/list of (Tensor, Tensor) that can be optionally given to be used as output buffers Returns: SortRetType, a named tuple which contains `values` and `indices`, can be accessed through either indexing (e.g. `result[0]` for values and `result[1]` for indices), or by `result.values` & `result.indices` Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[5,8,9,5], ... [0,0,1,7], ... [6,9,2,4]], ... dtype='float32') >>> out1 = paddle.compat.sort(input=x, dim=-1) >>> out2 = paddle.compat.sort(x, 1, descending=True) >>> out1 SortRetType(values=Tensor(shape=[3, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[5., 5., 8., 9.], [0., 0., 1., 7.], [2., 4., 6., 9.]]), indices=Tensor(shape=[3, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 3, 1, 2], [0, 1, 2, 3], [2, 3, 0, 1]])) >>> out2 SortRetType(values=Tensor(shape=[3, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[9., 8., 5., 5.], [7., 1., 0., 0.], [9., 6., 4., 2.]]), indices=Tensor(shape=[3, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[2, 1, 0, 3], [3, 2, 0, 1], [1, 0, 3, 2]])) T)expect_multiplerrrM)rr argsortr/rNr)r5rP descendingstablerHoutputsr<s r%rrsR@c40~~e*EG  g1v& g1v& g 77r'cgrmr=r5sortedreturn_inverse return_countsrPs r%rrKs%(r'cgrmr=rs r%rrU r'cgrmr=rs r%rr_rr'cgrmr=rs r%rrisr'zpaddle.compat.uniquez paddle.uniquec2[R"UUUUUS9$)a Returns the unique elements of `input` in ascending order. Args: input(Tensor): The input tensor, it's data type should be float32, float64, int32, int64. sorted(bool, optional): Does not affect the return result, same as PyTorch. 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. dim(int, optional): The axis to apply unique. If None, the input will be flattened. Default: None. Returns: tuple (output, inverse_indices, counts). `output` is the unique tensor for `input`. \ `inverse_indices` 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.compat.unique(x) >>> print(unique) Tensor(shape=[4], dtype=int64, place=Place(cpu), stop_gradient=True, [1, 2, 3, 5]) >>> _, inverse_indices, counts = paddle.compat.unique(x, return_inverse=True, return_counts=True) >>> print(inverse_indices) 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.compat.unique(x) >>> print(unique) Tensor(shape=[4], dtype=int64, place=Place(cpu), stop_gradient=True, [0, 1, 2, 3]) >>> unique = paddle.compat.unique(x, dim=0) >>> print(unique) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[2, 1, 3], [3, 0, 1]]) )rrrFr)r/rrs r%rrss%x == %#   r'>r(rFr$num_or_sectionszpaddle.compat.splitz paddle.splitc( ^U4SjnS Sjn[T[[45(a_[T5HPupVSn[U[5(a[ UR S55nOUnUS:dMA[SUSU35e [5(Ga[U[5(aUR S5nU[UR5-S:dS5eUS:aU[UR5-OUn[T[[45(af[RRT5(aA[T5H2up[U [5(dMTUR 5TU'M4 O-[T[ 5(d[S[T5S35e[T[ 5(a~TS:dS 5eU"TU"URU55m[T[5(a![[ R""UTU55$[[ R$"UTU55$[[ R""UTU55$[U[R&R(5(a [S 5e[U[ 5(aC[UR5U-S:dS5eUS:a[UR5U-OUnURn [T[ [[45(d [S 5e[T[ 5(aTS:dS 5eU"TU"URU55m[T[5(ad[RRT5(a[RR+T5m[[ R""UTU55$[[ R$"UTU55$[U[ 5(a XS:a[T5X::dS 5e[RRT5(a[RR+T5m[[ R""UTU55$)aN (PyTorch Compatible API) Split the input tensor into multiple sub-Tensors. Args: tensor (Tensor): A N-D Tensor. The data type is bool, bfloat16, float16, float32, float64, uint8, int8, int32 or int64. split_size_or_sections (int|list|tuple): If split_size_or_sections is an integer type, then tensor will be split into equally sized chunks (if possible). Last chunk will be smaller if the tensor size along the given dimension dim is not divisible by split_size. If split_size_or_sections is a list, then tensor will be split into len(split_size_or_sections) chunks with sizes in dim according to split_size_or_sections. Negative inputs are not allowed. For example: for a dim with 9 channels, [2, 3, -1] will not be interpreted as [2, 3, 4], but will be rejected and an exception will be thrown. dim (int|Tensor, optional): The dim along which to split, it can be a integer or a ``0-D Tensor`` with shape [] and data type ``int32`` or ``int64``. If :math::`dim < 0`, the dim to split along is :math:`rank(x) + dim`. Default is 0. Returns: tuple(Tensor), The tuple of segmented Tensors. Note: This is a pytorch compatible API that follows the function signature and behavior of torch.split. To use the original split of paddle, please consider `paddle.split` Examples: .. code-block:: pycon >>> import paddle >>> # x is a Tensor of shape [3, 8, 5] >>> x = paddle.rand([3, 8, 5]) >>> out0, out1, out2 = paddle.compat.split(x, split_size_or_sections=3, dim=1) >>> print(out0.shape) paddle.Size([3, 3, 5]) >>> print(out1.shape) paddle.Size([3, 3, 5]) >>> print(out2.shape) paddle.Size([3, 2, 5]) >>> out0, out1, out2 = paddle.compat.split(x, split_size_or_sections=[1, 2, 5], dim=1) >>> print(out0.shape) paddle.Size([3, 1, 5]) >>> print(out1.shape) paddle.Size([3, 2, 5]) >>> print(out2.shape) paddle.Size([3, 5, 5]) >>> # dim is negative, the real dim is (rank(x) + dim)=1 >>> out0, out1, out2 = paddle.compat.split(x, split_size_or_sections=3, dim=-2) >>> print(out0.shape) paddle.Size([3, 3, 5]) >>> print(out1.shape) paddle.Size([3, 3, 5]) >>> print(out2.shape) paddle.Size([3, 2, 5]) c>UT-nUT-nUS:XaU$[U5Vs/sHnTPM nnURU5 U$s snf)Nr)rangeappend) split_size shape_on_dim remaining_numnum_complete_section_sectionssplit_size_or_sectionss r% GetSplitSizesplit..GetSplitSizesf$'== +/EE A ' '166J0K0K1&0K  OOM *O s Ac[U5n[U[5(aX*:dX:a[SUSUSU35eX$)Nz:(InvalidArgument) The dim is expected to be in range of [-r\z ), but got )rurvry ValueError)shaperP shape_ranges r%GetShapeOnDimInRange#split..GetShapeOnDimInRangesZ%j c3  \!S%7 PQ\P]]_`k_llwx{w|}zr'rzWpaddle.compat.split expects split_sizes have only non-negative entries, but got size = z on dim z(rank(x) + dim) must >= 0zjThe type of 'split_size_or_sections' in split must be int, list or tuple in imperative mode, but received .z.split_size_or_sections must be greater than 0.zv'dim' is not allowed to be a pir.Value in a static graph: pir.Value can not be used for indexing python lists/tuples.z\The type of 'split_size_or_sections' in split must be int, list or tuple in imperative mode.zClen(split_size_or_sections) must not be more than input.shape[dim].)rPryreturnry)rvlisttuple enumerater ryr1rr rurr/utils _contain_varrar]r rsplit_with_numrwrxget_int_tensor_list) tensorrrPrri section_size shape_valindexr1 input_shapes ` r%rrs(@ (4-88()?@OAI,11 1 1! 45 ( a mnzm{|DEFDGH A c8 $ $((1+CS&&!+H-HH++.7sS&& ,tUm < <||(()?@@#,-C#DKE!$118N!9$&/u5$E 2C88 !789<  ,c 2 2)A- @ -&2&(rs#::& *A%( #  LL KK LL LL LL NN NN NN KK OO *0&BBBBBRRRR,RRRR,RRRR,RRRR,RRRR,RRRR,RRRR,RRRR,RRRR,RRRR, 6""6"Hoa ##" " s# &1 &1 &1 &1  &1RJ v$ ;= 26 ;= ;= ;=;= / ;=  ;=  ;=|v'#B= 26 B= B= B=B= / B=  B=  B=J  J A!H   v!:>R R R 7R R  R  Rjv!:>O O O 7O O  O  OdJ -*`* v" @8 @8 @8@8  @8  @8  @8F $'#& ( ( ("(! (  ( # ( ( %(#&    # !         $'$'    " "         %($'   #"      v$   =  =@9# MNlL lL,?lLFIlLlL  lLEs)(L: