|jUddlmZddlZddlmZmZddlmZmZddl Z ddl m Z ddl m Z m Z ddlmZmZmZdd lmZmZdd lmZdd lmZmZmZd d lmZd dlmZerddlm Z ddl m!Z!ddl"m#Z#edZ$de%d<gZ&eddgddg dMddddNd&Z'edgdgd' dOd dd(dPd-Z( dQdRd/Z)dSdTd0Z*e dUdVd6Z+e dWdXd8Z+ dYd:Z+e dWd1d;dZd=Z,e dWd[d?Z,eddgddgd3d@g dYdd;dAZ, d\d]dHZ-eddgddg d^dd;d_dJZ. d`dadLZ/dS)b) 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|Ut|tjjtjfst |}|j|krt||}trtj ||||St||\}}t|dgddt|dttt t"fdt|tt fr#|D] }t|dtt"fd!t%dit'}|||d } ||j} |d d |id | i| | 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) Nr&zx/input) r)uint16float16float32float64int32int64 complex64 complex128zmean/reduce_meanzaxis/dimzelements of axis/dimmean)r$keep_dim reduce_all reduce_meanXOuttypeinputsoutputsattrs)r9) isinstancerVarDescVarTypeDataTyperr%rr rr9rrrintlisttuplerrlocals"create_variable_for_type_inference append_op) r!r#r(r*r%r&r;itemhelperrC out_tensors b/lsinfo/ai/hellotax_ai/data_center/backend/venv/lib/python3.11/site-packages/paddle/tensor/stat.pyr9r94sT %$,"6 !FGG 6.u55E 7e  QA*{1dG55557a@@ D         *sD%:>qwGG 8J'    )r!r#) correctionr&unbiased bool | NonerSfloatc||dkrtd||rdnd}nt|}tjr,t rt j|||ng||||Stst|dgdd t||d |}|j tj kr tj n|j } tj tj||z d |||| } tjtj|d tjtj| d z } | | } |dkrn| |z } tj| tj| } tjr.tj| dkrt+jdd n| } d | _| | z} d} d|jvr | | } t3|jdkr!|dkrtjd| j} | j |j kr| |j }n| }|tj|||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 given?r0r!r2r3r4varTr)r(r*r%r6rzDegrees of freedom is <= 0.) stacklevelctj|d}tj||dt d|j}|S)Nr6r%rnan)paddlearangenumel index_fillflattenrVreshapeshape)r&indicesout_nans rQ _replace_nanzvar.._replace_nans`- 7;;;# KKMM7AuU||  '#)   rR) stop_gradient) ValueErrorrVr`is_compiled_with_cudar rr[r rr9r%r2r3sumpowrrbastypemaximum zeros_likeanywarningswarnrjrflen to_tensorassign)r!r#rTr(r*rSr&actual_correctionur%rPn corrected_nriresults rQr[r[sf aKLLL#+4CC!*-- #%% *@*B*B z $DD"             s555u    QdD!!Ag77FNNQWE AEAgDJ  FLOOW--  Z  '11 A AA++ n *;77    ! # # G ;!3C(D(D G M7A F F F F $K+J AG||!\*--  17||q.!33%az7OPPP 17""""17++  fc""" MrRTcLtst|dgddtjrDtr6||ng}||rdnd}nt |}t j|||||Stdit}tj |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!rZstdNrXrY) r rr`rlrVrr~r[rKsqrt)r!r#rTr(r*rSr&s rQr~r~+sp " # #  s555u   #%%B*@*B*BB'ttR   (1cJJz**Jz!T7HjAAA ////C ;s  rRcNtrtj|St|tst dt d it}|tj j j }| dd|id|i|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 numelrbr^sizeInputr>)r@rArBN)rb)r rrbrDr TypeErrorrrKrLrrErFINT64rM)r!r*rOr&s rQrbrbts0 |A!X&& ;9:: :111177,&,8   fgq\E3<PPP rR.rHmodeLiteral['min']tuple[Tensor, Tensor]cdSNrr!r#r(rr*s rQ nanmedianrs  CrRLiteral['avg', 'min']cdSrrrs rQrr SrRavgcxt|ttjjfst dt|t tfr"t|dkrtd|dvrtd|d|duot|t tf }|g}n=t|trt |}nt|tr|g}tr"tj ||||\}}d|_nt|d gd d t!dit#}|||d } ||j}|tj}|d d |i||d | d|_|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.rminMode & is not supported. Must be avg or min.NTr=)r5r6r2r3r4r1r)r#r(r)r> MedianIndexr?r)r)rDrr`pirValuerrIrJrurkrHr rrrjrrrKrLr%r6rM) r!r#r(rr* need_indexr&rgrOrCs rQrrs\ a(FJ$45 6 6FDEEE$u &&;3t99>>9::: >!!MMMMNNNd"MZtUm-L-L)LJ | D% Dzz D#  v%'4$?? W $  I I I     55FHH55'4@@77@@;;FLII888    !% u}}}G| rRr0tuple[Tensor, Tensor] | NonecdSrr)r!r#r(rr*r&s rQmedianr(s  CrR int | NonecdSrrrs rQrr4rrRrct|ttjjfst dt|t tfr"t|dkrtdt|j }|dkr|dvs Jdn3|1t|tr ||kr|| kstd|dvrtd |d |du}|d }|g}nt|tr|g}|d kr4|j tj ks|tj}t!j||||| \} } d | _|dkr|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]]) rrr)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)).rrrTrr0r)rDrr`rrrrIrJrurkrfrHr%r4ror3rrrj) r!r#r(rr*r&dimsneed_idx is_flattenvaluesrgs rQrr>sl a(FJ$45 6 6FDEEE$u &&;3t99>>9::: qw<!!MMMMNNN4H |  | D#  v u}}QW66 HHV^ $ $mAtWdDDDOFG G u}}}w rRrq'float | Sequence[float] | Tensor | Noneint | list[int] | None interpolation ignore_nanc tttjjfst dt|t tfr|g}nt|ttfr#t|dkrtdnxt|ttjjfrCt|j dkrtdt|j dkr|g}nt d|D]S}ts(t|ttjjfrn|dks|dkrtdTdvrtd tj }tj } tjddg|z} nKttrgg} } D]X} t| t r | |kr| | kstd | dkr| |z} | | d| | <Ytt!t d} tj| | t| dkrtjdnltj| d| d | dnAtt r |kr| kstd dkr|z d| <} | d }g}|D]}t+rtj|j}|r|||dz zI||dz z}j dz }tj||}tj| d ||}||tjfd}g}|D]P}||}|stj|}n|| }||Qt|dkrtj|d}n|d}|tj|||S|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. out (Tensor|None, optional): The output tensor. Default: None. 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(r^) fill_valuec^dkrHtj|tj}tj |Stj|tj}dkrtj |}dkr|Stj|tj}tj |}dkr|Sdkr8| j| jzdz S|||jz  j}tj| j| j|S)Nrr#rrrr) r`roundror5take_along_axisfloorceilr%lerp) indexidx indices_below tensor_below indices_upper tensor_upperweightsr#r sorted_tensorr!s rQ_compute_indexz)_compute_quantile.._compute_indexds I % %,u%%,,V\::C)-4HHH H U++226<@@ H $ $!1}4L G # #  E**11&,?? - =t    H $ $  J & &##AG,,|/B/B17/K/KK =// <<<DDQWMM{    ( (    ( (    rRr) rDrr`rrrrHrVrIrJrurkrfr rdappendrangemoveaxisisnan logical_notrmr rvr% full_likewhererrsortsqueezerestackrw)r!rr#r(rrr&q_numr out_shapeaxis_srcaxis_dst axis_singlemask valid_countsrgr last_indexnumsrrBretrs` ` ` @rQ_compute_quantilers>P a(FJ$45 6 675666!c5\""  C Ae} % %  q66Q;;455 5  A&*"23 4 4 qw<>> 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]]) F)r#r(rrr&r)r!rr#r(rr*r&s rQquantilers1`   #    rRlist[int] | int | Nonec,t|||||dS)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]]) T)r#r(rrr)r!rr#r(rs rQ nanquantilers.X   #    rR)NFN)r!rr#r'r(r)r*r+r%r,r&r-r.r)NNFN)r!rr#r'rTrUr(r)r*r+rSrVr&r-r.r)NTFN) r!rr#r'rTr)r(r)r*r+r.rr)r!rr*r+r.r)...) r!rr#rHr(r)rrr*r+r.r)....) r!rr#r'r(r)rrr*r+r.r)NFrN)r!rr#rHr(r)rrr*r+r&rr.r) r!rr#rr(r)rrr*r+r.r)NFrFN)r!rrrr#rr(r)rr rr)r&r-r.r)NFrN)r!rrrr#rr(r)rr r*r+r&r-r.r)NFr) r!rrrr#rr(r)rr r.r)0 __future__rrstypingrrtyping_extensionsrrr`rpaddle.frameworkr r paddle.utils.decorator_utilsr r r base.data_feederrrcommon_ops_importr frameworkrrr manipulationrmathrcollections.abcrrpaddle._typingrr __annotations____all__r9r[r~rbrrrrrrrRrQrs#""""""))))))))11111111  DCCCCCCC((((((EEEEEEEEEE......)((((((((((((#6 #w&%11(, y #yyyyy21yxG9ug6677(,  vvvvvv87vv(, FFFFFR"""""J         (+"%      xxxxv   ),        "%  c7^fe_vuoNN    [ [[[[ON[B$($,|||||~#w&%11$($, WWWWWW21Wz$($, SSSSSSSrR