o + i@s6ddlmZddlmZddlZddlZddlmZddlm Z m Z ddl m Z m Z mZddlmZddlmZdd lmZerTdd lmZdd lmZdd lmZmZgZe jjje jjje jjj e jjj!e jjj"e jjj#gZ$d`daddZ%d`daddZ&d`daddZ' d`dbddZ(    dcddd#d$Z)d`dad%d&Z*d`dad'd(Z+d`dad)d*Z,d`dad+d,Z-d`dad-d.Z.d`dad/d0Z/d`dad1d2Z0d`dad3d4Z1   dedfd7d8Z2d`dgd;d<Z3d`dad=d>Z4d`dad?d@Z5d`dadAdBZ6d`dadCdDZ7d`dadEdFZ8d`dadGdHZ9ed dIgd`dhdLdMZ:d`dadNdOZ; d`didTdUZ<  V W djdkd^d_Z=dS)l) annotations) TYPE_CHECKINGN)_C_ops) check_typecheck_variable_and_dtype)convert_np_dtype_to_dtype_corein_dynamic_or_pir_mode)Variable) LayerHelper)param_one_alias)Sequence)Tensor) DTypeLike ShapeLikexrname str | NonereturncCtsJdt|S)a Calculate elementwise sin of SparseTensor, requiring x to be a SparseCooTensor or SparseCsrTensor. .. math:: out = sin(x) Parameters: x (Tensor): The input Sparse Tensor with data type float32, float64, 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: A Sparse Tensor with the same data type and shape as ``x`` . Examples: .. code-block:: python >>> import paddle >>> dense_x = paddle.to_tensor([-2., 0., 1.]) >>> sparse_x = dense_x.to_sparse_coo(1) >>> out = paddle.sparse.sin(sparse_x) >>> out Tensor(shape=[3], dtype=paddle.float32, place=Place(cpu), stop_gradient=True, indices=[[0, 2]], values=[-0.90929741, 0.84147102]) >> import paddle >>> dense_x = paddle.to_tensor([-2., 0., 1.]) >>> sparse_x = dense_x.to_sparse_coo(1) >>> out = paddle.sparse.tan(sparse_x) >>> out Tensor(shape=[3], dtype=paddle.float32, place=Place(cpu), stop_gradient=True, indices=[[0, 2]], values=[2.18503976, 1.55740774]) r)r rZ sparse_tanrrrrtanXrrcCr)a Calculate elementwise asin of SparseTensor, requiring x to be a SparseCooTensor or SparseCsrTensor. .. math:: out = asin(x) Parameters: x (Tensor): The input Sparse Tensor with data type float32, float64, 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: A Sparse Tensor with the same data type and shape as ``x`` . Examples: .. code-block:: python >>> import paddle >>> dense_x = paddle.to_tensor([-2., 0., 1.]) >>> sparse_x = dense_x.to_sparse_coo(1) >>> out = paddle.sparse.asin(sparse_x) >>> out Tensor(shape=[3], dtype=paddle.float32, place=Place(cpu), stop_gradient=True, indices=[[0, 2]], values=[nan , 1.57079625]) r)r rZ sparse_asinrrrrasin{rrperm Sequence[int]cCstsJdt||S)a Changes the perm order of ``x`` without changing its data, requiring x to be a SparseCooTensor or SparseCsrTensor. .. math:: out = transpose(x, perm) Parameters: x (Tensor): The input Sparse Tensor with data type float32, float64. perm (list|tuple): Permute the input according to the data of perm. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: A transposed Sparse Tensor with the same data type as ``x``. Examples: .. code-block:: python >>> # doctest: +SKIP('indices overflow') >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> dense_x = paddle.to_tensor([[-2., 0.], [1., 2.]]) >>> sparse_x = dense_x.to_sparse_coo(1) >>> out = paddle.sparse.transpose(sparse_x, [1, 0]) >>> out Tensor(shape=[2, 2], dtype=paddle.float32, place=Place(gpu:0), stop_gradient=True, indices=[[0, 0]], values=[[-2., 0.], [ 1., 2.]]) r)r rZsparse_transpose)rrrrrr transposes$ r Faxisint | Sequence[int] | NonedtypeDTypeLike | Nonekeepdimboolc Csd}|dur d}t|}trt||||S|durg}n|g}|||d}|r2||j|dt|dgddt|d tt t t dt fdd}t |}|rX|j|d } n|j|jd } |j|d|id | i|d | S) a Computes the sum of sparse tensor elements over the given dimension, requiring x to be a SparseCooTensor or SparseCsrTensor. Args: x (Tensor): An N-D Tensor, the data type is bool, float16, float32, float64, int32 or int64. axis (int|list|tuple|None, optional): The dimensions along which the sum is performed. If :attr:`None`, sum all elements of :attr:`x` and return a Tensor with a single element, otherwise must be in the range :math:`[-rank(x), rank(x))`. If :math:`axis[i] < 0`, the dimension to reduce is :math:`rank + axis[i]`. dtype (str|None, optional): The dtype of output Tensor. The default value is None, the dtype of output is the same as input Tensor `x`. keepdim (bool, optional): Whether to reserve the reduced dimension in the output Tensor. The result Tensor will have one fewer dimension than the :attr:`x` unless :attr:`keepdim` is true, default value 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 summation operation on the specified axis of input Tensor `x`. if `x.dtype='bool'` or `x.dtype='int32'`, it's data type is `'int64'`, otherwise it's data type is the same as `x`. Examples: .. code-block:: python >>> import paddle >>> dense_x = paddle.to_tensor([[-2., 0.], [1., 2.]]) >>> sparse_x = dense_x.to_sparse_coo(1) >>> out1 = paddle.sparse.sum(sparse_x) >>> out1 Tensor(shape=[1], dtype=paddle.float32, place=Place(cpu), stop_gradient=True, indices=[0], values=1.) >>> out2 = paddle.sparse.sum(sparse_x, axis=0) >>> out2 Tensor(shape=[1, 2], dtype=paddle.float32, place=Place(cpu), stop_gradient=True, indices=[[0]], values=[[-1., 2.]]) >>> out3 = paddle.sparse.sum(sparse_x, axis=-1) >>> out3 Tensor(shape=[2], dtype=paddle.float32, place=Place(cpu), stop_gradient=True, indices=[[0, 1]], values=[-2., 3.]) >>> out4 = paddle.sparse.sum(sparse_x, axis=1, keepdim=True) >>> out4 Tensor(shape=[2, 1], dtype=paddle.float32, place=Place(cpu), stop_gradient=True, indices=[[0, 1]], values=[[-2.], [ 3.]]) FNT)r!r#r%)Zin_dtypeZ out_dtyperr&float32float64int16int32int64 sparse_sumr!r#outtypeinputsZoutputsattrs)rr rr-updater#rrintlisttupler1r r )create_sparse_variable_for_type_inference append_op) rr!r#r%rZ dtype_flagr3op_typehelperr/rrrsums@; r<cCr)a Calculate elementwise atan of SparseTensor, requiring x to be a SparseCooTensor or SparseCsrTensor. .. math:: out = atan(x) Parameters: x (Tensor): The input Sparse Tensor with data type float32, float64, 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: A Sparse Tensor with the same data type and shape as ``x`` . Examples: .. code-block:: python >>> import paddle >>> dense_x = paddle.to_tensor([-2., 0., 1.]) >>> sparse_x = dense_x.to_sparse_coo(1) >>> out = paddle.sparse.atan(sparse_x) >>> out Tensor(shape=[3], dtype=paddle.float32, place=Place(cpu), stop_gradient=True, indices=[[0, 2]], values=[-1.10714877, 0.78539819]) r)r rZ sparse_atanrrrratan4rr=cCr)a Calculate elementwise sinh of SparseTensor, requiring x to be a SparseCooTensor or SparseCsrTensor. .. math:: out = sinh(x) Parameters: x (Tensor): The input Sparse Tensor with data type float32, float64, 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: A Sparse Tensor with the same data type and shape as ``x`` . Examples: .. code-block:: python >>> import paddle >>> dense_x = paddle.to_tensor([-2., 0., 1.]) >>> sparse_x = dense_x.to_sparse_coo(1) >>> out = paddle.sparse.sinh(sparse_x) >>> out Tensor(shape=[3], dtype=paddle.float32, place=Place(cpu), stop_gradient=True, indices=[[0, 2]], values=[-3.62686038, 1.17520118]) r)r rZ sparse_sinhrrrrsinhWrr>cCr)a Calculate elementwise asinh of SparseTensor, requiring x to be a SparseCooTensor or SparseCsrTensor. .. math:: out = asinh(x) Parameters: x (Tensor): The input Sparse Tensor with data type float32, float64, 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: A Sparse Tensor with the same data type and shape as ``x`` . Examples: .. code-block:: python >>> import paddle >>> dense_x = paddle.to_tensor([-2., 0., 1.]) >>> sparse_x = dense_x.to_sparse_coo(1) >>> out = paddle.sparse.asinh(sparse_x) >>> out Tensor(shape=[3], dtype=paddle.float32, place=Place(cpu), stop_gradient=True, indices=[[0, 2]], values=[-1.44363546, 0.88137358]) r)r rZ sparse_asinhrrrrasinhzrr?cCr)a Calculate elementwise atanh of SparseTensor, requiring x to be a SparseCooTensor or SparseCsrTensor. .. math:: out = atanh(x) Parameters: x (Tensor): The input Sparse Tensor with data type float32, float64, 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: A Sparse Tensor with the same data type and shape as ``x`` . Examples: .. code-block:: python >>> import paddle >>> dense_x = paddle.to_tensor([-2., 0., 1.]) >>> sparse_x = dense_x.to_sparse_coo(1) >>> out = paddle.sparse.atanh(sparse_x) >>> out Tensor(shape=[3], dtype=paddle.float32, place=Place(cpu), stop_gradient=True, indices=[[0, 2]], values=[nan , inf.]) r)r rZ sparse_atanhrrrratanhrr@cCr)a Calculate elementwise tanh of SparseTensor, requiring x to be a SparseCooTensor or SparseCsrTensor. .. math:: out = tanh(x) Parameters: x (Tensor): The input Sparse Tensor with data type float32, float64, 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: A Sparse Tensor with the same data type and shape as ``x`` . Examples: .. code-block:: python >>> import paddle >>> dense_x = paddle.to_tensor([-2., 0., 1.]) >>> sparse_x = dense_x.to_sparse_coo(1) >>> out = paddle.sparse.tanh(sparse_x) >>> out Tensor(shape=[3], dtype=paddle.float32, place=Place(cpu), stop_gradient=True, indices=[[0, 2]], values=[-0.96402758, 0.76159418]) r)r rZ sparse_tanhrrrrtanhrrAcCr)a Calculate elementwise square of SparseTensor, requiring x to be a SparseCooTensor or SparseCsrTensor. .. math:: out = square(x) Parameters: x (Tensor): The input Sparse Tensor with data type float32, float64, 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: A Sparse Tensor with the same data type and shape as ``x`` . Examples: .. code-block:: python >>> import paddle >>> dense_x = paddle.to_tensor([-2., 0., 1.]) >>> sparse_x = dense_x.to_sparse_coo(1) >>> out = paddle.sparse.square(sparse_x) >>> out Tensor(shape=[3], dtype=paddle.float32, place=Place(cpu), stop_gradient=True, indices=[[0, 2]], values=[4., 1.]) r)r rZ sparse_squarerrrrsquarerrBcCr)a Calculate elementwise sqrt of SparseTensor, requiring x to be a SparseCooTensor or SparseCsrTensor. .. math:: out = sqrt(x) Parameters: x (Tensor): The input Sparse Tensor with data type float32, float64. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: A Sparse Tensor with the same data type and shape as ``x`` . Examples: .. code-block:: python >>> import paddle >>> dense_x = paddle.to_tensor([-2., 0., 1.]) >>> sparse_x = dense_x.to_sparse_coo(1) >>> out = paddle.sparse.sqrt(sparse_x) >>> out Tensor(shape=[3], dtype=paddle.float32, place=Place(cpu), stop_gradient=True, indices=[[0, 2]], values=[nan, 1. ]) r)r rZ sparse_sqrtrrrrsqrtrrCcCr)a Calculate the natural log of (1+x), requiring x to be a SparseCooTensor or SparseCsrTensor. .. math:: out = ln(1+x) Parameters: x (Tensor): The input Sparse Tensor with data type float32, float64, 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: A Sparse Tensor with the same data type and shape as ``x`` . Examples: .. code-block:: python >>> import paddle >>> dense_x = paddle.to_tensor([-2, 0, 1], dtype='float32') >>> sparse_x = dense_x.to_sparse_coo(1) >>> out = paddle.sparse.log1p(sparse_x) >>> out Tensor(shape=[3], dtype=paddle.float32, place=Place(cpu), stop_gradient=True, indices=[[0, 2]], values=[nan , 0.69314718]) r)r rZ sparse_log1prrrrlog1p)rrD index_dtype value_dtypecCs\tsJd|rt|tjjtjfst|}|r't|tjjtjfs't|}t|||S)a? cast non-zero-index of SparseTensor to `index_dtype`, non-zero-element of SparseTensor to `value_dtype` , requiring x to be a SparseCooTensor or SparseCsrTensor. Parameters: x (Tensor): The input Sparse Tensor with data type float32, float64. index_dtype (np.dtype|str, optional): Data type of the index of SparseCooTensor, or crows/cols of SparseCsrTensor. Can be uint8, int8, int16, int32, int64. value_dtype (np.dtype|str, optional): Data type of the value of SparseCooTensor, SparseCsrTensor. Can be bool, float16, float32, float64, int8, int32, int64, uint8. name (str|core.VarDesc.VarType|core.DataType|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: A Sparse Tensor with the same data type and shape as ``x`` . Examples: .. code-block:: python >>> import paddle >>> dense_x = paddle.to_tensor([-2, 0, 1]) >>> sparse_x = dense_x.to_sparse_coo(1) >>> out = paddle.sparse.cast(sparse_x, 'int32', 'float64') >>> out Tensor(shape=[3], dtype=paddle.float64, place=Place(cpu), stop_gradient=True, indices=[[0, 2]], values=[-2., 1.]) r) r isinstancerVarDescVarTypeZDataTyperr sparse_cast)rrErFrrrrcastLs#rKfactorfloatcCstsJdt|t|S)a Calculate elementwise pow of x, requiring x to be a SparseCooTensor or SparseCsrTensor. .. math:: out = x^{factor} Parameters: x (Tensor): The input Sparse Tensor with data type float32, float64. factor (float|int): factor of pow. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: A Sparse Tensor with the same data type and shape as ``x`` . Examples: .. code-block:: python >>> import paddle >>> dense_x = paddle.to_tensor([-2, 0, 3], dtype='float32') >>> sparse_x = dense_x.to_sparse_coo(1) >>> out = paddle.sparse.pow(sparse_x, 2) >>> out Tensor(shape=[3], dtype=paddle.float32, place=Place(cpu), stop_gradient=True, indices=[[0, 2]], values=[4., 9.]) r)r rZ sparse_powrM)rrLrrrrpow}srNcCstsJdt|dddS)a Calculate elementwise negative of x, requiring x to be a SparseCooTensor or SparseCsrTensor. .. math:: out = -x Parameters: x (Tensor): The input Sparse Tensor with data type float32, float64. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: A Sparse Tensor with the same data type and shape as ``x`` . Examples: .. code-block:: python >>> import paddle >>> dense_x = paddle.to_tensor([-2, 0, 3], dtype='float32') >>> sparse_x = dense_x.to_sparse_coo(1) >>> out = paddle.sparse.neg(sparse_x) >>> out Tensor(shape=[3], dtype=paddle.float32, place=Place(cpu), stop_gradient=True, indices=[[0, 2]], values=[ 2., -3.]) rgT)r r sparse_scalerrrrnegsrQcCr)a Calculate elementwise absolute value of x, requiring x to be a SparseCooTensor or SparseCsrTensor. .. math:: out = |x| Parameters: x (Tensor): The input Sparse Tensor with data type float32, float64, 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: A Sparse Tensor with the same data type and shape as ``x`` . Examples: .. code-block:: python >>> import paddle >>> dense_x = paddle.to_tensor([-2, 0, 3], dtype='float32') >>> sparse_x = dense_x.to_sparse_coo(1) >>> out = paddle.sparse.abs(sparse_x) >>> out Tensor(shape=[3], dtype=paddle.float32, place=Place(cpu), stop_gradient=True, indices=[[0, 2]], values=[2., 3.]) r)r rZ sparse_absrrrrabsrrRcCr)a the coalesced operator include sorted and merge, after coalesced, the indices of x is sorted and unique. Parameters: x (Tensor): the input SparseCooTensor. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: return the SparseCooTensor after coalesced. Examples: .. code-block:: python >>> import paddle >>> indices = [[0, 0, 1], [1, 1, 2]] >>> values = [1.0, 2.0, 3.0] >>> sp_x = paddle.sparse.sparse_coo_tensor(indices, values) >>> sp_x = paddle.sparse.coalesce(sp_x) >>> print(sp_x.indices()) Tensor(shape=[2, 2], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 1], [1, 2]]) >>> print(sp_x.values()) Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=True, [3., 3.]) r)r rZsparse_coalescerrrrcoalescerrScCsBtsJd|jtvrt|dtjjj}t |dt j ddS)a Convert each of the elements of input x from radian to degree, requiring x to be a SparseCooTensor or SparseCsrTensor. .. math:: rad2deg(x) = 180/ \pi * x Parameters: x (Tensor): The input Sparse Tensor with data type float32, float64, int32, int64. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: A Sparse Tensor with the same data type and shape as ``x`` . Examples: .. code-block:: python >>> import paddle >>> dense_x = paddle.to_tensor([3.142, 0., -3.142]) >>> sparse_x = dense_x.to_sparse_coo(1) >>> out = paddle.sparse.rad2deg(sparse_x) >>> out Tensor(shape=[3], dtype=paddle.float32, place=Place(cpu), stop_gradient=True, indices=[[0, 2]], values=[ 180.02334595, -180.02334595]) rNf@rOT r r# _int_dtype_rrJrrHrIZFP32rPnppirrrrrad2deg   rYcCsBtsJd|jtvrt|dtjjj}t |t j dddS)a Convert each of the elements of input x from degree to radian, requiring x to be a SparseCooTensor or SparseCsrTensor. .. math:: deg2rad(x) = \pi * x / 180 Parameters: x (Tensor): The input Sparse Tensor with data type float32, float64, int32, int64. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: A Sparse Tensor with the same data type and shape as ``x`` . Examples: .. code-block:: python >>> import paddle >>> dense_x = paddle.to_tensor([-180, 0, 180]) >>> sparse_x = dense_x.to_sparse_coo(1) >>> out = paddle.sparse.deg2rad(sparse_x) >>> out Tensor(shape=[3], dtype=paddle.float32, place=Place(cpu), stop_gradient=True, indices=[[0, 2]], values=[-3.14159274, 3.14159274]) rNrTrOTrUrrrrdeg2rad0rZr[cCr)a Calculate elementwise `exp(x)-1` , requiring x to be a SparseCooTensor or SparseCsrTensor. .. math:: out = exp(x) - 1 Parameters: x (Tensor): The input Sparse Tensor with data type float32, float64, 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: A Sparse Tensor with the same data type and shape as ``x`` . Examples: .. code-block:: python >>> import paddle >>> dense_x = paddle.to_tensor([-2., 0., 1.]) >>> sparse_x = dense_x.to_sparse_coo(1) >>> out = paddle.sparse.expm1(sparse_x) >>> out Tensor(shape=[3], dtype=paddle.float32, place=Place(cpu), stop_gradient=True, indices=[[0, 2]], values=[-0.86466473, 1.71828187]) r)r rZ sparse_expm1rrrrexpm1Vrr\inputshapercCsttr t||St|dgddt|dttfdd|i}d|i}td}||j }|j d|d|i|d|S)a Changes the shape of ``x`` without changing its value, requiring x to be a SparseCooTensor or SparseCsrTensor. Currently this function can only reshape the sparse dims of ``x`` , but ``shape`` argument must be specified as the shape of the reshaped tensor. Note that if x is a SparseCsrTensor, then len(shape) must be 2 or 3. There are some tricks when specifying the target shape. - 1. -1 means the value of this dimension is inferred from the total element number of x and remaining dimensions. Thus one and only one dimension can be set -1. - 2. 0 means the actual dimension value is going to be copied from the corresponding dimension of x. The indices of 0 in the target shape can not exceed the rank of x. Here are some examples to explain it. - 1. Given a 3-D tensor x with a shape [2, 4, 6], and the target shape is [6, 8], the reshape operator will transform x into a 2-D tensor with shape [6, 8] and leaving x's data unchanged. - 2. Given a 3-D tensor x with a shape [2, 4, 6], and the target shape is [2, 3, -1, 2], the reshape operator will transform x into a 4-D tensor with shape [2, 3, 4, 2] and leaving x's data unchanged. In this case, one dimension of the target shape is set to -1, the value of this dimension is inferred from the total element number of x and remaining dimensions. - 3. Given a 3-D tensor x with a shape [2, 4, 6], and the target shape is [-1, 0, 3, 2], the reshape operator will transform x into a 4-D tensor with shape [2, 4, 3, 2] and leaving x's data unchanged. In this case, besides -1, 0 means the actual dimension value is going to be copied from the corresponding dimension of x. .. note:: Alias Support: The parameter name ``input`` can be used as an alias for ``x``. For example, ``reshape(input=tensor_x, ...)`` is equivalent to ``reshape(x=tensor_x, ...)``. Args: x (Tensor): The input sparse tensor with data type ``float32``, ``float64``, ``int32``, ``int64`` or ``bool``. shape (list|tuple): Define the target shape. At most one dimension of the target shape can be -1. The data type is ``int32``. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: A reshaped Tensor with the same data type as ``x``. Examples: .. code-block:: python >>> import paddle >>> x_shape = [6, 2, 3] >>> new_shape = [1, 0, 2, -1, 3] >>> format = "coo" >>> dense_x = paddle.randint(-100, 100, x_shape) * paddle.randint(0, 2, x_shape) >>> if format == "coo": ... sp_x = dense_x.to_sparse_coo(len(x_shape)) >>> else: ... sp_x = dense_x.to_sparse_csr() >>> sp_out = paddle.sparse.reshape(sp_x, new_shape) >>> print(sp_out.shape) [1, 2, 2, 3, 3] r)float16r(r)r*r+r,r&Zuint16reshaper^sparse_reshaper/r0) r rrarrr6r7r r8r#r9)rr^rr2r3r;r/rrrr`ys(:   r`cCsFtrt|Sd}t|}||j}|j|d|id|iid|S)a Return whether every element of input tensor is `NaN` or not, requiring x to be a SparseCooTensor or SparseCsrTensor. Args: x (Tensor): The input tensor (SparseCooTensor or SparseCsrTensor), it's data type should be float16, float32, float64, int32, int64. name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: A Sparse Tensor with the same shape as ``x``, the bool result which shows every element of `x` whether it is `NaN` or not. Examples: .. code-block:: python >>> import paddle >>> import numpy as np >>> format = "coo" >>> np_x = np.asarray([[[0., 0], [1., 2.]], [[0., 0], [3., float('nan')]]]) >>> dense_x = paddle.to_tensor(np_x) >>> if format == "coo": ... sparse_x = dense_x.to_sparse_coo(len(np_x.shape)) >>> else: ... sparse_x = dense_x.to_sparse_csr() ... >>> sparse_out = paddle.sparse.isnan(sparse_x) >>> print(sparse_out) Tensor(shape=[2, 2, 2], dtype=paddle.bool, place=Place(gpu:0), stop_gradient=True, indices=[[0, 0, 1, 1], [1, 1, 1, 1], [0, 1, 0, 1]], values=[False, False, False, True ]) sparse_isnanrr/r0)r rrbr r8r#r9)rrr:r;r/rrrisnans$  rcaxes)Sequence[int] | Sequence[Tensor] | Tensorstartsendsc Cstr t||||S|||d}t|dgddt|dttfdt|dttfdt|dttfdd}t|}|j|j d}|j |d|id |i|d |S) a This operator produces a slice of ``x`` along multiple axes for sparse tensors. Slice uses ``axes``, ``starts`` and ``ends`` attributes to specify the start and end dimension for each axis in the list of axes and Slice uses this information to slice the input sparse tensor (x). If a negative value is passed to ``starts`` or ``ends`` such as :math:`-i`, it represents the reverse position of the axis :math:`i-1` (here 0 is the initial position). If the value passed to ``starts`` or ``ends`` is greater than the number of elements in the dimension (n), it represents n. For slicing to the end of a dimension with unknown size, it is recommended to pass in INT_MAX. The size of ``axes`` must be equal to ``starts`` and ``ends``. Args: x (Tensor): The input Tensor (``SparseCooTensor`` or ``SparseCsrTensor``), it's data type should be ``float16``, ``float32``, ``float64``, ``int32``, ``int64``. axes (list|tuple|Tensor): The data type is ``int32``.If ``axes`` is a list or tuple, the elements of it should be integers or a 0-D Tensor with shape []. If ``axes`` is a Tensor, it should be a 1-D Tensor. Axes that `starts` and `ends` apply to. starts (list|tuple|Tensor): The data type is ``int32``. If ``starts`` is a list or tuple, the elements of it should be integers or a 0-D Tensor with shape []. If ``starts`` is a Tensor, it should be a 1-D Tensor. It represents starting indices of corresponding axis in ``axes``. ends (list|tuple|Tensor): The data type is ``int32``. If ``ends`` is a list or tuple, the elements of it should be integers or a 0-D Tensor with shape []. If ``ends`` is a Tensor, it should be a 1-D Tensor. It represents ending indices of corresponding axis in ``axes``. Returns: A Sparse Tensor. The data type is same as ``x``. Examples: .. code-block:: python >>> import paddle >>> import numpy as np >>> format = 'coo' >>> np_x = np.asarray([[4, 0, 7, 0], [0, 0, 5, 0], [-4, 2, 0, 0]]) >>> dense_x = paddle.to_tensor(np_x) >>> if format == 'coo': ... sp_x = dense_x.to_sparse_coo(len(np_x.shape)) >>> else: ... sp_x = dense_x.to_sparse_csr() ... >>> axes = [0, 1] >>> starts = [1, 0] >>> ends = [3, -2] >>> sp_out = paddle.sparse.slice(sp_x, axes, starts, ends) >>> # sp_out is x[1:3, 0:-2] >>> print(sp_out) Tensor(shape=[2, 2], dtype=paddle.int64, place=Place(cpu), stop_gradient=True, indices=[[1, 1], [0, 1]], values=[-4, 2]) )rdrfrgrr' sparse_slicerdrfrgr.r/r0) r rrhrrr6r7r r8r#r9) rrdrfrgrr3r:r;r/rrrslices&=  riTq int | Nonecenterniterr5tuple[Tensor, Tensor, Tensor]csdd}ddddfddd"fd d d#fdd }t|s4tdt||s>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> paddle.device.set_device('gpu') >>> format = "coo" >>> paddle.seed(2023) >>> dense_x = paddle.randn((5, 5), dtype='float64') >>> if format == "coo": ... sparse_x = dense_x.to_sparse_coo(len(dense_x.shape)) >>> else: ... sparse_x = dense_x.to_sparse_csr() >>> print("sparse.pca_lowrank API only support CUDA 11.x") >>> # U, S, V = None, None, None >>> # use code blow when your device CUDA version >= 11.0 >>> U, S, V = paddle.sparse.pca_lowrank(sparse_x) >>> print(U) Tensor(shape=[5, 5], dtype=float64, place=Place(gpu:0), stop_gradient=True, [[-0.31412600, 0.44814876, 0.18390454, -0.19967630, -0.79170452], [-0.31412600, 0.44814876, 0.18390454, -0.58579808, 0.56877700], [-0.31412600, 0.44814876, 0.18390454, 0.78547437, 0.22292751], [-0.38082462, 0.10982129, -0.91810233, 0.00000000, 0.00000000], [ 0.74762770, 0.62082796, -0.23585052, 0.00000000, -0.00000000]]) >>> print(S) Tensor(shape=[5], dtype=float64, place=Place(gpu:0), stop_gradient=True, [1.56031096, 1.12956227, 0.27922715, 0.00000000, 0.00000000]) >>> print(V) Tensor(shape=[5, 5], dtype=float64, place=Place(gpu:0), stop_gradient=True, [[ 0.88568469, -0.29081908, 0.06163676, 0.19597228, -0.29796422], [-0.26169364, -0.27616183, 0.43148760, -0.42522796, -0.69874939], [ 0.28587685, 0.30695344, -0.47790836, -0.76982533, -0.05501437], [-0.23958121, -0.62770647, -0.71141770, 0.11463224, -0.17125926], [ 0.08918713, -0.59238761, 0.27478686, -0.41833534, 0.62498824]]) cSs$|j}|tjtjtjfvr|StjSN)r#paddler_r(r))rr#rrrget_floating_dtypesz'pca_lowrank..get_floating_dtypecSs|r|S|Srp)Z is_complexZconjrrrr conjugateszpca_lowrank..conjugatecSsZ|j}ttdt|}g|dd|d|d}|r'tj||St||S)Nr)r^r6rangelen is_sparserqsparser )rr^rrrrr s   zpca_lowrank..transposecs |Srprrs)rtr rr transjugates z pca_lowrank..transjugaterjNc s*|durdn|}|jdd\}}tjj}tj||f|jd}|}|} |durU|tj||d} t|D]} |tj| | d} |tj|| d} q:| S|} |tj||t||d} t|D]$} |tj| | t| | d} |tj|| t|| d} qn| S)Nrjrur.r) r^rqlinalgqrZrandnr#rzmatmulrw) rrkrnMmnr}RA_tZA_HQiZM_H)rtr{r rrget_approximate_basiss$ " "$z*pca_lowrank..get_approximate_basiscs|durdn|}|jdd\}}|durd}n|}|}||ks(||kr||||d}|} |dur@tj|| } n tj|| t|| } | jd|ks[J| j|f| jd|ksiJ| j|f| jd| jdksxJ| jtjj| dd\} } } | }||}nh||||d}|} |durtj|| }n tj|| t|| }|} | jd|ksJ| j|f| jd|ksJ| j|f| jd| jdksJ| jtjj| dd\} } } | }|| } | | |fS)NrrurnrrvF)Z full_matrices)r^rqrzr~r|Zsvd)rrkrnrrrZM_trrZQ_cZB_tUSZVhVBrtrr{r rr svd_lowranks>   z pca_lowrank..svd_lowrankzInput must be tensor, but got z#Input must be sparse, but got denseFalse.r z-sparse.pca_lowrank API only support CUDA 11.xruzq(=z>) must be non-negative integer and not greater than min(m, n)=zniter(=z) must be non-negative integerrz,input is expected to be 2-dimensional tensor)r!)r#placer.)rjN)rrjN)rqZ is_tensor ValueErrorr1ryversioncudar5splitr^minrxrzr<valuesZsparse_coo_tensorindicesr#rZzerosZonesr~Zto_dense)rrkrmrnrrrrZ cuda_versionrrr#Zs_sumZs_valcZcolumn_indicesrZC_tZ ones_m1_trrrr pca_lowrank_sZK '   $rrp)rrrrrr)rrrrrrrr)NNFN) rrr!r"r#r$r%r&rrrr)NNN) rrrEr$rFr$rrrr)rrrLrMrrrr)rrr^rrrrr) rrrdrerfrergrerrrr)NTrjN) rrrkrlrmr&rnr5rrrro)> __future__rtypingrnumpyrWrqrZpaddle.base.data_feederrrZpaddle.base.frameworkrrr Zpaddle.common_ops_importr Zpaddle.frameworkr Zpaddle.utils.decorator_utilsr collections.abcr rZpaddle._typingrr__all__rHrIZUINT8ZINT8ZINT16ZINT32ZINT64ZBOOLrVrrrr r<r=r>r?r@rArBrCrDrKrNrQrRrSrYr[r\r`rcrirrrrrsz         # #$ , l # # # # # # #% 1 $ # # # & & # [5 \