\;j.yddlZddlmZddlmZddlmZmZddlmZm Z ddl m Z ddl m Z mZd d lmZd d lmZgZdd Zdd ZddZddZddZddZddZddZddZy)N)_C_ops)DataType)in_dynamic_modein_dynamic_or_pir_mode) check_typecheck_variable_and_dtype)Variable) LayerHelpercore)_get_reduce_axis_with_tensor)wherectrtj|||St||\}}t |dgddt |dt tttfdt|ttfr|D]}t |dt tfdtd it}|||d}|j|j}|jdd|id |i| |S) a{ Computes the mean of the input tensor's elements along ``axis``. Args: x (Tensor): The input Tensor with data type float32, float64. axis (int|list|tuple, 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. 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, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. 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] zx/input)uint16float16float32float64zmean/reduce_meanzaxis/dimzelements of axis/dim)dimkeep_dim reduce_all reduce_meanXOuttypeinputsoutputsattrs)mean)rrr rr rintlisttupler isinstancer locals"create_variable_for_type_inferencedtype append_op) xaxiskeepdimnameritemhelperrouts [G:\00. PROJECTS\API\Inventory\templateJSON\kerjaOCR\Lib\site-packages\paddle/tensor/stat.pyr r sp{{1dG,,7a@ D  7    *sD%:>> 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] r)rrrvarTr)r+r,int64g?) rr r paddlesumpowr'castnumelastypeonesr stop_gradient) r)r*unbiasedr+r,ur/r'n one_consts r0r4r4zs@   s5u  QdD!A **VZZQ+T7 NC GGE FLLOW-  S71 A AKKAGG, !i-S) 4AO1HC Jr1ctst|dgddtdit}t j |S)aF Computes the standard-deviation of ``x`` along ``axis`` . Args: x (Tensor): The input Tensor with data type float16, float32, float64. axis (int|list|tuple, 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, 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)r3std)rr r4r%r6sqrt)r)r*r>r+r,r/s r0rCrCs;d " # s5u  //C ;;s r1c8trtj|St|ts t dt dit}|jtjjj}|jdd|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, int32, int64, complex64, complex128. name (str, 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 numelr'sizeInputr)rrr)r:)rrr:r$r TypeErrorr r%r&r VarDescVarTypeINT64r()r)r,r.r/s r0r:r:s0||A!X&9: :1177,,&&,,8  fgq\E3<P r1cht|ttjjfs t dt|t tfrt|dk(r td|g}n/t|tr t |}nt|tr|g}trtj|||St|dgddtd it!}||d}|j#|j$}|j#|j$}|j'dd|i||d| |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. 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 median along ``axis`` of ``x``. The output dtype is the same as `x`. 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 *In median, the input x should be a Tensor.rzAxis list should not be empty.r)int32r5rrrr nanmedianr*r+)r MedianIndexr)rQ)r$r r6pirValuerJr"r#len ValueErrorr!rrrQr r r%r&r'r()r)r*r+r,r.rr/medianss r0rQrQs^ a(FJJ$4$45 6DEE$u &3t9>9:: | D% Dz D# v411  I   5FH5'277@;;AGGD88   r1c t|ttjjfs t dt r|jdk(r tdd}t|j}|dk(r |dvsJdd}|d}|rtj|}d}n0t|tr ||kr|| k\s td|dkr||z }|j|}|d z }tj||d z|d \}} |jtj j"j$t&j(fvrd nd } |d zdk(rZtj*||g|d z g|g tj*||g|g|d zg z} tj,| | dz } n4tj,tj*||g|g|d zg | } | tj.tj,tj0|| |z|dz} |r,|r| j3d g|z} | S| j3g} | S|s| j5|} | S)a> Compute the median along the specified axis. Args: x (Tensor): The input Tensor, it's data type can be bool, float16, float32, float64, int32, int64. axis (int, optional): The axis along which to perform median calculations ``axis`` should be 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. 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 median along ``axis`` of ``x``. If data type of ``x`` is float64, data type of results will be float64, otherwise data type will be float32. Examples: .. code-block:: python >>> import paddle >>> 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.]]) rOrz/In median, the size of input x should not be 0.F)rNz8when input 0-D, axis can only be [-1, 0] or default NoneTzJIn median, axis should be none or an integer in range [-rank(x), rank(x)).r )r*largestrr)axesstartsendsrGrrR)r$r r6rTrUrJrrHrWrVshapeflattenr!topkr'r rKrLFP64rFLOAT64slicer9r7isnanreshapesqueeze) r)r*r+r, is_flattendimsszkth tensor_topkidxr' out_tensors r0medianroaswl a(FJJ$4$45 6DEEQVVq[JKKJ 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=float64, place=Place(cpu), stop_gradient=True, 3.50000000) >>> y2 = paddle.quantile(y, q=0.5, axis=1) >>> print(y2) Tensor(shape=[4], dtype=float64, 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=float64, 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=float64, place=Place(cpu), stop_gradient=True, [[nan ], [2.80000000], [4.80000000], [6.80000000]]) Fr*r+rrr)rr*r+s r0quantiler]sB Qg% PPr1c"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): The q for calculate quantile, which should be in range [0, 1]. If q is a list, each q will be calculated and the first dimension of output is same to the number of ``q`` . 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 axises. 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. 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``. In order to obtain higher precision, data type of results will be float64. 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=float64, place=Place(cpu), stop_gradient=True, 5.) >>> y2 = paddle.nanquantile(x, q=0.5, axis=1) >>> print(y2) Tensor(shape=[2], dtype=float64, 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=float64, 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=float64, 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=float64, place=Place(cpu), stop_gradient=True, [[nan], [nan]]) Trrrs r0 nanquantilersF Qg$ OOr1)NFN)NTFN)N)NFF)NF)r6rpaddle.base.libpaddlerpaddle.frameworkrrbase.data_feederrr common_ops_importr frameworkr r mathrsearchr__all__r r4rCr:rQrorrrrDr1r0rsd"*DC(). Xv2j7t"JPfslCLAQHCPr1