o p in@sBUddlmZddlZddlmZmZddlmZmZddl Z ddl m Z ddl m Z m Z ddlmZmZmZdd lmZmZdd lmZdd lmZmZmZd d lmZd dlmZeroddlm Z ddl m!Z!ddl"m#Z#edZ$de%d<gZ&eddgddg   dTddddUd&d'Z'edgdgd(    dVd dd)dWd.d/Z(  0  dXdYd1d2Z)dZd[d3d4Z*e 5 5 5d\d]d:d;Z+e 5 5 5 5d^d_d=d;Z+   > d`d?d;Z+e 5 5 5 5d^d]d@dAZ,e 5 5 5 5d^dadCdAZ,eddgddgd7dDg   > d`dEdAZ,   F dbdcdLdMZ-   FdddedOdPZ.   FdddfdRdSZ/dS)g) annotationsN) TYPE_CHECKINGLiteral) TypeAliasoverload)_C_ops)in_dynamic_modein_dynamic_or_pir_mode)ParamAliasDecoratorparam_two_aliasparam_two_alias_one_default) check_typecheck_variable_and_dtype)Variable) LayerHelperconvert_np_dtype_to_dtype_core)cast)_get_reduce_axis_with_tensor)Sequence)Tensor) DTypeLike)linearhigherlowermidpointnearestr_InterpolationxinputaxisdimF)dtypeoutrint | Sequence[int] | Nonekeepdimboolname str | Noner$DTypeLike | Noner% Tensor | Nonereturnc Cs|durt|tjjtjfst|}|j|krt||}tr(t j ||||dSt ||\}}t |dgddt |dttttfdt|ttfrX|D] }t |dttfdqLtdit}|||d } ||j} |jd d |id | i| d | S)aX Computes the mean of the input tensor's elements along ``axis``. Args: x (Tensor): The input Tensor with data type bool, bfloat16, float16, float32, float64, int32, int64, complex64, complex128. alias: ``input`` axis (int|list|tuple|None, optional): The axis along which to perform mean calculations. ``axis`` should be int, list(int) or tuple(int). If ``axis`` is a list/tuple of dimension(s), mean is calculated along all element(s) of ``axis`` . ``axis`` or element(s) of ``axis`` should be in range [-D, D), where D is the dimensions of ``x`` . If ``axis`` or element(s) of ``axis`` is less than 0, it works the same way as :math:`axis + D` . If ``axis`` is None, mean is calculated over all elements of ``x``. Default is None. alias: ``dim`` keepdim (bool, optional): Whether to reserve the reduced dimension(s) in the output Tensor. If ``keepdim`` is True, the dimensions of the output Tensor is the same as ``x`` except in the reduced dimensions(it is of size 1 in this case). Otherwise, the shape of the output Tensor is squeezed in ``axis`` . Default is False. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. dtype (str): The desired data type of returned tensor. Default: None. out(Tensor|None, optional): The output tensor. Default: None. Returns: Tensor, results of average along ``axis`` of ``x``, with the same data type as ``x``. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[[1., 2., 3., 4.], ... [5., 6., 7., 8.], ... [9., 10., 11., 12.]], ... [[13., 14., 15., 16.], ... [17., 18., 19., 20.], ... [21., 22., 23., 24.]]]) >>> out1 = paddle.mean(x) >>> print(out1.numpy()) 12.5 >>> out2 = paddle.mean(x, axis=-1) >>> print(out2.numpy()) [[ 2.5 6.5 10.5] [14.5 18.5 22.5]] >>> out3 = paddle.mean(x, axis=-1, keepdim=True) >>> print(out3.numpy()) [[[ 2.5] [ 6.5] [10.5]] [[14.5] [18.5] [22.5]]] >>> out4 = paddle.mean(x, axis=[0, 2]) >>> print(out4.numpy()) [ 8.5 12.5 16.5] >>> out5 = paddle.mean(x, dtype='float64') >>> out5 Tensor(shape=[], dtype=float64, place=Place(gpu:0), stop_gradient=True, 12.50000000) N)r%zx/input) r(uint16float16float32float64int32int64Z complex64Z complex128zmean/reduce_meanzaxis/dimzelements of axis/dimmean)r#Zkeep_dim reduce_allZ reduce_meanXOuttypeinputsoutputsattrs)r4) isinstancerVarDescVarTypeZDataTyperr$rr rr4rrrintlisttuplerrlocals"create_variable_for_type_inference append_op) r r"r'r)r$r%r5itemhelperr< out_tensorrIY/home/app/PaddleOCR-VL/.venv_paddleocr/lib/python3.10/site-packages/paddle/tensor/stat.pyr44sFJ     r4)r r") correctionr%unbiased bool | NonerKfloatcCs|dur |dkr td|dur|rdnd}nt|}ts't|dgddt||d |}|jtjkr7tjn|j} tj t ||d |||| d } t t |d t t | d } | | } |d kr| |} t| t| } trt| d krtjdd dn| } d | _| | } dd} d |jvr| | } t|jd kr|d krtjd | jd} | j|jkr| |j}n| }|durt|||S|S)ay Computes the variance of ``x`` along ``axis`` . .. 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, ``var(input=tensor_x, dim=1, ...)`` is equivalent to ``var(x=tensor_x, axis=1, ...)``. Args: x (Tensor): The input Tensor with data type float16, float32, float64. alias: ``input``. axis (int|list|tuple|None, optional): The axis along which to perform variance calculations. ``axis`` should be int, list(int) or tuple(int). alias: ``dim``. - If ``axis`` is a list/tuple of dimension(s), variance is calculated along all element(s) of ``axis`` . ``axis`` or element(s) of ``axis`` should be in range [-D, D), where D is the dimensions of ``x`` . - If ``axis`` or element(s) of ``axis`` is less than 0, it works the same way as :math:`axis + D` . - If ``axis`` is None, variance is calculated over all elements of ``x``. Default is None. unbiased (bool, optional): Whether to use the unbiased estimation. If ``unbiased`` is True, the divisor used in the computation is :math:`N - 1`, where :math:`N` represents the number of elements along ``axis`` , otherwise the divisor is :math:`N`. Default is True. keep_dim (bool, optional): Whether to reserve the reduced dimension in the output Tensor. The result tensor will have one fewer dimension than the input unless keep_dim is true. Default is False. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. correction (int|float, optional): Difference between the sample size and sample degrees of freedom. Defaults to 1 (Bessel's correction). If unbiased is specified, this parameter is ignored. out (Tensor|None, optional): Output tensor. Default is None. Returns: Tensor, results of variance along ``axis`` of ``x``, with the same data type as ``x``. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1.0, 2.0, 3.0], [1.0, 4.0, 5.0]]) >>> out1 = paddle.var(x) >>> print(out1.numpy()) 2.6666667 >>> out2 = paddle.var(x, axis=1) >>> print(out2.numpy()) [1. 4.3333335] Nrz0Only one of unbiased and correction may be giveng?gr r/r0r1varTr )r'r)r$r3rzDegrees of freedom is <= 0.) stacklevelcSs6tj|dd}t||dtd|j}|S)Nr3r$rnan)paddleZarangenumelZ index_fillflattenrNreshapeshape)r%indicesZout_nanrIrIrJ _replace_nanszvar.._replace_nan) stop_gradient) ValueErrorrNrrr4r$rTr/r0sumpowrrUastypemaximumZ zeros_likeanywarningswarnr[rXlen to_tensorZassign)r r"rLr'r)rKr%Zactual_correctionur$rHnZ corrected_nrZresultrIrIrJrPsR3       rPTcCs2ts t|dgddtdit}t|S)aP Computes the standard-deviation of ``x`` along ``axis`` . Args: x (Tensor): The input Tensor with data type float16, float32, float64. axis (int|list|tuple|None, optional): The axis along which to perform standard-deviation calculations. ``axis`` should be int, list(int) or tuple(int). If ``axis`` is a list/tuple of dimension(s), standard-deviation is calculated along all element(s) of ``axis`` . ``axis`` or element(s) of ``axis`` should be in range [-D, D), where D is the dimensions of ``x`` . If ``axis`` or element(s) of ``axis`` is less than 0, it works the same way as :math:`axis + D` . If ``axis`` is None, standard-deviation is calculated over all elements of ``x``. Default is None. unbiased (bool, optional): Whether to use the unbiased estimation. If ``unbiased`` is True, the standard-deviation is calculated via the unbiased estimator. If ``unbiased`` is True, the divisor used in the computation is :math:`N - 1`, where :math:`N` represents the number of elements along ``axis`` , otherwise the divisor is :math:`N`. Default is True. keepdim (bool, optional): Whether to reserve the reduced dimension(s) in the output Tensor. If ``keepdim`` is True, the dimensions of the output Tensor is the same as ``x`` except in the reduced dimensions(it is of size 1 in this case). Otherwise, the shape of the output Tensor is squeezed in ``axis`` . Default is False. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, results of standard-deviation along ``axis`` of ``x``, with the same data type as ``x``. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1.0, 2.0, 3.0], [1.0, 4.0, 5.0]]) >>> out1 = paddle.std(x) >>> print(out1.numpy()) 1.6329932 >>> out2 = paddle.std(x, unbiased=False) >>> print(out2.numpy()) 1.490712 >>> out3 = paddle.std(x, axis=1) >>> print(out3.numpy()) [1. 2.081666] r rOstdNrI)r rrPrCrTsqrt)r r"rLr'r)r%rIrIrJri s 8  ricCs`trt|St|tstdtd it}|jt j j j d}|j dd|id|id|S) a Returns the number of elements for a tensor, which is a 0-D int64 Tensor with shape []. Args: x (Tensor): The input Tensor, it's data type can be bool, float16, float32, float64, uint8, int8, int32, int64, complex64, 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 number of elements for the input Tensor, whose shape is []. Examples: .. code-block:: python >>> import paddle >>> x = paddle.full(shape=[4, 5, 7], fill_value=0, dtype='int32') >>> numel = paddle.numel(x) >>> print(numel.numpy()) 140 zx must be a Tensor in numelrUrRsizeZInputr7)r9r:r;N)rU)r rrUr=r TypeErrorrrCrDrr>r?ZINT64rE)r r)rGr%rIrIrJrU`s  rU.r@modeLiteral['min']tuple[Tensor, Tensor]cCdSNrIr r"r'rmr)rIrIrJ nanmedianrsLiteral['avg', 'min']cCrprqrIrrrIrIrJrsrtavgc Cs@t|ttjjfs tdt|ttfrt|dkrt d|dvr*t d|d|duo5t|ttf }|dur=g}nt|trGt|}nt|t rO|g}t r`t ||||\}}d|_n4t|d gd d tdit}|||d } ||j}|tj}|jd d |i||d | dd|_|dkr|r||fS|S)a? Compute the median along the specified axis, while ignoring NaNs. If the valid count of elements is a even number, the average value of both elements in the middle is calculated as the median. Args: x (Tensor): The input Tensor, it's data type can be int32, int64, float16, bfloat16, float32, float64. axis (None|int|list|tuple, optional): The axis along which to perform median calculations ``axis`` should be int or list of int. ``axis`` should be in range [-D, D), where D is the dimensions of ``x`` . If ``axis`` is less than 0, it works the same way as :math:`axis + D`. If ``axis`` is None, median is calculated over all elements of ``x``. Default is None. keepdim (bool, optional): Whether to reserve the reduced dimension(s) in the output Tensor. If ``keepdim`` is True, the dimensions of the output Tensor is the same as ``x`` except in the reduced dimensions(it is of size 1 in this case). Otherwise, the shape of the output Tensor is squeezed in ``axis`` . Default is False. mode (str, optional): Whether to use mean or min operation to calculate the nanmedian values when the input tensor has an even number of non-NaN elements along the dimension ``axis``. Support 'avg' and 'min'. Default is 'avg'. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor or tuple of Tensor. If ``mode`` == 'min' and ``axis`` is int, the result will be a tuple of two tensors (nanmedian value and nanmedian index). Otherwise, only nanmedian value will be returned. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[float('nan'), 2. , 3. ], [0. , 1. , 2. ]]) >>> y1 = x.nanmedian() >>> print(y1.numpy()) 2.0 >>> y2 = x.nanmedian(0) >>> print(y2.numpy()) [0. 1.5 2.5] >>> y3 = x.nanmedian(0, keepdim=True) >>> print(y3.numpy()) [[0. 1.5 2.5]] >>> y4 = x.nanmedian((0, 1)) >>> print(y4.numpy()) 2.0 >>> y5 = x.nanmedian(mode='min') >>> print(y5.numpy()) 2.0 >>> y6, y6_index = x.nanmedian(0, mode='min') >>> print(y6.numpy()) [0. 1. 2.] >>> print(y6_index.numpy()) [1 1 1] >>> y7, y7_index = x.nanmedian(1, mode='min') >>> print(y7.numpy()) [2. 1.] >>> print(y7_index.numpy()) [1 1] >>> y8 = x.nanmedian((0,1), mode='min') >>> print(y8.numpy()) 2.0 *In median, the input x should be a Tensor.rAxis list should not be empty.rvminMode & is not supported. Must be avg or min.NTr6)r2r3r/r0r1r.rs)r"r'rm)r7Z MedianIndexr8rz)rs)r=rrTpirValuerlrArBrdr\r@r rrsr[rrrCrDr$r3rE) r r"r'rmr)Z need_indexr%rYrGr<rIrIrJrssHN       cCrprqrIrrrIrIrJmedianrtr int | NonecCrprqrIrrrIrIrJrrtrzc Cs(t|ttjjfs tdt|ttfrt|dkrt dt|j }|dkr0|dvs/Jdn|durFt|t rB||krB|| ksFt d|dvrRt d |d |du}|dur\d }|durcg}nt|t rk|g}|d kr{|j tj ks{|tj}t||||\}} d | _|d kr|r|| fS|S)a Compute the median along the specified axis. .. 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``. When an alias replacement occurs, the default parameter for mode setting is min instead of avg. For example, ``median(input=tensor_x, dim=1, ...)`` is equivalent to ``median(x=tensor_x, axis=1, ...)``. Args: x (Tensor): The input Tensor, it's data type can be bfloat16, float16, float32, float64, int32, int64. alias: ``input``. axis (int|None, optional): The axis along which to perform median calculations ``axis`` should be int. alias: ``dim``. ``axis`` should be in range [-D, D), where D is the dimensions of ``x`` . If ``axis`` is less than 0, it works the same way as :math:`axis + D`. If ``axis`` is None, median is calculated over all elements of ``x``. Default is None. keepdim (bool, optional): Whether to reserve the reduced dimension(s) in the output Tensor. If ``keepdim`` is True, the dimensions of the output Tensor is the same as ``x`` except in the reduced dimensions(it is of size 1 in this case). Otherwise, the shape of the output Tensor is squeezed in ``axis`` . Default is False. mode (str, optional): Whether to use mean or min operation to calculate the median values when the input tensor has an even number of elements in the dimension ``axis``. Support 'avg' and 'min'. Default is 'avg'. When an alias replacement occurs, the default parameter for mode setting is min instead of avg. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor or tuple of Tensor. If ``mode`` == 'avg', the result will be the tensor of median values; If ``mode`` == 'min' and ``axis`` is None, the result will be the tensor of median values; If ``mode`` == 'min' and ``axis`` is not None, the result will be a tuple of two tensors containing median values and their indices. When ``mode`` == 'avg', if data type of ``x`` is float64, data type of median values will be float64, otherwise data type of median values will be float32. When ``mode`` == 'min', the data type of median values will be the same as ``x``. The data type of indices will be int64. Examples: .. code-block:: python >>> import paddle >>> import numpy as np >>> x = paddle.arange(12).reshape([3, 4]) >>> print(x) Tensor(shape=[3, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[0 , 1 , 2 , 3 ], [4 , 5 , 6 , 7 ], [8 , 9 , 10, 11]]) >>> y1 = paddle.median(x) >>> print(y1) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 5.50000000) >>> y2 = paddle.median(x, axis=0) >>> print(y2) Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [4., 5., 6., 7.]) >>> y3 = paddle.median(x, axis=1) >>> print(y3) Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [1.50000000, 5.50000000, 9.50000000]) >>> y4 = paddle.median(x, axis=0, keepdim=True) >>> print(y4) Tensor(shape=[1, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[4., 5., 6., 7.]]) >>> y5 = paddle.median(x, mode='min') >>> print(y5) Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, 5) >>> median_value, median_indices = paddle.median(x, axis=1, mode='min') >>> print(median_value) Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True, [1, 5, 9]) >>> print(median_indices) Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True, [1, 1, 1]) >>> # cases containing nan values >>> x = paddle.to_tensor(np.array([[1,float('nan'),3,float('nan')],[1,2,3,4],[float('nan'),1,2,3]])) >>> y6 = paddle.median(x, axis=-1, keepdim=True) >>> print(y6) Tensor(shape=[3, 1], dtype=float64, place=Place(cpu), stop_gradient=True, [[nan ], [2.50000000], [nan ]]) >>> median_value, median_indices = paddle.median(x, axis=1, keepdim=True, mode='min') >>> print(median_value) Tensor(shape=[3, 1], dtype=float64, place=Place(cpu), stop_gradient=True, [[nan], [2. ], [nan]]) >>> print(median_indices) Tensor(shape=[3, 1], dtype=int64, place=Place(cpu), stop_gradient=True, [[1], [1], [0]]) rwrrx)rNz8when input 0-D, axis can only be [-1, 0] or default NoneNzJIn median, axis should be none or an integer in range [-rank(x), rank(x)).ryr{r|Trvrz)r=rrTr}r~rlrArBrdr\rXr@r$r1r_r0rrr[) r r"r'rmr)dimsZneed_idxZ is_flattenr%rYrIrIrJr(s<t     rq'float | Sequence[float] | Tensor | Noneint | list[int] | None interpolation ignore_nancs\tttjjfs tdt|ttfr|g}n5t|tt fr*t |dkr)t dn#t|ttjjfrIt |j dkr>t dt |j dkrH|g}ntd|D]}t s_t|ttjjfr_n |dksg|dkrkt dqOdvrwt d t j }tj }d urtddg|}nttrgg} } D]%} t| tr| |kr| | kst d | dkr| |} | | d|| <qttt  d} t| | t | dkrtdn2t| d| d | dn"ttr|kr| kst d dkr|7d|<} | jd d} g}|D]B}tr4tj|jd}|rB||| dq&|| d}j d}tj||d}t| jd d||}||q&tfdd}g}|D]}||}|stj|d}n||}||q|t |dkrt|d}|S|d}|S)a Compute the quantile of the input along the specified axis. Args: x (Tensor): The input Tensor, it's data type can be float32, float64, int32, int64. q (int|float|list|Tensor): The q for calculate quantile, which should be in range [0, 1]. If q is a list or a 1-D Tensor, each element of q will be calculated and the first dimension of output is same to the number of ``q`` . If q is a 0-D Tensor, it will be treated as an integer or float. axis (int|list, optional): The axis along which to calculate quantile. ``axis`` should be int or list of int. ``axis`` should be in range [-D, D), where D is the dimensions of ``x`` . If ``axis`` is less than 0, it works the same way as :math:`axis + D`. If ``axis`` is a list, quantile is calculated over all elements of given axes. If ``axis`` is None, quantile is calculated over all elements of ``x``. Default is None. keepdim (bool, optional): Whether to reserve the reduced dimension(s) in the output Tensor. If ``keepdim`` is True, the dimensions of the output Tensor is the same as ``x`` except in the reduced dimensions(it is of size 1 in this case). Otherwise, the shape of the output Tensor is squeezed in ``axis`` . Default is False. interpolation (str, optional): The interpolation method to use when the desired quantile falls between two data points. Must be one of linear, higher, lower, midpoint and nearest. Default is linear. ignore_nan: (bool, optional): Whether to ignore NaN of input Tensor. If ``ignore_nan`` is True, it will calculate nanquantile. Otherwise it will calculate quantile. Default is False. Returns: Tensor, results of quantile along ``axis`` of ``x``. In order to obtain higher precision, data type of results will be float64. zinput x should be a Tensor.rzq should not be emptyrz(q should be a 0-D tensor or a 1-D tensorz8Type of q should be int, float, list or tuple, or tensorzq should be in range [0, 1])rrrrrz[interpolation must be one of 'linear', 'lower', 'higher', 'nearest' or 'midpoint', but got NzQAxis should be None, int, or a list, element should in range [-rank(x), rank(x)).rT)r"r'rR)Z fill_valuecsdkrt|tj}tj|dSt|tj}dkr*tj|d}dkr0|St|tj}tj|d}dkrG|SdkrQ||dS|||jj}t|j|j|S)Nrr"rrrr ) rTroundr_r2Ztake_along_axisfloorceilr$Zlerp)indexidxZ indices_belowZ tensor_belowZ indices_upperZ tensor_upperweightsr"rZ sorted_tensorr rIrJ_compute_indexJs0   z)_compute_quantile.._compute_indexr)r=rrTr}r~rlr@rNrArBrdr\rXrrVappendrangeZmoveaxisisnanZ logical_notr]r rer$Z full_likewhererasortZsqueezerWstack)r rr"r'rrZq_numrZ out_shapeZaxis_srcZaxis_dstZ axis_singlemaskZ valid_countsrYr last_indexnumsrr;r%rIrrJ_compute_quantiles&              "      r float | Sequence[float] | TensorcCt|||||ddS)a Compute the quantile of the input along the specified axis. If any values in a reduced row are NaN, then the quantiles for that reduction will be NaN. Args: x (Tensor): The input Tensor, it's data type can be float32, float64, int32, int64. q (int|float|list|Tensor): The q for calculate quantile, which should be in range [0, 1]. If q is a list or a 1-D Tensor, each element of q will be calculated and the first dimension of output is same to the number of ``q`` . If q is a 0-D Tensor, it will be treated as an integer or float. axis (int|list, optional): The axis along which to calculate quantile. ``axis`` should be int or list of int. ``axis`` should be in range [-D, D), where D is the dimensions of ``x`` . If ``axis`` is less than 0, it works the same way as :math:`axis + D`. If ``axis`` is a list, quantile is calculated over all elements of given axes. If ``axis`` is None, quantile is calculated over all elements of ``x``. Default is None. keepdim (bool, optional): Whether to reserve the reduced dimension(s) in the output Tensor. If ``keepdim`` is True, the dimensions of the output Tensor is the same as ``x`` except in the reduced dimensions(it is of size 1 in this case). Otherwise, the shape of the output Tensor is squeezed in ``axis`` . Default is False. interpolation (str, optional): The interpolation method to use when the desired quantile falls between two data points. Must be one of linear, higher, lower, midpoint and nearest. Default is linear. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, results of quantile along ``axis`` of ``x``. Examples: .. code-block:: python >>> import paddle >>> y = paddle.arange(0, 8 ,dtype="float32").reshape([4, 2]) >>> print(y) Tensor(shape=[4, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[0., 1.], [2., 3.], [4., 5.], [6., 7.]]) >>> y1 = paddle.quantile(y, q=0.5, axis=[0, 1]) >>> print(y1) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 3.50000000) >>> y2 = paddle.quantile(y, q=0.5, axis=1) >>> print(y2) Tensor(shape=[4], dtype=float32, place=Place(cpu), stop_gradient=True, [0.50000000, 2.50000000, 4.50000000, 6.50000000]) >>> y3 = paddle.quantile(y, q=[0.3, 0.5], axis=0) >>> print(y3) Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[1.80000000, 2.80000000], [3. , 4. ]]) >>> y[0,0] = float("nan") >>> y4 = paddle.quantile(y, q=0.8, axis=1, keepdim=True) >>> print(y4) Tensor(shape=[4, 1], dtype=float32, place=Place(cpu), stop_gradient=True, [[nan ], [2.80000000], [4.80000000], [6.80000000]]) Fr"r'rrrr rr"r'rrIrIrJquantile}sJrlist[int] | int | NonecCr)a Compute the quantile of the input as if NaN values in input did not exist. If all values in a reduced row are NaN, then the quantiles for that reduction will be NaN. Args: x (Tensor): The input Tensor, it's data type can be float32, float64, int32, int64. q (int|float|list|Tensor): The q for calculate quantile, which should be in range [0, 1]. If q is a list or a 1-D Tensor, each element of q will be calculated and the first dimension of output is same to the number of ``q`` . If q is a 0-D Tensor, it will be treated as an integer or float. axis (int|list, optional): The axis along which to calculate quantile. ``axis`` should be int or list of int. ``axis`` should be in range [-D, D), where D is the dimensions of ``x`` . If ``axis`` is less than 0, it works the same way as :math:`axis + D`. If ``axis`` is a list, quantile is calculated over all elements of given axes. If ``axis`` is None, quantile is calculated over all elements of ``x``. Default is None. keepdim (bool, optional): Whether to reserve the reduced dimension(s) in the output Tensor. If ``keepdim`` is True, the dimensions of the output Tensor is the same as ``x`` except in the reduced dimensions(it is of size 1 in this case). Otherwise, the shape of the output Tensor is squeezed in ``axis`` . Default is False. interpolation (str, optional): The interpolation method to use when the desired quantile falls between two data points. Must be one of linear, higher, lower, midpoint and nearest. Default is linear. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, results of quantile along ``axis`` of ``x``. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor( ... [[0, 1, 2, 3, 4], ... [5, 6, 7, 8, 9]], ... dtype="float32") >>> x[0,0] = float("nan") >>> y1 = paddle.nanquantile(x, q=0.5, axis=[0, 1]) >>> print(y1) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 5.) >>> y2 = paddle.nanquantile(x, q=0.5, axis=1) >>> print(y2) Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [2.50000000, 7. ]) >>> y3 = paddle.nanquantile(x, q=[0.3, 0.5], axis=0) >>> print(y3) Tensor(shape=[2, 5], dtype=float32, place=Place(cpu), stop_gradient=True, [[5. , 2.50000000, 3.50000000, 4.50000000, 5.50000000], [5. , 3.50000000, 4.50000000, 5.50000000, 6.50000000]]) >>> y4 = paddle.nanquantile(x, q=0.8, axis=1, keepdim=True) >>> print(y4) Tensor(shape=[2, 1], dtype=float32, place=Place(cpu), stop_gradient=True, [[3.40000000], [8.20000000]]) >>> nan = paddle.full(shape=[2, 3], fill_value=float("nan")) >>> y5 = paddle.nanquantile(nan, q=0.8, axis=1, keepdim=True) >>> print(y5) Tensor(shape=[2, 1], dtype=float32, place=Place(cpu), stop_gradient=True, [[nan], [nan]]) TrrrrIrIrJ nanquantilesLr)NFN)r rr"r&r'r(r)r*r$r+r%r,r-r)NNFN)r rr"r&rLrMr'r(r)r*rKrNr%r,r-r)NTFN) r rr"r&rLr(r'r(r)r*r-rrq)r rr)r*r-r)...) r rr"r@r'r(rmrnr)r*r-ro)....) r rr"r&r'r(rmrur)r*r-r)NFrvN) r rr"rr'r(rmrur)r*r-r)NFrF)r rrrr"rr'r(rrrr(r-r)NFr) r rrrr"rr'r(rrr-r) r rrrr"rr'r(rrr-r)0 __future__rrbtypingrrZtyping_extensionsrrrTrZpaddle.frameworkrr Zpaddle.utils.decorator_utilsr r r Zbase.data_feederrrZcommon_ops_importrZ frameworkrrrZ manipulationrmathrcollections.abcrrZpaddle._typingrr__annotations____all__r4rPrirUrsrrrrrIrIrIrJs        |p @%   {     < W