o Ne$@s^ddlmZddlZddlZddlZddlmZddlmZddl m Z ddl m Z m Z mZmZmZmZmZmZddl mZdd l mZdd lmZdd lmZd d lmZd dlmZddlmZmZmZm Z ddl!m"Z"d dlm#Z#ddl$m%Z%m&Z&gdZ'dXddZ(    dYddZ)   dZddZ*ddZ+d[ddZ,d\dd Z-d]d!d"Z.d]d#d$Z/d^d%d&Z0e"d'd(d)e d_d*d+Z1d`d,d-Z2d`d.d/Z3dad1d2Z4dbd3d4Z5dcd5d6Z6d7d8Z7ddd:d;Z8dddd?Z:d@dAZ;dBdCZdedHdIZ?d]dJdKZ@e"dLdMd)dNdOZA   P dfdQdRZBd]dSdTZCe"dLdUd)d[dVdWZDdS)g)print_functionN) LayerHelper) ParamAttr) Initializer)_current_expected_placeconvert_np_dtype_to_dtype__non_static_mode_varbase_creator device_guard_in_legacy_dygraphin_dygraph_mode_get_paddle_place)Variable)Constant)VarDesc)core) templatedoc)utils)check_variable_and_dtype check_type check_dtype convert_dtype) deprecated) check_shape)_C_ops _legacy_C_ops) create_tensorcreate_parametercreate_global_varcasttensor_array_to_tensorconcatsumsassignfill_constant_batch_size_like fill_constantargminargmaxargsortoneszerosreversehas_infhas_nanisfiniterangelinspace zeros_like ones_likediageyetriuFcCs4t|dgddtdit}|j|j||dS)a  Create a variable, which will hold a Tensor with data type dtype. Args: dtype(string|numpy.dtype): the data type of Tensor to be created, the data type is bool, float16, float32, float64, int8, int16, int32 and int64. name(string, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` persistable(bool): Set the persistable flag of the create tensor. default value is False. Returns: Variable: The tensor to be created according to dtype. Examples: .. code-block:: python import paddle.fluid as fluid tensor = fluid.layers.create_tensor(dtype='float32') dtype)boolfloat16float32float64int8int32r>int64r)namer8 persistableN)r)rrlocalsZcreate_variabler@)r8r@rAhelperrDJD:\Projects\ConvertPro\env\Lib\site-packages\paddle/fluid/layers/tensor.pyrCs rc Cst|dtttjfd|D]}t|dttjtjtjtj tj fdq t |dgddt|dt dt fdt|dt dtfdtd it}|durRt |d }|||t|||S) a :api_attr: Static Graph This function creates a parameter. The parameter is a learnable variable, which can have gradient, and can be optimized. NOTE: this is a very low-level API. This API is useful when you create operator by your self. instead of using layers. Parameters: shape (list of int): Shape of the parameter dtype (str): Data type of the parameter name (str, optional): For detailed information, please refer to :ref:`api_guide_Name` . Usually name is no need to set and None by default. attr (ParamAttr, optional): Attributes of the parameter is_bias (bool, optional): This can affect which default initializer is chosen when default_initializer is None. If is_bias, initializer.Constant(0.0) will be used. Otherwise, Xavier() will be used. default_initializer (Initializer, optional): Initializer for the parameter Returns: The created parameter. Examples: .. code-block:: python import paddle paddle.enable_static() W = paddle.static.create_parameter(shape=[784, 200], dtype='float32') shaper item of shaper8) r9r:r;r<r=int16r>r?uint8attrNdefault_initializer)r@)r)rlisttuplenumpyndarrayintrIr=rHr>r?rtyperrrrBrr)rFr8r@rJZis_biasrKitemrCrDrDrErbs*%   rc Cst|dtttjfd|D]}t|dttjtjtjtj tj fdq t |dgddt d it }|j||||dd}|j|tt||d d |S) a* This function creates a new tensor variable with value in the global block(block 0). Parameters: shape (list[int]|tuple[int]): Shape of the variable value (float): The value of the variable. The new created variable will be filled with it. dtype (str): Data type of the variable persistable (bool, optional): If this variable is persistable. Default: False force_cpu (bool, optional): Force this variable to be on CPU. Default: False name (str, optional): For detailed information, please refer to :ref:`api_guide_Name` . Usually name is no need to set and None by default. Returns: Variable: The created Variable Examples: .. code-block:: python import paddle paddle.enable_static() var = paddle.static.create_global_var(shape=[2,3], value=1.0, dtype='float32', persistable=True, force_cpu=True, name='new_var') rFr rGr8 r9r:r;r<r=rHr>r?rIuint16 global_varT)r8rFrAr@ stop_gradient)value force_cpu) initializerN)rU)rrLrMrNrOrPrIr=rHr>r?rrrBZcreate_global_variableZset_variable_initializerrfloat) rFrWr8rArXr@rRrCvarrDrDrEr s4    r cCstrt|tjjst|}t||Str.t|tjjs"t|}t |d|j d|}|St |dgddt |dgddt dit}|j||jd}|jdd |gid |gi|j |j d d |S)a This OP takes in the Tensor :attr:`x` with :attr:`x.dtype` and casts 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') in_dtype out_dtypex) r9r:r;r<rHr>r?rIrTr!r8rSr8rVXOut)r\r]rQinputsoutputsattrsN)r!)r isinstancerrVarTyperrr!r rr8rrrrB"create_variable_for_type_inferencerV append_op)r^r8outrCrDrDrEr!s6   r!c Cs tr%t|tr|}|d}t|tsdd|D}t||}|StrOt|tr6|}|d}t|tsBdd|D}t}t ||d||St |dt t tfdt|tst |D]\}}t|dt|d gd d|j|djkrtd qbn|g}t |dttfdt|trt|jdd d gddtdit}|j|d}|djtjjjkrt|dksJdt||jd d}|jdd|di|g|gd|ddd|Sd|i}i} t|trd|_ || d<|jd|d|gi| d|S)a This OP concatenates the input along the axis. Args: input(list|tuple|Tensor): ``input`` can be Tensor, Tensor list or Tensor tuple which is with data type bool, float16, float32, float64, int32, int64. All the Tensors in ``input`` must have the same data type. axis(int|Tensor, optional): Specify the axis to operate on the input Tensors. It's a scalar with data type int or a Tensor with shape [1] and data type int32 or int64. 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): 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 data type as ``input``. Examples: .. code-block:: python import paddle.fluid as fluid import numpy as np in1 = np.array([[1, 2, 3], [4, 5, 6]]) in2 = np.array([[11, 12, 13], [14, 15, 16]]) in3 = np.array([[21, 22], [23, 24]]) with fluid.dygraph.guard(): x1 = fluid.dygraph.to_variable(in1) x2 = fluid.dygraph.to_variable(in2) x3 = fluid.dygraph.to_variable(in3) # When the axis is negative, the real axis is (axis + Rank(x)). # As follows, axis is -1, Rank(x) is 2, the real axis is 1 out1 = fluid.layers.concat(input=[x1, x2, x3], axis=-1) out2 = fluid.layers.concat(input=[x1, x2], axis=0) print(out1.numpy()) # [[ 1 2 3 11 12 13 21 22] # [ 4 5 6 14 15 16 23 24]] print(out2.numpy()) # [[ 1 2 3] # [ 4 5 6] # [11 12 13] # [14 15 16]] rcS g|] }|jddkr|qSrrFcount.0trDrDrE K zconcat..cSrkrlrmrorDrDrErrTrsaxisinputr#input[])r9r:r;r<r>r?z:All the Tensors in the input must have the same data type.r>r?zBThe data type of axis must be int32 or int64 when axis is a Tensorr8rzuIf the elements of 'input' in concat are Variable(LoDTensorArray), number of the elements must be 1, but received %s.r"r`raZOutIndexFrt use_stackrbTraN)r#)!r rfrrNrRrr#r r rrrLrM enumeraterstrr8 TypeErrorrPrrrBrh input_dtypedescrQrrrgZLOD_TENSOR_ARRAYlenrirV) rurtr@rjidr^rC out_indexrcrerDrDrEr#s0             r#cstr:t|ts Jdddlm}m}ddlm}|r|n|}||d}|t tt fdd|} || fSt |d tt fd t|tr^t |D]\} } t | d t| d t d qLtdit} | j| d } | jdd }| jd d|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(Variable): A LodTensorArray variable. axis(int): The axis along which the tensors in attr::`input` will be concatenated or stacked. name(str|None): A name for this layer(optional). If set None, the layer will be named automatically. use_stack(bool): Act as concat_op or stack_op. For stack mode, all tensors in the tensor array must have the same shape. Returns: Variable: The concatenated or stacked tensor variable. Variable: 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 paddle.fluid as fluid import numpy as np x0 = fluid.layers.assign(np.random.rand(2, 2).astype("float32")) x1 = fluid.layers.assign(np.random.rand(2, 2).astype("float32")) i = fluid.layers.fill_constant(shape=[1], dtype="int64", value=0) array = fluid.layers.create_array(dtype='float32') fluid.layers.array_write(x0, i, array) fluid.layers.array_write(x1, i + 1, array) output, output_index = fluid.layers.tensor_array_to_tensor(input=array) z2The 'input' in tensor_array_to_tensor must be listr)stackr#r) to_variablertcst|jSN)rPrFr^rrDrEsz(tensor_array_to_tensor..rur"rvrwrxr>r`ryrzrbN)r")r rfrLnnrr#ZdygraphrrNarraymaprrr|r}rrBrhrri)rurtr@r{rr#ropressizesiZinput_xrCrjrrDrrEr"sBP      r"cCst|dtttfdt|tst|tr#|D] }t|dgddqn t|dgddtdit}|durA|j| d}n t|dgdd|j dd |id |id d id |S)a This function computes the sum of multiple input Tensors elementwisely. - Case 1, sum of 3 Tensors .. code-block:: text # Input Tensors x0.shape = [2, 3] x0.data = [[1., 2., 3.], [4., 5., 6.]] x1.shape = [2, 3] x1.data = [[10., 20., 30.], [40., 50., 60.]] x2.shape = [2, 3] x2.data = [[100., 200., 300.], [400., 500., 600.]] # Output Tensor out.shape = [2, 3] out.data = [[111., 222., 333.], [444., 555., 666.]] Args: input (list): A list of Variables which hold input Tensors with the same data type and shape. Optional data types are: float32, float64, int32, int64. out (Variable, optional): Output Tensor. It can be any existing Variable. The default value is None, then a new Variable will be created and returned. Returns: Variable: The sum of inputs. The shape and data type is the same with input. \ If :code:`out` is not None, the returned value is :code:`out` . Examples: .. code-block:: python import paddle.fluid as fluid x0 = fluid.layers.fill_constant(shape=[16, 32], dtype='int64', value=1) x1 = fluid.layers.fill_constant(shape=[16, 32], dtype='int64', value=2) x2 = fluid.layers.fill_constant(shape=[16, 32], dtype='int64', value=3) x3 = fluid.layers.fill_constant(shape=[16, 32], dtype='int64', value=0) # Sum of multiple Tensors, the result is stored to a new Variable sum0 (sum0=x0+x1+x2, the value is [[6, ..., 6], ..., [6, ..., 6]]) sum0 = fluid.layers.sums(input=[x0, x1, x2]) # Sum of multiple Tensors, sum1 and x3 represents the same Variable (x3=x0+x1+x2, the value is [[6, ..., 6], ..., [6, ..., 6]]) sum1 = fluid.layers.sums(input=[x0, x1, x2], out=x3) rur$r:r;r<r>r?sumNrxrjr;r<r>r?r`raZ use_mkldnnFrb)r) rrrMrLrfrrrBrhrri)rurjZ input_sectionrCrDrDrEr$s22r$c Cs"td!it}t|dttjtttt t fd|durdnd}t |r0t |t s0t|g}n t |ttfrr?rIr9z/(When the type of input in assign is Variable.)rxr`rarQrcrdrcss|]}t|tVqdSr)rfr)rpr^rDrDrE szassign..zHRequired type(input) numpy.ndarray, but found `list(Variable)` in input.zzpaddle.assign doesn't support float64 input now due to current platform protobuf data limitation, we convert it to float32Z bool_valuescSg|]}t|qSrDrPrpvrDrDrErrzassign..Z fp32_valuescSrrD)rZrrDrDrErrrZ int32_valuescSrrDrrrDrDrErrrZ int64_valuescSrrDrrrDrDrErrrzWhen the type of 'input' in assign is numpy.ndarray, the data type of 'input' must be bool, float32, int32 or int64, but received %s.izXThe size of input is too big. Please consider saving it to file and 'load_op' to load itrFr8 assign_value)rQrdre)r%)5rrBrrrNrOrLrMrZrPr9Zisscalarrfr}rrVarBaser r rr%Z assign_out_r eagerTensorrrr8rhrirrFanyr~rrrgZFP64warningswarnZFP32BOOLflatZINT32INT64rsize ValueErrorr,Z assign_value_rrZ_bump_inplace_version)ruoutputrCZ is_inplacer8Z value_namevaluesrDrDrEr%Ls             r%c Csd|i}t|}t|ts.|dvr tt||d<t||d<ntt||d<t||d<trt}|r:t }t|t t frV|D]}t|tsUt t dd|}nqCt|tj jsat|}|durtt|t|||}d|_|S|durt||t|||d|_|Strt|}|durt|d }t|tr|dvrtt|d |d<n tt|d |d<t|dt|d|d |jd|dd | d|_|Stdit} i} t|trt|j|krt||}|| d<t |t!|d gdd t"|d tt t fd |durt#|dt|gd tdit} tj$| ||d d|dur7| j%|d }|j|d <| j&d | d|gi|ddd|_|S)a This OP creates a Tensor with specified `shape` and `dtype`, and initializes it with a constant specified by `value`. The attribute `stop_gradient` of the created Tensor is set to True. Args: shape(list|tuple|Tensor): Shape of the output Tensor, the data type of ``shape`` is int32 or int64. If ``shape`` is a list or tuple, the elements of it should be integers or Tensors with shape [1]. If ``shape`` is an Tensor, it should be an 1-D Tensor with date type int32 or int64. dtype(np.dtype|str): Data type of the output Tensor which can be float16, float32, float64, uint8, int16, int32, int64. value(bool|float|int|Tensor): The constant value used to initialize the Tensor to be created. If ``value`` is an Tensor, it should be an 1-D Tensor. force_cpu(bool, optional): data should be on CPU if it's true, default value is False. out(Tensor, optional): Optional output which can be any created Tensor that meets the requirements to store the result of operation. if ``out`` is None, a new Tensor will be create to store the result. 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 which is created according to shape and dtype. Examples: .. code-block:: python import paddle.fluid as fluid # attr shape is a list which doesn't contain Tensor. data1 = fluid.layers.fill_constant(shape=[2,1], value=0, dtype='int64') # data1=[[0],[0]] data2 = fluid.layers.fill_constant(shape=[2,1], value=5, dtype='int64', out=data1) # data1=[[5], [5]] data2=[[5], [5]] # attr shape is a list which contains Tensor. positive_2 = fluid.layers.fill_constant([1], "int32", 2) data3 = fluid.layers.fill_constant(shape=[1, positive_2], dtype='float32', value=1.5) # data3=[[1.5, 1.5]] # attr shape is a Tensor. shape = fluid.layers.fill_constant([2], "int32", 2) # shape=[2,2] data4 = fluid.layers.fill_constant(shape=shape, dtype='bool', value=True) # data4=[[True,True],[True,True]] # attr value is a Tensor. val = fluid.layers.fill_constant([1], "float32", 2.0) # val=[2.0] data5 = fluid.layers.fill_constant(shape=[2,1], value=val, dtype='float32') #data5=[[2.0],[2.0]] rX)rIrHr>r? str_valuerWcSst|tr |jdS|S)Nr)rfrrNrrrDrDrErszfill_constant..NTrxrr8rFr'Z ValueTensor) r9r:r;r<rIrHr>r?Z complex64Z complex128rj)rcrerFZop_typerarQrcrdrerV)r')'rrfrr}rPrZr rrCPUPlacerLrMrrrgrrfullrVZfull_r rZconvert_shape_to_listr rNrRrr'r8rrBr!rrrrZget_shape_tensor_inputsrhri) rFr8rWrXrjr@replacerRrCrcrDrDrEr's0               r'z1.8.0z!paddle.fluid.layers.fill_constant)ZsinceZ update_toc Cstr't|tjjst|}t}|rt}t |||||||}d|_ |St d it } | j |d}||jt||||d} t|dvrPtt|| d<ntt|| d<| jdd|id|gi| d d|_ |S) a This OP creates a Tesnor according the shape and dtype, and initializes the Tensor with the constants provided in ``value``. When the input is LoDTensor and the input_dim_idx is 0, the output_dim_idx dimension is set to the value of the batch_size input by the input, the Stop_gradient attribute of the created Tensor is False by default. Args: input(Variable): Tensor which data type is float32, float64, int32 and int64. shape(list): The shape of Tensor to be created, Tensor's shape may be changed according the input. dtype(np.dtype|core.VarDesc.VarType|str): The data type of created Tensor which can be float32, float64, int32, int64. value(float|int): The constant value used to initialize the Tensor to be created. input_dim_idx(int): When the value is 0 and the input is LoDTensor, the output_dim_idx dimension of the created Tensor is set to the batch_size value of input. The default value is 0. output_dim_idx(int): Used to specify which dimension of Tensor is created to be set the value of batch_size of input Tensor. The default value is 0. force_cpu(bool): data should be on CPU if it's true, default value is False. Returns: Variable: Tensor which will be created according to dtype. Examples: .. code-block:: python import paddle.fluid as fluid like = fluid.layers.fill_constant(shape=[1,2], value=10, dtype='int64') #like=[[10, 10]] data = fluid.layers.fill_constant_batch_size_like( input=like, shape=[1], value=0, dtype='int64') #like=[[10, 10]] data=[0] Tr&rx)rFr8rW input_dim_idxoutput_dim_idxrX)r?r>rZInputrarbN)r&)r rfrrrgrrrrZfull_batch_size_likerVrrBrhr8rZrr}rPri) rurFr8rWrrrXrrjrCrerDrDrEr&Zs<+   r&cCZt|dgddtd it}|tjj}|jdd|id|gid|idd |_|S) a :alias_main: paddle.argmin :alias: paddle.argmin,paddle.tensor.argmin,paddle.tensor.search.argmin :old_api: paddle.fluid.layers.argmin **argmin** This OP computes the indices of the min elements of the input tensor's element along the provided axis. Args: x(Variable): An input N-D Tensor with type float32, float64, int16, int32, int64, uint8. axis(int, optional): Axis to compute indices along. 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. Returns: Variable: A Tensor with data type int64. Examples: .. code-block:: python import paddle.fluid as fluid import numpy as np in1 = np.array([[[5,8,9,5], [0,0,1,7], [6,9,2,4]], [[5,2,4,2], [4,7,7,9], [1,7,0,6]]]) with fluid.dygraph.guard(): x = fluid.dygraph.to_variable(in1) out1 = fluid.layers.argmin(x=x, axis=-1) out2 = fluid.layers.argmin(x=x, axis=0) out3 = fluid.layers.argmin(x=x, axis=1) out4 = fluid.layers.argmin(x=x, axis=2) print(out1.numpy()) # [[0 0 2] # [1 0 2]] print(out2.numpy()) # [[0 1 1 1] # [0 0 0 0] # [1 1 1 0]] print(out3.numpy()) # [[1 1 1 2] # [2 0 2 0]] print(out4.numpy()) # [[0 0 2] # [1 0 2]] r^r;r<rIrHr>r?r(arg_minr`rartrbTN)r rrrBrhrrgrrirVr^rtrCrjrDrDrEr(s5 r(cCr) a4 **argmax** This OP computes the indices of the max elements of the input tensor's element along the provided axis. Args: x(Variable): An input N-D Tensor with type float32, float64, int16, int32, int64, uint8. axis(int, optional): Axis to compute indices along. 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. Returns: Variable: A Tensor with data type int64. Examples: .. code-block:: python import paddle.fluid as fluid import numpy as np in1 = np.array([[[5,8,9,5], [0,0,1,7], [6,9,2,4]], [[5,2,4,2], [4,7,7,9], [1,7,0,6]]]) with fluid.dygraph.guard(): x = fluid.dygraph.to_variable(in1) out1 = fluid.layers.argmax(x=x, axis=-1) out2 = fluid.layers.argmax(x=x, axis=0) out3 = fluid.layers.argmax(x=x, axis=1) out4 = fluid.layers.argmax(x=x, axis=2) print(out1.numpy()) # [[2 3 1] # [0 3 1]] print(out2.numpy()) # [[0 0 0 0] # [1 1 1 1] # [0 0 0 1]] print(out3.numpy()) # [[2 2 0 1] # [0 1 1 1]] print(out4.numpy()) # [[2 3 1] # [0 3 1]] r^rr)arg_maxr`rartrbTN)rrrrDrDrEr)s1 r)cCsnt|dgddtd it}|j|jdd}|jtjjdd}|jdd|i||d||d d ||fS) a :alias_main: paddle.argsort :alias: paddle.argsort,paddle.tensor.argsort,paddle.tensor.search.argsort :old_api: paddle.fluid.layers.argsort This OP sorts the input along the given axis, and returns sorted output data Varibale and its corresponding index Variable with the same shape as :attr:`input`. Args: input(Variable): An input N-D Tensor with type float32, float64, int16, int32, int64, uint8. axis(int, optional): Axis to compute indices along. 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. descending(bool, optional) : Descending is a flag, if set to true, algorithm will sort by descending order, else sort by ascending order. Default is false. 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: tuple: A tuple of sorted data Variable(with the same shape and data type as input) and the sorted indices(with the same shape as input's and with data type int64). Examples: .. code-block:: python import paddle.fluid as fluid import numpy as np in1 = np.array([[[5,8,9,5], [0,0,1,7], [6,9,2,4]], [[5,2,4,2], [4,7,7,9], [1,7,0,6]]]).astype(np.float32) with fluid.dygraph.guard(): x = fluid.dygraph.to_variable(in1) out1 = fluid.layers.argsort(input=x, axis=-1) out2 = fluid.layers.argsort(input=x, axis=0) out3 = fluid.layers.argsort(input=x, axis=1) print(out1[0].numpy()) # [[[5. 5. 8. 9.] # [0. 0. 1. 7.] # [2. 4. 6. 9.]] # [[2. 2. 4. 5.] # [4. 7. 7. 9.] # [0. 1. 6. 7.]]] print(out1[1].numpy()) # [[[0 3 1 2] # [0 1 2 3] # [2 3 0 1]] # [[1 3 2 0] # [0 1 2 3] # [2 0 3 1]]] print(out2[0].numpy()) # [[[5. 2. 4. 2.] # [0. 0. 1. 7.] # [1. 7. 0. 4.]] # [[5. 8. 9. 5.] # [4. 7. 7. 9.] # [6. 9. 2. 6.]]] print(out3[0].numpy()) # [[[0. 0. 1. 4.] # [5. 8. 2. 5.] # [6. 9. 9. 7.]] # [[1. 2. 0. 2.] # [4. 7. 4. 6.] # [5. 7. 7. 9.]]] ru)r;r<rHr>r?rIr*Tr_)rVr`)raZIndices)rt descendingrbN)r*) rrrBrhr8rrgrri)rurtrr@rCrjZidsrDrDrEr*'s*J  r*cCtddditS)a The OP creates a tensor of specified :attr:`shape` and :attr:`dtype`, and fills it with 1. Its :attr:`stop_gradient` will be set to True to stop gradient computation. Parameters: shape(tuple|list|Tensor): Shape of output Tensor, the data type of shape is int32 or int64. dtype (np.dtype|str): Data type of output Tensor, it supports bool, float16, float32, float64, int32 and int64. force_cpu (bool, optional): Whether force to store the output Tensor in CPU memory. If :attr:`force_cpu` is False, the output Tensor will be stored in running device memory. Default: False. Returns: Tensor: A tensor of data type :attr:`dtype` with shape :attr:`shape` and all elements set to 1. Examples: .. code-block:: python import paddle.fluid as fluid data0 = fluid.layers.ones(shape=[2, 4], dtype='float32') # [[1., 1., 1., 1.], [1., 1., 1., 1.]] # shape is a Tensor shape = fluid.layers.fill_constant(shape=[2], dtype='int32', value=2) data1 = fluid.layers.ones(shape=shape, dtype='int32') #[[1, 1], [1, 1]] rW?NrDr'rB)rFr8rXrDrDrEr+sr+cCr)aG The OP creates a tensor of specified :attr:`shape` and :attr:`dtype`, and fills it with 0. Its :attr:`stop_gradient` will be set to True to stop gradient computation. Parameters: shape(tuple|list|Tensor): Shape of output Tensor, the data type of ``shape`` is int32 or int64. dtype (np.dtype|str): Data type of output Tensor, it supports bool, float16, float32, float64, int32 and int64. force_cpu (bool, optional): Whether force to store the output Tensor in CPU memory. If :attr:`force_cpu` is False, the output Tensor will be stored in running device memory. Default: False. name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: A tensor of data type :attr:`dtype` with shape :attr:`shape` and all elements set to 0. Examples: .. code-block:: python import paddle.fluid as fluid data = fluid.layers.zeros(shape=[3, 2], dtype='float32') # [[0., 0.], [0., 0.], [0., 0.]] # shape is a Tensor shape = fluid.layers.fill_constant(shape=[2], dtype='int32', value=2) data1 = fluid.layers.zeros(shape=shape, dtype='int32') #[[0, 0], [0, 0]] rWgNrDr)rFr8rXr@rDrDrEr,sr,cCst|dddt|dttttfdt|tr|g}tr#t ||St d it }|j |j d}|jdd|id|gid|id|S) a! :alias_main: paddle.reverse :alias: paddle.reverse,paddle.tensor.reverse,paddle.tensor.manipulation.reverse :old_api: paddle.fluid.layers.reverse The OP reverses the tensor :attr:`x` along the given :attr:`axis`. .. code-block:: text Case 1: Given a LoDTensor: x = [[0, 1, 2], [3, 4, 5], [6, 7, 8]] axis = [0, 1] Then: output = [[8, 7, 6], [5, 4, 3], [2, 1, 0]] Case 2: Given a LoDTensorArray: x = {[[0, 1], [2, 3]], [[4, 5, 6]], [[7],[8], [9]]} axis = 0 Then: output = {[[7],[8], [9]], [[4, 5, 6]], [[0, 1], [2, 3]]} Parameters: x (Variable): A tensor or LoDTensorArray to be reversed, its data type supports bool, float32, float64, int32, int64 and uint8. If input is a LoDTensorArray, returns a new reversed LoDTensorArray without changing the internal order of each inner tensor. axis (int|tuple|list): A dimension or a set of dimensions of :attr:`x` to reverse. Must be in the range [-rank( :attr:`x` ), rank( :attr:`x` )). If it is a tuple or a list, reversing will be apply on each axis in the tuple or list. If input is a LoDTensorArray, the value of axis shall be 0, or a list [0] or tuple (0, ) with shape [1]. Returns: Variable: The reversed tensor with the same shape and data type as :attr:`x`. Examples: .. code-block:: python import paddle.fluid as fluid import numpy as np data = fluid.layers.assign(np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype='float32')) # [[0., 1., 2.], [3., 4., 5.], [6., 7., 8.]] result1 = fluid.layers.reverse(data, 0) # [[6., 7., 8.], [3., 4., 5.], [0., 1., 2.]] result2 = fluid.layers.reverse(data, [0, 1]) # [[8., 7., 6.], [5., 4., 3.], [2., 1., 0.]] # example of LoDTensorArray data1 = fluid.layers.assign(np.array([[0, 1, 2]], dtype='float32')) data2 = fluid.layers.assign(np.array([[3, 4, 5]], dtype='float32')) tensor_array = fluid.layers.create_array(dtype='float32') i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=0) fluid.layers.array_write(data1, i, tensor_array) fluid.layers.array_write(data2, i+1, tensor_array) reversed_tensor_array = fluid.layers.reverse(tensor_array, 0) # {[[3, 4, 5]], [[0, 1, 2]]} r^)r;r<r>r?rIr-rtrxr`rarbN)r-)rrrPrMrLrrfr rr-rrBrhr8rirrDrDrEr-s">  r-TcC0tdit}|jdd|ii||dddS)an Saves a variable as a file. Args: x(variable): The Tensor/LoDTensor to be saved. file_path(str): The file path where the variable will be saved. overwrite(bool): Whether or not cover the given file when it has already existed. If it's set 'False' and the file is existed, a runtime error will be thrown. saveru file_path overwriterQrcrdargsN)rrrBrir^rrrCrDrDrErs  rcCr)a Saves a list of variables into a single file. Args: x(list): A list of Tensor/LoDTensor variables to be saved together in a single file. file_path(str): The file path where variables will be saved. overwrite(bool): Whether or not cover the given file when it has already existed. If it's set 'False' and the file is existed, a runtime error will be thrown. Returns: There is no return value. Examples: .. code-block:: python import paddle.fluid as fluid v1 = fluid.layers.data(name="data", shape=(4, 6), dtype="float32") v2 = fluid.layers.data(name="data", shape=(6, 8, 4), dtype="float32") normed = fluid.layers.save_combine([v1, v2], file_path="output") save_combinerurrN)rrrrDrDrEr&s rcCs.tdit}|jdid|id|iddS)z Loads a list of variable from a single file. Args: out(list): The list of variables to be read from the disk file. file_path(str): The path of the disk file. load_combinerar)rQrcrrN)rr)rjrrCrDrDrErLs  rcCXtrt|St|dtdtd it}|j|jd}|j dd|id|id|S) a Test if any of x contains an infinity number Args: x (Tensor): The Tensor to be checked. Returns: Tensor: The tensor storing the output, only a bool value, indicating that whether there is infinity number in x or not. Examples: .. code-block:: python import paddle data = paddle.randn(shape=[4, 32, 32], dtype="float32") res = paddle.fluid.layers.has_inf(data) # [False] r^r.isinfrxr`rarN)r) r rrrrrrBrhr8rir^rCrjrDrDrEr.[ r.cCr) a Test if any of x contains a NAN Args: x (Tensor): The Tensor to be checked. Returns: Tensor: The tensor variable storing the output, only a bool value, indicating that whether there is NAN in x or not. Examples: .. code-block:: python import paddle data = paddle.randn(shape=[2,3], dtype="float32") res = paddle.fluid.layers.has_nan(data) # [False] r^r/isnanrxr`rarN)r) r rrrrrrBrhr8rirrDrDrEr/xrr/cCsJt|dgddtd it}|jdd}|jdd|id|id|S) a Test if any of x contains an infinity/NAN number. If all the elements are finite, returns true, else false. Args: x(Tensor): The Tensor to be checked. Returns: Tensor: The tensor storing the output, contains a bool value. Examples: .. code-block:: python import paddle x = paddle.rand(shape=[4, 6], dtype='float32') y = paddle.fluid.layers.isfinite(x) print(y) r^rr0r9rxr`rarN)r0)rrrBrhrirrDrDrEr0s  r0cCsd}t|tst|tst|tstt|||g}t|tjjs(t|}t|tsKt dt dg||dd}Wdn1sEwYn |j |krUt ||}t|tsxt dt dg||dd}Wdn1srwYn |j |krt ||}t|tst dt dg||dd}Wdn1swYn |j |krt ||}t rt||||tStrt|||}d|_|St|dgddtdit}|j||d }|jd |||d d |id d|_|dur|j||S)aT This OP returns a 1-D Tensor with spaced values within a given interval. Values are generated into the half-open interval [``start``, ``end``) with the ``step``. (the interval including ``start`` but excluding ``end``). If ``dtype`` is float32 or float64, we advise adding a small epsilon to ``end`` to avoid floating point rounding errors when comparing against ``end``. Parameters: start(float|int|Tensor): Start of interval. The interval includes this value. If ``start`` is a Tensor, it is a 1-D Tensor with shape [1], with data type int32, int64, float32, float64. end(float|int|Tensor): End of interval. The interval does not include this value. If ``end`` is a Tensor, it is a 1-D Tensor with shape [1], with data type int32, int64, float32, float64. step(float|int|Tensor): Spacing between values. For any out, it is the istance between two adjacent values, out[i+1] - out[i]. If ``step`` is a Tensor, it is a 1-D Tensor with shape [1], with data type int32, int64, float32, float64. dtype(str|np.dtype|core.VarDesc.VarType, optional): The data type of the output tensor. Supported data types: int32, int64, float32, float64. 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 1-D Tensor with values from the interval [``start``, ``end``) taken with common difference ``step`` beginning from ``start``. Its data type is set by ``dtype``. Raises: TypeError: If ``dtype`` is not int32, int64, float32, float64. examples: .. code-block:: python import paddle.fluid as fluid out1 = fluid.layers.range(0, 10, 2, 'int32') # [0, 2, 4, 6, 8] start_var = fluid.layers.fill_constant([1], 'int64', 3) out2 = fluid.layers.range(start_var, 7, 1, 'int64') # [3, 4, 5, 6] NcpurT)rXr8rz range/aranger1)rF)StartZEndZSteprar)r1)rfrrPmathceilrrrgrr r'r8r!r rZarangerr rr1rVrrrBrhrir set_shape)startendstepr8r@Z out_shaperjrCrDrDrEr1sh1               r1c Cs|durd}|}|}|}t|tst|dtdt|tjjs#t|}t|tsCtdt dg||}Wdn1s>wYt|tsctdt dg||}Wdn1s^wYt|tstdt dgd|}Wdn1s~wYt rt ||||t Strt |||d|Stdit}t|j} t|j} t|} t|trt|jd gd dn t|d ttfdt|trt|jd gd dn t|d ttfdt|trt|jddgdt|dgd d| d ks| d kr | dvs| dks| dkr"| dkr"td| | ||j|d} |jd|||dd|id| gidt|trG| j|f| S)a This OP return fixed number of evenly spaced values within a given interval. Args: start(int|float|Tensor): The input :attr:`start` is start variable of range. It is a scalar, \ or a Tensor of shape [1] with input data type int32, int64, float32 or float64. stop(int|float|Tensor): The input :attr:`stop` is start variable of range. It is a scalar, \ or a Tensor of shape [1] with input data type int32, int64, float32 or float64. num(int|Tensor): The input :attr:`num` is given num of the sequence. It is an int scalar, \ or a Tensor of shape [1] with data type int32. dtype(np.dtype|str, optional): The data type of output tensor, it could be int32, int64, float32 and float64. Default: if None, the data type is float32. name(str, optional): Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`.Default: None. Returns: Tensor: the output data type will be float32, float64. The 1-D tensor with fixed number of evenly spaced values, \ the data shape of this tensor is :math:`[num]` . If the :attr:`num` is set 1, the output tensor just has \ the value with input :attr:`start`. Examples: .. code-block:: python import paddle data = paddle.linspace(0, 10, 5, 'float32') # [0.0, 2.5, 5.0, 7.5, 10.0] data = paddle.linspace(0, 10, 1, 'float32') # [0.0] Nr;numr2rrr>r8rrstop)r>r?r;r<r<)r;r>r?zThe dtype of start/stop is {}/{} but the attr(dtype) of linspace is {}, which may cause data type overflows. Please reset attr(dtype) of linspace.rx)rZStopNumrarQrcrerd)r2)rfrrrPrrrgrr r'r rr2rr rrrBrr8rrZrformatrhrirr) rrrr8r@Z tensor_numZ tensor_startZ tensor_stoprCZ start_dtypeZ stop_dtyper]rjrDrDrEr2s                    r2cCs|t|dgddtdit}|dur|j|jd}n t|dgdd|jdd|gid |jd d |gid d |_|S)a This OP creates a zeros tensor which has identical shape and dtype with `x`. Args: x(Variable): The input tensor which specifies shape and dtype, the input data dtype could be bool, float32, float64, int32, int64. out(Variable, optional): If is :attr:`None` , the op will create the variable as output, the data type and shape of this variable will be same as input :attr:`x`. If is a tensor, the data type and shape need to be same as input :attr:`x`. The default value is :attr:`None` . Returns: Variable: The N-D tensor, the element in tensor is related to input data type, if the input data type is bool, the output value is False, otherwise is zero. The output shape is the same as the input. Examples: .. code-block:: python import paddle.fluid as fluid x = fluid.data(name='x', dtype='float32', shape=[3]) data = fluid.layers.zeros_like(x) # [0.0, 0.0, 0.0] r^r9r;r<r>r?r3Nrxrj fill_any_liker`r)rWr8rarT)r3)rrrBrhr8rirVr^rjrCrDrDrEr3zs( r3z2.0.0z paddle.diagcCs~t|dttjfdt|jdgddtd it}t|ts%t |}|j |jd}|j dd|gid|gidd|_ |S) a1 :alias_main: paddle.diag :alias: paddle.diag,paddle.tensor.diag,paddle.tensor.creation.diag :old_api: paddle.fluid.layers.diag This OP creates a square matrix which has diagonal values specified by input :attr:`diagonal`. Args: diagonal(Variable|numpy.ndarray): The input tensor should be 1D tensor, the input shape is :math:`[ N]` , \ specifying diagonal values by this input tensor. The input data type should be float32, float64, int32, int64. Returns: Variable, the output data type is the same as input data type.: The tensor variable storing the square matrix, \ the diagonal values specified by input :attr:`diagonal`. the output shape is :math:`[N, N]` with two dims. Examples: .. code-block:: python # [[3, 0, 0] # [0, 4, 0] # [0, 0, 5] import paddle.fluid as fluid import numpy as np diagonal = np.arange(3, 6, dtype='int32') data = fluid.layers.diag(diagonal) # diagonal.shape=(3,) data.shape=(3, 3) diagonalr5rrxZDiagonalrarTN)r5) rrrNrOrr8rrBrfr%rhrirV)rrCrjrDrDrEr5s r5r;cCs|dd}||dt|tjjst|}|dur||dn|}tr-t|||t}n6t r;t d|d|d|}n(t dit }t |dgdd|j|d }|jdid |gi|||d d d |durdgt|}|||g}|ddg} trt |dd|\}} t |dd| St|tstd|D] } | dkrtdqddlm} m} | ||d}| || d}d |_|S)a This function constructs a or a batch of 2-D tensor with ones on the diagonal and zeros elsewhere. Args: num_rows(int): the number of rows in each batch tensor. num_columns(int, optional): the number of columns in each batch tensor. If None, default: num_rows. batch_shape(list, optional): If provided, the returned tensor will have a leading batch size of this shape, the data type of ``batch_shape`` is int. Default is None. dtype(np.dtype|str, optional): The data type of the returned tensor. It should be int32, int64, float16, float32, float64, default is 'float32'. name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor: An identity Tensor or LoDTensor of shape batch_shape + [num_rows, num_columns]. Examples: .. code-block:: python import paddle.fluid as fluid data = fluid.layers.eye(3, dtype='int32') # [[1, 0, 0] # [0, 1, 0] # [0, 0, 1]] data = fluid.layers.eye(2, 3, dtype='int32') # [[1, 0, 0] # [0, 1, 0]] data = fluid.layers.eye(2, batch_shape=[3]) # Construct a batch of 3 identity tensors, each 2 x 2. # data[i, :, :] is a 2 x 2 identity tensor, i = 0, 1, 2. cSs^t|ttjtjjfrt|jdkr|jddvsJdSt|tr&|dkr-t d |dS)Nrr)rrz {} should be a non-negative int.) rfrrrrrrrFrPr~r)rJmessagerDrDrE _check_attrs $zeye.._check_attrnum_rowsN num_columnsr8r6rrxra)rrr8TrrrF expand_timeszbatch_shape should be a listrz)batch_shape should be a positive int list)reshapeexpand)r^rF)r^r)r6)rfrrrgrr rr6rr rrrBrrhrirr Zreshape2rrLr~rrrV)rrZ batch_shaper8r@rrjrCZre_shaper_Z batch_valrrrDrDrEr6s^*           r6cCsrt|dgddtd it}|dur|j|jd}n t|dgdd|jdd|gid d id |gid |S)a0 **ones_like** This function creates a ones tensor which has identical shape and dtype with `x`. Args: x(Variable): The input tensor which specifies shape and dtype. out(Variable): The output tensor. Returns: out(Variable): The tensor variable storing the output. Examples: .. code-block:: python import paddle.fluid as fluid x = fluid.layers.data(name='x', dtype='float32', shape=[3], append_batch_size=False) data = fluid.layers.ones_like(x) # [1.0, 1.0, 1.0] r^rr4Nrxrjrr`rWrrar)r4)rrrBrhr8rirrDrDrEr4=s" r4z paddle.triucCsddl}|jj|||dS)Nr)r^rr@)paddleZtensorr7)rurr@rrDrDrEr7fsr7)NF)NNFN)FFN)rN)rNFr)FNN)rrFrl)rFN)F)FN)T)NN)NNr;N)E __future__rrrNrZ layer_helperrZ param_attrrrYrZ frameworkrrr r r r r rrrrrZlayer_function_generatorrrZ data_feederrrrrZ paddle.utilsrrrrr__all__rrr r!r#r"r$r%r'r&r(r)r*r+r,r-rrrr.r/r0r1r2r3r5r6r4r7rDrDrDrEs    (         ! = A 9 { p K   K B > _  O & d a / 1 c )