ёif%SSKJr SSKrSSKJrJr SSKJrJr SSK r SSK J r SSK J r J r SSKJrJrJr SS KJrJr SS KJr SS KJrJrJr S S KJr S SKJr \(aSSKJ r SSK J!r! SSK"J#r# \Sr$S\%S'/r&\"SS/SS/5S-SSS.S.Sjjj5r'\"S/S/S.5S/S SS.S0Sjjj5r(S1S2Sjjr)S3S4Sjjr*\S5S6S"jj5r+\S7S8S#jj5r+S9S$jr+\S7S S%.S:S&jjj5r,\S7S;S'jj5r,\"SS/SS/S!S(/5S9SS%.S)jj5r,S<S=S*jjr-\"SS/SS/5S>SS%.S?S+jjj5r.S@SAS,jjr/g)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_Interpolationxinputaxisdim)dtypeoutcUb_[U[RR[R45(d [ U5nUR U:wa [X5n[5(a[R"XX%S9$[X5upa[US/SQS5 [US[[[ ["4S5 [U[[ 45(a!UHn[US[["4S5 M [%S 0['5D6nXUS.n UR)UR 5n UR+SS U0S U 0U S 9 U $) ap 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) r&zx/input) booluint16float16float32float64int32int64 complex64 complex128zmean/reduce_meanzaxis/dimzelements of axis/dim)r$keep_dim reduce_all reduce_meanXOuttypeinputsoutputsattrs)mean) isinstancerVarDescVarTypeDataTyperr%rr rr<rrrintlisttuplerrlocals"create_variable_for_type_inference append_op) r!r#keepdimnamer%r&r3itemhelperr; out_tensors R/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/paddle/tensor/stat.pyr<r<4s:T %$,,"6"6 !FGG.u5E 77e QA{{1G557@      *sD%:>qwwG 8J'  )r!r#) correctionr&cUbUS:wa [S5eUb U(aSOSnO [U5n[5(d[US/SQS5 [ XSU5nUR [ R:Xa[ RO UR n [ R"[ R"X- S 5XXIS 9n [ R"[ R"U5S 5[ R"[ R"U 5S 5- n U RU 5n US :wa}X- n [ R"U [ R"U 55n [ R"5(a3[ R "U S :*5(a["R$"S S S9 OU n SU lX-n Sn S UR(;aU "U 5n [+UR(5S :Xa%US :Xa[ R,"S U R&S9n U R UR :waU RUR 5nOU nUb[ R."X5 U$U$)a 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] rz0Only one of unbiased and correction may be giveng?gr!r+r,r-varTr)rGrHr%r/rzDegrees of freedom is <= 0.) stacklevelc[R"UR5SS9n[R"UR 5US[ S55R UR5nU$)Nr/r%rnan)paddlearangenumel index_fillflattenfloatreshapeshape)r&indicesout_nans rL _replace_nanvar.._replace_nansS-- 7;## KKM7AuU| '#))  rM) stop_gradient) ValueErrorr[r rr<r%rVr+r,sumpowrrXastypemaximum zeros_likeanywarningswarnrbr]len to_tensorassign)r!r#unbiasedrGrHrNr&actual_correctionur%rKn corrected_nr`results rLrQrQsf aKLL#+C!*-    s5u  QdD!Agg7FNNQWWE AEADJ  FLLOW-  Z '1 A AA+ nn **;7   ! ! # # ;!3C(D(D MM7A F $KJ AGG|!*-  177|q.!3%%az7O7OP 177"""177+  f" MrMc[5(d[US/SQS5 [S0[5D6n[R "U5$)a 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!rPstd)r rrQrDrVsqrt)r!r#rorGrHr&s rLrvrv s>p " # # s5u  //C ;;s rMcB[5(a[R"U5$[U[5(d [ S5e[ S0[5D6nUR[RRRS9nURSSU0SU0S9 U$)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 numelrTsizeInputr6)r8r9r:)rX)r rrXr=r TypeErrorrrDrErr>r?INT64rF)r!rHrJr&s rLrXrX`s0||A!X&&9: :1177,,&&,,8  fgq\E3<P rM.modecgNrwr!r#rGr~rHs rL nanmedianrs rMcgrrwrs rLrrrMcV[U[[RR45(d [ S5e[U[ [45(a[U5S:Xa [S5eUS;a[SUS35eUSL=(a [U[ [45(+nUc/nO9[U[5(a [ U5nO[U[5(aU/n[5(a![R"XX#5upgSUlO[US /S QS 5 [!S0[#5D6nXUS .n UR%UR&5nUR%[R(5nUR+S S U0XgS .U S9 SUlUS:Xa U(aXg4$U$)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.avgminMode & is not supported. Must be avg or min.NTr5)r.r/r+r,r-r*r)r#rGr~)r6 MedianIndexr7r)r)r=rrVpirValuer|rBrCrlrcrAr rrrbrrrDrEr%r/rF) r!r#rGr~rH need_indexr&r^rJr;s rLrrs\ a(FJJ$4$45 6 6DEE$u &&3t9>9:: >!5&LMNNd"MZtUm-L)LJ | D% Dz D#  v''?  $  I   5FH54@77@;;FLLI88  !% u}| rMr(cgrrw)r!r#rGr~rHr&s rLmedianrs rMcgrrwrs rLrr rrMrc[U[[RR45(d [ S5e[U[ [45(a[U5S:Xa [S5e[UR5nUS:XaUS;dS5eO.Ub+[U[5(a X:aX*:d [S5eUS;a[S US 35eUSLnUcS nUc/nO[U[5(aU/nUS :Xa=UR[R:XdUR[R5n[ R""XX#US 9upS U lUS:Xa U(aX4$U $)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)).rrrTrr(r)r=rrVrrr|rBrCrlrcr]rAr%r-rfr,rrrb) r!r#rGr~rHr&dimsneed_idx is_flattenvaluesr^s rLrr*sfl a(FJJ$4$45 6 6DEE$u &&3t9>9:: qww!5&LMNN4H |  | D#  v u}QWW6 HHV^^ $mmAWDOF G u} rMcB ^^^^[T[[RR45(d [ S5e[U[ [45(aU/nO[U[[45(a[U5S::a [S5eO{[U[[RR45(aA[UR5S:a [S5e[UR5S:XaU/nO [ S5eUHZn[5(d1[U[[RR45(a OUS:dUS:dMQ[S5e TS;a[S T35e[TR5n[TR5n Tc [R"T5mSmS/U-n GO*[T[5(a//pTHMn [U [ 5(a X:aX*:d [S 5eU S:aX-n U RU 5 SX'MO [[![T5*S55n [R""TX5m[U 5S:Xa[R"T5mSmOa[R"TU SU S 5mU SmO=[T[ 5(a TU:aTU*:d [S 5eTS:aTU- mSU T'TR%5n U R'5R)TS S 9n/nUHn[+5(a[R,"UTR.S9nU(aURX~S- -5 MPX~S- -nTRTS- n[R0"UUS9n[R2"U R5TS S 9UU5nURU5 M [R6"TT5mUUUU4Sjn/nUHJnU"U5nU(d[R8"UTS9nOUR;U 5nURU5 ML [U5S:a[R<"US5nOUSnUb[R>"UU5 U$U$)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 zQAxis should be None, int, or a list, element should in range [-rank(x), rank(x)).rT)r#rGrT) fill_valuecr>TS:XaI[R"U5R[R5n[R"T UTS9$[R "U5R[R5nTS:wa[R"T UTS9nTS:XaW$[R "U5R[R5n[R"T UTS9nTS:XaU$TS:Xa:URT R5WRT R5-S- $XRUR5- RT R5n[R"WRT R5URT R5U5$)Nrr#rrrr) rVroundrfr.take_along_axisfloorceilr%lerp) indexidx indices_below tensor_below indices_upper tensor_upperweightsr# interpolation sorted_tensorr!s rL_compute_index)_compute_quantile.._compute_indexPsh I %,,u%,,V\\:C))-4H H U+226<<@ H $!11}4L G #  E*11&,,? -- =t  H $  J &##AGG,|/B/B177/KK // <<DDQWWM{{    (    (   rMr) r=rrVrrr|rAr[rBrCrlrcr]r rZappendrangemoveaxisisnan logical_notrdr rmr% full_likewhererisortsqueezer\stackrn)r!qr#rGr ignore_nanr&q_numr out_shapeaxis_srcaxis_dst axis_singlemask valid_countsr^r last_indexnumsrr:retrs` ` ` @rL_compute_quantilers$P a(FJJ$4$45 6 6566!c5\"" C Ae} % % q6Q;45 5  A&**"2"23 4 4 qww>> 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#rGrrr&r)r!rr#rGrrHr&s rLquantilers'`   #  rMc [UUUUUSS9$)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#rGrrr)r!rr#rGrs rL nanquantilers$X   #  rM)NFN)r!rr#int | Sequence[int] | NonerGr)rH str | Noner%zDTypeLike | Noner& Tensor | Nonereturnr)NNFN)r!rr#rroz bool | NonerGr)rHrrNr[r&rrr)NTFN) r!rr#rror)rGr)rHrrrr)r!rrHrrr)...) r!rr#rArGr)r~Literal['min']rHrrtuple[Tensor, Tensor])....) r!rr#rrGr)r~Literal['avg', 'min']rHrrr)NFrN)r!rr#rArGr)r~rrHrr&ztuple[Tensor, Tensor] | Nonerr) r!rr#z int | NonerGr)r~rrHrrr)NFrFN)r!rrz'float | Sequence[float] | Tensor | Noner#int | list[int] | NonerGr)rr rr)r&rrr)NFrN)r!rr float | Sequence[float] | Tensorr#rrGr)rr rHrr&rrr)NFr) r!rrrr#zlist[int] | int | NonerGr)rr rr)0 __future__rrjtypingrrtyping_extensionsrrrVrpaddle.frameworkr r paddle.utils.decorator_utilsr r r base.data_feederrrcommon_ops_importr frameworkrrr manipulationrmathrcollections.abcrrpaddle._typingrr __annotations____all__r<rQrvrXrrrrrrwrMrLrs#)1  D(EE.((#6  #w&%1(, y #y y $yy  y  y y y2yxG9ug67(,  kk k $kk k  kk k k8k`(, = = $== =  =  =@"J                 (+"%   $          xv   ),           &     "%         c7^fe_vuoN    [ [O[B$($,| |.| !| | " |  | | |~#w&%1$($, WW W'W !W W " W  W W W2Wz$($, S S'S !S S " S  SrM