o #j@sBddlZddlZddlZddlZddlZddlmZddlmZddl m Z m Z m Z m Z mZddlmZmZddlmZddlmZmZmZmZmZmZmZmZmZmZgZd d Z d d Z! d^ddZ" d_ddZ#d`ddZ$daddZ%dbddZ&dcddZ'daddZ(dcddZ)dad d!Z*ddd"d#Z+dad$d%Z,dad&d'Z-dad(d)Z.dad*d+Z/ded,d-Z0dad.d/Z1dfd1d2Z2d3d4Z3dgd5d6Z4edgd7d8Z5dgd9d:Z6edgd;d<Z7d=d>Z8dhdAdBZ9dgdCdDZ:didEdFZ;dadGdHZdjdMdNZ?dadOdPZ@djdQdRZAdkdTdUZBdldVdWZCdjdXdYZDedmdZd[ZEedjd\d]ZFdS)nN)_C_ops)inplace_apis_in_dygraph_only) check_dtype check_typecheck_variable_and_dtype convert_dtypeconvert_float_to_uint16)Variable device_guard) ParamAttr) LayerHelper_current_expected_place_current_expected_place__get_paddle_placeconvert_np_dtype_to_dtype_core dygraph_onlyin_dynamic_modein_dynamic_or_pir_mode in_pir_modecC4|tjjjkr tjjjS|tjjjkrtjjjS|SN)rVarDescVarType COMPLEX64FP32 COMPLEX128FP64dtyper!W/var/www/html/Deteccion_Ine/venv/lib/python3.10/site-packages/paddle/tensor/creation.py_complex_to_real_dtype4   r#cCrr)rrrrrrrrr!r!r"_real_to_complex_dtype=r$r%Fc Cst|dtttjfd|D]}t|dttjtjtjtj tj fdq t |dgddt d it }|j||||dd}|j|tjjjt||d d |S) a4 This function creates a new tensor variable with value in the global block(block 0). Args: shape (list[int]|tuple[int]): Shape of the variable value (float): The value of the variable. The new created variable will be filled with it. dtype (str): Data type of the variable persistable (bool, optional): If this variable is persistable. Default: False force_cpu (bool, optional): Force this variable to be on CPU. Default: False name (str, optional): For detailed information, please refer to :ref:`api_guide_Name` . Usually name is no need to set and None by default. Returns: Variable: The created Variable Examples: .. code-block:: python >>> import paddle >>> paddle.enable_static() >>> var = paddle.static.create_global_var(shape=[2,3], value=1.0, dtype='float32', ... persistable=True, force_cpu=True, name='new_var') shapecreate_global_var item of shaper ) boolfloat16float32float64int8int16int32int64uint8uint16 global_varT)r r& persistablename stop_gradient)value force_cpu) initializerN)r3)rlisttuplenpndarrayintr1r-r.r/r0rr localsZcreate_global_variableZset_variable_initializerpaddlennr9ZConstantInitializerfloat) r&r7r r4r8r5itemhelpervarr!r!r"r'FsF r'c Cst|dtttjfd|D]}t|dttjtjtjtj tj fdq t |dgddt|dt dt fdt|dt dtjjjfdtd it}|durUt |d }|||t|||S) a This function creates a parameter. The parameter is a learnable variable, which can have gradient, and can be optimized. Note: This is a very low-level API. This API is useful when you create operator by your self, instead of using layers. Args: shape (list of int): Shape of the parameter dtype (str): Data type of the parameter. It can be set as 'float16', 'float32', 'float64'. name (str, optional): For detailed information, please refer to :ref:`api_guide_Name` . Usually name is no need to set and None by default. attr (ParamAttr, optional): Attribute object of the specified argument. For detailed information, please refer to :ref:`api_paddle_ParamAttr` None by default, which means that ParamAttr will be initialized as it is. is_bias (bool, optional): This can affect which default initializer is chosen when default_initializer is None. If is_bias, initializer.Constant(0.0) will be used. Otherwise, Xavier() will be used. default_initializer (Initializer, optional): Initializer for the parameter Returns: The created parameter. Examples: .. code-block:: python >>> import paddle >>> paddle.enable_static() >>> W = paddle.create_parameter(shape=[784, 200], dtype='float32') r&create_parameterr(r ) r)r*r2r+r,r-r.r/r0r1attrNdefault_initializer)r5)rF)rr:r;r<r=r>r1r-r.r/r0rtyper r@rAr9Z Initializerr r?rFr)r&r r5rGZis_biasrHrCrDr!r!r"rFsB!  rFcCs4t|dgddtdit}|j|j||dS)a Create a variable, which will hold a Tensor with data type dtype. Args: dtype(string|numpy.dtype): the data type of Tensor to be created, the data type is bool, float16, float32, float64, int8, int16, int32 and int64. name(string, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` persistable(bool): Set the persistable flag of the create tensor. default value is False. Returns: Variable: The tensor to be created according to dtype. Examples: .. code-block:: python >>> import paddle >>> tensor = paddle.tensor.create_tensor(dtype='float32') r )r)r*r+r,r-r/r/r0 create_tensorr5r r4N)rJ)rr r?create_variabler5)r r5r4rDr!r!r"rJs rJc Cs|durt}|}|}|}t|ttjjfst|dtdt|tj j s)t |}t|ttjjfsOt dt dg||dd}Wdn1sJwYt|ttjjfsut dt dg||dd}Wdn1spwYt|ttjjfst dt dgd|dd}Wdn1swYtrt||||tStdit}t|j} t|j} t|} t|trt|jd gd dn t|d ttfdt|trt|jd gd dn t|d ttfdt|trt|jddgdt|d gd d| d ks| d kr| dvs%| dks | dkr.| dkr.td| | ||j|d} |jd|||dd |id| gidt|trS| j|f| S)a Return fixed number of evenly spaced values within a given interval. Note: no gradient calculation is performed. Args: start(int|float|Tensor): The input :attr:`start` is start of range. It is a int, float, \ or a 0-D Tensor with data type int32, int64, float32 or float64. stop(int|float|Tensor): The input :attr:`stop` is end of range. It is a int, float, \ or a 0-D Tensor with data type int32, int64, float32 or float64. num(int|Tensor): The input :attr:`num` is given num of the sequence. It is an int, \ or a 0-D Tensor with data type int32. dtype(np.dtype|str, optional): The data type of output tensor, it could be int32, int64, float32 and float64. Default: if None, the data type is float32. name(str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: the output data type will be float32, float64. The 1-D tensor with fixed number of evenly spaced values, \ the data shape of this tensor is :math:`[num]` . If the :attr:`num` is set 1, the output tensor just has \ the value with input :attr:`start`. Examples: .. code-block:: python >>> import paddle >>> data = paddle.linspace(0, 10, 5, 'float32') >>> print(data.numpy()) [0. 2.5 5. 7.5 10.] >>> data = paddle.linspace(0, 10, 1, 'float32') >>> print(data.numpy()) [0.] NnumlinspacecpuTr8r/startr*r2r+r,r/r0stopr r,r+r/r0zThe dtype of start/stop is {}/{} but the attr(dtype) of linspace is {}, which may cause data type overflows. Please reset attr(dtype) of linspace.r)StartStopNumOutrIinputsattrsoutputs)rN)r@get_default_dtype isinstancer pirOpResultrr>rrrrr fill_constantrrrNrr r?rr rrB ValueErrorformat"create_variable_for_type_inference append_opdesc set_shape) rRrTrMr r5 tensor_num tensor_start tensor_stoprD start_dtype stop_dtype out_dtypeoutr!r!r"rNs             rN$@cCsL|durt}|}|}|}|} t|ttjjfs t|dtdt|tj j tj fs.t |}t|ttjjfsRt dtdg||}Wdn1sMwYt|ttjjfsvt dtdg||}Wdn1sqwYt|ttjjfst dtdgd|}Wdn1swYt|ttjjfst dtdg||} Wdn1swYtrt|||| |tStdit} t|j} t|j} t| j} t|}t|trt|jdgddn t|dttfdt|trt|jd gddn t|d ttfdt|tr)t|jddgdt|tr:t|jd gddn t|d ttfdt|d gd d| d ks[| d ks[| d kr`|dvst| dkso| dkso| dkr~|dkr~td| | | || j|d}| jd|||| dd |id|gidt|tr|j|f|S)a  Return fixed number of logarithmical-evenly spaced values within the interval \ :math:`[base^{start}, base^{stop}]`. Notes: This API does not compute the gradient. Args: start(int|float|Tensor): The input :attr:`start` is exponent of first entry in \ the sequence. It is a scalar, or a 0-D Tensor of shape [] with input data \ type int32, int64, float32 or float64. stop(int|float|Tensor): The input :attr:`stop` is exponent of last entry in the \ sequence. It is a scalar, or a 0-D Tensor of shape [] with input data \ type int32, int64, float32 or float64. num(int|Tensor): The input :attr:`num` is given number of items in the sequence. \ It is an int scalar, or a 0-D Tensor of shape [] with data type int32. base(int|float|Tensor): The input :attr:`base` is base of the logarithm function. \ It is a scalar, or a 0-D Tensor of shape [] with input data type int32, int64, \ float32 or float64. dtype(np.dtype|str, optional): The data type of output tensor, it could be \ int32, int64, float32 or float64. Default: if None, the data type is float32. \ name(str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: The output data type will be float32, float64. The 1-D tensor with \ fixed number of logarithmical-evenly spaced values, the data shape of this \ tensor is :math:`[num]`. If the :attr:`num` is set 1, the output tensor \ just has the value with exponential of :attr:`start` with base :attr:`base`. Examples: .. code-block:: python >>> import paddle >>> data = paddle.logspace(0, 10, 5, 2, 'float32') >>> print(data.numpy()) [1.0000000e+00 5.6568542e+00 3.2000000e+01 1.8101933e+02 1.0240000e+03] >>> data = paddle.logspace(0, 10, 1, 2, 'float32') >>> print(data.numpy()) [1.] NrMlogspacerOrPr/rR)r+r,r/r0rTbaser )r/r0r+r,r,rUr0zThe dtype of start/stop/base is {}/{}/{} but the attr(dtype) of logspace is {}, which may cause data type overflows. Please reset attr(dtype) of logspace.r)rVrWrXZBaserYrZ)rq)r@r^r_r r`rarr>rrrDataTyperr rbrrrqrr r?rr rrBrcrdrerfrgrh)rRrTrMrrr r5rirjrkZ tensor_baserDrlrmZ base_dtypernror!r!r"rqs)                      rqTcCsdd}dd}t|tjrt|}t|tjst|r)t|ts)t|}nt|ttfr@t|}|j tj kr?t dnjt|t j rYtsY||d}|||}||_|St|tjj rstrs||d}|||}||_|St|tjtj frtrtj |}nt |}|j|s||d}|||}||_|Stdt||s|j dvrt }t|r|d vrd nd }|||}|j d vr|d }|r|||}t|tjrtjj ||ddd|dSt j ||dd|dS)NcSs(|rt|t|jkr|t|S|Sr)rr astype)Ztensorr r!r!r"_handle_tensor_dtype)sz3_to_tensor_non_static.._handle_tensor_dtypecSsB|rt|t|jkrt|dvrt|dS|t|S|S)N)r2r+)rr r rt)r=r r!r!r"_handle_np_dtype/s  z/_to_tensor_non_static.._handle_np_dtypez Faild to convert input data to a regular ndarray : - Usually this means the input data contains nested lists with different lengths. FzrCan't constructs a 'paddle.Tensor' with data type {}, data type must be scalar|list|tuple|np.ndarray|paddle.Tensor)r*r+r, complex64 complex128)r*r+rwrxr/r0)r7placer4 zero_copyr5r6)r7rzr4r{r6)r_r<numberarrayr=isscalarstrr:r;r Zobject_rcr@TensorrZ_copy_tor6reagerZ LoDTensorrzZ_equals TypeErrorrdrIr^Z iscomplexobjrt)datar rzr6rurvZ default_typer!r!r"_to_tensor_non_static(s                     rcCst|ttjjfr|}|dur||jkrt||}nt|tjr&t |}t|tj st |r>> import paddle >>> type(paddle.to_tensor(1)) >>> paddle.to_tensor(1) Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, 1) >>> x = paddle.to_tensor(1, stop_gradient=False) >>> print(x) Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=False, 1) >>> paddle.to_tensor(x) # A new tensor will be created with default stop_gradient=True Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, 1) >>> paddle.to_tensor([[0.1, 0.2], [0.3, 0.4]], place=paddle.CPUPlace(), stop_gradient=False) Tensor(shape=[2, 2], dtype=float32, place=Place(cpu), stop_gradient=False, [[0.10000000, 0.20000000], [0.30000001, 0.40000001]]) >>> type(paddle.to_tensor([[1+1j, 2], [3+2j, 4]], dtype='complex64')) >>> paddle.to_tensor([[1+1j, 2], [3+2j, 4]], dtype='complex64') Tensor(shape=[2, 2], dtype=complex64, place=Place(cpu), stop_gradient=True, [[(1+1j), (2+0j)], [(3+2j), (4+0j)]]) Nz [(](.+?)[)]r) rrrrrecompileSfindallrr@Zstaticr r)rr rzr6Zre_expZ place_strr!r!r" to_tensorsE $rcCs|dur|j}nt|tjjtjfst|}tr"t ||||j St r/t |||t St dit}t|dgddt|dgdd|j|d}|jdd |gi||d d |gid d |_|S)a This function creates a tensor filled with ``fill_value`` which has identical shape of ``x`` and ``dtype``. If the ``dtype`` is None, the data type of Tensor is same with ``x``. Args: x(Tensor): The input tensor which specifies shape and data type. The data type can be bool, float16, float32, float64, int32, int64. fill_value(bool|float|int): The value to fill the tensor with. Note: this value shouldn't exceed the range of the output data type. dtype(np.dtype|str, optional): The data type of output. The data type can be one of bool, float16, float32, float64, int32, int64. The default value is None, which means the output data type is the same as input. name(str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: Tensor which is created according to ``x``, ``fill_value`` and ``dtype``. Examples: .. code-block:: python >>> import paddle >>> input = paddle.full(shape=[2, 3], fill_value=0.0, dtype='float32', name='input') >>> output = paddle.full_like(input, 2.0) >>> print(output.numpy()) [[2. 2. 2.] [2. 2. 2.]] N full_likex)r)r*r+r,r.r/r0r2r zfull_like/zeros_like/ones_likerZ fill_any_likeX)r7r rYrZTr)r r_rrrrsrrrrrzrPlacer r?rrrerfr6)r fill_valuer r5rDror!r!r"r$s<   rc Cs^trt}|r t}t|tjjtjfst|}t r+t|tjjr+t j jj |}t r@t|}t|ttfr?t j|}n!t|ttfrUt j|rTt j||}n t|t j jr]ntd|durrt||||}d|_|S|durt|||||d|_|SdSd|i}t|}t|ts|dvrtt||d<t||d<ntt||d<t||d<tdit }i} t|trt|j!|krt "||}|| d<t j#|t$|d gd dt%|d tttfd|durt&|d t|gdtdit }t jj'| ||dd |dur|j(|d}|j!|d <|j)d| d|gi|ddd|_|S)Nz0Shape only supports OpReslut, or list, or tuple.Tr8)r-r1r.r/r0Z str_valuer7rbZ ValueTensorr ) r)r*r+r,r-r1r.r/r0rwrxr2r&ror[r\r&op_typerrYrIr[r]r\r6)rb)*rrrZCPUPlacer_rrrsrrr@r`Zvartype_to_datatyperrBr:r;utilsconvert_shape_to_listZ _contain_varZget_int_tensor_listrarrfullr6Zfull_rr rr>r r?r rZ check_shaperrrget_shape_tensor_inputsrerf) r&r r7r8ror5rzr\rDr[r!r!r"rbws          rbcC |durt}td|||dS)a^ Create a Tensor of specified :attr:`shape` and :attr:`dtype` and fill it with 1. Args: shape (tuple|list|Tensor): Shape of the Tensor to be created. The data type is ``int32`` or ``int64`` . If ``shape`` is a list or tuple, the elements of it should be integers or 0-D Tensor with shape []. If ``shape`` is an Tensor, it should be an 1-D Tensor which represents a list. dtype (np.dtype|str, optional): Data type of output Tensor, it should be one of bool, float16, float32, float64, int32 and int64. If it is set to None, the data type will be float32. name (str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: A Tensor of data type :attr:`dtype` with shape :attr:`shape` and all elements are 1. Examples: .. code-block:: python >>> import paddle >>> # shape is a list/tuple >>> data1 = paddle.ones(shape=[3, 2]) >>> print(data1.numpy()) [[1. 1.] [1. 1.] [1. 1.]] >>> # shape is a Tensor >>> shape = paddle.to_tensor([3, 2]) >>> data2 = paddle.ones(shape=shape) >>> print(data2.numpy()) [[1. 1.] [1. 1.] [1. 1.]] >>> # shape is a Tensor List >>> shape = [paddle.to_tensor(3), paddle.to_tensor(2)] >>> data3 = paddle.ones(shape=shape) >>> print(data3.numpy()) [[1. 1.] [1. 1.] [1. 1.]] Ng?r7r&r r5r@r^rbr&r r5r!r!r"oness+rcCt|d||dS)a Returns a Tensor filled with the value 1, with the same shape and data type (use ``dtype`` if ``dtype`` is not None) as ``x``. Args: x(Tensor): The input tensor which specifies shape and dtype. The dtype of ``x`` can be bool, float16, float32, float64, int32, int64. dtype(str|np.dtype, optional): The data type of the output tensor. Supported data types: bool, float16, float32, float64, int32, int64. If ``dtype`` is None, the data type is the same as ``x``. Default is None. name(str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: A Tensor filled with the value 1, with the same shape and data type (use ``dtype`` if ``dtype`` is not None) as ``x``. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([1,2,3]) >>> out1 = paddle.ones_like(x) >>> print(out1.numpy()) [1 1 1] >>> out2 = paddle.ones_like(x, dtype='int32') >>> print(out2.numpy()) [1 1 1] rPrrr r5rrr r5r!r!r" ones_like s rcCr)a Creates a tensor of specified :attr:`shape` and :attr:`dtype`, and fills it with 0. Args: shape (tuple|list|Tensor): Shape of the Tensor to be created. The data type is ``int32`` or ``int64`` . If ``shape`` is a list or tuple, each element of it should be integer or 0-D Tensor with shape []. If ``shape`` is an Tensor, it should be an 1-D Tensor which represents a list. dtype(np.dtype|str, optional): Data type of output Tensor, it supports bool, float16, float32, float64, int32 and int64. Default: if None, the data type is float32. name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: A tensor of data type :attr:`dtype` with shape :attr:`shape` and all elements set to 0. Examples: .. code-block:: python >>> import paddle >>> # shape is a list/tuple >>> data1 = paddle.zeros(shape=[3, 2]) >>> print(data1.numpy()) [[0. 0.] [0. 0.] [0. 0.]] >>> # shape is a Tensor >>> shape = paddle.to_tensor([3, 2]) >>> data2 = paddle.zeros(shape=shape) >>> print(data2.numpy()) [[0. 0.] [0. 0.] [0. 0.]] >>> # shape is a Tensor List >>> shape = [paddle.to_tensor(3), paddle.to_tensor(2)] >>> data3 = paddle.zeros(shape=shape) >>> print(data3.numpy()) [[0. 0.] [0. 0.] [0. 0.]] Ngrrrr!r!r"zeros.s,rcCr)a Returns a Tensor filled with the value 0, with the same shape and data type (use ``dtype`` if ``dtype`` is not None) as ``x``. Args: x(Tensor): The input tensor which specifies shape and dtype. The dtype of ``x`` can be bool, float16, float32, float64, int32, int64. dtype(str|np.dtype, optional): The data type of the output tensor. Supported data types: bool, float16, float32, float64, int32, int64. If ``dtype`` is None, the data type is the same as ``x``. Default is None. name (str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: A Tensor filled with the value 0, with the same shape and data type (use ``dtype`` if ``dtype`` is not None) as ``x``. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([1, 2, 3]) >>> out1 = paddle.zeros_like(x) >>> print(out1.numpy()) [0 0 0] >>> out2 = paddle.zeros_like(x, dtype='int32') >>> print(out2.numpy()) [0 0 0] rrrrr!r!r" zeros_like_s!rcCsdd}||d|durt}t|tjjst|}|dur&||dn|}tr5t |||t }n(t dit }t |dgdd|j|d }|jdid |gi|||d d d d |_|S)a6 This function constructs 2-D Tensor with ones on the diagonal and zeros elsewhere. Args: num_rows(int): the number of rows in each batch Tensor. num_columns(int, optional): the number of columns in each batch Tensor. If None, default: num_rows. dtype(np.dtype|str, optional): The data type of the returned Tensor. It should be int32, int64, float16, float32, float64. Default: if None, the data type is float32. name(str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: An identity Tensor or LoDTensor of shape [num_rows, num_columns]. Examples: .. code-block:: python >>> import paddle >>> data = paddle.eye(3, dtype='int32') >>> print(data.numpy()) [[1 0 0] [0 1 0] [0 0 1]] >>> data = paddle.eye(2, 3, dtype='int32') >>> print(data.numpy()) [[1 0 0] [0 1 0]] cSs`t|ttjjtjjfrt|j dkr|j ddvsJdSt|t r'|dkr.t |ddS)NrPr)rPz should be a non-negative int.) r_r rrrr@r`rarr&r>r)rGmessager!r!r" _check_attrs$zeye.._check_attrnum_rowsN num_columnseyer r*r+r,r/r0rrY)rrr Tr)r)r@r^r_rrrrrrrrr r?rrerfr6)rrr r5rrorDr!r!r"rsB!     rcCs |durt}t||||dS)a\ Return a Tensor with the ``fill_value`` which size is same as ``shape``. Args: shape (tuple|list|Tensor): Shape of the Tensor to be created. The data type is ``int32`` or ``int64`` . If ``shape`` is a list or tuple, each element of it should be integer or 0-D Tensor with shape []. If ``shape`` is an Tensor, it should be an 1-D Tensor which represents a list. fill_value(bool|float|int|Tensor): The constant value used to initialize the Tensor to be created. If ``fill_value`` is an Tensor, it shoule be an 0-D Tensor which represents a scalar. dtype(np.dtype|str, optional): Data type of the output Tensor which can be float16, float32, float64, int32, int64, if dytpe is `None`, the data type of created Tensor is `float32`. name (str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: Tensor which is created according to ``shape``, ``fill_value`` and ``dtype``. Examples: .. code-block:: python >>> import paddle >>> # shape is a list/tuple >>> data1 = paddle.full(shape=[3, 2], fill_value=1.) >>> print(data1.numpy()) [[1. 1.] [1. 1.] [1. 1.]] >>> # shape is a Tensor >>> shape = paddle.to_tensor([3, 2]) >>> data2 = paddle.full(shape=shape, fill_value=2.) >>> print(data2.numpy()) [[2. 2.] [2. 2.] [2. 2.]] >>> # shape is a Tensor List >>> shape = [paddle.to_tensor(3), paddle.to_tensor(2)] >>> data3 = paddle.full(shape=shape, fill_value=3.) >>> print(data3.numpy()) [[3. 3.] [3. 3.] [3. 3.]] >>> # fill_value is a Tensor. >>> val = paddle.full([], 2.0, "float32") >>> data5 = paddle.full(shape=[3, 2], fill_value=val) >>> print(data5.numpy()) [[2. 2.] [2. 2.] [2. 2.]] N)r&r r7r5r)r&rr r5r!r!r"rs8rrPc Cs|dur|}d}|dur>|||fD],}t|ttjjfr*t|s't}nd}qt|tjs;t|t s;t}nd}qd}t|ttjjf o]t|ttjjf o]t|ttjjf }t so|rot t |||g}t|t jjt jfs}t|}|rtrt||||tSt|ttjjfstdtdg||dd}Wdn1swYn |j|krt||}t|ttjjfstdtdg||dd}Wdn1swYn |j|krt||}t|ttjjfstdtdg||dd}Wdn 1swYn |j|kr%t||}tr3t||||tSt|dgd d tdit}|j||d } |jd |||d d| idd| _ |durg| j!"|| S)a) Returns a 1-D Tensor with spaced values within a given interval. Values are generated into the half-open interval [``start``, ``end``) with the ``step``. (the interval including ``start`` but excluding ``end``). If ``dtype`` is float32 or float64, we advise adding a small epsilon to ``end`` to avoid floating point rounding errors when comparing against ``end``. Parameters: start(float|int|Tensor): Start of interval. The interval includes this value. If ``end`` is None, the half-open interval is [0, ``start``). If ``start`` is a Tensor, it is a 0-D Tensor which represents a scalar and data type is int32, int64, float32, float64. Default is 0. end(float|int|Tensor, optional): End of interval. The interval does not include this value. If ``end`` is a Tensor, it is a 0-D Tensor which represents a scalar and data type is int32, int64, float32, float64. If ``end`` is None, the half-open interval is [0, ``start``). Default is None. step(float|int|Tensor, optional): Spacing between values. For any out, it is the istance between two adjacent values, out[i+1] - out[i]. If ``step`` is a Tensor, it is a 0-D Tensor which represents a scalar and data type is int32, int64, float32, float64. . Default is 1. dtype(str|np.dtype, optional): The data type of the output tensor. Supported data types: int32, int64, float32, float64. If ``dytpe`` is None, the data type is float32. Default is None. name (str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: A 1-D Tensor with values from the interval [``start``, ``end``) taken with common difference ``step`` beginning from ``start``. Its data type is set by ``dtype``. Examples: .. code-block:: python >>> import paddle >>> out1 = paddle.arange(5) >>> print(out1.numpy()) [0 1 2 3 4] >>> out2 = paddle.arange(3, 9, 2.0) >>> print(out2.numpy()) [3. 5. 7.] >>> # use 4.999 instead of 5.0 to avoid floating point rounding errors >>> out3 = paddle.arange(4.999, dtype='float32') >>> print(out3.numpy()) [0. 1. 2. 3. 4.] >>> start_var = paddle.to_tensor(3) >>> out4 = paddle.arange(start_var, 7) >>> print(out4.numpy()) [3 4 5 6] Nrr0rOrPTrQr )r+r,r/r0r*r2z range/arangerange)r&)rVZEndZSteprYrIr[r])r)#r_r r@r`ra is_integerr^r<integerr>rmathceilrrrrsrrrarangerr rbr rrrr r?rerfr6rgrh) rRendstepr r5valZ out_shapeZis_value_inputrDror!r!r"rs:               rcCs|j}|jdd}|dusJd|t|dgd|t|jdkr-td|d|jdd }t|tfsBt d |d |jd d}|durU|j |j d }n |j ||j dd}|j dd|i||dkrkdnddd|id|S)zBase op of tril_op and triu_oprNzx cannot be None in ) r*r2r+r,r/r0r)rwrxrz x shape in z must be at least 2-Ddiagonalrz diagonal in z must be a python Intr5rFrKZ tril_triurtrilT)rlowerrYrZ)Z layer_typekwargsgetrrr&rcr_r>rrer rLrf)rDrrrr5ror!r!r" _tril_triu_ops:   rcC&tr t||SttditS)a Returns the lower triangular part of a matrix (2-D tensor) or batch of matrices :attr:`x`, the other elements of the result tensor are set to 0. The lower triangular part of the matrix is defined as the elements on and below the diagonal. Args: x (Tensor): The input x which is a Tensor. Support data types: ``bool``, ``float64``, ``float32``, ``int32``, ``int64``, ``complex64``, ``complex128``. diagonal (int, optional): The diagonal to consider, default value is 0. If :attr:`diagonal` = 0, all elements on and below the main diagonal are retained. A positive value includes just as many diagonals above the main diagonal, and similarly a negative value excludes just as many diagonals below the main diagonal. The main diagonal are the set of indices :math:`\{(i, i)\}` for :math:`i \in [0, \min\{d_{1}, d_{2}\} - 1]` where :math:`d_{1}, d_{2}` are the dimensions of the matrix. name (str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: Results of lower triangular operation by the specified diagonal of input tensor x, it's data type is the same as x's Tensor. Examples: .. code-block:: python >>> import paddle >>> data = paddle.arange(1, 13, dtype="int64").reshape([3,-1]) >>> print(data) Tensor(shape=[3, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[1 , 2 , 3 , 4 ], [5 , 6 , 7 , 8 ], [9 , 10, 11, 12]]) >>> tril1 = paddle.tril(data) >>> print(tril1) Tensor(shape=[3, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[1 , 0 , 0 , 0 ], [5 , 6 , 0 , 0 ], [9 , 10, 11, 0 ]]) >>> # example 2, positive diagonal value >>> tril2 = paddle.tril(data, diagonal=2) >>> print(tril2) Tensor(shape=[3, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[1 , 2 , 3 , 0 ], [5 , 6 , 7 , 8 ], [9 , 10, 11, 12]]) >>> # example 3, negative diagonal value >>> tril3 = paddle.tril(data, diagonal=-1) >>> print(tril3) Tensor(shape=[3, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[0 , 0 , 0 , 0 ], [5 , 0 , 0 , 0 ], [9 , 10, 0 , 0 ]]) rN)r)rrrrr r?rrr5r!r!r"rs: rcCtr t||SdS)z Inplace version of ``tril`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_tril`. N)rrtril_rr!r!r"r rcCr)a Return the upper triangular part of a matrix (2-D tensor) or batch of matrices :attr:`x`, the other elements of the result tensor are set to 0. The upper triangular part of the matrix is defined as the elements on and above the diagonal. Args: x (Tensor): The input x which is a Tensor. Support data types: ``float64``, ``float32``, ``int32``, ``int64``, ``complex64``, ``complex128``. diagonal (int, optional): The diagonal to consider, default value is 0. If :attr:`diagonal` = 0, all elements on and above the main diagonal are retained. A positive value excludes just as many diagonals above the main diagonal, and similarly a negative value includes just as many diagonals below the main diagonal. The main diagonal are the set of indices :math:`\{(i, i)\}` for :math:`i \in [0, \min\{d_{1}, d_{2}\} - 1]` where :math:`d_{1}, d_{2}` are the dimensions of the matrix. name (str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: Results of upper triangular operation by the specified diagonal of input tensor x, it's data type is the same as x's Tensor. Examples: .. code-block:: python >>> import paddle >>> x = paddle.arange(1, 13, dtype="int64").reshape([3,-1]) >>> print(x) Tensor(shape=[3, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[1 , 2 , 3 , 4 ], [5 , 6 , 7 , 8 ], [9 , 10, 11, 12]]) >>> # example 1, default diagonal >>> triu1 = paddle.tensor.triu(x) >>> print(triu1) Tensor(shape=[3, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[1 , 2 , 3 , 4 ], [0 , 6 , 7 , 8 ], [0 , 0 , 11, 12]]) >>> # example 2, positive diagonal value >>> triu2 = paddle.tensor.triu(x, diagonal=2) >>> print(triu2) Tensor(shape=[3, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 0, 3, 4], [0, 0, 0, 8], [0, 0, 0, 0]]) >>> # example 3, negative diagonal value >>> triu3 = paddle.tensor.triu(x, diagonal=-1) >>> print(triu3) Tensor(shape=[3, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[1 , 2 , 3 , 4 ], [5 , 6 , 7 , 8 ], [0 , 10, 11, 12]]) triuN)r)rrrrr r?rr!r!r"rs< rcCr)z Inplace version of ``triu`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_triu`. N)rrtriu_rr!r!r"rUrrcstdkrtdttfrdtrttS|dd}tdit tttfs6t dt D]\}}t |j dgddq:t}fd d t|D}jdd tid |id |S)a5 Takes a list of N tensors as input :attr:`*args`, each of which is 1-dimensional vector, and creates N-dimensional grids. Args: *args(Tensor|list of Tensor) : tensors (tuple(list) of tensor): the shapes of input k tensors are (N1,), (N2,),..., (Nk,). Support data types: ``float64``, ``float16``, ``float32``, ``int32``, ``int64``. **kwargs (optional): Currently, only accept name in **kwargs The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: k tensors. The shape of each tensor is (N1, N2, ..., Nk) Examples: .. code-block:: python >>> import paddle >>> x = paddle.randint(low=0, high=100, shape=[100]) >>> y = paddle.randint(low=0, high=100, shape=[200]) >>> grid_x, grid_y = paddle.meshgrid(x, y) >>> print(grid_x.shape) [100, 200] >>> print(grid_y.shape) [100, 200] rPrr5Nmeshgridz2The type of input args in meshgrid should be list.zcreate data type)r2r*r+r,r/r0csg|] }j|jdqS)r)rer ).0iargsrDr!r" szmeshgrid..rrYr)r)rr_r:r;rrrrr r?rrrr rrf)rrr5idZinput_rMror!rr"r`s2   rrc Cst|ts t|}trt||||Sd|gi}|||d}dd}|||||td it}|j|j d}|j dd|gi|||dd|gidd |_ |S) aH Creates a tensor whose diagonals of certain 2D planes (specified by dim1 and dim2) are filled by ``input``. By default, a 2D plane formed by the last two dimensions of the returned tensor will be selected. The argument ``offset`` determines which diagonal is generated: - If offset = 0, it is the main diagonal. - If offset > 0, it is above the main diagonal. - If offset < 0, it is below the main diagonal. Args: input(Tensor|numpy.ndarray): The input tensor. Must be at least 1-dimensional. The input data type should be float32, float64, int32, int64. offset(int, optional): Which diagonal to consider. Default: 0 (main diagonal). dim1(int, optional): The first dimension with respect to which to take diagonal. Default: -2. dim2(int, optional): The second dimension with respect to which to take diagonal. Default: -1. Returns: Tensor, the output data type is the same as input data type. Examples: .. code-block:: python >>> import paddle >>> diag_embed_input = paddle.arange(6) >>> diag_embed_output1 = paddle.diag_embed(diag_embed_input) >>> print(diag_embed_output1) Tensor(shape=[6, 6], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [0, 0, 2, 0, 0, 0], [0, 0, 0, 3, 0, 0], [0, 0, 0, 0, 4, 0], [0, 0, 0, 0, 0, 5]]) >>> diag_embed_output2 = paddle.diag_embed(diag_embed_input, offset=-1, dim1=0,dim2=1 ) >>> print(diag_embed_output2) Tensor(shape=[7, 7], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0], [0, 0, 2, 0, 0, 0, 0], [0, 0, 0, 3, 0, 0, 0], [0, 0, 0, 0, 4, 0, 0], [0, 0, 0, 0, 0, 5, 0]]) >>> diag_embed_input_2dim = paddle.reshape(diag_embed_input,[2,3]) >>> print(diag_embed_input_2dim) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 1, 2], [3, 4, 5]]) >>> diag_embed_output3 = paddle.diag_embed(diag_embed_input_2dim,offset= 0, dim1=0, dim2=2 ) >>> print(diag_embed_output3) Tensor(shape=[3, 2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[[0, 0, 0], [3, 0, 0]], [[0, 1, 0], [0, 4, 0]], [[0, 0, 2], [0, 0, 5]]]) Input)offsetdim1dim2cSst|jdgddt|j}t|dksJdt|t|t|ks6Jdt|d t||ft|t|ksOJdt|d t||f|dkrU|nt||d}|dkrc|nt||d}||kswJd ||fdS) Nr)r/r0r*r+r, diag_embedrPzLInput must be at least 1-dimensional, But received Input's dimensional: %s. zHDim1 is out of range (expected to be in range of [%d, %d], but got %d). zHDim2 is out of range (expected to be in range of [%d, %d], but got %d). rzMdim1 and dim2 cannot be the same dimension.But received dim1 = %d, dim2 = %d )rr r:r&rr<abs)inputrrrZ input_shapeZdim1_Zdim2_r!r!r" __check_inputs:  z!diag_embed..__check_inputrrrYrZTN)r) r_r rrrrr r?rer rfr6) rrrrr[r\rrDror!r!r"rs$ @   rc Cs,trt|jdkrt||dSt|dd}t||dSd}t|dtdt|j dgddt|dt dt dit }|j |j d}| |j }|j |j d}t|jdkrm|jd d |id |i||d d n$|jdd |i||ddddd d|_|jd d |id |i||d d d|_|S)a If ``x`` is a vector (1-D tensor), a 2-D square tensor with the elements of ``x`` as the diagonal is returned. If ``x`` is a tensor (more than 1-D), a 2-D square tensor with the elements of flattened ``x`` as the diagonal is returned. The argument ``offset`` controls the diagonal offset. If ``offset`` = 0, it is the main diagonal. If ``offset`` > 0, it is superdiagonal. If ``offset`` < 0, it is subdiagonal. Args: x (Tensor): The input tensor. It can be any shape. Its data type should be float16, float32, float64, int32, int64. offset (int, optional): The diagonal offset. A positive value represents superdiagonal, 0 represents the main diagonal, and a negative value represents subdiagonal. Default: 0 (main diagonal). name (str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor, a square matrix. The output data type is the same as input data type. Examples: .. code-block:: python :name: code-example-1 >>> import paddle >>> x = paddle.to_tensor([1, 2, 3]) >>> y = paddle.diagflat(x) >>> print(y) Tensor(shape=[3, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[1, 0, 0], [0, 2, 0], [0, 0, 3]]) >>> y = paddle.diagflat(x, offset=1) >>> print(y) Tensor(shape=[4, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 1, 0, 0], [0, 0, 2, 0], [0, 0, 0, 3], [0, 0, 0, 0]]) >>> y = paddle.diagflat(x, offset=-1) >>> print(y) Tensor(shape=[4, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 0, 0, 0], [1, 0, 0, 0], [0, 2, 0, 0], [0, 0, 3, 0]]) .. code-block:: python :name: code-example-2 >>> import paddle >>> x = paddle.to_tensor([[1, 2], [3, 4]]) >>> y = paddle.diagflat(x) >>> print(y) Tensor(shape=[4, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[1, 0, 0, 0], [0, 2, 0, 0], [0, 0, 3, 0], [0, 0, 0, 4]]) >>> y = paddle.diagflat(x, offset=1) >>> print(y) Tensor(shape=[5, 5], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 1, 0, 0, 0], [0, 0, 2, 0, 0], [0, 0, 0, 3, 0], [0, 0, 0, 0, 4], [0, 0, 0, 0, 0]]) >>> y = paddle.diagflat(x, offset=-1) >>> print(y) Tensor(shape=[5, 5], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 0, 0, 0, 0], [1, 0, 0, 0, 0], [0, 2, 0, 0, 0], [0, 0, 3, 0, 0], [0, 0, 0, 4, 0]]) rPrrrdiagflatrrrdiag_v2rrYr padding_valuerIr[r]r\Zflatten_contiguous_range)rYZXShape)Z start_axisZ stop_axisTN)r)rrr&rdiagflattenrr rr r>r r?rerfr6) rrr5yrrDZout1Z out1_shapeZout2r!r!r"rsPV rcCstr t|||St|dtdt|jdgddt|dtdt|dttfdt |j dkrCt |j dkrCt d t |j t dit}|j|jd }|jdd |id |i||d d d|_|S)a If ``x`` is a vector (1-D tensor), a 2-D square tensor with the elements of ``x`` as the diagonal is returned. If ``x`` is a matrix (2-D tensor), a 1-D tensor with the diagonal elements of ``x`` is returned. The argument ``offset`` controls the diagonal offset: If ``offset`` = 0, it is the main diagonal. If ``offset`` > 0, it is superdiagonal. If ``offset`` < 0, it is subdiagonal. Args: x (Tensor): The input tensor. Its shape is either 1-D or 2-D. Its data type should be float16, float32, float64, int32, int64. offset (int, optional): The diagonal offset. A positive value represents superdiagonal, 0 represents the main diagonal, and a negative value represents subdiagonal. padding_value (int|float, optional): Use this value to fill the area outside the specified diagonal band. Only takes effect when the input is a 1-D Tensor. The default value is 0. name (str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor, a square matrix or a vector. The output data type is the same as input data type. Examples: .. code-block:: python :name: code-example-1 >>> import paddle >>> paddle.disable_static() >>> x = paddle.to_tensor([1, 2, 3]) >>> y = paddle.diag(x) >>> print(y) Tensor(shape=[3, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[1, 0, 0], [0, 2, 0], [0, 0, 3]]) >>> y = paddle.diag(x, offset=1) >>> print(y) Tensor(shape=[4, 4], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 1, 0, 0], [0, 0, 2, 0], [0, 0, 0, 3], [0, 0, 0, 0]]) >>> y = paddle.diag(x, padding_value=6) >>> print(y) Tensor(shape=[3, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[1, 6, 6], [6, 2, 6], [6, 6, 3]]) .. code-block:: python :name: code-example-2 >>> import paddle >>> paddle.disable_static() >>> x = paddle.to_tensor([[1, 2, 3], [4, 5, 6]]) >>> y = paddle.diag(x) >>> print(y) Tensor(shape=[2], dtype=int64, place=Place(cpu), stop_gradient=True, [1, 5]) >>> y = paddle.diag(x, offset=1) >>> print(y) Tensor(shape=[2], dtype=int64, place=Place(cpu), stop_gradient=True, [2, 6]) >>> y = paddle.diag(x, offset=-1) >>> print(y) Tensor(shape=[1], dtype=int64, place=Place(cpu), stop_gradient=True, [4]) rrrSrrrPrz?The dimension of input x must be either 1 or 2, but received {}rrrYrrTN)r)rrrrr rr r>rBrr&rcrdr r?rerfr6)rrrr5rDror!r!r"rs6KrcCs|durt}t|}tr$tj|}t|t|t }d|_ |St d it }i}t |dgddt|dtttfdt|trPt |jdddgdi}tjj|||dd |j|d }t||d<|jd|d |gi|dd d|_ |S)a] Returns a Tensor with uninitialized data which size is same as ``shape``. Args: shape (tuple|list|Tensor): Shape of the Tensor to be created. The data type is ``int32`` or ``int64`` . If ``shape`` is a list or tuple, each element of it should be integer or 0-D Tensor with shape []. If ``shape`` is an Tensor, it should be an 1-D Tensor which represents a list. dtype(np.dtype|str, optional): Data type of the output Tensor which can be bool, float16, float32, float64, int32, int64, complex64, complex128 if dytpe is `None`, the data type of created Tensor use global default dtype (see ``get_default_dtype`` for details). name(str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: Tensor which is created according to ``shape`` and ``dtype``, and is uninitialized. Examples: .. code-block:: python >>> import paddle >>> # shape is a list/tuple >>> data1 = paddle.empty(shape=[3, 2]) >>> print(data1.numpy()) >>> # doctest: +SKIP('change everytime') [[1. 1.] [1. 1.] [1. 1.]] >>> # shape is a Tensor >>> shape = paddle.to_tensor([3, 2]) >>> data2 = paddle.empty(shape=shape) >>> print(data2.numpy()) >>> # doctest: +SKIP('change everytime') [[1. 1.] [1. 1.] [1. 1.]] >>> # shape is a Tensor List >>> shape = [paddle.to_tensor(3), paddle.to_tensor(2)] >>> data3 = paddle.empty(shape=shape) >>> print(data3.numpy()) >>> # doctest: +SKIP('change everytime') [[1. 1.] [1. 1.] [1. 1.]] NTemptyr )r)r*r+r,r/r0rwrxr&r/r0rrrYr)r)r@r^rrrrrrrrr6r r?rrr r:r;r_r rrerf)r&r r5rorDr[r\r!r!r"r sH1      rcCs|dur|j}t|}trt|jt|t}d|_|St r5t |}t|t|t}d|_|St d it }t |dgddt|dgdd|j|d}i}i}t||d<t |}t jj|||dd|jd |d |gi|dd d|_|S) a Returns a Tensor with uninitialized data which has identical shape of ``x`` and ``dtype``. If the ``dtype`` is None, the data type of Tensor is same with ``x``. Args: x(Tensor): The input tensor which specifies shape and data type. The data type can be bool, float16, float32, float64, int32, int64. dtype(np.dtype|str, optional): The data type of output. The data type can be one of bool, float16, float32, float64, int32, int64. The default value is None, which means the output data type is the same as input. name(str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: Tensor which is created according to ``x`` and ``dtype``, and is uninitialized. Examples: .. code-block:: python >>> import paddle >>> paddle.set_device("cpu") # and use cpu device >>> x = paddle.randn([2, 3], 'float32') >>> output = paddle.empty_like(x) >>> print(output) >>> # doctest: +SKIP('change everytime') [[1.8491974e+20 1.8037303e+28 1.7443726e+28] [4.9640171e+28 3.0186127e+32 5.6715899e-11]] NT empty_liker)r)r*r+r,r/r0r2r rrrrYr)r)r rrrrr&rrr6rr@r r?rrrerrrf)rr r5ror&rDr[r\r!r!r"rrsd      rc Cs||urt|ttjjfr|S|}td%it}t|dttjjtj t t t t tfdt|r>> import paddle >>> import numpy as np >>> data = paddle.full(shape=[3, 2], fill_value=2.5, dtype='float64') >>> print(data.numpy()) [[2.5 2.5] [2.5 2.5] [2.5 2.5]] >>> array = np.array([[1, 1], ... [3, 4], ... [1, 3]]).astype(np.int64) >>> result1 = paddle.zeros(shape=[3, 3], dtype='float32') >>> paddle.assign(array, result1) >>> print(result1.numpy()) [[1 1] [3 4] [1 3]] >>> result2 = paddle.assign(data) >>> print(result2.numpy()) [[2.5 2.5] [2.5 2.5] [2.5 2.5]] >>> result3 = paddle.assign(np.array([[2.5, 2.5], [2.5, 2.5], [2.5, 2.5]], dtype='float32')) >>> print(result3.numpy()) [[2.5 2.5] [2.5 2.5] [2.5 2.5]] rrN r*r2r+r,r/r0r1r-r)z/(When the type of input in assign is Variable.)rrrYrrcss"|] }t|ttjjfVqdSr)r_r r@r`rarrr!r!r" I s zassign..css2|]}t|ttjjtjjfr|jdkVqdS))rPN) r_r rrrr@r`rar&rr!r!r"rM s zJUnsupport paddle.assign([Variable, Variable...]) with non-scalar variable.cSs$t|ttjjtjjfst|S|Sr) r_r rrrr@r`rar)rr!r!r"convert_scalarX s zassign..convert_scalarrrzrThe type of received input == `object`, it is not supported to convert to tensor, such as [[Var], [Var], [3], [4]]zzpaddle.assign doesn't support float64 input now due to current platform protobuf data limitation, we convert it to float32Z bool_valuescSg|]}t|qSr!r>rvr!r!r"r zassign..Z fp32_valuescSrr!)rBrr!r!r"r rZ int32_valuescSrr!rrr!r!r"r rZ int64_valuescSrr!rrr!r!r"r rzWhen the type of 'input' in assign is numpy.ndarray, the data type of 'input' must be bool, float32, int32 or int64, but received %s.izXThe size of input is too big. Please consider saving it to file and 'load_op' to load itZ assign_valuer r&)rIr]r\)r);r_r r@r`rar r?rr<r=r:r;rBr>r)r~rr}rrrrrrZ assign_out_rrr rerfrr&anyallrmaprZsqueezerrrrwarningswarnrrsZFLOAT64ZFLOAT32ZBOOLZflatZINT32ZINT64rsizercrrZ assign_value_r) rrrrDrrretr Z value_namevaluesr!r!r"rs-        t          rcCs|S)a Returns a copy of input Tensor. It will always have a Tensor copy. In addition, This function is derivable, so gradients will flow back from the output to input. Parameters: x (Tensor): The input Tensor. name(str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor, A Tensor copied from ``input``. Examples: .. code-block:: python >>> import paddle >>> import numpy as np >>> x = paddle.ones([2]) >>> x.stop_gradient = False >>> x.retain_grads() >>> clone_x = paddle.clone(x) >>> clone_x.retain_grads() >>> y = clone_x**3 >>> y.backward() >>> print(clone_x.grad.numpy()) [3. 3.] >>> print(x.grad.numpy()) [3. 3.] )clone)rr5r!r!r"r s rcCstdit}t|dtdt|ttjjfr#t|j dgddd|dur.|j |j d}d}|dur7d}n$t }| || rGd}n|rNd }n |rUd }n|r[d }d |i}|jdd |gid|gi|d|S)a The OP copies the :attr:`input` to the :attr:`output`. NOTE: currently, only support CUDAPlace <-> CUDAPinnedPlace. Parameters: input (Tensor): A tensor. Its data type supports float16, float32, float64, int32, int64, and bool. device (Place): Target place for the output. output (Tensor, optional): A tensor. If :attr:`output` is None, a new tensor will be created as :attr:`output`. Default: None. Returns: Tensor, A tensor with the same shape, data type and value as :attr:`input`. Examples: .. code-block:: python >>> import paddle >>> data = paddle.full(shape=[3, 2], fill_value=2.5, dtype='float64') >>> print(data.numpy()) [[2.5 2.5] [2.5 2.5] [2.5 2.5]] >>> # doctest: +SKIP('NOTE(zhiqiu): not public') >>> result = paddle._memcpy(data, place=paddle.CPUPlace()) >>> print(result2) [[2.5 2.5] [2.5 2.5] [2.5 2.5]] memcpyrrz/(When the type of input in memcpy is Variable.)NrrrrPrdst_place_typerrYr)r)r r?rr r_rrrrr rerZ set_placeZ is_cpu_placeZ is_gpu_placeZis_cuda_pinned_placeZ is_xpu_placerf)rrzrrDrpr\r!r!r"_memcpy sB   rc Cstr t||St|dddgdt|dddgdd}t|fit}||d}|jt|jd}d|i}i}|j ||||d |S) aReturn a compelx tensor given the real and image component. Args: real (Tensor): The real component. The data type should be 'float32' or 'float64'. imag (Tensor): The image component. The data type should be the same as ``real``. name (str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: The output tensor. The data type is 'complex64' or 'complex128', with the same precision as ``real`` and ``imag``. Note: ``paddle.complex`` supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor Examples: .. code-block:: python >>> import paddle >>> x = paddle.arange(2, dtype=paddle.float32).unsqueeze(-1) >>> y = paddle.arange(3, dtype=paddle.float32) >>> z = paddle.complex(x, y) >>> print(z) Tensor(shape=[2, 3], dtype=complex64, place=Place(cpu), stop_gradient=True, [[0j , 1j , 2j ], [(1+0j), (1+1j), (1+2j)]]) realr+r,compleximag)rYrrYrZ) rrrrr r?rer%r rf) rrr5rrDr[ror]r\r!r!r"r0 s(    rr0c Ct|tjjs t|}tr |dur|}t||||t}|St|t r)|dkr-t d|dur?t|t r:|dkr>t dn|}t|t sJt dt d it }|j |d}|jdid|gi||||d d |S) a0 Return the indices of the lower triangular part of the 2-D matrix whose row and col is knowed.Indices are ordered based on row and then columns. The lower triangular part of the matrix is defined as the elements on and below the diagonal. Args: row (int): The input x which is a int number describe the number of row of the matrix. col (int): The input x which is a int number describe the number of col of the matrix. offset (int, optional): The offset to consider, default value is 0. - If offset = 0, all elements on and below the main diagonal are retained. - If offset > 0, include just as many diagonals above the main diagonal. - If offset < 0, excludes just as many diagonals below the main diagonal. dtype (int, optional): the data type of the output tensor, can be int32, int64. Returns: Tensor: Results of the indices of lower triangular part of a row * col matrix, where the first row contains row coordinates of and the second row contains column coordinates. Examples: .. code-block:: python >>> import paddle >>> # example 1, default offset value >>> data1 = paddle.tril_indices(4,4,0) >>> print(data1) Tensor(shape=[2, 10], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 1, 1, 2, 2, 2, 3, 3, 3, 3], [0, 0, 1, 0, 1, 2, 0, 1, 2, 3]]) >>> # example 2, positive offset value >>> data2 = paddle.tril_indices(4,4,2) >>> print(data2) Tensor(shape=[2, 15], dtype=int64, place=Place(cpu), stop_gradient=True, [[0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3], [0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]]) >>> # example 3, negative offset value >>> data3 = paddle.tril_indices(4,4,-1) >>> print(data3) Tensor(shape=[2, 6], dtype=int64, place=Place(cpu), stop_gradient=True, [[1, 2, 2, 3, 3, 3], [0, 0, 1, 0, 1, 2]]) Nr row should be a non-negative int col should be a non-negative intzoffset should be a int tril_indicesrro)rowscolsrr r)r)r_rrrrrrrrr>rr r?rerfrowcolrr rorDr!r!r"rd s60    rc Cr) a Return the indices of the upper triangular part of the 2-D matrix whose row and col is known. Indices are ordered based on row and then columns. The upper triangular part of the matrix is defined as the elements on and above the diagonal. Args: row (int): The input x which is a int number describe the number of row of the matrix. col (int, optional): The input x which is a int number describe the number of col of the matrix. default value for col is None, then it will be set equal to row, indicting a square matix. offset (int, optional): The offset to consider, default value is 0. - If offset = 0, all elements on and above the main diagonal are retained. - If offset > 0, include just as few diagonals above the main diagonal. - If offset < 0, excludes just as few diagonals below the main diagonal. dtype (str|np.dtype|paddle.dtype, optional): the data type of the output tensor, can be int32, int64, default value is int64. Returns: Tensor: Results of the indices of upper triangular part of a row * col matrix, where the first row contains row coordinates of and the second row contains column coordinates. Examples: .. code-block:: python >>> import paddle >>> # example 1, default offset value >>> data1 = paddle.triu_indices(4,4,0) >>> print(data1.numpy()) [[0 0 0 0 1 1 1 2 2 3] [0 1 2 3 1 2 3 2 3 3]] >>> # example 2, positive offset value >>> data2 = paddle.triu_indices(4,4,2) >>> print(data2.numpy()) [[0 0 1] [2 3 3]] >>> # example 3, negative offset value >>> data3 = paddle.triu_indices(4,4,-1) >>> print(data3.numpy()) [[0 0 0 0 1 1 1 1 2 2 2 3 3] [0 1 2 3 0 1 2 3 1 2 3 2 3]] Nrrrzoffset should be a int triu_indicesrro)r r rr r)r )r_rrrrrrr rr>rr r?rerfrr!r!r"r  s6+    r cCsDt|dddgdt|dddgdt|t||t|S)asReturn a Cartesian coordinates corresponding to the polar coordinates compelx tensor given the ``abs`` and ``angle`` component. Args: abs (Tensor): The abs component. The data type should be 'float32' or 'float64'. angle (Tensor): The anglee component. The data type should be the same as ``abs``. name (str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: The output tensor. The data type is 'complex64' or 'complex128', with the same precision as ``abs`` and ``angle``. Note: ``paddle.polar`` supports broadcasting. If you want know more about broadcasting, please refer to `Introduction to Tensor`_ . .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor Examples: .. code-block:: python >>> import paddle >>> import numpy as np >>> abs = paddle.to_tensor([1, 2], dtype=paddle.float64) >>> angle = paddle.to_tensor([np.pi / 2, 5 * np.pi / 4], dtype=paddle.float64) >>> out = paddle.polar(abs, angle) >>> print(out) Tensor(shape=[2], dtype=complex128, place=Place(cpu), stop_gradient=True, [ (6.123233995736766e-17+1j) , (-1.4142135623730954-1.414213562373095j)]) rr+r,z paddle.polarangle)rr@rcossin)rr r5r!r!r"polar s   rcCsR|t||j}td|j}||tj | ||S)a}Fills the tensor with numbers drawn from the Cauchy distribution. Args: x (Tenosr): the tensor will be filled, The data type is float32 or float64. loc (scalar, optional): Location of the peak of the distribution. The data type is float32 or float64. scale (scalar, optional): The half-width at half-maximum (HWHM). The data type is float32 or float64. Must be positive values. name (str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: input tensor with numbers drawn from the Cauchy distribution. Examples: .. code-block:: python >>> import paddle >>> x = paddle.randn([3, 4]) >>> x.cauchy_(1, 2) >>> # doctest: +SKIP('random check') >>> print(x) Tensor(shape=[3, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 3.80087137, 2.25415039, 2.77960515, 7.64125967], [ 0.76541221, 2.74023032, 1.99383152, -0.12685823], [ 1.45228469, 1.76275957, -4.30458832, 34.74880219]]) g?) Znormal_r@rrtr Z subtract_Zscale_r<piZtan_Zadd_)rlocscaler5Zhalfr!r!r"cauchy_- s "rcCsVtjt|jdj}t||j}|jt |t dd| t | |S)a7Fills the tensor with numbers drawn from the Geometric distribution. Args: x (Tenosr): the tensor will be filled, The data type is float32 or float64. probs (Real|Tensor): Probability parameter. The value of probs must be positive. When the parameter is a tensor, probs is probability of success for each trial. name (str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: input tensor with numbers drawn from the Geometric distribution. Examples: .. code-block:: python >>> import paddle >>> x = paddle.randn([3, 4]) >>> x.geometric_(0.3) >>> # doctest: +SKIP('random check') >>> print(x) Tensor(shape=[3, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[2.42739224, 4.78268528, 1.23302543, 3.76555204], [1.38877118, 0.16075331, 0.16401523, 2.47349310], [1.72872102, 2.76533413, 0.33410925, 1.63351011]]) rrP)minmax) r<Zfinforr tinyr@rrtZuniform_rBZlog_Zdivide_log1p)rZprobsr5rr!r!r" geometric_O s r)FFN)NNFN)NF)NN)rpNN)NNT)FNN)NNN)rNrPNN)rN)rrr)rrNr)rr0)Nrr0)rrPN)Grrrnumpyr<r@rZpaddle.utils.inplace_utilsrZbase.data_feederrrrrr Zbase.frameworkr r Zbase.param_attrr Z frameworkr rrrrrrrrr__all__r#r%r'rFrJrNrqrrrrrbrrrrrrrrrrrrrrrrrrrrrrrr rrrr!r!r!r"sz   0   R R * z  f C S S d 0 # 1 $ Q > 1@  B  A w  m g f d $ Q 4 T O& !