x-jtddlmZddlmZmZmZmZddlmZddl Z ddl m Z ddl m Z ddl mZddlmZdd lmZd d lmZd d lmZmZmZmZmZd d lmZer ddlmZddl mZgdZ dZ!e j"e j#e j$e j%e j&e j'e j(e j)e j*e j+g Z,e,\ Z-Z.Z/Z0Z1Z2Z3Z4Z5Z6e-e/e/e0e1e2e3e4e-e6g e/e.e/e0e1e2e3e4e.e6g e/e/e/e0e1e2e3e4e/e6g e0e0e0e0e1e2e3e4e0e6g e1e1e1e1e1e2e3e4e1e6g e2e2e2e2e2e2e3e4e2e3g e3e3e3e3e3e3e3e4e3e3g e4e4e4e4e4e4e4e4e4e4g e-e.e/e0e1e2e3e4e5e6g e6e6e6e6e6e3e3e4e6e6g g Z7de8e,DZ9eddhdddgdZ:GddeZ;edd hd!d" dhdd$did+Z<edd hd,d- dhdd$did.Z=djd0Z>Gd1d2eZ?dkd8Z@dld9ZAdld:ZBedd hd;d<dd$dmd?ZCedd hd@dAdd$dmdBZDGdCdDeZEdndodFZFGdGdHeZGedd hdIdJ dpdqdNZHe drdsdUZIe drdtdXZIe drdudYZIe drdvdZZIedd hd[d\ dwd^ZIehd_d`da dxdydfZJdS)z) 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.|dkrtSdS)N paddle_triton)r)names V/var/www/html/banglarbhumi/venv/lib/python3.11/site-packages/paddle/compat/__init__.py __getattr__r&;s!  """cti|]5\}}ttD]\}}||ft||6S) enumerate_types_promote_matrix).0it1jt2s r% r2[s_ 26"" 2Hoa #r'xyzpaddle.compat.equalz paddle.equal) illegal_keys func_name correct_nameinputrotherreturnboolc|j|jkr'tj||St|j|j}|j|kr||}|j|kr||}tj||S)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)r8r9 common_dtypes r%rrbsD {ek!!u--22444##EK==L {l"" <(( {l"" <((  E5 ) ) . . 0 00r'c$eZdZUded<ded<dS) MedianRetTypervaluesindicesN__name__ __module__ __qualname____annotations__r)r'r%rFrF"NNNOOOOOr'rFaxiszpaddle.compat.medianz paddle.medianFoutdim int | NonekeepdimrQ%tuple[Tensor, Tensor] | Tensor | NoneTensor | MedianRetTypecD|Ct|dtj|||d}|tj|||S|St|dtj|||d|\}}|t |d|d St || S) 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]) NFrrOrTmodeT)rOrTrYrQrrrGrH)rr>rassignrFr8rRrTrQresultrGrHs r%rrsd {#u%%%u3eLLL ? M&# & & &J #t$$$ - W5c    ? AA??? ?FG<<<>> 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]) NFrrXTrrrZ)rr>r r[maximum zeros_likerFr\s r%r r sf {#u%%%!%c7OOO ? M&# & & &J #t$$$ * W5    .&*;G*D*DEE ? M&#a& ) ) ) M'3q6 * * * AA??? ?FG<<<>> import paddle >>> seed = paddle.compat.seed() )r default_cpu_generatorr!r>)r!s r%r!r!"s3  % ' ' , , . .D K Kr'c$eZdZUded<ded<dS) MinMaxRetTyperrGrHNrIr)r'r%rere2rNr'rer6strargsrkwargscdfd fd}d}d}t}|tz}|dkr |dkro|dkr\}}n0|dkrd}|d}n|d }|d}|&t|ttjjfr nf|dkr`|r d}nId vr d }nzO_min_max_param_checker..invalid_arguments_exception..9s!444!T!WW%444r'cFg|]\}}|dt|jS)=rm)r-kros r%rpzO_min_max_param_checker..invalid_arguments_exception..:s3OOO1Q33a!133OOOr', 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) )extenditemsjoin TypeError) error_prefix type_strs signature error_msgrgr6rhs r%invalid_arguments_exceptionz;_min_max_param_checker..invalid_arguments_exception8s44t444 OO OOOPPPIIi((  [I [ [< [ [*3 [ [4= [ [NW [ [ [ ###r'cRd} |}n#t$r dwxYw|SN)KeyError)keyresr}rhs r% try_get_keysz,_min_max_param_checker..try_get_keysFsI :+CC : : :--//T 9 : s$FrrrTrRr9zBThe second input must be int or Tensor or implicit None in compat.z, but received z. )rj)len isinstancer r>pirValuernra) r6rgrhr dim_or_otherrTnum_args total_arg_numr}s ``` @r%_min_max_param_checkerr7s< $ $ $ $ $ $ $ $LG4yyHs6{{*Mq))+++ !   q==$( !L'' ]]7L"l9--GG'<..L"l9--G  : 8VZ%56$ $ .-// /  !    87LL%e} F""%g !,6:;K0LMM855777  --// /  <(FJ4D)EFF !   c ) ))) CQZ C Ckop|k}k} C C C      r'c|j}|tjks0|tjks |tjks|tjkr|jstd|ddSdS)z@Prevent integral input tensor type to have `stop_gradient=False`zTensors with integral type: 'z' should stop gradient.N)r=r>int32int64uint8int16 stop_gradientrxr8in_dtypes r%_min_max_tensor_allow_gradr{sz{HFL  v| # # v| # # v| # #" QQQQ    $ #r'c|j}|tjks |tjks|tjkrt d|ddS)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>float16bfloat16rrxrs r%_min_max_allow_cpu_compositersd{HFN"" v & & v| # # X X X X    $ #r'zpaddle.compat.minz paddle.min-Tensor | tuple[Tensor, Tensor] | list[Tensor]Tensor | MinMaxRetTypect|tjjtjfs%t dt |jdt|tdg|Ri|\}}d}|&t|dtj |}nmt|tr2t|d|j rtr|jst#|tj||d}tj|||}|rt)|| }nt)|||| }nt-j|||d\} } d| _t)| | }n[t)|tjgtj|j  }n%t|dt-j||}|kt|t(rAtj|j|d tj|j|d ntj|||S) 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 ''rNFTrOrTrOrZr=devicerr)rr>rrrrxrnrJrrrrrandimr place is_gpu_placerargmintake_along_axisresqueeze_r min_with_indexrzerosrminimumr[rGrH r8rQrgrhrrTretrHrGvalsindss r%rrsB efj. > ? ?  _U H\ _ _ _   u%%%25J4JJJ6JJL' C#u%%%j L# & &!2#t$$$ :    ?)A)A)C)C ?,U333!-L$OOO/7'vwGGGCC'%LAA ' 0 0l 0 C CCC $2<% d&*"#4>>> fl5;CC #u%%%nUL11  c= ) ) $ M#*c!f - - - M#+s1v . . . . M#s # # # Jr'zpaddle.compat.maxz paddle.maxct|tjjtjfs%t dt |jdt|tdg|Ri|\}}d}|&t|dtj |}nmt|tr2t|d|j rtr|jst#|tj||d}tj|||}|rt)|| }nt)|||| }nt-j|||d\} } d| _t)| | }n[t)|tjgtj|j  }n%t|dt-j||}|kt|t(rAtj|j|d tj|j|d ntj|||S) 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]]) rrrNFTrrrZrrr)rr>rrrrxrnrJrrrrrarr rrrargmaxrrerr max_with_indexrrrr_r[rGrHrs r%rr2sB efj. > ? ?  _U H\ _ _ _   u%%%25J4JJJ6JJL' C#u%%%j L# & &2#t$$$ :    ?)A)A)C)C ?,U333 -L$OOO/7'vwGGGCC'%LAA ' 0 0l 0 C CCC $2<% d&*"#4>>> fl5;CC #u%%%nUL11  c= ) ) $ M#*c!f - - - M#+s1v . . . . M#s # # # Jr'c$eZdZUded<ded<dS) SlogdetResultrsign logabsdetNrIr)r'r%rrs'LLLr'rSlogdetResult | Nonectj||\}}|6tj||dtj||dt ||S)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.) rPNrr)r slogdet_v2r>r[r)r3rQrrs r%rrs_R's333OD)  dCF### iQ((( y ) ))r'c$eZdZUded<ded<dS) SortRetTyperrGrHNrIr)r'r%rrrNr'rzpaddle.compat.sortz paddle.sort descendingstablect|dtj||||\}}|6tj||dtj||dt ||S)a5 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_multipleNrrrZ)rr argsortr>r[r)r8rRrrrQoutputsrHs r%rrsv@c40000~eS*fEEGW  gs1v&&& gs1v&&& gw 7 7 77r'.sortedreturn_inverse Literal[True] return_countstuple[Tensor, Tensor, Tensor]cdSrr)r8rrrrRs r%rrKs %(Cr'Literal[False]tuple[Tensor, Tensor]cdSrr)rs r%rrU  Cr'cdSrr)rs r%rr_rr'cdSrr)rs r%rris Sr'zpaddle.compat.uniquez paddle.uniqueTc4tj|||||S)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]]) )rrrOr)r>rrs r%rrss-x = %#     r'>r3rOr$num_or_sectionszpaddle.compat.splitz paddle.splittensorsplit_size_or_sectionsint | Sequence[int]tuple[Tensor, ...]c fd}dd}tttfrltD]\\}}d}t|tr#t |d}n|}|dkrtd|d|]trt|tr|d}|t|j zdks Jd |dkr|t|j zn|}tttfrgtj rGtD]7\}} t| tr||<8n5tt s td td tt rdks Jd |||j |ttr#tt!j||Stt!j||Stt!j||St|tjjrtd t|t rDt|j |zdks Jd |dkrt|j |zn|}|j } tt ttfstdtt rĉdks Jd |||j |ttratj rtj tt!j||Stt!j||St|t r/| |dkr#t| |ks Jdtj rtj tt!j||S)a (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|z}|z}|dkr|Sfdt|D}|||S)Nrcg|]}Sr)r))r-_rs r%rpz/split..GetSplitSize..s'+,&r')rangeappend) split_size shape_on_dim remaining_numnum_complete_sectionsectionsrs r% GetSplitSizezsplit..GetSplitSizesu$'== +/EE A  ' '056J0K0KH OOM * * *Or'rRrar:ct|}t|tr%|| ks||krtd|d|d|||S)Nz:(InvalidArgument) The dim is expected to be in range of [-rtz ), but got )rrra ValueError)shaperR shape_ranges r%GetShapeOnDimInRangez#split..GetShapeOnDimInRangesr%jj c3   k\!!SK%7%7 }Q\}}`k}}x{}}Szr'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].N)rRrar:ra)rlisttupler*r rar@rr rrr>utils _contain_varrxrnr rsplit_with_numrrget_int_tensor_list) rrrRrrr. section_size shape_valindexr@ input_shapes ` r%rrsK@     (4-88 ()?@@  OA|I,11 ) 1 1! 4 455 ( a HnzHHEFHH PL c8 $ $ ((1++CS&&&!+++-H++++.77sS&&&& ,tUm < < |(()?@@ !#,-C#D#D!!KE4!$11!8N!9$&&/u52C88 < !788<<<  ,c 2 2 L)A---@.--&2\&(<(r paddle.baser paddle.base.frameworkr paddle.frameworkr paddle.utils.decorator_utilsr rjrproxyrrrrrrrcollections.abcrr__all__r&rint8rrrrfloat32float64r;rr+u1i1i2i4i8f2f4f8b1bfr,r*rArrFrr r!rerrrrrrrrrrrr)r'r%r s#"""""::::::::::::&&&&&& ******A@@@@@%$$$$$((((((   ###  L K L L L N N N K O *0&BBBBBRRRR,RRRR,RRRR,RRRR,RRRR,RRRR,RRRR,RRRR,RRRR,RRRR, 6"" s# &1&1&1  &1RJ v$ ;= 26 ;=;=;=;=;=  ;=|v'#B= 26 B=B=B=B=B=  B=J     J A!A!A!A!H         v!:>RRRRR  Rjv!:>OOOOO  OdJ -*-*-*-*-*`* v" @8@8@8@8  @8F $'#& (((( ( %(#&        $'$'        %($'  v$   ===  =@999# MNlLlLlLlL  lLlLlLr'