o p i(@sddlmZddlmZmZmZddlZddlmZddlm Z ddl m Z er:ddl m Z dd lmZdd lmZdd lmZdd lmZgZehd ddd dVdWddZGdddeZGdddeZ dXdYd$d%Zed&d'hd(d)d *   dZd[d.d/ZGd0d1d1ejZd\d7d8Zd]d9d:Zd]d;d<Z dXdYd=d%Zed&d'hd>d?ddd@d^dBdCZed&d'hdDdEddd@d^dFdGZGdHdIdIeZ ed&d'hdJdKd  d_dd@d`dPdQZ!ed&d'hdRdSd  d_dd@d`dTdUZ"dS)a) annotations) TYPE_CHECKINGAny NamedTupleN)_C_ops)Variable)in_dynamic_mode)Sequence)Tensor)Size2)nn)ForbidKeywordsDecorator>axisZnum_or_sectionsnamexzpaddle.compat.splitz paddle.splitZ illegal_keys func_nameZ correct_nametensorr split_size_or_sectionsint | Sequence[int]dimintreturntuple[Tensor, ...]c sfdd}ddd}tttfr:tD]#\}}d}t|tr)t|d}n|}|dkr9td |d |qtrt|trG|d}|t |j dksTJd |dkr_|t |j n|}tttfrt j rtD]\}} t| tr||<qrnttstd td ttrdksJd|||j |ttrtt||Stt||Stt||St|t jjrtdt|trt |j |dksJd |dkrt |j |n|}|j } ttttfstdttrAdksJd|||j |ttr8t j r/t j tt||Stt||St|tr[| |dkr[t | |ks[Jdt j rht j tt||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:: python >>> 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) [3, 3, 5] >>> print(out1.shape) [3, 3, 5] >>> print(out2.shape) [3, 2, 5] >>> out0, out1, out2 = paddle.compat.split(x, split_size_or_sections=[1, 2, 5], dim=1) >>> print(out0.shape) [3, 1, 5] >>> print(out1.shape) [3, 2, 5] >>> print(out2.shape) [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) [3, 3, 5] >>> print(out1.shape) [3, 3, 5] >>> print(out2.shape) [3, 2, 5] cs@|}|}|dkr|Sfddt|D}|||S)Nrcsg|]}qSr).0_rr[/home/app/PaddleOCR-VL/.venv_paddleocr/lib/python3.10/site-packages/paddle/tensor/compat.py osz/split..GetSplitSize..)rangeappend)Z split_sizeZ shape_on_dimZ remaining_numZnum_complete_sectionsectionsrrr GetSplitSizeis  zsplit..GetSplitSizerrrcSsFt|}t|tr|| ks||krtd|d|d|||S)Nz:(InvalidArgument) The dim is expected to be in range of [-, z ), but got )len isinstancer ValueError)shaperZ shape_rangerrrGetShapeOnDimInRangeus z#split..GetShapeOnDimInRangerzWpaddle.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)rrrr)r'listtuple enumeraterritemr(r r&r)paddleutilsZ _contain_var TypeErrortypersplitZsplit_with_numpirValueZget_int_tensor_list) rrrr$r*iZ section_sizeZ shape_valindexr/Z input_shaperrrr4)s @                   r4c@eZdZUded<ded<dS) SortRetTyper valuesindicesN__name__ __module__ __qualname____annotations__rrrrr:  r:c@r9) MinMaxRetTyper r;r<Nr=rrrrrCrBrCFout-Tensor | tuple[Tensor, Tensor] | list[Tensor]expect_multipleboolcC|durdSts td|rKt|ttfrt|dkr&tdt|dt|dtj r6t|dtj sItdt|ddt|dd dSt|tj s[td t|ddS NzlUsing `out` static graph CINN backend is currently not supported. Directly return the tensor tuple instead. rz-Expected a list or tuple of two tensors, got z instead.rz-Expected Tensor type in the tuple/list, got (r%z ) instead.zExpected a Tensor, got r RuntimeErrorr'r-r,r&r2r3r0r rDrFrrr_check_out_status,  rNrrzpaddle.compat.sortz paddle.sortinput descendingstablecCsTt|ddt||||\}}|dur$t||dt||dt||dS)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)rFNrrJr;r<)rNrZargsortr0assignr:)rQrrRrSrDZoutputsr<rrrsorts @ rVcsheZdZUdZded<ded<ded<ded<ehddd d  ddfdd ZdddZZS)Unfolda A compatible version of paddle.nn.Unfold: The keyword arguments are in non-plural forms, example: `kernel_size` instead of `kernel_sizes`. `padding` restricts the size of the input to be 1(int) or 2, Size4 is not allowed. All the input parameters allow `Tensor` or `pir.Value` as inputs, and will be converted to lists. Other aspects are the same. To use a more input-flexible version of Unfold, please refer to `paddle.nn.Unfold`. Args: kernel_size(int|list|tuple|Tensor): The size of convolution kernel, should be [k_h, k_w] or an integer k treated as [k, k]. stride(int|list|tuple|Tensor, optional): The strides, should be [stride_h, stride_w] or an integer stride treated as [sride, stride]. For default, strides will be [1, 1]. padding(int|list|tuple|Tensor, optional): The paddings of each dimension, should be a single integer or [padding_h, padding_w]. If [padding_h, padding_w] was given, it will expanded to [padding_h, padding_w, padding_h, padding_w]. If an integer padding was given, [padding, padding, padding, padding] will be used. By default, paddings will be 0. dilation(int|list|tuple|Tensor, optional): The dilations of convolution kernel, should be [dilation_h, dilation_w], or an integer dilation treated as [dilation, dilation]. For default, it will be [1, 1]. Examples: .. code-block:: python >>> import paddle >>> x = paddle.randn((100, 3, 224, 224)) >>> unfold = paddle.compat.Unfold(kernel_size=[3, 3]) >>> result = unfold(x) >>> print(result.shape) [100, 27, 49284] r kernel_sizes dilationspaddingsstrides>rXrZrYr[zpaddle.compat.Unfoldzpaddle.nn.UnfoldrrJr kernel_sizedilationpaddingstriderNonecst||||dSN)super__init__)selfr\r]r^r_ __class__rrrcos zUnfold.__init__rQr cCs@ddd}tjj|||j||j||jdd||j|jdS)NFcSsv|}trt|tjjtjfr|}n t|ttt fs t d|r9t|ttfr9t |dkr9t dt |d|S)Nz^paddle.compat.Unfold does not allow paddle.Tensor or pir.Value as inputs in static graph mode.rzOThe `padding` field of paddle.compat.Unfold can only have size 1 or 2, now len=z2. Did you mean to use paddle.nn.Unfold() instead?) r r'r0r5r6r tolistr,r-rr2r&r()r size_checkresrrrto_list_if_necessary~s z,Unfold.forward..to_list_if_necessaryT)rh)rXr[rZrYrF)r Z functionalZunfoldrXr[rZrYr)rdrQrjrrrforward}s  zUnfold.forward)rJrrJ) r\r r]r r^r r_r rr`)rQr rr ) r>r?r@__doc__rArrcrl __classcell__rrrerrWJs  rWrstrargsrkwargscsVdfdd fdd}d}d}t}|t}|dkr%|dkrX|dkr2\}}n|dkr?d }|d }n|d }|d }|dusTt|ttjjfrWn/|dkr|rcd }nd vrld }nd vrd }t|ttjjfs|dur|durt|ttjjfst|turd dt|d||fS)Nc s\ddD}|ddDd|}dd|d|dd d }t|S) NcSsg|]}t|jqSrr3r>)rvrrrr szO_min_max_param_checker..invalid_arguments_exception..cSs$g|]\}}|dt|jqS)=rs)rkrtrrrr s$r%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) )extenditemsjoinr2)Z error_prefixZ type_strs signature error_msg)rprrqrrinvalid_arguments_exceptions z;_min_max_param_checker..invalid_arguments_exceptioncs*d}z|}W|Stydwra)KeyError)keyri)r|rqrr try_get_keyss  z,_min_max_param_checker..try_get_keysFrrJrkeepdimrotherzBThe second input must be int or Tensor or implicit None in compat.z, but received z. )rr)r&r'rr0r5r6r3r)rrprqr dim_or_otherrnum_argsZ total_arg_numr)rprr|rqr_min_max_param_checkersP        rcCsL|j}|tjks|tjks|tjks|tjkr$|js"td|ddSdS)z@Prevent integral input tensor type to have `stop_gradient=False`zTensors with integral type: 'z' should stop gradient.N)dtyper0Zint32int64Zuint8int16 stop_gradientr2rQZin_dtyperrr_min_max_tensor_allow_grads     rcCs8|j}|tjks|tjks|tjkrtd|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)rr0Zfloat16Zbfloat16rr2rrrr_min_max_allow_cpu_composites    rcCrHrIrKrMrrrrNrOzpaddle.compat.minz paddle.min)rDTensor | MinMaxRetTypec Ot|tjjtjfstdt|jdt|t dg|Ri|\}}d}|dur7t |dt |}not|t rt |d|j rtrx|jsxt|tj||dd}tj|||d}|rit||d }n=t|j|d|j|dd }n.t|||d\} } d| _t| | d }nt|tjgtj|jd d }n t |dt||}|durt|trt|j|d t|j|d |St|||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 ''minNFTrrrrTrZdevicerrJ)r'r0r5r6r r2r3r>rrrNrrndimr place is_gpu_placerZargmintake_along_axisrCsqueeze_rZmin_with_indexrzerosrminimumrUr;r< rQrDrprqrrretr<r;valsZindsrrrrsZa           rzpaddle.compat.maxz paddle.maxc Or) 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]]) rrmaxNFTrrrTrrrJ)r'r0r5r6r r2r3r>rrrNrrrr rrrZargmaxrrCrrZmax_with_indexrrrmaximumrUr;r<rrrrrsZa           rc@r9) MedianRetTyper r;r<Nr=rrrrrFrBrzpaddle.compat.medianz paddle.median int | Noner%tuple[Tensor, Tensor] | Tensor | NoneTensor | MedianRetTypecCs|dur t|dtj|||dd}|durt|||S|St|dtj|||dd\}}|durNt||dt||dt|d|ddSt||dS) 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]) NFrrrmodeTrrJrT)rNr0medianrUrrQrrrDresultr;r<rrrrKs 2     rzpaddle.compat.nanmedianzpaddle.nanmediancCs|dur t|dtj|||dd}|durt|||S|St|dtj|||dd\}}t|t|}|durWt||dt||dt|d|ddSt||dS) a Returns the median of the values in input, ignoring NaN values. Args: input (Tensor): The input tensor. dim (int|None, optional): The dimension to reduce. If None, computes the nanmedian 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 nanmedian (dim=None), out must be a single tensor. For nanmedian along a dimension (dim specified, including dim=-1), out must be a tuple of two tensors (values, indices). Returns: Tensor|MedianRetType: The median values, ignoring NaN. 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 >>> 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]) NFrrTrrJrT)rNr0 nanmedianrUrZ zeros_likerrrrrrs"3     r)r)rr rrrrrrrk)rDrErFrG)rPFFN) rQr rrrRrGrSrGrr:)rrorprrqr)rQr ) rQr rprrDrErqrrr)NF) rQr rrrrGrDrrr)# __future__rtypingrrrr0rZbase.frameworkrZ frameworkr collections.abcr r Zpaddle._typingr r Zpaddle.utils.decorator_utilsr__all__r4r:rCrNrVrWrrrrrrrrrrrrs         0 C O D  @