o #jv@s.ddlZddlZddlmZddlmZddlmZddlm Z m Z m Z m Z ddl mZddlmZmZmZmZmZmZmZmZd d lmZmZmZgZdd d ZddZeddZddZ dddZ!dddZ"dddZ#dddZ$eddZ%edd Z&edd!d"Z'dd#d$Z(dd%d&Z)dd'd(Z*ed)d*Z+dd+d,Z,dd-d.Z-dd/d0Z.d dd gdfd1d2Z/dd3d4Z0edd5d6Z1dd7d8Z2dd9d:Z3dd;d<Z4dd=d>Z5dd?d@Z6eddAdBZ7  C ddDdEZ8  C ddFdGZ9ddHdIZ:eddJdKZ;ddLdMZeddSdTZ?ddUdVZ@ddWdXZAddYdZZBdd[d\ZCdd]d^ZDdd_d`ZEddadbZFddcddZGeddedfZHddgdhdiZIddgdjdkZJddgdldmZKddndoZLddpdqZMddrdsZNddtduZOddvdwZPddxdyZQddzd{ZRdd|d}ZSedd~dZTddZUddZVdddZW P PdddZXe PdddZYdddZZedddZ[edddZ\dddZ]dddZ^edddZ_edddZ`edddZaedddZbe%e&e'e)e*e+dZcecdD] \ZeZfegejhjieeefqddZjdddZkedddZldddZmdddZndS)N)_C_ops) fill_constant)inplace_apis_in_dygraph_only) check_dtype check_typecheck_variable_and_dtype convert_dtype)Variable) LayerHelper_current_expected_placeconvert_np_dtype_to_dtype_core dygraph_onlyin_dynamic_modein_dynamic_or_pir_mode in_pir_mode)_complex_to_real_dtype_real_to_complex_dtypezerosFcstr3t|ts Jdddlm}m}|r|n|}||d}ttfdd|D}||fSt rwt |dttj j fdt|trgt |D]\} } t | d t| d tj j d| setd qJn|sotd tj||St |dttfdt|trt |D]\} } t | d t| d tdqtdit} | j| d } | jd d } | jdd|i| g| gd|dd| | fS)a This function concatenates or stacks all tensors in the input LoDTensorArray along the axis mentioned and returns that as the output. For Example: .. code-block:: text Case 1: Given: input.data = {[[0.6, 0.1, 0.3], [0.5, 0.3, 0.2]], [[1.3], [1.8]], [[2.3, 2.1], [2.5, 2.4]]} axis = 1, use_stack = False Then: output.data = [[0.6, 0.1, 0.3, 1.3, 2.3, 2.1], [0.5, 0.3, 0.2, 1.8, 2.5, 2.4]] output_index.data = [3, 1, 2] Case 2: Given: input.data = {[[0.6, 0.1], [0.5, 0.3]], [[0.3, 1.3], [0.2, 1.8]], [[2.3, 2.1], [2.5, 2.4]]} axis = 1, use_stack = True Then: output.data = [[[0.6, 0.1] [0.3, 1.3] [2.3, 2.1], [[0.5, 0.3] [0.2, 1.8] [2.5, 2.4]]] output_index.data = [2, 2, 2] Args: input(TensorArray): A TensorArray variable. axis(int): The axis along which the tensors in attr::`input` will be concatenated or stacked. use_stack(bool): Act as concat_op or stack_op. For stack mode, all tensors in the tensor array must have the same shape. name(str|None): A name for this layer(optional). If set None, the layer will be named automatically. Returns: Tensor: The concatenated or stacked tensor variable. Tensor: A 1-D tensor variable with int32 data type. The data in this \ tensor contains all input including tensors' sizes along the axis. Examples: .. code-block:: python >>> import numpy >>> import paddle >>> x0 = paddle.assign(numpy.random.rand(2, 2).astype("float32")) >>> x1 = paddle.assign(numpy.random.rand(2, 2).astype("float32")) >>> i = paddle.full(shape=[1], dtype="int64", fill_value=0) >>> array = paddle.tensor.array.create_array(dtype='float32') >>> paddle.tensor.array.array_write(x0, i, array) >>> paddle.tensor.array.array_write(x1, i + 1, array) >>> output, output_index = paddle.tensor.manipulation.tensor_array_to_tensor(input=array) z2The 'input' in tensor_array_to_tensor must be listr)concatstackaxiscsg|] }t|jqS)intshape).0xrr[/var/www/html/Deteccion_Ine/venv/lib/python3.10/site-packages/paddle/tensor/manipulation.py sz*tensor_array_to_tensor..inputtensor_array_to_tensorinput[]z%input should be tensor array vairabledtypeint32XOutZOutIndexr use_stacktypeinputsoutputsattrsN)r#)r isinstancelistpaddlerr to_tensornparrayrrpirOpResult enumeratestrZis_dense_tensor_array_type TypeErrorZ_pir_opsZarray_to_tensorr r locals"create_variable_for_type_inference input_dtype append_op)r"rr-namerropressizesiZinput_xhelperout out_indexrrr r#.slP        r#cCst|tjjtjfst|}trt||St |dgddt |dgddt d it }|j ||jd}|jdd|gid|gi|j|jd d |S) a Take in the Tensor :attr:`x` with :attr:`x.dtype` and cast it to the output with :attr:`dtype`. It's meaningless if the output dtype equals the input dtype, but it's fine if you do so. Args: x (Tensor): An input N-D Tensor with data type bool, float16, float32, float64, int32, int64, uint8. dtype (np.dtype|str): Data type of the output: bool, float16, float32, float64, int8, int32, int64, uint8. Returns: Tensor, A Tensor with the same shape as input's. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([2, 3, 4], 'float64') >>> y = paddle.cast(x, 'uint8') r) boolfloat16float32float64int16r(int64uint8uint16castr') rJrKrLrMint8rNr(rOrPrQr' stop_gradientr)r+)Zin_dtypeZ out_dtyper.N)rR)r3rVarDescVarTypeZDataTyper rrrRrrr r>r?rUrAr')rr'rGrHrrr rRs6    rRcCs,trt|tjjst|}t||SdS)z Inplace version of ``cast`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_cast`. N)rr3rrVrWr rcast_)rr'rrr rXs  rXcCst|ttfrBt|}t|dkrtdtt|D]%}||dkr2td||t|j||<qtt|jd||||<qn tdt |t rd}d}d}ddtt|D}t|ttfrnd d|D}nt|t j j r|d } t| }d dtt|D}t|ttfrd d|D}nt|t j j r|d } t| }d dtt|D}t|||||gStrut|tttjjfstdt|tttjjfstdddtt|D}t|tjjrd|_ddtt|D}n+t|ttfr)tj|r)t|D]\}} t| tjjr!d||<qtj|}t|tjjr@d|_ddtt|D}n+t|ttfrktj|rkt|D]\}} t| tjjrcd||<qStj|}t|||||gSt|tttfstdt|tttfstdtd(it} d|i} d|i}ddtt|D}t|trd|_|| d<ddtt|D}nDt|ttfrg|d<tj|rtj|| d<t|D]\}} t| tr|ddd||<q|d| qn||d<t|tr d|_|| d<d dtt|D}nDt|ttfrdg|d!<tj|r`tj|| d"<t|D]\}} t| trV|d!dd||<q?|d!| q?n||d!<||d#<| j| d$d%} | j!d| |d&| id'| S))a This operator produces a slice of ``input`` along multiple axes. Similar to numpy: https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html 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 data tensor. 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 n (the number of elements in this dimension), 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``. Following examples will explain how slice works: .. code-block:: text Case1: Given: data = [ [1, 2, 3, 4], [5, 6, 7, 8], ] axes = [0, 1] starts = [1, 0] ends = [2, 3] Then: result = [ [5, 6, 7], ] Case2: Given: data = [ [1, 2, 3, 4], [5, 6, 7, 8], ] axes = [0, 1] starts = [0, 1] ends = [-1, 1000] # -1 denotes the reverse 0th position of dimension 0. Then: result = [ [2, 3, 4], ] # result = data[0:1, 1:4] Args: input (Tensor): A ``Tensor`` . The data type is ``float16``, ``float32``, ``float64``, ``int32`` or ``int64``. axes (list|tuple): The data type is ``int32`` . Axes that `starts` and `ends` apply to . starts (list|tuple|Tensor): The data type is ``int32`` . If ``starts`` is a list or tuple, each element of it should be integer or 0-D int Tensor with shape []. If ``starts`` is an Tensor, it should be an 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, each element of it should be integer or 0-D int Tensor with shape []. If ``ends`` is an Tensor, it should be an 1-D Tensor . It represents ending indices of corresponding axis in ``axes``. Returns: Tensor, A ``Tensor``. The data type is same as ``input``. Examples: .. code-block:: python >>> import paddle >>> input = paddle.rand(shape=[4, 5, 6], dtype='float32') >>> # example 1: >>> # attr starts is a list which doesn't contain tensor. >>> axes = [0, 1, 2] >>> starts = [-3, 0, 2] >>> ends = [3, 2, 4] >>> sliced_1 = paddle.slice(input, axes=axes, starts=starts, ends=ends) >>> # sliced_1 is input[1:3, 0:2, 2:4]. >>> # example 2: >>> # attr starts is a list which contain tensor. >>> minus_3 = paddle.full([1], -3, "int32") >>> sliced_2 = paddle.slice(input, axes=axes, starts=[minus_3, 0, 2], ends=ends) >>> # sliced_2 is input[1:3, 0:2, 2:4]. rz-Input axes should not be an empty list/tuple.rz8Input axes must be a python list or tuple, but reveived rNcSg|]}dqSrrrrFrrr r!ezslice..cS(g|]}t|tjjr|dn|qSrr3reagerTensoritemrrbrrr r!hFcSrYrr[rrr r!or\cSr]r^r_rcrrr r!rrdcSrYrerr[rrr r!yr\z7Input starts must be an OpResult, python list or tuple.z5Input ends must be an OpResult, python list or tuple.cSrYrZrr[rrr r!r\TcSrYrerr[rrr r!r\rfcSrYrerr[rrr r!r\z7Input starts must be an Variable, python list or tuple.z5Input ends must be an Variable, python list or tuple.sliceInputaxescSrYrZrr[rrr r!r\ StartsTensorcSrYrerr[rrr r!r\startsStartsTensorList EndsTensorcSrYrerr[rrr r!r\endsEndsTensorList infer_flagsr"r&r+r/r0r2r1)rg)"r3r4tuplelen ValueErrorrangemaxrminr/rrr`ranumpyrrgrr5r9r:rUutils _contain_varr;get_int_tensor_listr r r>_convert_to_tensor_listappendr?r@rA)r"rirkrnrFr2Z starts_tensorZ ends_tensorrpZtensor_tdimrGr0rHrrr rg sD               rgcCstr t||St|dgddt|dttfdt|tr$t|}t|t|j kr=t dt|j dt|dt |D]\}}|t|j krZt d|||t|j fqAt dit }||j}||j}|jd d |gi|g|gd d |id |S)a Permute the data dimensions of `input` according to `perm`. The `i`-th dimension of the returned tensor will correspond to the perm[i]-th dimension of `input`. Args: x (Tensor): The input Tensor. It is a N-D Tensor of data types bool, float32, float64, int32. perm (list|tuple): Permute the input according to the data of perm. name (str): The name of this layer. It is optional. Returns: Tensor, A transposed n-D Tensor, with data type being bool, float32, float64, int32, int64. For Example: .. code-block:: text x = [[[ 1 2 3 4] [ 5 6 7 8] [ 9 10 11 12]] [[13 14 15 16] [17 18 19 20] [21 22 23 24]]] shape(x) = [2,3,4] # Example 1 perm0 = [1,0,2] y_perm0 = [[[ 1 2 3 4] [13 14 15 16]] [[ 5 6 7 8] [17 18 19 20]] [[ 9 10 11 12] [21 22 23 24]]] shape(y_perm0) = [3,2,4] # Example 2 perm1 = [2,1,0] y_perm1 = [[[ 1 13] [ 5 17] [ 9 21]] [[ 2 14] [ 6 18] [10 22]] [[ 3 15] [ 7 19] [11 23]] [[ 4 16] [ 8 20] [12 24]]] shape(y_perm1) = [4,3,2] Examples: .. code-block:: python >>> import paddle >>> x = paddle.randn([2, 3, 4]) >>> x_transposed = paddle.transpose(x, perm=[1, 0, 2]) >>> print(x_transposed.shape) [3, 2, 4] r rJrKrLrMr(rOrQ complex64 complex128 transposepermzInput(perm) is the permutation of dimensions of Input(x), its length should be equal to dimensions of Input(x), but received dimension of Input(x) is z, the length of Input(perm) is .zEach element in Input(perm) should be less than Input(x)'s dimension, but %d-th element in Input(perm) is %d which exceeds Input(x)'s dimension %d. transpose2r)r+ZXShaperr.N)r)rrrrrr4rrr3rsrrtr;r r>r?r'rA)rrrBidxr~rGrHx_shaperrr rsJ2      rcCs&|j |kr |jksntd|jd|jd|dur5|dks*||j|kr5td|j|dtrN|durA|j|}|dkrGgSt|||Std it}|durn|duse|j|dkritd|j|}g}t|D] }| | |j qt|j dd |gid |i||d d |S)a( This layer unstacks input Tensor :code:`x` into several Tensors along :code:`axis`. If :code:`axis` < 0, it would be replaced with :code:`axis+rank(x)`. If :code:`num` is None, it would be inferred from :code:`x.shape[axis]`, and if :code:`x.shape[axis]` <= 0 or is unknown, :code:`ValueError` is raised. Args: x (Tensor): Input Tensor. It is a N-D Tensors of data types float32, float64, int32, int64, complex64, complex128. axis (int): The axis along which the input is unstacked. num (int|None): The number of output variables. Returns: list(Tensor), The unstacked Tensors list. The list elements are N-D Tensors of data types float32, float64, int32, int64, complex64, complex128. Examples: .. code-block:: python >>> import paddle >>> x = paddle.ones(name='x', shape=[2, 3, 5], dtype='float32') # create a tensor with shape=[2, 3, 5] >>> y = paddle.unstack(x, axis=1) # unstack with second axis, which results 3 tensors with shape=[2, 5] z`axis` must be in the range [-, )Nrz`num` must be in the range [0, unstackzunknown unstack numberr)Y)rnumr.)r) ndimrtrrrrr r>rur}r?r'rA)rrrrGouts_rrr rCs2   rrfc Cstr t|||||St|dddgdd}t|fit}|dks(||kr0td||f|j|jd}|j |d|gid |i||||d d d |S) a Reset the values of `input` according to the shard it beloning to. Every value in `input` must be a non-negative integer, and the parameter `index_num` represents the integer above the maximum value of `input`. Thus, all values in `input` must be in the range [0, index_num) and each value can be regarded as the offset to the beginning of the range. The range is further split into multiple shards. Specifically, we first compute the `shard_size` according to the following formula, which represents the number of integers each shard can hold. So for the i'th shard, it can hold values in the range [i*shard_size, (i+1)*shard_size). :: shard_size = (index_num + nshards - 1) // nshards For each value `v` in `input`, we reset it to a new value according to the following formula: :: v = v - shard_id * shard_size if shard_id * shard_size <= v < (shard_id+1) * shard_size else ignore_value That is, the value `v` is set to the new offset within the range represented by the shard `shard_id` if it in the range. Otherwise, we reset it to be `ignore_value`. Args: input (Tensor): Input tensor with data type int64 or int32. It's last dimension must be 1. index_num (int): An integer represents the integer above the maximum value of `input`. nshards (int): The number of shards. shard_id (int): The index of the current shard. ignore_value (int, optional): An integer value out of sharded index range. The default value is -1. Returns: Tensor. Examples: .. code-block:: python >>> import paddle >>> label = paddle.to_tensor([[16], [1]], "int64") >>> shard_label = paddle.shard_index(input=label, ... index_num=20, ... nshards=2, ... shard_id=0) >>> print(shard_label.numpy()) [[-1] [ 1]] r"rOr( shard_indexrz%The shard_id(%d) should be in [0, %d)r&r)r+) index_numnshardsshard_id ignore_valueT)r/r0r1r2rU) rrrrr r>rtr?r'rA)r"rrrrop_typerGrHrrr r{s0/   rcCstdit}t|dgddt|dttttdtj j fdt|dttttdtj j fd|dur=dgt |j }|durD|j }t rNt|||S||j}d|i}i}d d }d d } t|tryd |_||d<dgt |j |d<nUtj|rg} g} |D]2} t| trd | _| | | dq| | |d} tdgd| d | d| | | | q| |d<| |d<n |D]}| |q||d<t|trd |_||d<nWtj|r$g}g}|D]2}t|trd |_|||dq|||d} tdgd|d | d|| ||q||d<||d<n|D]}||q&||d<|jd|d|it |dkrBdn|d|S)a Crop input into output, as specified by offsets and shape. .. code-block:: text * Case 1 (input is a 2-D Tensor): Input: X.shape = [3, 5] X.data = [[0, 1, 2, 0, 0], [0, 3, 4, 0, 0], [0, 0, 0, 0, 0]] Parameters: shape = [2, 2] offsets = [0, 1] Output: Out.shape = [2, 2] Out.data = [[1, 2], [3, 4]] * Case 2 (input is a 3-D Tensor): Input: X.shape = [2, 3, 4] X.data = [[[0, 1, 2, 3], [0, 5, 6, 7], [0, 0, 0, 0]], [[0, 3, 4, 5], [0, 6, 7, 8], [0, 0, 0, 0]]] Parameters: shape = [2, 2, -1] offsets = [0, 0, 1] Output: Out.shape = [2, 2, 3] Out.data = [[[1, 2, 3], [5, 6, 7]], [[3, 4, 5], [6, 7, 8]]] Parameters: x (Tensor): 1-D to 6-D Tensor, the data type is float32, float64, int32 or int64. shape (list|tuple|Tensor, optional): The output shape is specified by `shape`. Its data type is int32. If a list/tuple, it's length must be the same as the dimension size of `x`. If a Tensor, it should be a 1-D Tensor. When it is a list, each element can be an integer or a Tensor of shape: [1]. If Variable contained, it is suitable for the case that the shape may be changed each iteration. offsets (list|tuple|Variable, optional): Specifies the cropping offsets at each dimension. Its data type is int32. If a list/tuple, it's length must be the same as the dimension size of `x`. If a Tensor, it should be a 1-D Tensor. When it is a list, each element can be an integer or a Tensor of shape: [1]. If Variable contained, it is suitable for the case that the offsets may be changed each iteration. Default: None, the offsets are 0 at each dimension. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, The cropped Tensor has same data type with `x`. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> # x.shape = [3, 3] >>> # x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> # shape can be a 1-D Tensor or list or tuple. >>> shape = paddle.to_tensor([2, 2], dtype='int32') >>> # shape = [2, 2] >>> # shape = (2, 2) >>> out = paddle.crop(x, shape) >>> # out.shape = [2, 2] >>> # out = [[1,2], [4,5]] >>> # offsets can be a 1-D Tensor or list or tuple. >>> offsets = paddle.to_tensor([0, 1], dtype='int32') >>> # offsets = [1, 0] >>> # offsets = (1, 1) >>> out = paddle.crop(x, shape, offsets) >>> # out.shape = [2, 2] >>> # if offsets = [0, 0], out = [[1,2], [4,5]] >>> # if offsets = [0, 1], out = [[2,3], [5,6]] >>> # if offsets = [1, 0], out = [[4,5], [7,8]] >>> # if offsets = [1, 1], out = [[5,6], [8,9]] crop_tensorrrLrMr(rOrNoffsetsrr)cSsNt|ts tdt||dkrtdt||dkr%tdt|dS)NzIAttr(shape)'s dtype of Op(crop_tensor) should be int32, but received: %s.rzDAttr(shape) of Op(crop_tensor) should not be zero, but received: %s.rfzgWhen the element in Attr(shape) of Op(crop_tensor) is negative, only -1 is supported, but received: %s.r3rr=r/rtr<)Z shape_valrrr _attr_shape_check<s& zcrop.._attr_shape_checkcSs6t|ts tdt||dkrtdt|dS)NzKAttr(offsets)'s dtype of Op(crop_tensor) should be int32, but received: %s.rzVAttr(offsets) of Op(crop_tensor) should be greater or equal to zero, but received: %s.r)Z offset_valrrr _attr_offsets_checkMs z!crop.._attr_offsets_checkTZOffsetsrfr(rZ force_cpurHZ OffsetsTensorShape ShapeTensorr+r.)r)r r>rrr4rrr r/r5r9r:rsrrrcropr?r'r3rUryrzr}rrA)rrrrBrGrHZiptsr2rrZnew_offsets_tensorZ offsets_attrr~temp_outoffsetZnew_shape_tensorZ shape_attrdim_sizerrr rsW                       rcCs*t|ttfstdt|t||S)aF **Notes**: **This API is ONLY available in Dygraph mode** This function fill the Tensor with value inplace. Args: x (Tensor): ``x`` is the Tensor we want to filled data inplace value (Scale): ``value`` is the value to be filled in x Returns: x(Tensor), Tensor x filled with value inplace Examples: .. code-block:: python >>> import paddle >>> tensor = paddle.to_tensor([0, 1, 2, 3, 4]) >>> tensor.fill_(0) >>> print(tensor.tolist()) [0, 0, 0, 0, 0] z;The type of 'value' must be int or float, but received %s.)r3floatrr=r/rfill_)rvaluerrr rs rcCs t|dS)a  **Notes**: **This API is ONLY available in Dygraph mode** This function fill the Tensor with zero inplace. Args: x (Tensor): ``x`` is the Tensor we want to filled with zero inplace Returns: x (Tensor), Tensor x filled with zero inplace Examples: .. code-block:: python >>> import paddle >>> tensor = paddle.to_tensor([0, 1, 2, 3, 4]) >>> tensor.zero_() >>> print(tensor.tolist()) [0, 0, 0, 0, 0] g)rrrrrr zero_s rcCs8trt|jdkrt||||St|||dSdS)a[ Note: This API is ONLY available in Dygraph mode. This function fill the value into the x Tensor's diagonal inplace. Args: x(Tensor): ``x`` is the original Tensor value(Scale): ``value`` is the value to filled in x offset(int,optional): the offset to the main diagonal. Default: 0 (main diagonal). wrap(bool,optional): the diagonal 'wrapped' after N columns for tall matrices. name(str,optional): Name for the operation (optional, default is None) Returns: Tensor, Tensor with diagonal filled with value. Examples: .. code-block:: python >>> import paddle >>> x = paddle.ones((4, 3)) * 2 >>> x.fill_diagonal_(1.0) >>> print(x.tolist()) [[1.0, 2.0, 2.0], [2.0, 1.0, 2.0], [2.0, 2.0, 1.0], [2.0, 2.0, 2.0]] rTN)rrsrrfill_diagonal_)rrrwraprBrrr rs rc Cs|j}|t|kr|t| ksJd|t|kr!|t| ks%Jdt|dks/Jd|t|;}|t|;}g}tt|D]}||krT||krT|||qCt||||||||||} || t|t|jks}Jd|t|jdkr|ddg}tr|rt |||||St |||||St |dgd d t |d gd d t dit } | |j} | jd ||d d| i|||dd| S)Nz9dim1 should between [-rank,rank) in fill_diagonal_tensor_z9dim2 should between [-rank,rank) in fill_diagonal_tensor_rz0Tensor dims should >= 2 in fill_diagonal_tensor_zthe y shape should be rrfr)) rKrLrMrQrPrSrNr(rOrJrrz/paddle.tensor.manipulation.fill_diagonal_tensorrfill_diagonal_tensorr)rr+)rdim1dim2r.r)rrsrur}rwrrreshaperrfill_diagonal_tensor_rrr r>r?r'rA) ryrrrinplaceZinshapeZ predshaperFZdiaglenrGrHrrr _fill_diagonal_tensor_impls~         rcCt|||||ddS)a7 Note: This API is ONLY available in Dygraph mode. This function fill the source Tensor y into the x Tensor's diagonal inplace. Args: x (Tensor): ``x`` is the original Tensor y (Tensor): ``y`` is the Tensor to filled in x dim1 (int,optional): first dimension with respect to which to fill diagonal. Default: 0. dim2 (int,optional): second dimension with respect to which to fill diagonal. Default: 1. offset (int,optional): the offset to the main diagonal. Default: 0 (main diagonal). name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, Tensor with diagonal filled with y. Examples: .. code-block:: python >>> import paddle >>> x = paddle.ones((4, 3)) * 2 >>> y = paddle.ones((3,)) >>> x.fill_diagonal_tensor_(y) >>> print(x.tolist()) [[1.0, 2.0, 2.0], [2.0, 1.0, 2.0], [2.0, 2.0, 1.0], [2.0, 2.0, 2.0]] TrrrrrrrrrrrBrrr rQs rcCr)a This function fill the source Tensor y into the x Tensor's diagonal. Args: x (Tensor): ``x`` is the original Tensor y (Tensor): ``y`` is the Tensor to filled in x dim1 (int,optional): first dimension with respect to which to fill diagonal. Default: 0. dim2 (int,optional): second dimension with respect to which to fill diagonal. Default: 1. offset (int,optional): the offset to the main diagonal. Default: 0 (main diagonal). name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, Tensor with diagonal filled with y. Examples: .. code-block:: python >>> import paddle >>> x = paddle.ones((4, 3)) * 2 >>> y = paddle.ones((3,)) >>> nx = x.fill_diagonal_tensor(y) >>> print(nx.tolist()) [[1.0, 2.0, 2.0], [2.0, 1.0, 2.0], [2.0, 2.0, 1.0], [2.0, 2.0, 2.0]] Frrrrrr rts rcCs|dS)az Note: This API is ONLY available in Dygraph mode. This function translate the paddle.Tensor to python list. Args: x (Tensor): ``x`` is the Tensor we want to translate to list. Returns: list, A list that contain the same value of current Tensor. Examples: .. code-block:: python >>> import paddle >>> t = paddle.to_tensor([0,1,2,3,4]) >>> expectlist = t.tolist() >>> print(expectlist) [0, 1, 2, 3, 4] >>> expectlist = paddle.tolist(t) >>> print(expectlist) [0, 1, 2, 3, 4] F)rxtolistrrrr rsrc Cs|}tr%t|tr|d}t|ttjjfsdd|D}t||St |dt t tfdt|tsYt |D]\}}t |dt|dgdd|j|djkrWtd q8n|g}t |d ttfdt|trut|jd d d gdd tdit}|j|d}|djtjjjkrt|dksJdt||jd d}|jdd|di|g|gd|ddd|Sd|i}i} t|trd|_||d<n|| d <|jd|d|gi| d|S)a Concatenates the input along the axis. It doesn't support 0-D Tensor because it requires a certain axis, and 0-D Tensor doesn't have any axis. Args: x (list|tuple): ``x`` is a Tensor list or Tensor tuple which is with data type bool, float16, float32, float64, int32, int64, int8, uint8. All the Tensors in ``x`` must have same data type. axis (int|Tensor, optional): Specify the axis to operate on the input Tensors. Tt should be integer or 0-D int Tensor with shape []. The effective range is [-R, R), where R is Rank(x). When ``axis < 0``, it works the same way as ``axis+R``. Default is 0. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, A Tensor with the same data type as ``x``. Examples: .. code-block:: python >>> import paddle >>> x1 = paddle.to_tensor([[1, 2, 3], ... [4, 5, 6]]) >>> x2 = paddle.to_tensor([[11, 12, 13], ... [14, 15, 16]]) >>> x3 = paddle.to_tensor([[21, 22], ... [23, 24]]) >>> zero = paddle.full(shape=[1], dtype='int32', fill_value=0) >>> # When the axis is negative, the real axis is (axis + Rank(x)) >>> # As follow, axis is -1, Rank(x) is 2, the real axis is 1 >>> out1 = paddle.concat(x=[x1, x2, x3], axis=-1) >>> out2 = paddle.concat(x=[x1, x2], axis=0) >>> out3 = paddle.concat(x=[x1, x2], axis=zero) >>> print(out1) Tensor(shape=[2, 8], dtype=int64, place=Place(cpu), stop_gradient=True, [[1 , 2 , 3 , 11, 12, 13, 21, 22], [4 , 5 , 6 , 14, 15, 16, 23, 24]]) >>> print(out2) Tensor(shape=[4, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[1 , 2 , 3 ], [4 , 5 , 6 ], [11, 12, 13], [14, 15, 16]]) >>> print(out3) Tensor(shape=[4, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[1 , 2 , 3 ], [4 , 5 , 6 ], [11, 12, 13], [14, 15, 16]]) rcSs g|] }|jddkr|qSr^)rcount)rtrrr r!s zconcat..r"rr$r%) rJrKrLrMr(rOrSZunit8rQ:All the Tensors in the input must have the same data type.rr(rOzBThe data type of axis must be int32 or int64 when axis is a Tensorr&rzuIf the elements of 'input' in concat are Variable(LoDTensorArray), number of the elements must be 1, but received %s.r#r)r*Fr,r.T AxisTensorr+N)r) rr3r rbr5r9Valuerrrr4rrr;rr<r'r=rrr r>r?r@descr/rrVrWLOD_TENSOR_ARRAYrsrArU) rrrBr"idrGrHrIr0r2rrr rs~3           rcCst|}tr t|St|dttfd|dkrtdt|D]\}}t |dt |dgdd|j |dj kr@td q!g}g}d}|t|kr||}tt |j } d} | t| krt|| krs|| | ||n9|| | | ko|| dko| | dk} | r|| } td | d |d | || | | kr| | || <||| <| d7} | t| ks`|d7}|t|ksMtdit} d} g}| |kr|| j| d | d7} | |ksd|i}| jd|d|iid|S)a  Broadcast a list of tensors following broadcast semantics Note: 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 Args: input (list|tuple): ``input`` is a Tensor list or Tensor tuple which is with data type bool, float16, float32, float64, int32, int64, complex64, complex128. All the Tensors in ``input`` must have same data type. Currently we only support tensors with rank no greater than 5. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: list(Tensor), The list of broadcasted tensors following the same order as ``input``. Examples: .. code-block:: python >>> import paddle >>> x1 = paddle.rand([1, 2, 3, 4]).astype('float32') >>> x2 = paddle.rand([1, 2, 1, 4]).astype('float32') >>> x3 = paddle.rand([1, 1, 3, 1]).astype('float32') >>> out1, out2, out3 = paddle.broadcast_tensors(input=[x1, x2, x3]) >>> # out1, out2, out3: tensors broadcasted from x1, x2, x3 with shape [1,2,3,4] r"broadcast_tensorsrz8At least 1 tensor is needed to perform broadcast_tensorsr$r%rrrzIInput tensors to broadcast_tensors does not follow bcast semanticsTensor z conflicts with Tensor z in reversed dimension r&r)r+r.N)r)rsrrrrr4rrr=r;rr<r'reversedrr}r r>r?r@rA)r"rBZ num_inputsrrZ output_shape_r_last_tensor_indexZoutput_shape_rjtensorrrFinvalidZ last_indexrGrHr0rrr r=s           rcCst|tr|g}trt||Std it}t|dtd| d}t |dgddt|dt t fd|durA| |}n|j||dd}|jdd|id |id|id |S) a Reverse the order of a n-D tensor along given axis in axis. Args: x (Tensor): A Tensor(or LoDTensor) with shape :math:`[N_1, N_2,..., N_k]` . The data type of the input Tensor x should be float32, float64, int32, int64, bool. axis (list|tuple|int): The axis(axes) to flip on. Negative indices for indexing from the end are accepted. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, Tensor or LoDTensor calculated by flip layer. The data type is same with input x. Examples: .. code-block:: python >>> import paddle >>> image_shape=(3, 2, 2) >>> img = paddle.arange(image_shape[0] * image_shape[1] * image_shape[2]).reshape(image_shape) >>> tmp = paddle.flip(img, [0,1]) >>> print(tmp) Tensor(shape=[3, 2, 2], dtype=int64, place=Place(cpu), stop_gradient=True, [[[10, 11], [8 , 9 ]], [[6 , 7 ], [4 , 5 ]], [[2 , 3 ], [0 , 1 ]]]) >>> out = paddle.flip(tmp,-1) >>> print(out) Tensor(shape=[3, 2, 2], dtype=int64, place=Place(cpu), stop_gradient=True, [[[11, 10], [9 , 8 ]], [[7 , 6 ], [5 , 4 ]], [[3 , 2 ], [1 , 0 ]]]) flipr)rrKrLrMr(rOrJrNF)rBr'Z persistabler+r.)r)r3rrrrr r>rr r@rr4rrr?Zcreate_variablerA)rrrBrGr'rHrrr rs4 (   rc Cstdit}t|dtd|d}t|dgddt|dttfdt|j }t|}|dkr:t d||dkrEt d||d |d krYt |d |d |kset d |d |d |d |krr|d | ks{t d |d |d |kr|d | kst d |d |d;}|d kr|S|dkrt t ||d |d Sttd |}||d ||d ||d <||d <|d krtt ||d |St t|||d S)a Rotate a n-D tensor by 90 degrees. The rotation direction and times are specified by axes and the absolute value of k. Rotation direction is from axes[0] towards axes[1] if k > 0, and from axes[1] towards axes[0] for k < 0. Args: x (Tensor): The input Tensor(or LoDTensor). The data type of the input Tensor x should be float16, float32, float64, int32, int64, bool. float16 is only supported on gpu. k (int, optional): Direction and number of times to rotate, default value: 1. axes (list|tuple, optional): Axes to rotate, dimension must be 2. default value: [0, 1]. 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, Tensor or LoDTensor calculated by rot90 layer. The data type is same with input x. Examples: .. code-block:: python >>> import paddle >>> data = paddle.arange(4) >>> data = paddle.reshape(data, (2, 2)) >>> print(data.numpy()) [[0 1] [2 3]] >>> y = paddle.rot90(data, 1, [0, 1]) >>> print(y.numpy()) [[1 3] [0 2]] >>> y= paddle.rot90(data, -1, [0, 1]) >>> print(y.numpy()) [[2 0] [3 1]] >>> data2 = paddle.arange(8) >>> data2 = paddle.reshape(data2, (2,2,2)) >>> print(data2.numpy()) [[[0 1] [2 3]] [[4 5] [6 7]]] >>> y = paddle.rot90(data2, 1, [1, 2]) >>> print(y.numpy()) [[[1 3] [0 2]] [[5 7] [4 6]]] rot90r)rrrirz2expected total rotation axes == 2, but got axes = z/expected total dims >= 2, but got total dims = rrzJexpected rotation axes to be different, but got axis0 = {}, and axis1 = {}z%Rotation axis0 out of range, axis0 = z%Rotation axis1 out of range, axis1 = N)r)r r>rr r@rr4rrrsrrtabsformatrrur) rkrirBrGr'Zinput_total_dimsZtotal_rot_dimsZ axes_listrrr rsT4  (   rcCsVt|ttjjfs tdt|j}|dkr1t|tr|dvr#tdt|tr,|dvr0tdn@t|trA||dksA|| krEtdt|trU||dksU|| krYtd|dkra||}|dkri||}||krqtd t r{t |||St |d gd d t dit}||j}||j}|jd d|i||d||dd|S)a  Flattens a contiguous range of axes in a tensor according to start_axis and stop_axis. Note: The output Tensor will share data with origin Tensor and doesn't have a Tensor copy in ``dygraph`` mode. If you want to use the Tensor copy version, please use `Tensor.clone` like ``flatten_clone_x = x.flatten().clone()``. For Example: .. code-block:: text Case 1: Given X.shape = (3, 100, 100, 4) and start_axis = 1 end_axis = 2 We get: Out.shape = (3, 100 * 100, 4) Case 2: Given X.shape = (3, 100, 100, 4) and start_axis = 0 stop_axis = -1 We get: Out.shape = (3 * 100 * 100 * 4) Args: x (Tensor): A tensor of number of dimentions >= axis. A tensor with data type float16, float32, float64, int8, int32, int64, uint8. start_axis (int): the start axis to flatten stop_axis (int): the stop axis to flatten name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, A tensor with the contents of the input tensor, whose input axes are flattened by indicated :attr:`start_axis` and :attr:`end_axis`, and data type is the same as input :attr:`x`. Examples: .. code-block:: python >>> import paddle >>> image_shape=(2, 3, 4, 4) >>> x = paddle.arange(end=image_shape[0] * image_shape[1] * image_shape[2] * image_shape[3]) >>> img = paddle.reshape(x, image_shape) >>> out = paddle.flatten(img, start_axis=1, stop_axis=2) >>> print(out.shape) [2, 12, 4] >>> # out shares data with img in dygraph mode >>> img[0, 0, 0, 0] = -1 >>> print(out[0, 0, 0]) Tensor(shape=[], dtype=int64, place=Place(cpu), stop_gradient=True, -1) The input x should be a Tensorr)rrfzYThe start_axis should be int, and should be 0 or -1 when the input tensor is a 0-D-TensorzXThe stop_axis should be int, and should be 0 or -1 when the input tensor is a 0-D-Tensorr@The start_axis should be a int, and in range [-rank(x), rank(x))?The stop_axis should be a int, and in range [-rank(x), rank(x))-The stop_axis should be larger than stat_axisr) rKrLrMrSrNr(rOrPrQflattenZflatten_contiguous_ranger)r) start_axis stop_axisr.N)r)r3r r5r9r:rtrsrrrrrrr r>r?r'rA)rrrrBx_dimrGrHrrrr rbsfC        rcCst|ts tdt|j}t|tr||dks|| kr"tdt|tr2||dks2|| kr6td|dkr>||}|dkrF||}||krNtdtrXt|||SdS)z Inplace version of ``flatten`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_flatten`. rrrrrrN) r3r rtrsrrrrflatten_)rrrrBrrrr rs4      rc Cs8|j}t|tkr |g}t|tkr|g}t|}|dur>tt|D]}|||ks2||| kr>> import paddle >>> x = paddle.to_tensor([[1.0, 2.0, 3.0], ... [4.0, 5.0, 6.0], ... [7.0, 8.0, 9.0]]) >>> out_z1 = paddle.roll(x, shifts=1) >>> print(out_z1.numpy()) [[9. 1. 2.] [3. 4. 5.] [6. 7. 8.]] >>> out_z2 = paddle.roll(x, shifts=1, axis=0) >>> print(out_z2.numpy()) [[7. 8. 9.] [1. 2. 3.] [4. 5. 6.]] >>> out_z3 = paddle.roll(x, shifts=1, axis=1) >>> print(out_z3.numpy()) [[3. 1. 2.] [6. 4. 5.] [9. 7. 8.]] NzEaxis is out of range, it should be in range [{}, {}), but received {}r')rKrLrQrMr(rOrrrollr)r)Z ShiftsTensorr+r.shiftsr))rr)r)rr/rrsrurtrrrrrr r>rr4rrr?r'r3r rA) rrrrBZ origin_shapeZlen_origin_shaperFrGrHrrr rsX+     rcCs@|durdn|}trt||St|ts:t|ts:t|tr.|jt j j j kr.|g}n t ddddt|tdit}||dj}|djt j j j krt|dksdJdt||jd d }|D] }t|dgd dql|jd d |di|g|gd|ddd|S|jdd |id|id|id|S)a Stacks all the input tensors ``x`` along ``axis`` dimemsion. All tensors must be of the same shape and same dtype. For example, given N tensors of shape [A, B], if ``axis == 0``, the shape of stacked tensor is [N, A, B]; if ``axis == 1``, the shape of stacked tensor is [A, N, B], etc. .. code-block:: text Case 1: Input: x[0].shape = [1, 2] x[0].data = [ [1.0 , 2.0 ] ] x[1].shape = [1, 2] x[1].data = [ [3.0 , 4.0 ] ] x[2].shape = [1, 2] x[2].data = [ [5.0 , 6.0 ] ] Attrs: axis = 0 Output: Out.dims = [3, 1, 2] Out.data =[ [ [1.0, 2.0] ], [ [3.0, 4.0] ], [ [5.0, 6.0] ] ] Case 2: Input: x[0].shape = [1, 2] x[0].data = [ [1.0 , 2.0 ] ] x[1].shape = [1, 2] x[1].data = [ [3.0 , 4.0 ] ] x[2].shape = [1, 2] x[2].data = [ [5.0 , 6.0 ] ] Attrs: axis = 1 or axis = -2 # If axis = -2, axis = axis+ndim(x[0])+1 = -2+2+1 = 1. Output: Out.shape = [1, 3, 2] Out.data =[ [ [1.0, 2.0] [3.0, 4.0] [5.0, 6.0] ] ] Args: x (list[Tensor]|tuple[Tensor]): Input ``x`` can be a ``list`` or ``tuple`` of tensors, the Tensors in ``x`` must be of the same shape and dtype. Supported data types: float32, float64, int32, int64. axis (int, optional): The axis along which all inputs are stacked. ``axis`` range is ``[-(R+1), R+1)``, where ``R`` is the number of dimensions of the first input tensor ``x[0]``. If ``axis < 0``, ``axis = axis+R+1``. The default value of axis is 0. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, The stacked tensor with same data type as input. Examples: .. code-block:: python >>> import paddle >>> x1 = paddle.to_tensor([[1.0, 2.0]]) >>> x2 = paddle.to_tensor([[3.0, 4.0]]) >>> x3 = paddle.to_tensor([[5.0, 6.0]]) >>> out = paddle.stack([x1, x2, x3], axis=0) >>> print(out.shape) [3, 1, 2] >>> print(out) Tensor(shape=[3, 1, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[[1., 2.]], [[3., 4.]], [[5., 6.]]]) >>> out = paddle.stack([x1, x2, x3], axis=-2) >>> print(out.shape) [1, 3, 2] >>> print(out) Tensor(shape=[1, 3, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[[1., 2.], [3., 4.], [5., 6.]]]) Nrz2The type of '{}' in {} must be {}, but received {}rrz*list[Tensor], tuple[Tensor] or TensorArrayrzpIf the elements of 'x' in stack are Variable(LoDTensorArray), number of the elements must be 1, but received %s.r(r&rKrLrMr(rOrQr#r)r*Tr,r.rr)r)rrrr3r4rrr rr/rrVrWrr=rr r>r?r'rsrrA)rrrBrGrHrIrFrrr rts\Z     rcs|}|}trot|tr|d}|t|jdksJd|dkr)|t|jn|}t|ttfrOtj |rNt |D]\}}t|trM||||<q>> import paddle >>> # x is a Tensor of shape [3, 9, 5] >>> x = paddle.rand([3, 9, 5]) >>> out0, out1, out2 = paddle.split(x, num_or_sections=3, axis=1) >>> print(out0.shape) [3, 3, 5] >>> print(out1.shape) [3, 3, 5] >>> print(out2.shape) [3, 3, 5] >>> out0, out1, out2 = paddle.split(x, num_or_sections=[2, 3, 4], axis=1) >>> print(out0.shape) [3, 2, 5] >>> print(out1.shape) [3, 3, 5] >>> print(out2.shape) [3, 4, 5] >>> out0, out1, out2 = paddle.split(x, num_or_sections=[2, 3, -1], axis=1) >>> print(out0.shape) [3, 2, 5] >>> print(out1.shape) [3, 3, 5] >>> print(out2.shape) [3, 4, 5] >>> # axis is negative, the real axis is (rank(x) + axis)=1 >>> out0, out1, out2 = paddle.split(x, num_or_sections=3, axis=-2) >>> print(out0.shape) [3, 3, 5] >>> print(out1.shape) [3, 3, 5] >>> print(out2.shape) [3, 3, 5] rz(rank(x) + axis) must >= 0zfThe type of 'num_or_sections' in split must be int, list or tuple in imperative mode, but received %s.Tznum_or_sections must be than 0.zThe input's size along the split dimension must be evenly divisible by Attr(num_or_sections). But %d is not evenly divisible by %d. z._get_SectionsTensorListrrcSsg|] }t|tr dn|qSre)r3r )relerrr r!szsplit..sectionsZSectionsTensorListcg|] }jdqSr&r?r@r[rrr r! r+r.N)r)rr3r rbrsrr4rrr5ryrzr;rr=r/rZsplit_with_numrrr9r:rUr{rrrr'r r>rurA)rrrrBr"r~indexrb input_shaper0r2rrrrrr rs=                    rcCs*|jdkr td|jt||d|dS)a[ Split the input tensor into multiple sub-Tensors along the vertical axis, which is equivalent to ``paddle.split`` with ``axis=0``. Args: x (Tensor): A Tensor whose dimension must be greater than 1. The data type is bool, float16, float32, float64, uint8, int8, int32 or int64. num_or_sections (int|list|tuple): If ``num_or_sections`` is an int, then ``num_or_sections`` indicates the number of equal sized sub-Tensors that the ``x`` will be divided into. If ``num_or_sections`` is a list or tuple, the length of it indicates the number of sub-Tensors and the elements in it indicate the sizes of sub-Tensors' dimension orderly. The length of the list must not be larger than the ``x`` 's size of axis 0. 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: list[Tensor], The list of segmented Tensors. Examples: .. code-block:: python >>> import paddle >>> # x is a Tensor of shape [8, 6, 7] >>> x = paddle.rand([8, 6, 7]) >>> out0, out1 = paddle.vsplit(x, num_or_sections=2) >>> print(out0.shape) [4, 6, 7] >>> print(out1.shape) [4, 6, 7] >>> out0, out1, out2 = paddle.vsplit(x, num_or_sections=[1, 3, 4]) >>> print(out0.shape) [1, 6, 7] >>> print(out1.shape) [3, 6, 7] >>> print(out2.shape) [4, 6, 7] >>> out0, out1, out2 = paddle.vsplit(x, num_or_sections=[2, 3, -1]) >>> print(out0.shape) [2, 6, 7] >>> print(out1.shape) [3, 6, 7] >>> print(out2.shape) [3, 6, 7] rz=The input tensor's dimension must be greater than 1, but got r)rrB)rrtr)rrrBrrr vsplits + rc Cst|durg}nt|tr|g}n t|trt|}|}|}tr&t||StrWt|tr1|g}t|tj j r>> import paddle >>> x = paddle.rand([5, 1, 10]) >>> output = paddle.squeeze(x, axis=1) >>> print(x.shape) [5, 1, 10] >>> print(output.shape) [5, 10] >>> # output shares data with x in dygraph mode >>> x[0, 0, 0] = 10. >>> print(output[0, 0]) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 10.) NTrOZ default_dtypesqueezer") rKrQrLrMrJrSr(rOrr axis/axesrir&Zsqueeze2r)rrq)r)r3rrrr4rrrrr5r9r:rUryrzr{r r>rrr r|r?r'rA) rrrBr"rirGr2rHrrrr r s\M          rcCsP|durg}nt|tr|g}n t|trt|}|}|}tr&t||SdS)z Inplace version of ``squeeze`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_tensor_squeeze`. N)r3rrrr4rrsqueeze_rrrBr"rirrr r s   rrOcCs|durg}n|g}t|}tr>> import paddle >>> x = paddle.to_tensor([1, 1, 2, 2, 3, 1, 1, 2]) >>> output = paddle.unique_consecutive(x) # >>> print(output) Tensor(shape=[5], dtype=int64, place=Place(cpu), stop_gradient=True, [1, 2, 3, 1, 2]) >>> _, inverse, counts = paddle.unique_consecutive(x, return_inverse=True, return_counts=True) >>> print(inverse) Tensor(shape=[8], dtype=int64, place=Place(cpu), stop_gradient=True, [0, 0, 1, 1, 2, 3, 3, 4]) >>> print(counts) Tensor(shape=[5], dtype=int64, place=Place(cpu), stop_gradient=True, [2, 2, 1, 2, 1]) >>> x = paddle.to_tensor([[2, 1, 3], [3, 0, 1], [2, 1, 3], [2, 1, 3]]) >>> output = paddle.unique_consecutive(x, axis=0) # >>> print(output) Tensor(shape=[3, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[2, 1, 3], [3, 0, 1], [2, 1, 3]]) >>> x = paddle.to_tensor([[2, 1, 3], [3, 0, 1], [2, 1, 3], [2, 1, 3]]) >>> output = paddle.unique_consecutive(x, axis=0) # >>> print(output) Tensor(shape=[3, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[2, 1, 3], [3, 0, 1], [2, 1, 3]]) Nrrr"runique_consecutivereturn_inverse return_countsr'r(rOr)r'rrrTrT)r+IndexCountsr)rq)r)r rrrr}rsrrrrrJrrr r>r?r'rA)rrrrr'rB attr_dtyperHinversecountsrrGr2r1rrr r srH          rc Cs6|durg}n|g}t|}trEt||||||\}} } } |g} |r)| | |r0| | |r7| | t| dkrA| dSt| Str}t||||||d\}} } } |g} |ra| | |rh| | |ro| | t| dkry| dSt| St|dgddt |dt dt |d t dt |d t dt |d d d gdt|dkrt |ddt dt dit} |||||dd}| j|jdd}| j|dd} | j|dd} | j|dd} || | | d}|g} |r| | |r| | |r| | | jdd|i||dt| dkr| dSt| S)a Returns the unique elements of `x` in ascending order. Args: x(Tensor): The input tensor, it's data type should be float32, float64, int32, int64. return_index(bool, optional): If True, also return the indices of the input tensor that result in the unique Tensor. return_inverse(bool, optional): If True, also return the indices for where elements in the original input ended up in the returned unique tensor. return_counts(bool, optional): If True, also return the counts for each unique element. axis(int, optional): The axis to apply unique. If None, the input will be flattened. Default: None. dtype(np.dtype|str, optional): The date type of `indices` or `inverse` tensor: int32 or int64. Default: int64. name(str, optional): Name for the operation. For more information, please refer to :ref:`api_guide_Name`. Default: None. Returns: tuple (out, indices, inverse, counts). `out` is the unique tensor for `x`. `indices` is \ provided only if `return_index` is True. `inverse` is provided only if `return_inverse` \ is True. `counts` is provided only if `return_counts` is True. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([2, 3, 3, 1, 5, 3]) >>> unique = paddle.unique(x) >>> print(unique) Tensor(shape=[4], dtype=int64, place=Place(cpu), stop_gradient=True, [1, 2, 3, 5]) >>> _, indices, inverse, counts = paddle.unique(x, return_index=True, return_inverse=True, return_counts=True) >>> print(indices) Tensor(shape=[4], dtype=int64, place=Place(cpu), stop_gradient=True, [3, 0, 1, 4]) >>> print(inverse) Tensor(shape=[6], dtype=int64, place=Place(cpu), stop_gradient=True, [1, 2, 2, 0, 3, 2]) >>> print(counts) Tensor(shape=[4], dtype=int64, place=Place(cpu), stop_gradient=True, [1, 1, 3, 1]) >>> x = paddle.to_tensor([[2, 1, 3], [3, 0, 1], [2, 1, 3]]) >>> unique = paddle.unique(x) >>> print(unique) Tensor(shape=[4], dtype=int64, place=Place(cpu), stop_gradient=True, [0, 1, 2, 3]) >>> unique = paddle.unique(x, axis=0) >>> print(unique) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[2, 1, 3], [3, 0, 1]]) NrrTr")rKrQrLrMr(rOunique return_indexrrr'r(rOr)r'rrrrZ is_sortedrT)r+ZIndicesrrr)rq)r)r rrrr}rsrrrrrrJrrr r>r?r'rA)rrrrrr'rBrrHindicesrrrrGr2r1rrr r@ sA                 rc Cs|}|}tr.t|tr|g}nt|tr|}nt|ttfr(dd|D}t||St r_t|tr9|g}t|t j j rDd|_ nt|ttfrYt j|rYt jj|dd}t||St|dttttfdt|dgd dtdit}d |i}i}t|tr|g}t|trd|_ ||d <nt|ttfrt j|rt j||d <n||d<|j|jd}|j|jd} |jd |||| dd|S)a Insert single-dimensional entries to the shape of input Tensor ``x``. Takes one required argument axis, a dimension or list of dimensions that will be inserted. Dimension indices in axis are as seen in the output tensor. Note that the output Tensor will share data with origin Tensor and doesn't have a Tensor copy in ``dygraph`` mode. If you want to use the Tensor copy version, please use `Tensor.clone` like ``unsqueeze_clone_x = x.unsqueeze(-1).clone()``. Args: x (Tensor): The input Tensor to be unsqueezed. Supported data type: bfloat16, float16, float32, float64, bool, int8, int32, int64. axis (int|list|tuple|Tensor): Indicates the dimensions to be inserted. The data type is ``int32`` . If ``axis`` is a list or tuple, each element of it should be integer or 0-D Tensor with shape []. If ``axis`` is a Tensor, it should be an 1-D Tensor . If ``axis`` is negative, ``axis = axis + ndim(x) + 1``. name (str|None): Name for this layer. Please refer to :ref:`api_guide_Name`, Default None. Returns: Tensor, Unsqueezed Tensor with the same data type as input Tensor. Examples: .. code-block:: python >>> import paddle >>> x = paddle.rand([5, 10]) >>> print(x.shape) [5, 10] >>> out1 = paddle.unsqueeze(x, axis=0) >>> print(out1.shape) [1, 5, 10] >>> out2 = paddle.unsqueeze(x, axis=[0, 2]) >>> print(out2.shape) [1, 5, 1, 10] >>> axis = paddle.to_tensor([0, 1, 2]) >>> out3 = paddle.unsqueeze(x, axis=axis) >>> print(out3.shape) [1, 1, 1, 5, 10] >>> # out1, out2, out3 share data with x in dygraph mode >>> x[0, 0] = 10. >>> print(out1[0, 0, 0]) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 10.) >>> print(out2[0, 0, 0, 0]) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 10.) >>> print(out3[0, 0, 0, 0, 0]) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 10.) cS$g|]}t|tr|dn|qSr^r3r rbrcrrr r!' zunsqueeze..TrOrr unsqueezer") rQrKrQrLrMrJrSrNr(rOrr unsqueeze2r)Z AxesTensorZAxesTensorListrir&rrqN)r)rr3rr rr4rrrrrr5r9r:rUryrzr{rrr r>r|r?r'rA) rrrBr"rirGr0r2rHrrrr r sj8            rcCsV|}|}t|tr |g}nt|tr|}nt|ttfr%dd|D}t||S)z Inplace version of ``unsqueeze`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_tensor_unsqueeze`. cSrr^rrcrrr r!v rzunsqueeze_..)r3rr rr4rrr unsqueeze_rrrr ri s    rcCs|durd}trt|||St|dgddt|dddgdt|tr0t|d ddgdtdit}|d}| |}t|tsZ|j d||d |d d d |id|S|j d|||ddd id |id|S)a Output is obtained by gathering entries of ``axis`` of ``x`` indexed by ``index`` and concatenate them together. .. code-block:: text Given: x = [[1, 2], [3, 4], [5, 6]] index = [1, 2] axis=[0] Then: out = [[3, 4], [5, 6]] Args: x (Tensor): The source input tensor with rank>=1. Supported data type is int32, int64, float32, float64 and uint8 (only for CPU), float16 (only for GPU). index (Tensor): The index input tensor with rank=0 or rank=1. Data type is int32 or int64. axis (Tensor|int, optional): The axis of input to be gathered, it's can be int or a Tensor with data type is int32 or int64. The default value is None, if None, the ``axis`` is 0. 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: output (Tensor), If the index is a 1-D tensor, the output is a tensor with the same shape as ``x``. If the index is a 0-D tensor, the output will reduce the dimension where the axis pointing. Examples: .. code-block:: python >>> import paddle >>> input = paddle.to_tensor([[1,2],[3,4],[5,6]]) >>> index = paddle.to_tensor([0,1]) >>> output = paddle.gather(input, index, axis=0) >>> print(output) Tensor(shape=[2, 2], dtype=int64, place=Place(cpu), stop_gradient=True, [[1, 2], [3, 4]]) Nrr)rKrLrMrNr(rOrPrQgatherrr(rOrr)rF)r overwriter+rq)r)rAxisr)r) rrrrr3r r r>r@r?rA)rrrrBrGr'rHrrr r} s>0      rcst|ts tdt||t|j |jvr%td|j d|jdtr.t ||St|t j r9t |}|j }|dkrB|nt||}||}tditt|dtd}t|dgddfd d t|D}jdd |id |id |id|S)aY Removes a tensor dimension, then split the input tensor into multiple sub-Tensors. Args: input (Tensor): The input variable which is an N-D Tensor, data type being bool, float16, float32, float64, int32, int64, complex64 or complex128. axis (int32|int64, optional): A scalar with type ``int32|int64`` shape [1]. The dimension along which to unbind. If :math:`axis < 0`, the dimension to unbind along is :math:`rank(input) + axis`. Default is 0. Returns: list(Tensor), The list of segmented Tensor variables. Examples: .. code-block:: python >>> import paddle >>> # input is a Tensor which shape is [3, 4, 5] >>> input = paddle.rand([3, 4, 5]) >>> [x0, x1, x2] = paddle.unbind(input, axis=0) >>> # x0.shape [4, 5] >>> # x1.shape [4, 5] >>> # x2.shape [4, 5] >>> [x0, x1, x2, x3] = paddle.unbind(input, axis=1) >>> # x0.shape [3, 5] >>> # x1.shape [3, 5] >>> # x2.shape [3, 5] >>> # x3.shape [3, 5] z1The type of 'axis' must be int, but received %s.zThe axis must in range(rz).runbindr") rJrKrQrLrMr(rOrrcrrrr[rrr r! rzunbind..r)r+rr.N)r)r3rr=r/rurrtrrrr7ZgenericZasscalarrrsr r>rr r@rrA)r"rrZaxis_rr'rrrr r sD       rTcCsxtr t||||St|dgddt|dtdtd it}||j }|j d|||dd|id|id|S) a **Scatter Layer** Output is obtained by updating the input on selected indices based on updates. .. code-block:: python >>> import paddle >>> #input: >>> x = paddle.to_tensor([[1, 1], [2, 2], [3, 3]], dtype='float32') >>> index = paddle.to_tensor([2, 1, 0, 1], dtype='int64') >>> # shape of updates should be the same as x >>> # shape of updates with dim > 1 should be the same as input >>> updates = paddle.to_tensor([[1, 1], [2, 2], [3, 3], [4, 4]], dtype='float32') >>> overwrite = False >>> # calculation: >>> if not overwrite: ... for i in range(len(index)): ... x[index[i]] = paddle.zeros([2]) >>> for i in range(len(index)): ... if (overwrite): ... x[index[i]] = updates[i] ... else: ... x[index[i]] += updates[i] >>> # output: >>> out = paddle.to_tensor([[3, 3], [6, 6], [1, 1]]) >>> print(out.shape) [3, 2] **NOTICE**: The order in which updates are applied is nondeterministic, so the output will be nondeterministic if index contains duplicates. Args: x (Tensor): The input N-D Tensor with ndim>=1. Data type can be float32, float64. index (Tensor): The index is a 1-D or 0-D Tensor. Data type can be int32, int64. The length of index cannot exceed updates's length, and the value in index cannot exceed input's length. updates (Tensor): Update input with updates parameter based on index. When the index is a 1-D tensor, the updates shape should be the same as input, and dim value with dim > 1 should be the same as input. When the index is a 0-D tensor, the updates should be a (N-1)-D tensor, the ith dim of the updates should be queal with the (i+1)th dim of the input. overwrite (bool, optional): The mode that updating the output when there are same indices.If True, use the overwrite mode to update the output of the same index,if False, use the accumulate mode to update the output of the same index. Default value is True. 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, The output is a Tensor with the same shape as x. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1, 1], [2, 2], [3, 3]], dtype='float32') >>> index = paddle.to_tensor([2, 1, 0, 1], dtype='int64') >>> updates = paddle.to_tensor([[1, 1], [2, 2], [3, 3], [4, 4]], dtype='float32') >>> output1 = paddle.scatter(x, index, updates, overwrite=False) >>> print(output1) Tensor(shape=[3, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[3., 3.], [6., 6.], [1., 1.]]) >>> output2 = paddle.scatter(x, index, updates, overwrite=True) >>> # CPU device: >>> # [[3., 3.], >>> # [4., 4.], >>> # [1., 1.]] >>> # GPU device maybe have two results because of the repeated numbers in index >>> # result 1: >>> # [[3., 3.], >>> # [4., 4.], >>> # [1., 1.]] >>> # result 2: >>> # [[3., 3.], >>> # [2., 2.], >>> # [1., 1.]] r')rLrMrKr(rOrQscatterr)r)ZIdsUpdatesr+rqN)r) rrrrrrJr r>r?r'rA)rrupdatesrrBrGrHrrr r/ s$I  rcCt||||S)z Inplace version of ``scatter`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_tensor_scatter`. )rscatter_)rrrrrBrrr r srcCsntr t|||S|j|jkrtdtd it}|jdd}||}|j d|||dd|id|S) ak Output is obtained by applying sparse addition to a single value or slice in a Tensor. :attr:`x` is a Tensor with ndim :math:`R` and :attr:`index` is a Tensor with ndim :math:`K` . Thus, :attr:`index` has shape :math:`[i_0, i_1, ..., i_{K-2}, Q]` where :math:`Q \leq R` . :attr:`updates` is a Tensor with ndim :math:`K - 1 + R - Q` and its shape is :math:`index.shape[:-1] + x.shape[index.shape[-1]:]` . According to the :math:`[i_0, i_1, ..., i_{K-2}]` of :attr:`index` , add the corresponding :attr:`updates` slice to the :attr:`x` slice which is obtained by the last one dimension of :attr:`index` . .. code-block:: text Given: * Case 1: x = [0, 1, 2, 3, 4, 5] index = [[1], [2], [3], [1]] updates = [9, 10, 11, 12] we get: output = [0, 22, 12, 14, 4, 5] * Case 2: x = [[65, 17], [-14, -25]] index = [[], []] updates = [[[-1, -2], [1, 2]], [[3, 4], [-3, -4]]] x.shape = (2, 2) index.shape = (2, 0) updates.shape = (2, 2, 2) we get: output = [[67, 19], [-16, -27]] Args: x (Tensor): The x input. Its dtype should be int32, int64, float32, float64. index (Tensor): The index input with ndim > 1 and index.shape[-1] <= x.ndim. Its dtype should be int32 or int64 as it is used as indexes. updates (Tensor): The updated value of scatter_nd_add op, and it must have the same dtype as x. It must have the shape index.shape[:-1] + x.shape[index.shape[-1]:]. name (str|None): The output tensor name. If set None, the layer will be named automatically. Returns: output (Tensor), The output is a tensor with the same shape and dtype as x. Examples: .. code-block:: python >>> import paddle >>> x = paddle.rand(shape=[3, 5, 9, 10], dtype='float32') >>> updates = paddle.rand(shape=[3, 9, 10], dtype='float32') >>> index = paddle.to_tensor([[1, 1], ... [0, 1], ... [1, 3]], dtype='int64') >>> output = paddle.scatter_nd_add(x, index, updates) >>> print(output.shape) [3, 5, 9, 10] z'x and updates must have same data type.scatter_nd_addrZinput_param_name)r)rrr+r/r0r1N)r) rrrr'rtr r>r@r?rA)rrrrBrGr'outputrrr r sE    rcCstt||j|||S)a **Scatter_nd Layer** Output is obtained by scattering the :attr:`updates` in a new tensor according to :attr:`index` . This op is similar to :code:`scatter_nd_add`, except the tensor of :attr:`shape` is zero-initialized. Correspondingly, :code:`scatter_nd(index, updates, shape)` is equal to :code:`scatter_nd_add(paddle.zeros(shape, updates.dtype), index, updates)` . If :attr:`index` has repeated elements, then the corresponding updates are accumulated. Because of the numerical approximation issues, the different order of repeated elements in :attr:`index` may cause different results. The specific calculation method can be seen :code:`scatter_nd_add` . This op is the inverse of the :code:`gather_nd` op. Args: index (Tensor): The index input with ndim >= 1 and index.shape[-1] <= len(shape). Its dtype should be int32 or int64 as it is used as indexes. updates (Tensor): The updated value of scatter_nd op. Its dtype should be float32, float64. It must have the shape index.shape[:-1] + shape[index.shape[-1]:] shape(tuple|list): Shape of output tensor. name (str|None): The output Tensor name. If set None, the layer will be named automatically. Returns: output (Tensor), The output is a tensor with the same type as :attr:`updates` . Examples: .. code-block:: python >>> import paddle >>> index = paddle.to_tensor([[1, 1], ... [0, 1], ... [1, 3]], dtype="int64") >>> updates = paddle.rand(shape=[3, 9, 10], dtype='float32') >>> shape = [3, 5, 9, 10] >>> output = paddle.scatter_nd(index, updates, shape) )rrr')rrrrBrrr scatter_nd s&r cCst|dtdt||||dS)ag Split the input tensor into multiple sub-Tensors. Args: x (Tensor): A N-D Tensor. The data type is bool, float16, float32, float64, int32 or int64. chunks(int): The number of tensor to be split along the certain axis. axis (int|Tensor, optional): The axis along which to split, it can be a integer or a ``0-D Tensor`` with shape [] and data type ``int32`` or ``int64``. If :math::`axis < 0`, the axis to split along is :math:`rank(x) + axis`. Default is 0. 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: list(Tensor), The list of segmented Tensors. Examples: .. code-block:: python >>> import paddle >>> x = paddle.rand([3, 9, 5]) >>> out0, out1, out2 = paddle.chunk(x, chunks=3, axis=1) >>> # out0.shape [3, 3, 5] >>> # out1.shape [3, 3, 5] >>> # out2.shape [3, 3, 5] >>> # axis is negative, the real axis is (rank(x) + axis) which real >>> # value is 1. >>> out0, out1, out2 = paddle.chunk(x, chunks=3, axis=-2) >>> # out0.shape [3, 3, 5] >>> # out1.shape [3, 3, 5] >>> # out2.shape [3, 3, 5] chunkschunk)rrrB)rrr)rr rrBrrr r s#rc Cs>dd}tr!t|tjjr|jdksJd|}t||St rB|||t|t t fr>> import paddle >>> data = paddle.to_tensor([1, 2, 3], dtype='int32') >>> out = paddle.tile(data, repeat_times=[2, 1]) >>> print(out) Tensor(shape=[2, 3], dtype=int32, place=Place(cpu), stop_gradient=True, [[1, 2, 3], [1, 2, 3]]) >>> out = paddle.tile(data, repeat_times=(2, 2)) >>> print(out) Tensor(shape=[2, 6], dtype=int32, place=Place(cpu), stop_gradient=True, [[1, 2, 3, 1, 2, 3], [1, 2, 3, 1, 2, 3]]) >>> repeat_times = paddle.to_tensor([1, 2], dtype='int32') >>> out = paddle.tile(data, repeat_times=repeat_times) >>> print(out) Tensor(shape=[1, 6], dtype=int32, place=Place(cpu), stop_gradient=True, [[1, 2, 3, 1, 2, 3]]) cSst|dttttjjfdt|ttjjfr"t|j dks!Jdn)|D]&}t|ttjjfr:| dks9Jdq$t t j t jf}t||sJJdq$t|dgddt|jdkrb|jsdtd dSdS) N repeat_timestilerz-repeat_times must be a Tensor with ndim == 1.zEElements in repeat_times must be Tensor with one element or integers.rrJrKrQrLrMr(rOrJzWhen the date type is bool for the input 'x' of tile op, you must set its stop_gradient to be True by some_var.stop_gradient == True supporting some_var is the input.)rr4rrr r5r9r:r3rsrnumelrr7r(rOrr r'rUrt)rrelem type_tuplerrr check_inputf s@ ztile..check_inputrz6Only support ndim == 1 while repeat_times is a Tensor.cSsJg}t|D]\}}t|tr|dq|||dks"Jdq|S)Nrfrz7All elements in repeat_times must be positive for tile.r;r3r r})Zlist_repeat_timesZattrs_repeat_timesrtimesrrr get_attr_repeat_times s    z#tile..get_attr_repeat_timesrr)TZ RepeatTimesrfrZrepeat_times_tensorrr r+r.N)r)rr3rr`rarrrrrr4rrr5ryrzr|r r>r rUr@r?rA) rrrBrrrGr0r2r'rHrrr r< sL*,               rcCstr t|d|jSt|dgddt|dtdt|jdkr)|j s)t d|g|gd}t dit }|j dd }||}|jd |d |jid |id |S)a Expand the input tensor ``x`` to the same shape as the input tensor ``y``. Both the number of dimensions of ``x`` and ``y`` must be less than or equal to 6, and the number of dimensions of ``y`` must be greather than or equal to that of ``x``. The dimension to expand must have a value of 0. Args: x (Tensor): The input tensor, its data type is bool, float32, float64, int32 or int64. y (Tensor): The input tensor that gives the shape to expand to. 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: N-D Tensor, A Tensor with the same shape as ``y``. The data type is the same as ``x``. Examples: .. code-block:: python >>> import paddle >>> data_x = paddle.to_tensor([1, 2, 3], 'int32') >>> data_y = paddle.to_tensor([[1, 2, 3], [4, 5, 6]], 'int32') >>> out = paddle.expand_as(data_x, data_y) >>> print(out) Tensor(shape=[2, 3], dtype=int32, place=Place(cpu), stop_gradient=True, [[1, 2, 3], [1, 2, 3]]) Nr)rJrLrMr(rOrKrQ expand_asrrJzWhen the data type of input 'x' for expand_as is bool, you must set its stop_gradient to be False by some_var.stop_gradient = True, supporting some_var as the input 'x'.rr Z expand_as_v2Z target_shaper+rq)r)rrrrrrr r r'rUrtr r>r@r?rA)rrrBr0rGr'rHrrr r s0   rc Cstr t||Str9t}t|ttfr$tj |r#tj ||}nt|tj j r/d|_ntdt||St|trJt|jdksIJdn&ttjtjf}|D]}t|trft|jdkseJdqSt||soJdqSt|dgddt|d tttfdt|jd kr|jstd d |gi}i}tdit}dd} t|trd|_||d<nt|ttfr| ||d <tj |rtj ||d<|jdd} | | } |j!d|d| i|d| S)a5 Broadcast the input tensor to a given shape. Both the number of dimensions of ``x`` and the number of elements in ``shape`` should be less than or equal to 6. The dimension to broadcast to must have a value 0. Args: x (Tensor): The input tensor, its data type is bool, float16, float32, float64, int32 or int64. shape (list|tuple|Tensor): The result shape after broadcasting. The data type is int32. If shape is a list or tuple, all its elements should be integers or 0-D or 1-D Tensors with the data type int32. If shape is a Tensor, it should be an 1-D Tensor with the data type int32. The value -1 in shape means keeping the corresponding dimension unchanged. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: N-D Tensor, A Tensor with the given shape. The data type is the same as ``x``. Examples: .. code-block:: python >>> import paddle >>> data = paddle.to_tensor([1, 2, 3], dtype='int32') >>> out = paddle.broadcast_to(data, shape=[2, 3]) >>> print(out) Tensor(shape=[2, 3], dtype=int32, place=Place(cpu), stop_gradient=True, [[1, 2, 3], [1, 2, 3]]) T0Shape only supports OpReslut, or list, or tuple.rzshape must be an 1-D Tensor.z2Elements in shape must be 1-D Tensors or integers.r)rJrQrKrLrMr(rO broadcast_torrJzWhen the data type of input 'x' for broadcast_to is bool, you must set its stop_gradient to be False by some_var.stop_gradient = True, supporting some_var as the input.r)expandcSsRg}t|D] \}}t|tr|dq|||dks&|dks&Jdq|S)Nrfrz=All elements in shape of broadcast_to must be positive or -1.rZlist_expand_shapeZattrs_expand_shaperrrrr get_attr_expand_shapea   z+broadcast_to..get_attr_expand_shaperexpand_shapes_tensorr  expand_v2r+r.Nr)"rrrrr r3r4rrr5ryrzr{r9r:rUr=r rsrrr7r(rOrrr r'rtr r>r|r@r?rA) rrrBZplacerrr0r2rGrr'rHrrr r sp               rc Cstr t||StrCt|jdkr|jstdt|t j j r%d|_nt|t t fr9t j|r8t j|}ntdt||St|trS|dksRJdn%|D]"}t|trg|dksfJdqUttjtjf}t||swJdqUt|dgd d t|d t t tfd t|jdkr|jstdd |gi}i}tdit}d d}t|trd|_||d<nt|t t fr|||d <t j|rt j||d<|jdd} || } |jd|d| i|d| S)a Expand the input tensor to a given shape. Both the number of dimensions of ``x`` and the number of elements in ``shape`` should be less than or equal to 6. And the number of dimensions of ``x`` should be less than the number of elements in ``shape``. The dimension to expand must have a value 0. Args: x (Tensor): The input Tensor, its data type is bool, float32, float64, int32 or int64. shape (list|tuple|Tensor): The result shape after expanding. The data type is int32. If shape is a list or tuple, all its elements should be integers or 0-D or 1-D Tensors with the data type int32. If shape is a Tensor, it should be an 1-D Tensor with the data type int32. The value -1 in shape means keeping the corresponding dimension unchanged. 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: N-D Tensor, A Tensor with the given shape. The data type is the same as ``x``. Examples: .. code-block:: python >>> import paddle >>> data = paddle.to_tensor([1, 2, 3], dtype='int32') >>> out = paddle.expand(data, shape=[2, 3]) >>> print(out) Tensor(shape=[2, 3], dtype=int32, place=Place(cpu), stop_gradient=True, [[1, 2, 3], [1, 2, 3]]) rJzWhen the data type of input 'x' for expand is bool, you must set its stop_gradient to be False by some_var.stop_gradient = True, supporting some_var as the input.Trrz'shape must be a Tensor with one elementz>Elements in shape must be Tensor with one element or integers.r)rJrKrLrMr(rOrQrrr)cSsRg}t|D] \}}t|tr|dq|||dks&|dks&Jdq|S)Nrrfz7All elements in shape of expand must be positive or -1.rrrrr rrz%expand..get_attr_expand_shaperr r r!r+r.Nr") rrrrr r'rUrtr3r5r9r:r4rrryrzr{r=r rrr7r(rOrrr r>r|r@r?rA) rrrBrrr0r2rGrr'rHrrr rsv                rc s"fdd}trXt|ttfr>> import paddle >>> x = paddle.rand([2, 4, 6], dtype="float32") >>> positive_four = paddle.full([1], 4, "int32") >>> out = paddle.reshape(x, [-1, 0, 3, 2]) >>> print(out.shape) [2, 4, 3, 2] >>> out = paddle.reshape(x, shape=[positive_four, 12]) >>> print(out.shape) [4, 12] >>> shape_tensor = paddle.to_tensor([8, 6], dtype=paddle.int32) >>> out = paddle.reshape(x, shape=shape_tensor) >>> print(out.shape) [8, 6] >>> # out shares data with x in dygraph mode >>> x[0, 0, 0] = 10. >>> print(out[0, 0]) Tensor(shape=[], dtype=float32, place=Place(cpu), stop_gradient=True, 10.) csd}g}t|D]N\}}t|ttjjfr|dq|||dkr1|dks.Jd||}q|dkrH|tjksGJd|tjfq|dksVJd|t |fq|S)NrfaOnly one dimension value of 'shape' in reshape can be -1. But received shape[%d] is also -1. # N = x.shape()[2] # N is an int. (NOT recommend under @to_static) N = paddle.shape(x)[2] # N is a Tensor. (Recommend) z = paddle.reshape([N, -1, 4]) # z.shape is [-1, -1, 4] If your target shape in Reshape represents dynamic shape, please turn it into a Tensor under @to_static. See above example for details.rz}The index of 0 in `shape` must be less than the input tensor X's dimensions. But received shape[%d] = 0, X's dimensions = %d.zzEach dimension value of 'shape' in reshape must not be negative except one unknown dimension. But received shape[%d] = %s.) r;r3r r5r9r:r}rsrr<)Z list_shaperZ attrs_shapeZdim_idxrrrr get_attr_shape4s2       zreshape..get_attr_shapeTz>shape must be an instance of `list`, `tuple` `Variable`, got '.'r) rKrLrMrSrPrNr(rOrJrQrrrrzKshape must be an instance of `list`, `tuple` `OpResult(in pir mode)`, got ') rKrLrMrNr(rOrJrQrSrPrrr)rrreshape2r&rrqN)r&)rr3r4rrrr`rar}rbrrrrUrtr/rrrr5r9r:ryrzr{r r|r r>r?r'rA) rrrBr$ new_shaperrHr0r2rGrrrr rs =%             rcstrBtjjt|ttfr(fdd|D}||jkr |}|St ||}|St|r8d|_ t ||}|St dt |ddS)z Inplace version of ``reshape`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_tensor_reshape`. cs$g|]}t|r|dn|qSr^)r3rbrcZtmp_tensor_typerr r!rzreshape_..TzAshape must be an instance of `list`, `tuple` or `Variable`, got 'r%N) rrr`rar3r4rrrrreshape_rUrtr/)rrrBrHrr(r r)s*     r))rBcGs|g}|D]-}t|tjtjjjtjjjjfst |}n|}| dkr*| d}n|}| |qt |dkr<|dS|S)aJ Convert inputs to tensors and return the view with at least 1-dimension. Scalar inputs are converted, one or high-dimensional inputs are preserved. Args: inputs (Tensor|list(Tensor)): One or more tensors. The data type is ``float16``, ``float32``, ``float64``, ``int16``, ``int32``, ``int64``, ``int8``, ``uint8``, ``complex64``, ``complex128``, ``bfloat16`` or ``bool``. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: One Tensor, if there is only one input. List of Tensors, if there are more than one inputs. Examples: .. code-block:: python >>> import paddle >>> # one input >>> x = paddle.to_tensor(123, dtype='int32') >>> out = paddle.atleast_1d(x) >>> print(out) Tensor(shape=[1], dtype=int32, place=Place(cpu), stop_gradient=True, [123]) >>> # more than one inputs >>> x = paddle.to_tensor(123, dtype='int32') >>> y = paddle.to_tensor([1.23], dtype='float32') >>> out = paddle.atleast_1d(x, y) >>> print(out) [Tensor(shape=[1], dtype=int32, place=Place(cpu), stop_gradient=True, [123]), Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=True, [1.23000002])] >>> # more than 1-D input >>> x = paddle.to_tensor(123, dtype='int32') >>> y = paddle.to_tensor([[1.23]], dtype='float32') >>> out = paddle.atleast_1d(x, y) >>> print(out) [Tensor(shape=[1], dtype=int32, place=Place(cpu), stop_gradient=True, [123]), Tensor(shape=[1, 1], dtype=float32, place=Place(cpu), stop_gradient=True, [[1.23000002]])] rrZr)r3r5rabase frameworkr libpaddler9r:r6r~rr}rsrBr0rHr"rresultrrr atleast_1ds$+      r/cGsg}|D];}t|tjtjjjtjjjjfst |}n|}| dkr*| d}n| dkr8tj |dd}n|}| |qt|dkrJ|dS|S)aD Convert inputs to tensors and return the view with at least 2-dimension. Two or high-dimensional inputs are preserved. Args: inputs (Tensor|list(Tensor)): One or more tensors. The data type is ``float16``, ``float32``, ``float64``, ``int16``, ``int32``, ``int64``, ``int8``, ``uint8``, ``complex64``, ``complex128``, ``bfloat16`` or ``bool``. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: One Tensor, if there is only one input. List of Tensors, if there are more than one inputs. Examples: .. code-block:: python >>> import paddle >>> # one input >>> x = paddle.to_tensor(123, dtype='int32') >>> out = paddle.atleast_2d(x) >>> print(out) Tensor(shape=[1, 1], dtype=int32, place=Place(cpu), stop_gradient=True, [[123]]) >>> # more than one inputs >>> x = paddle.to_tensor(123, dtype='int32') >>> y = paddle.to_tensor([1.23], dtype='float32') >>> out = paddle.atleast_2d(x, y) >>> print(out) [Tensor(shape=[1, 1], dtype=int32, place=Place(cpu), stop_gradient=True, [[123]]), Tensor(shape=[1, 1], dtype=float32, place=Place(cpu), stop_gradient=True, [[1.23000002]])] >>> # more than 2-D input >>> x = paddle.to_tensor(123, dtype='int32') >>> y = paddle.to_tensor([[[1.23]]], dtype='float32') >>> out = paddle.atleast_2d(x, y) >>> print(out) [Tensor(shape=[1, 1], dtype=int32, place=Place(cpu), stop_gradient=True, [[123]]), Tensor(shape=[1, 1, 1], dtype=float32, place=Place(cpu), stop_gradient=True, [[[1.23000002]]])] r)rrrrr3r5rar*r+r r,r9r:r6r~rrr}rsr-rrr atleast_2d&s(*       r1cGsg}|D]K}t|tjtjjjtjjjjfst |}n|}| dkr*| d}n | dkr:tj |ddgd}n| dkrHtj |dd}n|}| |qt|dkrZ|dS|S)aa Convert inputs to tensors and return the view with at least 3-dimension. Three or high-dimensional inputs are preserved. Args: inputs (Tensor|list(Tensor)): One or more tensors. The data type is ``float16``, ``float32``, ``float64``, ``int16``, ``int32``, ``int64``, ``int8``, ``uint8``, ``complex64``, ``complex128``, ``bfloat16`` or ``bool``. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: One Tensor, if there is only one input. List of Tensors, if there are more than one inputs. Examples: .. code-block:: python >>> import paddle >>> # one input >>> x = paddle.to_tensor(123, dtype='int32') >>> out = paddle.atleast_3d(x) >>> print(out) Tensor(shape=[1, 1, 1], dtype=int32, place=Place(cpu), stop_gradient=True, [[[123]]]) >>> # more than one inputs >>> x = paddle.to_tensor(123, dtype='int32') >>> y = paddle.to_tensor([1.23], dtype='float32') >>> out = paddle.atleast_3d(x, y) >>> print(out) [Tensor(shape=[1, 1, 1], dtype=int32, place=Place(cpu), stop_gradient=True, [[[123]]]), Tensor(shape=[1, 1, 1], dtype=float32, place=Place(cpu), stop_gradient=True, [[[1.23000002]]])] >>> # more than 3-D input >>> x = paddle.to_tensor(123, dtype='int32') >>> y = paddle.to_tensor([[[[1.23]]]], dtype='float32') >>> out = paddle.atleast_3d(x, y) >>> print(out) [Tensor(shape=[1, 1, 1], dtype=int32, place=Place(cpu), stop_gradient=True, [[[123]]]), Tensor(shape=[1, 1, 1, 1], dtype=float32, place=Place(cpu), stop_gradient=True, [[[[1.23000002]]]])] r)rrrrrrr0r-rrr atleast_3dls,*        r2cCsvtr t||St|dgddt|dddgdtd it}|}||}|jd||dd |id |S) a This function is actually a high-dimensional extension of :code:`gather` and supports for simultaneous indexing by multiple axes. :attr:`index` is a K-dimensional integer tensor, which is regarded as a (K-1)-dimensional tensor of :attr:`index` into :attr:`input`, where each element defines a slice of params: .. math:: output[(i_0, ..., i_{K-2})] = input[index[(i_0, ..., i_{K-2})]] Obviously, :code:`index.shape[-1] <= input.rank` . And, the output tensor has shape :code:`index.shape[:-1] + input.shape[index.shape[-1]:]` . .. code-block:: text Given: x = [[[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]], [[12, 13, 14, 15], [16, 17, 18, 19], [20, 21, 22, 23]]] x.shape = (2, 3, 4) * Case 1: index = [[1]] gather_nd(x, index) = [x[1, :, :]] = [[12, 13, 14, 15], [16, 17, 18, 19], [20, 21, 22, 23]] * Case 2: index = [[0,2]] gather_nd(x, index) = [x[0, 2, :]] = [8, 9, 10, 11] * Case 3: index = [[1, 2, 3]] gather_nd(x, index) = [x[1, 2, 3]] = [23] Args: x (Tensor): The input Tensor which it's data type should be bool, float16, float32, float64, int32, int64. index (Tensor): The index input with rank > 1, index.shape[-1] <= input.rank. Its dtype should be int32, int64. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: output (Tensor), A tensor with the shape index.shape[:-1] + input.shape[index.shape[-1]:] Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[[1, 2], [3, 4], [5, 6]], ... [[7, 8], [9, 10], [11, 12]]]) >>> index = paddle.to_tensor([[0, 1]]) >>> output = paddle.gather_nd(x, index) >>> print(output) Tensor(shape=[1, 2], dtype=int64, place=Place(cpu), stop_gradient=True, [[3, 4]]) r)rJrKrQrLrMrNr(rOZ gather_nprr(rO gather_ndrr+r N)r3) rrr3rr r>r@r?rA)rrrBrGr'r rrr r3s(K    r3cstr t|||||Stditt|dgddt|dttfdt|dttt fdt|dttt fdt|dttt fddd }||d||d||d||dfd d }d |i}d|i} d dt t |D} t |t rd|_ ||d<n=t |ttfrg| d<tj|r|||d<t|D]\} } t | t r| ddd| | <q| d| qn|| d<t |t rd|_ ||d<n?t |ttfr g| d<tj|r|||d<t|D]\} } t | t r| ddd| | <q| d| qn|| d<t |t rd|_ ||d<nBt |ttfr[g| d<tj|rW|||d<t|D]\} } t | t rM| ddd| | <q6| d| q6n|| d<| | d<jdd} jd|| d| id| S)a5 This operator produces a slice of ``x`` along multiple axes. Similar to numpy: https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html 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 data tensor. 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` th(here 0 is the initial position). The ``strides`` represents steps of slicing and if the ``strides`` is negative, slice operation is in the opposite direction. If the value passed to ``starts`` or ``ends`` is greater than n (the number of elements in this dimension), 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`` , ``ends`` and ``strides``. Following examples will explain how strided_slice works: .. code-block:: text Case1: Given: data = [ [1, 2, 3, 4], [5, 6, 7, 8], ] axes = [0, 1] starts = [1, 0] ends = [2, 3] strides = [1, 1] Then: result = [ [5, 6, 7], ] Case2: Given: data = [ [1, 2, 3, 4], [5, 6, 7, 8], ] axes = [0, 1] starts = [0, 1] ends = [2, 0] strides = [1, -1] Then: result = [ [8, 7, 6], ] Case3: Given: data = [ [1, 2, 3, 4], [5, 6, 7, 8], ] axes = [0, 1] starts = [0, 1] ends = [-1, 1000] strides = [1, 3] Then: result = [ [2], ] Args: x (Tensor): An N-D ``Tensor``. The data type is ``bool``, ``float16``, ``float32``, ``float64``, ``int32`` or ``int64``. axes (list|tuple): The data type is ``int32`` . Axes that `starts` and `ends` apply to. It's optional. If it is not provides, it will be treated as :math:`[0,1,...,len(starts)-1]`. starts (list|tuple|Tensor): The data type is ``int32`` . If ``starts`` is a list or tuple, the elements of it should be integers or Tensors with shape []. If ``starts`` is an Tensor, it should be an 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 Tensors with shape []. If ``ends`` is an Tensor, it should be an 1-D Tensor. It represents ending indices of corresponding axis in ``axes``. strides (list|tuple|Tensor): The data type is ``int32`` . If ``strides`` is a list or tuple, the elements of it should be integers or Tensors with shape []. If ``strides`` is an Tensor, it should be an 1-D Tensor. It represents slice step of corresponding axis in ``axes``. 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`` with the same dimension as ``x``. The data type is same as ``x``. Examples: .. code-block:: python >>> import paddle >>> x = paddle.zeros(shape=[3,4,5,6], dtype="float32") >>> # example 1: >>> # attr starts is a list which doesn't contain Tensor. >>> axes = [1, 2, 3] >>> starts = [-3, 0, 2] >>> ends = [3, 2, 4] >>> strides_1 = [1, 1, 1] >>> strides_2 = [1, 1, 2] >>> sliced_1 = paddle.strided_slice(x, axes=axes, starts=starts, ends=ends, strides=strides_1) >>> # sliced_1 is x[:, 1:3:1, 0:2:1, 2:4:1]. >>> # example 2: >>> # attr starts is a list which contain tensor Tensor. >>> minus_3 = paddle.full(shape=[1], fill_value=-3, dtype='int32') >>> sliced_2 = paddle.strided_slice(x, axes=axes, starts=[minus_3, 0, 2], ends=ends, strides=strides_2) >>> # sliced_2 is x[:, 1:3:1, 0:2:1, 2:4:2]. strided_slicerrrirkrnstridescSsht|trt|j|ddgddSt|D]\}}|dt|d}t|tr1t|j|dgdqdS)Nr(rOr4[r%)r3r rr'r;r<)Z list_inputZ input_namerFvarvar_namerrr check_list_elements_dtypes   z0strided_slice..check_list_elements_dtypecsdg}|D]+}t|trd|_||qt|tsJd}tdgd|d|d||q|S)NTr(rr)r3r rUr}rr?r)Zold_listZnew_list_tensorr~rrrr get_new_list_tensors    z*strided_slice..get_new_list_tensorrhcSrYrZrr[rrr r!r\z!strided_slice..TrjrlrfrmroZ StridesTensorZStridesTensorListrpr&r+rqN)r4)rrr4r r>rrr4rrr rursr3rUr5ryrzr;r}r?r@rA)rrirkrnr5rBr9r:r0r2rprFr~rHrrr r4sV                      r4c sZdgd}t|d|t|d|t|dttttffdd}g}g}tt|tj rP|dksBJd d |d t |j ||j }t |}n9t |trY||}|rftt|dtj ri|}n |d}t |d krw|d }t |tr||}t |tr||}t|t|}}t |t |}} || kr|||d n | |kr||| d t|jt|j} } tj|j td} tj|j td} d }t t |D]_}||||}}| || |}}|d krd | |<||| }n,|d krd | |<||| }n||ks*Jdd|d|d|d|d d| |<d| |<|| |9}qg}g}g}d }d }t |j D]}| |sa|||| ||| |9}qH||||t |j D]}| |s|||| ||| |9}qr|j|d||g}|j|d||g}|||}|S)a This function computes a contraction, which sum the product of elements from two tensors along the given axes. Args: x (Tensor): The left tensor for contraction with data type ``float16`` or ``float32`` or ``float64``. y (Tensor): The right tensor for contraction with the same data type as ``x``. axes (int|tuple|list|Tensor, optional): The axes to contract for ``x`` and ``y``, defaulted to integer ``2``. 1. It could be a non-negative integer ``n``, in which the function will sum over the last ``n`` axes of ``x`` and the first ``n`` axes of ``y`` in order. 2. It could be a 1-d tuple or list with data type ``int``, in which ``x`` and ``y`` will be contracted along the same given axes. For example, ``axes`` =[0, 1] applies contraction along the first two axes for ``x`` and the first two axes for ``y``. 3. It could be a tuple or list containing one or two 1-d tuple|list|Tensor with data type ``int``. When containing one tuple|list|Tensor, the data in tuple|list|Tensor specified the same axes for ``x`` and ``y`` to contract. When containing two tuple|list|Tensor, the first will be applied to ``x`` and the second to ``y``. When containing more than two tuple|list|Tensor, only the first two axis sequences will be used while the others will be ignored. 4. It could be a tensor, in which the ``axes`` tensor will be translated to a python list and applied the same rules described above to determine the contraction axes. Note that the ``axes`` with Tensor type is ONLY available in Dygraph mode. 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` . Return: Output (Tensor), The contraction result with the same data type as ``x`` and ``y``. In general, :math:`output.ndim = x.ndim + y.ndim - 2 \times n_{axes}`, where :math:`n_{axes}` denotes the number of axes to be contracted. NOTES: 1. This function supports tensor broadcast, the size in the corresponding dimensions of ``x`` and ``y`` should be equal, or applies to the broadcast rules. 2. This function also supports axes expansion, when the two given axis sequences for ``x`` and ``y`` are of different lengths, the shorter sequence will expand the same axes as the longer one at the end. For example, if ``axes`` =[[0, 1, 2, 3], [1, 0]], the axis sequence for ``x`` is [0, 1, 2, 3], while the corresponding axis sequences for ``y`` will be expanded from [1, 0] to [1, 0, 2, 3]. Examples: .. code-block:: python >>> import paddle >>> data_type = 'float64' >>> # For two 2-d tensor x and y, the case axes=0 is equivalent to outer product. >>> # Note that tensordot supports empty axis sequence, so all the axes=0, axes=[], axes=[[]], and axes=[[],[]] are equivalent cases. >>> x = paddle.arange(4, dtype=data_type).reshape([2, 2]) >>> y = paddle.arange(4, dtype=data_type).reshape([2, 2]) >>> z = paddle.tensordot(x, y, axes=0) >>> print(z) Tensor(shape=[2, 2, 2, 2], dtype=float64, place=Place(cpu), stop_gradient=True, [[[[0., 0.], [0., 0.]], [[0., 1.], [2., 3.]]], [[[0., 2.], [4., 6.]], [[0., 3.], [6., 9.]]]]) >>> # For two 1-d tensor x and y, the case axes=1 is equivalent to inner product. >>> x = paddle.arange(10, dtype=data_type) >>> y = paddle.arange(10, dtype=data_type) >>> z1 = paddle.tensordot(x, y, axes=1) >>> z2 = paddle.dot(x, y) >>> print(z1) Tensor(shape=[], dtype=float64, place=Place(cpu), stop_gradient=True, 285.) >>> print(z2) Tensor(shape=[], dtype=float64, place=Place(cpu), stop_gradient=True, 285.) >>> # For two 2-d tensor x and y, the case axes=1 is equivalent to matrix multiplication. >>> x = paddle.arange(6, dtype=data_type).reshape([2, 3]) >>> y = paddle.arange(12, dtype=data_type).reshape([3, 4]) >>> z1 = paddle.tensordot(x, y, axes=1) >>> z2 = paddle.matmul(x, y) >>> print(z1) Tensor(shape=[2, 4], dtype=float64, place=Place(cpu), stop_gradient=True, [[20., 23., 26., 29.], [56., 68., 80., 92.]]) >>> print(z2) Tensor(shape=[2, 4], dtype=float64, place=Place(cpu), stop_gradient=True, [[20., 23., 26., 29.], [56., 68., 80., 92.]]) >>> # When axes is a 1-d int list, x and y will be contracted along the same given axes. >>> # Note that axes=[1, 2] is equivalent to axes=[[1, 2]], axes=[[1, 2], []], axes=[[1, 2], [1]], and axes=[[1, 2], [1, 2]]. >>> x = paddle.arange(24, dtype=data_type).reshape([2, 3, 4]) >>> y = paddle.arange(36, dtype=data_type).reshape([3, 3, 4]) >>> z = paddle.tensordot(x, y, axes=[1, 2]) >>> print(z) Tensor(shape=[2, 3], dtype=float64, place=Place(cpu), stop_gradient=True, [[506. , 1298., 2090.], [1298., 3818., 6338.]]) >>> # When axes is a list containing two 1-d int list, the first will be applied to x and the second to y. >>> x = paddle.arange(60, dtype=data_type).reshape([3, 4, 5]) >>> y = paddle.arange(24, dtype=data_type).reshape([4, 3, 2]) >>> z = paddle.tensordot(x, y, axes=([1, 0], [0, 1])) >>> print(z) Tensor(shape=[5, 2], dtype=float64, place=Place(cpu), stop_gradient=True, [[4400., 4730.], [4532., 4874.], [4664., 5018.], [4796., 5162.], [4928., 5306.]]) >>> # Thanks to the support of axes expansion, axes=[[0, 1, 3, 4], [1, 0, 3, 4]] can be abbreviated as axes= [[0, 1, 3, 4], [1, 0]]. >>> x = paddle.arange(720, dtype=data_type).reshape([2, 3, 4, 5, 6]) >>> y = paddle.arange(720, dtype=data_type).reshape([3, 2, 4, 5, 6]) >>> z = paddle.tensordot(x, y, axes=[[0, 1, 3, 4], [1, 0]]) >>> print(z) Tensor(shape=[4, 4], dtype=float64, place=Place(cpu), stop_gradient=True, [[23217330., 24915630., 26613930., 28312230.], [24915630., 26775930., 28636230., 30496530.], [26613930., 28636230., 30658530., 32680830.], [28312230., 30496530., 32680830., 34865130.]]) tensordot)rKrLrMrrricstrt|Stdd)Nz!The 'axes' with type 'Tensor' in zm is not available in static graph mode, please convert its type to int|Tuple|List, or use dynamic graph mode.)rrr=)r7rrr _var_to_listxsztensordot.._var_to_listrzThe 'axes' in z+ should not be negative, but received axes=rrNr&z(The dimensional size for 'x' and 'y' in z+ should match each other, but 'x' has size z in dim z while 'y' has size T)r)rrrrrr4r r7Z issubdtyper/integerrurr3rsextendrrrJsumrr}rmatmul)rrrirBr@r=Zaxes_xZaxes_yZ len_axes_xZ len_axes_yZshape_xZshape_yZneed_contracted_dim_xZneed_contracted_dim_yZcontraction_sizerFZdim_xZdim_ysxZsyZperm_xZperm_yZ shape_outZnot_contraction_size_xZnot_contraction_size_yrHrr<r r;s{                     r;cCsttrt|St|dddgdd}t|fit}d|i}|jt|jd}d|i}i}|j ||||d|S) aTransform a real tensor to a complex tensor. The data type of the input tensor is 'float32' or 'float64', and the data type of the returned tensor is 'complex64' or 'complex128', respectively. The shape of the input tensor is ``(* ,2)``, (``*`` means arbitary shape), i.e. the size of the last axis shoule be 2, which represent the real and imag part of a complex number. The shape of the returned tensor is ``(*,)``. Args: x (Tensor): The input tensor. Data type is 'float32' or 'float64'. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, The output. Data type is 'complex64' or 'complex128', with the same precision as the input. Examples: .. code-block:: python >>> import paddle >>> x = paddle.arange(12, dtype=paddle.float32).reshape([2, 3, 2]) >>> y = paddle.as_complex(x) >>> print(y) Tensor(shape=[2, 3], dtype=complex64, place=Place(cpu), stop_gradient=True, [[1j , (2+3j) , (4+5j) ], [(6+7j) , (8+9j) , (10+11j)]]) rrLrM as_complexr)r&r+rq) rrrCrr r>r?rr'rA)rrBrrGr0rHr1r2rrr rCs rCcCsntrt|St|dddgdd}t|fit}d|i}|jt|jd}d|i}|j |||d|S) aTransform a complex tensor to a real tensor. The data type of the input tensor is 'complex64' or 'complex128', and the data type of the returned tensor is 'float32' or 'float64', respectively. When the shape of the input tensor is ``(*, )``, (``*`` means arbitary shape), the shape of the output tensor is ``(*, 2)``, i.e. the shape of the output is the shape of the input appended by an extra ``2``. Args: x (Tensor): The input tensor. Data type is 'complex64' or '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 output. Data type is 'float32' or 'float64', with the same precision as the input. Examples: .. code-block:: python >>> import paddle >>> x = paddle.arange(12, dtype=paddle.float32).reshape([2, 3, 2]) >>> y = paddle.as_complex(x) >>> z = paddle.as_real(y) >>> print(z) Tensor(shape=[2, 3, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[[0. , 1. ], [2. , 3. ], [4. , 5. ]], [[6. , 7. ], [8. , 9. ], [10., 11.]]]) rrras_realr)r&r+r ) rrrDrr r>r?rr'rA)rrBrrGr0rHr1rrr rDs! rDcCst|ttjjfr|jst|dg}|durt|}d}tr8t|ttjjfr1t |||St |||St d it }t|dgdd||j}|jd|t|trZ|nddd |i|t|trh|ndd d |S) a Returns a new tensor which repeats the ``x`` tensor along dimension ``axis`` using the entries in ``repeats`` which is a int or a Tensor. Args: x (Tensor): The input Tensor to be operated. The data of ``x`` can be one of float32, float64, int32, int64. repeats (Tensor or int): The number of repetitions for each element. repeats is broadcasted to fit the shape of the given axis. axis (int, optional): The dimension in which we manipulate. Default: None, the output tensor is flatten. 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 with same data type as ``x``. Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1, 2, 3], [4, 5, 6]]) >>> repeats = paddle.to_tensor([3, 2, 1], dtype='int32') >>> out = paddle.repeat_interleave(x, repeats, 1) >>> print(out) Tensor(shape=[2, 6], dtype=int64, place=Place(cpu), stop_gradient=True, [[1, 1, 1, 2, 2, 3], [4, 4, 4, 5, 5, 6]]) >>> out = paddle.repeat_interleave(x, 2, 0) >>> print(out) Tensor(shape=[4, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[1, 2, 3], [1, 2, 3], [4, 5, 6], [4, 5, 6]]) >>> out = paddle.repeat_interleave(x, 2, None) >>> print(out) Tensor(shape=[12], dtype=int64, place=Place(cpu), stop_gradient=True, [1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6]) rNrrepeat_interleaverrz,paddle.tensor.manipulation.repeat_interleave)r)Z RepeatsTensorr+)r~ZRepeatsr.)rE)r3r r5r9rrrrrrZ#repeat_interleave_with_tensor_indexrEr r>rr?r'rAr)rZrepeatsrrBrGrHrrr rE5s8,   rEcCs|t|tr|gn|}t|tr|gn|}t|t|ks Jdt|tt|kr.tdt|tt|kr>> import paddle >>> x = paddle.ones([3, 2, 4]) >>> outshape = paddle.moveaxis(x, [0, 1], [1, 2]).shape >>> print(outshape) [4, 3, 2] >>> x = paddle.ones([2, 3]) >>> outshape = paddle.moveaxis(x, 0, 1).shape # equivalent to paddle.t(x) >>> print(outshape) [3, 2] z5'source' must have the same number with 'destination'z)Each elemment of 'source' must be unique!z.Each elemment of 'destination' must be unique!rz*Each elemment of 'source' must be integer.z#'source' must be in the range of [-rrrr)rJrKrLrMr(rOrrmoveaxisrr)rrr.N)rF)r3rrssetrtrr4rur;zipremoverrrrr r>r?r'rA)rsourceZ destinationrBsrcdstrrZsrc_dimsZdst_dimsrFrrHrGrrrr rFs           rFcC6t|r tg||j}t|}t|||}|S)a Fills elements of self tensor with value where mask is True. The shape of mask must be broadcastable with the shape of the underlying tensor. Args: x (Tensor) : The Destination Tensor. Supported data types are float, double, int, int64_t,float16 and bfloat16. mask (Tensor): The boolean tensor indicate the position to be filled. The data type of mask must be bool. value (Scalar or 0-D Tensor): The value used to fill the target tensor. Supported data types are float, double, int, int64_t,float16 and bfloat16. 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, same dimention and dtype with x. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> x = paddle.ones((3, 3), dtype="float32") >>> mask = paddle.to_tensor([[True, True, False]]) >>> print(mask) Tensor(shape=[1, 3], dtype=bool, place=Place(gpu:0), stop_gradient=True, [[True , True , False]]) >>> out = paddle.masked_fill(x, mask, 2) >>> print(out) Tensor(shape=[3, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True, [[2., 2., 1.], [2., 2., 1.], [2., 2., 1.]]) )r7isscalarr5fullr' logical_notwherermaskrrBrHrrr masked_fills " rTcCrM)a Inplace version of ``masked_fill`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_masked_fill`. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> x = paddle.ones((3, 3), dtype="float32") >>> mask = paddle.to_tensor([[True, False, False]]) >>> out = paddle.masked_fill_(x, mask, 2) >>> print(out) Tensor(shape=[3, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True, [[2., 1., 1.], [2., 1., 1.], [2., 1., 1.]]) )r7rNr5rOr'rPZwhere_rRrrr masked_fill_!s  rUcCs`t|j}|dkr||ksJd|d|d|S|| ks*Jd|d|d||7}|S)Nrz"'axis' must be in the range of [-rr)rsr)arrrrrrr non_negative_axis=s  rWcCsVt|j}t|j|||<t|}tt|jD]}|j||j|kr(dSq|SN)r4rrrrurs)rVrrbroadcast_shape_listbroadcast_shaperFrrr infer_broadcast_shapeJs r[c Csht|jt|jkrtdt||}|r>t|||}|s |j}t||}t|}t|j|||<t|}t||}n7t t|jD]}||kra|j||j|krat d ||j|j|qE|j|}||k sut d ||t rt|||St|dgddt|ddd gdtdit}|} || } |jd||d d |id | id | S)a Take values from the input array by given indices matrix along the designated axis. Args: arr (Tensor) : The input Tensor. Supported data types are float32 and float64. indices (Tensor) : Indices to take along each 1d slice of arr. This must match the dimension of arr, and need to broadcast against arr. Supported data type are int and int64. axis (int) : The axis to take 1d slices along. broadcast (bool, optional): whether the indices broadcast. Returns: Tensor, The indexed element, same dtype with arr Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[1, 2, 3], [4, 5, 6], [7,8,9]]) >>> index = paddle.to_tensor([[0]]) >>> axis = 0 >>> result = paddle.take_along_axis(x, index, axis) >>> print(result) Tensor(shape=[1, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[1, 2, 3]]) <`indices` and `arr` must have the same number of dimensions!zhSize does not match at dimension {} expected index {} to be smaller than self {} apart from dimension {}Hone of element of indices is out of bounds for dimension {} with size {}rrKrLrMr(rOrPrQtake_along_axisrr(rO)rhrrResultrqN)r_)rsrrtrWr[r5rr4rrru RuntimeErrorrallrrr_rr r>r@r?rA) rVrr broadcastrZrYrF axis_max_sizerGr'r.rrr r_Vsd         r_assignc Cs4t|jt|jkrtdt||}|r?t|||}tr/t|tjtj j fs-t |n|}|r7t ||}t ||j}n|t|tjtj j frt|jt|jkrWtdt t|jD](}||krn|j||j|ksx|j||j|krtd||j|j||jq^n t ||j}d} |jD]} | | 9} q| dkrt ||j}|j|} || kstd|| trt|jdvrtdtt|jt||||||St|dgd d t|d d d gd t|dtd tdit} | } | | }| jd |||d|||dd|id|S)aA Put values into the destination array by given indices matrix along the designated axis. Args: arr (Tensor) : The Destination Tensor. Supported data types are float32 and float64. indices (Tensor) : Indices to put along each 1d slice of arr. This must match the dimension of arr, and need to broadcast against arr if broadcast is 'True'. Supported data type are int and int64. values (Tensor) : The value element(s) to put. The data types should be same as arr. axis (int) : The axis to put 1d slices along. reduce (str, optional): The reduce operation, default is 'assign', support 'add', 'assign', 'mul', 'multiply', "mean", "amin" and "amax". include_self (bool, optional): whether to reduce with the elements of arr, default is 'True'. broadcast (bool, optional): whether to broadcast indices, default is 'True'. Returns: Tensor, The indexed element, same dtype with arr Examples: .. code-block:: python >>> import paddle >>> x = paddle.to_tensor([[10, 30, 20], [60, 40, 50]]) >>> index = paddle.to_tensor([[0]]) >>> value = 99 >>> axis = 0 >>> result = paddle.put_along_axis(x, index, value, axis) >>> print(result) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[99, 99, 99], [60, 40, 50]]) >>> index = paddle.zeros((2,2)).astype("int32") >>> value=paddle.to_tensor([[1,2],[3,4]]).astype(x.dtype) >>> result = paddle.put_along_axis(x, index, value, 0, "add", True, False) >>> print(result) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[14, 36, 20], [60, 40, 50]]) >>> result = paddle.put_along_axis(x, index, value, 0, "mul", True, False) >>> print(result) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[30 , 240, 20 ], [60 , 40 , 50 ]]) >>> result = paddle.put_along_axis(x, index, value, 0, "mean", True, False) >>> print(result) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[4 , 12, 20], [60, 40, 50]]) >>> result = paddle.put_along_axis(x, index, value, 0, "amin", True, False) >>> print(result) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[1 , 2 , 20], [60, 40, 50]]) >>> result = paddle.put_along_axis(x, index, value, 0, "amax", True, False) >>> print(result) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[10, 30, 20], [60, 40, 50]]) >>> result = paddle.put_along_axis(x, index, value, 0, "add", False, False) >>> print(result) Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[4 , 6 , 20], [60, 40, 50]]) r\z?`indices` and `values` must have the same number of dimensions!zSize does not match at dimension {} expected index {} to be smaller than self {} apart from dimension {} and to be smaller size than values {}rr])r(rOzHThe data type of indices should be one of ['int32', 'int64'], but got {}rr^put_along_axisrr(rO include_self)rhrr)rZReduceZ Include_selfr`rqN)rf) rsrrtrWr[rr3r5rar9r:r6rrurarastyper'rbr r=r<rrfrrrJr r>r@r?rA)rVrvaluesrreducergrcrZrFelementsrrdrGr'r.rrr rfsO                rfcCs~t|jt|jkrtdt||}t|||}t|tjs$t|n|}|r.t ||}t ||j}t ||||||S)z Inplace version of ``put_along_axis`` API, the output Tensor will be inplaced with input ``arr``. Please refer to :ref:`api_paddle_put_along_axis`. r\) rsrrtrWr[r3r5rar6rrput_along_axis_)rVrrirrjrgrZrrr rlYs       rlcCstr t||||Stdit}t|dgddt|dddgdt|dgdd||j}|jd|||d d |id |id |S)as Adds the elements of the input tensor with value tensor by selecting the indices in the order given in index. Args: x (Tensor) : The Destination Tensor. Supported data types are int32, int64, float16, float32, float64. index (Tensor): The 1-D Tensor containing the indices to index. The data type of ``index`` must be int32 or int64. axis (int): The dimension in which we index. value (Tensor): The tensor used to add the elements along the target axis. name(str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor, same dimention and dtype with x. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> paddle.device.set_device('gpu') >>> input_tensor = paddle.to_tensor(paddle.ones((3, 3)), dtype="float32") >>> index = paddle.to_tensor([0, 2], dtype="int32") >>> value = paddle.to_tensor([[1, 1, 1], [1, 1, 1]], dtype="float32") >>> outplace_res = paddle.index_add(input_tensor, index, 0, value) >>> print(outplace_res) Tensor(shape=[3, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True, [[2., 2., 2.], [1., 1., 1.], [2., 2., 2.]]) index_addrrz$paddle.tensor.manipulation.index_addrr(rOZ add_value)r)rZAddValuer+rr.N)rm) rrrmr r>rr?r'rA)rrrrrBrGrHrrr rmts@   rmcCst||||S)aG Inplace version of ``index_add`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_index_add`. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:GPU) >>> import paddle >>> paddle.device.set_device('gpu') >>> input_tensor = paddle.to_tensor(paddle.ones((3, 3)), dtype="float32") >>> index = paddle.to_tensor([0, 2], dtype="int32") >>> value = paddle.to_tensor([[1, 1], [1, 1], [1, 1]], dtype="float32") >>> inplace_res = paddle.index_add_(input_tensor, index, 1, value) >>> print(inplace_res) Tensor(shape=[3, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True, [[2., 1., 2.], [2., 1., 2.], [2., 1., 2.]]) )r index_add_rrrrrBrrr rnsrncCr)a Puts values from the tensor values into the tensor x using the indices specified in indices (which is a tuple of Tensors). The expression paddle.index_put_(x, indices, values) is equivalent to tensor[indices] = values. Returns x. If accumulate is True, the elements in values are added to x. If accumulate is False, the behavior is undefined if indices contain duplicate elements. Args: x (Tensor) : The Source Tensor. Supported data types are int32, int64, float16, float32, float64, bool. indices (Tuple of Tensor): The tuple of Tensor containing the indices to index. The data type of ``tensor in indices`` must be int32, int64 or bool. value (Tensor): The tensor used to be assigned to x. accummulate (Bool, optional): Whether the elements in values are added to x. Default: False. name(str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor, same dimention and dtype with x. Examples: .. code-block:: python >>> import paddle >>> x = paddle.zeros([3, 3]) >>> value = paddle.ones([3]) >>> ix1 = paddle.to_tensor([0,1,2]) >>> ix2 = paddle.to_tensor([1,2,1]) >>> indices=(ix1,ix2) >>> out = paddle.index_put_(x,indices,value) >>> print(x) Tensor(shape=[3, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[0., 1., 0.], [0., 0., 1.], [0., 1., 0.]]) >>> print(out) Tensor(shape=[3, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[0., 1., 0.], [0., 0., 1.], [0., 1., 0.]]) )r index_put_)rrr accumulaterBrrr rps)rpcCs|tr t||||Std it}t|dgddt|dgdd||j}|jd|||dd|id|id |S) av Outplace version of ``index_put_`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_index_put`. Examples: .. code-block:: python >>> import paddle >>> x = paddle.zeros([3, 3]) >>> value = paddle.ones([3]) >>> ix1 = paddle.to_tensor([0,1,2]) >>> ix2 = paddle.to_tensor([1,2,1]) >>> indices=(ix1,ix2) >>> out = paddle.index_put(x,indices,value) >>> print(x) Tensor(shape=[3, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[0., 0., 0.], [0., 0., 0.], [0., 0., 0.]]) >>> print(out) Tensor(shape=[3, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[0., 1., 0.], [0., 0., 1.], [0., 1., 0.]]) index_putrrz$paddle.tensor.manipulation.index_putr)rrrrHrqr.N)rr) rrrrr r>rr?r'rA)rrrrqrBrGrHrrr rrs4  rrcCst||}t|ttfr%t|jd|t|t|j|dd}n/t|ttjjfrKt t|d|t |dt||ddg}n t d t |||}|S)a Expand a certain dimension of the input x Tensor into a desired shape. Args: x (Tensor) : An N-D Tensor. The data type is float16, float32, float64, int16, int32, int64, bool, uint16. axis (int): :attr:`axis` to be unflattened, specified as an index into `x.shape`. shape (list|tuple|Tensor): Unflatten :attr:`shape` on the specified :attr:`axis`. At most one dimension of the target :attr:`shape` can be -1. If the input :attr:`shape` does not contain -1 , the product of all elements in ``shape`` should be equal to ``x.shape[axis]``. The data type is `int` . If :attr:`shape` is a list or tuple, the elements of it should be integers or Tensors with shape []. If :attr:`shape` is an Tensor, it should be an 1-D Tensor. name(str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor, return the unflatten tensor of :attr:`x`. Examples: .. code-block:: python >>> import paddle >>> x = paddle.randn(shape=[4, 6, 8]) >>> shape = [2, 3] >>> axis = 1 >>> res = paddle.unflatten(x, axis, shape) >>> print(res.shape) [4, 2, 3, 8] >>> x = paddle.randn(shape=[4, 6, 8]) >>> shape = (-1, 2) >>> axis = -1 >>> res = paddle.unflatten(x, axis, shape) >>> print(res.shape) [4, 6, 4, 2] >>> x = paddle.randn(shape=[4, 6, 8]) >>> shape = paddle.to_tensor([2, 2]) >>> axis = 0 >>> res = paddle.unflatten(x, axis, shape) >>> print(res.shape) [2, 2, 6, 8] Nrr(zKThe data type of x should be one of ['List', 'Tuple', 'Tensor'], but got {})rWr3r4rrrr r5r9rrrRr=rr/r)rrrrBr'rrr unflatten<s$ ,.  rscCr)a View x with specified shape, stride and offset. Note that the output Tensor will share data with origin Tensor and doesn't have a Tensor copy in ``dygraph`` mode. Args: x (Tensor): An N-D Tensor. The data type is ``float32``, ``float64``, ``int32``, ``int64`` or ``bool`` shape (list|tuple): Define the target shape. Each element of it should be integer. stride (list|tuple): Define the target stride. Each element of it should be integer. offset (int): Define the target Tensor's offset from x's holder. Default: 0. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, A as_strided Tensor with the same data type as ``x``. Examples: .. code-block:: python >>> import paddle >>> paddle.base.set_flags({"FLAGS_use_stride_kernel": True}) >>> x = paddle.rand([2, 4, 6], dtype="float32") >>> out = paddle.as_strided(x, [8, 6], [6, 1]) >>> print(out.shape) [8, 6] >>> # the stride is [6, 1]. )r as_strided)rrZstriderrBrrr rtsrtcCs<t|ttfr t||St|tjjst|}t ||S)a| View x with specified shape or dtype. Note that the output Tensor will share data with origin Tensor and doesn't have a Tensor copy in ``dygraph`` mode. Args: x (Tensor): An N-D Tensor. The data type is ``float32``, ``float64``, ``int32``, ``int64`` or ``bool`` shape_or_dtype (list|tuple|np.dtype|str|VarType): Define the target shape or dtype. If list or tuple, shape_or_dtype represents shape, each element of it should be integer. If np.dtype or str or VarType, shape_or_dtype represents dtype, it can be bool, float16, float32, float64, int8, int32, int64, uint8. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, A viewed Tensor with the same data as ``x``. Examples: .. code-block:: python >>> import paddle >>> paddle.base.set_flags({"FLAGS_use_stride_kernel": True}) >>> x = paddle.rand([2, 4, 6], dtype="float32") >>> out = paddle.view(x, [8, 6]) >>> print(out.shape) [8, 6] >>> import paddle >>> paddle.base.set_flags({"FLAGS_use_stride_kernel": True}) >>> x = paddle.rand([2, 4, 6], dtype="float32") >>> out = paddle.view(x, "uint8") >>> print(out.shape) [2, 4, 24] ) r3r4rrr view_shaperrVrWr Z view_dtype)rZshape_or_dtyperBrrr views &  rvcCst||jS)a View x with other's shape. Note that the output Tensor will share data with origin Tensor and doesn't have a Tensor copy in ``dygraph`` mode. Args: x (Tensor): An N-D Tensor. The data type is ``float32``, ``float64``, ``int32``, ``int64`` or ``bool`` other (Tensor): The result tensor has the same size as other. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, A viewed Tensor with the same shape as ``other``. Examples: .. code-block:: python >>> import paddle >>> paddle.base.set_flags({"FLAGS_use_stride_kernel": True}) >>> x = paddle.rand([2, 4, 6], dtype="float32") >>> y = paddle.rand([8, 6], dtype="float32") >>> out = paddle.view_as(x, y) >>> print(out.shape) [8, 6] )rrur)rotherrBrrr view_assrxcCr)a View x with specified shape, stride and offset, which contains all slices of size from x in the dimension axis. Note that the output Tensor will share data with origin Tensor and doesn't have a Tensor copy in ``dygraph`` mode. Args: x (Tensor): An N-D Tensor. The data type is ``float32``, ``float64``, ``int32``, ``int64`` or ``bool`` axis (int): The axis along which the input is unfolded. size (int): The size of each slice that is unfolded. step (int): The step between each slice. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, A unfold Tensor with the same data type as ``x``. Examples: .. code-block:: python >>> import paddle >>> paddle.base.set_flags({"FLAGS_use_stride_kernel": True}) >>> x = paddle.arange(9, dtype="float64") >>> out = paddle.unfold(x, 0, 2, 4) >>> print(out) Tensor(shape=[2, 2], dtype=float64, place=Place(cpu), stop_gradient=True, [[0., 1.], [4., 5.]]) )rZ tensor_unfold)rrsizesteprBrrr unfolds r{)rrrrrrcCst|ts tdt|tstj||jd}n t|jdkr"tdt|j}t|tr7||dks7|| kr;td|dkrC||}t t t|j}||d<d||<|rft ||t ||f||St ||}t ||f|}t ||}|S)Nzindex must be Tensorr&rz"value must be scalar or 0-D tensorrz8The axis should be int, and in range [-rank(x), rank(x)))r3r rtr5r6r'rsrrr4rurrprr)rrrrrrrrHrrr _index_fill_impl s0       r|cCt||||dS)a Outplace version of ``index_fill_`` API, the output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_index_fill_`. Examples: .. code-block:: python >>> import paddle >>> input_tensor = paddle.to_tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype='int64') >>> index = paddle.to_tensor([0, 2], dtype="int32") >>> value = -1 >>> res = paddle.index_fill(input_tensor, index, 0, value) >>> print(input_tensor) Tensor(shape=[3, 3], dtype=int64, place=Place(gpu:0), stop_gradient=True, [[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> print(res) Tensor(shape=[3, 3], dtype=int64, place=Place(gpu:0), stop_gradient=True, [[-1, -1, -1], [ 4, 5, 6], [-1, -1, -1]]) Fr|rorrr index_fillBsrcCr})a Fill the elements of the input tensor with value by the spcific axis and index. Args: x (Tensor) : The Destination Tensor. Supported data types are int32, int64, float16, float32, float64. index (Tensor): The 1-D Tensor containing the indices to index. The data type of ``index`` must be int32 or int64. axis (int): The dimension along which to index. value (float): The tensor used to fill with. name(str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor, same dimention and dtype with x. Examples: .. code-block:: python >>> import paddle >>> input_tensor = paddle.to_tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype='int64') >>> index = paddle.to_tensor([0, 2], dtype="int32") >>> value = -1 >>> res = paddle.index_fill_(input_tensor, index, 0, value) >>> print(input_tensor) Tensor(shape=[3, 3], dtype=int64, place=Place(gpu:0), stop_gradient=True, [[-1, -1, -1], [ 4, 5, 6], [-1, -1, -1]]) >>> print(res) Tensor(shape=[3, 3], dtype=int64, place=Place(gpu:0), stop_gradient=True, [[-1, -1, -1], [ 4, 5, 6], [-1, -1, -1]]) Tr~rorrr index_fill_^s$rcCst||||||S)a, Embed the values of Tensor ``y`` into Tensor ``x`` along the diagonal elements of Tensor ``x``, with respect to ``axis1`` and ``axis2``. This function returns a tensor with fresh storage. The argument ``offset`` controls which diagonal to consider: - 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. Note: ``y`` should have the same shape as :ref:`paddle.diagonal `. Args: x (Tensor): ``x`` is the original Tensor. Must be at least 2-dimensional. y (Tensor): ``y`` is the Tensor to embed into ``x`` offset (int, optional): which diagonal to consider. Default: 0 (main diagonal). axis1 (int, optional): first axis with respect to which to take diagonal. Default: 0. axis2 (int, optional): second axis with respect to which to take diagonal. Default: 1. name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor, Tensor with diagonal embedeed with ``y``. Examples: .. code-block:: python >>> import paddle >>> x = paddle.arange(6.0).reshape((2, 3)) >>> y = paddle.ones((2,)) >>> out = x.diagonal_scatter(y) >>> print(out) Tensor(shape=[2, 3], dtype=float32, place=Place(gpu:0), stop_gradient=True, [[1., 1., 2.], [3., 1., 5.]]) r)rrrZaxis1Zaxis2rBrrr diagonal_scatters(rc Cs|j}|j}t|tst|}|dkr|||7}|dkr#|t|7}||=t|t|kr>> import paddle >>> x = paddle.zeros((2,3,4)).astype("float32") >>> values = paddle.ones((2,4)).astype("float32") >>> res = paddle.select_scatter(x,values,1,1) >>> print(res) Tensor(shape=[2, 3, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[[0., 0., 0., 0.], [1., 1., 1., 1.], [0., 0., 0., 0.]], [[0., 0., 0., 0.], [1., 1., 1., 1.], [0., 0., 0., 0.]]]) rzEexpected values to have a size equal to the slice of x. value size = z slice size = r)default_main_programrrh)rirkrnsteps decrease_axes none_axesr'Z ValueTensorselect_scatterr& set_valuer+)r/r0r1r2Z inplace_mapN)r)rr3r4rsrar<rubase.frameworkrr'rhrrZset_value_with_tensorr r>r?Z current_blockrA)rrirrrBrZ value_shaperFrrkrnrrirrr0r2r'rGr Z cur_blockrrr rs          r)rFNrX)rNre)NNN)rFN)rrrF)rrrN)rrfN)NN)FFNrON)FFFNrONr^)TN)rN)T)reTT)reT)FN)orxr7r5rZ paddle.tensorrZpaddle.utils.inplace_utilsrZbase.data_feederrrrr rr r+r r r rrrrrZcreationrrr__all__r#rRrXrgrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrrr)r/r1r2r3r4r;rCrDrErFrTrUrWr[r_rfrlrmrnrprrrsrtrvrxr{Z __METHODSitemsrBfuncsetattrr`rar|rrrrrrrr s     (  L   T c 8 LO "   [ #  !  uH h  $ f  Y 2     (   _ S^   V ) '  D r xN EF H k X b . 0 O s*  _ * F   + <D ! -  $ "  &+