o #j@sVddlZddlmZmZddlmZddlmZddlmZddl m Z m Z m Z ddl mZmZmZmZdd lmZmZmZmZgZd3d d Zd3d d Zd4ddZ    d5ddZd6ddZed7ddZd8ddZd8ddZd9d d!Z ed:d"d#Z!d;d$d%Z"edd-d.Z&d8d/d0Z'd?d1d2Z(dS)@N)_C_ops _legacy_C_ops)_current_expected_place)DataType)Variable)in_dynamic_modein_dynamic_or_pir_mode in_pir_mode) check_dtype check_shape check_typecheck_variable_and_dtype) LayerHelperconvert_np_dtype_to_dtype_core dygraph_onlycCsdtrt|St|dgddtd it}|j|jd}|jdd|id|iidd |_ |S) a  For each element :math:`x_i` in input ``x``, take a sample from the Bernoulli distribution, also called two-point distribution, with success probability :math:`x_i`. The Bernoulli distribution with success probability :math:`x_i` is a discrete probability distribution with probability mass function .. math:: p(y)=\begin{cases} x_i,&y=1\\ 1-x_i,&y=0 \end{cases}. Args: x (Tensor): The input Tensor, it's data type should be float32, float64. name (str, optional): For details, please refer to :ref:`api_guide_Name`. Generally, no setting is required. Default: None. Returns: Tensor: A Tensor filled samples from Bernoulli distribution, whose shape and dtype are same as ``x``. Examples: .. code-block:: python >>> import paddle >>> paddle.set_device('cpu') # on CPU device >>> paddle.seed(100) >>> x = paddle.rand([2,3]) >>> print(x) >>> # doctest: +SKIP("Random output") Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[0.55355281, 0.20714243, 0.01162981], [0.51577556, 0.36369765, 0.26091650]]) >>> # doctest: -SKIP >>> out = paddle.bernoulli(x) >>> print(out) >>> # doctest: +SKIP("Random output") Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[1., 0., 1.], [0., 1., 0.]]) >>> # doctest: -SKIP xfloat32float64float16uint16 bernoullirandintdtypeXOuttypeinputsoutputsattrsTNr) rrrrrlocals"create_variable_for_type_inferencer append_op stop_gradientrnamehelperoutr-U/var/www/html/Deteccion_Ine/venv/lib/python3.10/site-packages/paddle/tensor/random.pyr,s,  rcCs^trt|St|dddgdtd it}|j|jd}|jdd|id|iid|S) aN Returns a tensor filled with random number from a Poisson Distribution. .. math:: out_i \sim Poisson (lambda = x_i) Args: x(Tensor): A tensor with rate parameter of poisson Distribution. The data type should be bfloat16, float16, 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 Tensor filled with random number with the same shape and dtype as ``x``. Examples: .. code-block:: python >>> import paddle >>> paddle.set_device('cpu') >>> paddle.seed(100) >>> x = paddle.uniform([2,3], min=1.0, max=5.0) >>> out = paddle.poisson(x) >>> print(out) >>> # doctest: +SKIP("Random output") Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[2., 5., 0.], [5., 1., 3.]]) >>> # doctest: -SKIP rrrpoissonrrrrN)r/) rrr/rrr%r&rr'r)r-r-r.r/js! r/FcCsptr t|||St|dgddtd it}|jtdd}|jdd|id|i||dd d |_ |S) a Returns a Tensor filled with random values sampled from a Multinomical distribution. The input ``x`` is a tensor with probabilities for generating the random number. Each element in ``x`` should be larger or equal to 0, but not all 0. ``replacement`` indicates whether it is a replaceable sample. If ``replacement`` is True, a category can be sampled more than once. Args: x(Tensor): A tensor with probabilities for generating the random number. The data type should be float32, float64. num_samples(int, optional): Number of samples, default is 1. replacement(bool, optional): Whether it is a replaceable sample, 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: Tensor: A Tensor filled with sampled category index after ``num_samples`` times samples. Examples: .. code-block:: python >>> import paddle >>> paddle.seed(100) # on CPU device >>> x = paddle.rand([2,4]) >>> print(x) >>> # doctest: +SKIP("Random output") Tensor(shape=[2, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[0.55355281, 0.20714243, 0.01162981, 0.51577556], [0.36369765, 0.26091650, 0.18905126, 0.56219709]]) >>> # doctest: -SKIP >>> paddle.seed(200) # on CPU device >>> out1 = paddle.multinomial(x, num_samples=5, replacement=True) >>> print(out1) >>> # doctest: +SKIP("Random output") Tensor(shape=[2, 5], dtype=int64, place=Place(cpu), stop_gradient=True, [[3, 3, 0, 0, 0], [3, 3, 3, 1, 0]]) >>> # doctest: -SKIP >>> # out2 = paddle.multinomial(x, num_samples=5) >>> # InvalidArgumentError: When replacement is False, number of samples >>> # should be less than non-zero categories >>> paddle.seed(300) # on CPU device >>> out3 = paddle.multinomial(x, num_samples=3) >>> print(out3) >>> # doctest: +SKIP("Random output") Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[3, 0, 1], [3, 1, 0]]) >>> # doctest: -SKIP r)rrrr multinomialint64rrr) num_samples replacementrTN)r1) rrr1rrr%r&rr'r()rr3r4r*r+r,r-r-r.r1s"9 r1r?c Cs~t|dddt|dttfdt|dddtd it}||} t|} |j dd|id| i||||||| dd| S) a This OP initializes a variable with random values sampled from a uniform distribution in the range [min, max). The input_dim_idx used to get the input dimension value which will be used to resize the output dimension. .. code-block:: text *Case 1: Given: input =[[0.946741 , 0.1357001 , 0.38086128]] # input.shape=[1,3] shape=[2,4] result.shape[output_dim_idx] = input.shape[input_dim_idx], output_dim_idx = 0, input_dim_idx = 0, result.shape[0] = input.shape[0], then: result=[[ 0.3443427 , -0.23056602, 0.3477049 , 0.06139076]] # result.shape=[1,4] *Case 2: Given: input =[[0.946741 , 0.1357001 , 0.38086128]] # input.shape=[1,3] shape=[2,4] input_dim_idx=1 output_dim_idx=1 result.shape[output_dim_idx] = input.shape[input_dim_idx], output_dim_idx = 1, input_dim_idx = 1, result.shape[1] = input.shape[1], then: result=[[-0.23133647, -0.84195036, 0.21441269], [-0.08774924, 0.25605237, -0.09403259]] # result.shape=[2,3] Args: input (Variable): A Tensor. Supported data types: float32, float64. shape (tuple|list): A python list or python tuple. The shape of the output Tensor, the data type is int. input_dim_idx (int, optional): An index used to get the input dimension value which will be used to resize the output dimension. Default 0. output_dim_idx (int, optional): An index used to indicate the specific dimension that will be replaced by corresponding input dimension value. Default 0. min (float, optional): The lower bound on the range of random values to generate, the min is included in the range. Default -1.0. max (float, optional): The upper bound on the range of random values to generate, the max is excluded in the range. Default 1.0. seed (int, optional): Random seed used for generating samples. 0 means use a seed generated by the system.Note that if seed is not 0, this operator will always generate the same random numbers every time. dtype(np.dtype|core.VarDesc.VarType|str, optional): The data type of output Tensor. Supported data types: float32, float64. Default float32. Returns: Variable: A Tensor of the specified shape filled with uniform_random values. The shape of the Tensor is determined by the shape parameter and the specified dimension of the input Tensor. Examples: .. code-block:: python >>> import paddle >>> import paddle.base as base >>> from paddle.tensor import random >>> paddle.enable_static() >>> # example 1: >>> input = paddle.static.data(name="input", shape=[1, 3], dtype='float32') >>> out_1 = random.uniform_random_batch_size_like(input, [2, 4]) >>> print(out_1.shape) [1, 4] >>> # example 2: >>> out_2 = random.uniform_random_batch_size_like(input, [2, 4], input_dim_idx=1, output_dim_idx=1) >>> print(out_2.shape) [2, 3] ZInput)rrruniform_random_batch_size_likeshaperr)r8 input_dim_idxoutput_dim_idxminmaxseedrrN)r7) rr listtupler rr%r&rr') inputr8rr9r:r;r<r=r+r,Zc_dtyper-r-r.r7s<B r7c Csd}gd}|durtj}||vrtd|||t|tjjs't |}t rAtj |}t }t|t|t||||St||t|d||i} ||||dd} tj j| | ||dtdit} | |} | jd | d | i| d d | _| S)a Returns a Tensor filled with random values sampled from a Gaussian distribution, with ``shape`` and ``dtype``. Args: shape (tuple|list|Tensor): Shape of the Tensor to be created. The data type is ``int32`` or ``int64`` . If ``shape`` is a list or tuple, each element of it should be integer or 0-D Tensor with shape []. If ``shape`` is an Tensor, it should be an 1-D Tensor which represents a list. mean (float|int, optional): Mean of the output tensor, default is 0.0. std (float|int, optional): Standard deviation of the output tensor, default is 1.0. seed (int, optional): Random seed of generator. dtype (str|np.dtype, optional): The data type of the output Tensor. Supported data types: float32, float64. Default is None, use global default dtype (see ``get_default_dtype`` for details). 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 filled with random values sampled from a Gaussian distribution, with ``shape`` and ``dtype``. z%gaussian/standard_normal/randn/normal)rrrrZbfloat16Nz0{} only supports {}, but the default dtype is {}rF)meanstdr=rZ use_mkldnnr!r#r8Zop_typegaussianZgaussian_randomrrTrE)paddle frameworkget_default_dtype TypeErrorformat isinstancerVarDescVarTyperrutilsconvert_shape_to_listrrrEfloatr r get_shape_tensor_inputsrr%r&r'r() r8rBrCr=rr*Zop_type_for_checksupported_dtypesZplacer!r#r+r,r-r-r.rEKsP    rEcCst|t|t|t|S)a` This is the inplace version of OP ``gaussian``, which returns a Tensor filled with random values sampled from a gaussian distribution. The output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_tensor_gaussian`. Args: x(Tensor): The input tensor to be filled with random values. mean (float|int, optional): Mean of the output tensor, default is 0.0. std (float|int, optional): Standard deviation of the output tensor, default is 1.0. seed (int, optional): Random seed of generator. 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 input tensor x filled with random values sampled from a gaussian distribution. Examples: .. code-block:: python >>> import paddle >>> x = paddle.randn([3, 4]) >>> paddle.tensor.random.gaussian_(x) >>> print(x) Tensor(shape=[3, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 0.86384124, 0.67328387, 0.21874231, -0.12615913], [ 0.69844258, 0.42084831, -0.42476156, -0.00072985], [ 1.72819555, 1.87785017, 0.48915744, 0.09235018]]) )rZgaussian_inplace_rQint)rrBrCr=r*r-r-r. gaussian_srUcCst|dd||dS)a7 Returns a Tensor filled with random values sampled from a standard normal distribution with mean 0 and standard deviation 1, with ``shape`` and ``dtype``. Args: shape (tuple|list|Tensor): Shape of the Tensor to be created. The data type is ``int32`` or ``int64`` . If ``shape`` is a list or tuple, each element of it should be integer or 0-D Tensor with shape []. If ``shape`` is an Tensor, it should be an 1-D Tensor which represents a list. dtype (str|np.dtype, optional): The data type of the output Tensor. Supported data types: float32, float64. Default is None, use global default dtype (see ``get_default_dtype`` for details). 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 filled with random values sampled from a standard normal distribution with mean 0 and standard deviation 1, with ``shape`` and ``dtype``. Examples: .. code-block:: python >>> import paddle >>> # doctest: +SKIP("Random output") >>> # example 1: attr shape is a list which doesn't contain Tensor. >>> out1 = paddle.standard_normal(shape=[2, 3]) >>> print(out1) >>> # doctest: +SKIP("Random output") Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[-0.33719197, -0.25688133, -0.42868865], [-0.27804616, -0.25058213, -0.28209466]]) >>> # doctest: -SKIP >>> # example 2: attr shape is a list which contains Tensor. >>> dim1 = paddle.to_tensor(2, 'int64') >>> dim2 = paddle.to_tensor(3, 'int32') >>> out2 = paddle.standard_normal(shape=[dim1, dim2, 2]) >>> print(out2) >>> # doctest: +SKIP("Random output") Tensor(shape=[2, 3, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[[ 0.81888396, -0.64831746], [ 1.28911388, -1.88154876], [-0.03271919, -0.32410008]], [[-0.20224631, 0.46683890], [ 1.91947734, 0.71657443], [ 0.33410960, -0.64256823]]]) >>> # doctest: -SKIP >>> # example 3: attr shape is a Tensor, the data type must be int64 or int32. >>> shape_tensor = paddle.to_tensor([2, 3]) >>> out3 = paddle.standard_normal(shape_tensor) >>> print(out3) >>> # doctest: +SKIP("Random output") Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 0.01182475, -0.44895259, -1.79227340], [ 1.52022707, -0.83830303, 0.05261501]]) >>> # doctest: -SKIP rAr6)r8rBrCrr*rFr8rr*r-r-r.standard_normals?rWcCs t|||S)a Returns a Tensor filled with random values sampled from a standard normal distribution with mean 0 and standard deviation 1, with ``shape`` and ``dtype``. Args: shape (tuple|list|Tensor): Shape of the Tensor to be created. The data type is ``int32`` or ``int64`` . If ``shape`` is a list or tuple, each element of it should be integer or 0-D Tensor with shape []. If ``shape`` is an Tensor, it should be an 1-D Tensor which represents a list. dtype (str|np.dtype, optional): The data type of the output Tensor. Supported data types: float32, float64. Default is None, use global default dtype (see ``get_default_dtype`` for details). 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 filled with random values sampled from a standard normal distribution with mean 0 and standard deviation 1, with ``shape`` and ``dtype``. Examples: .. code-block:: python >>> import paddle >>> # example 1: attr shape is a list which doesn't contain Tensor. >>> out1 = paddle.randn(shape=[2, 3]) >>> print(out1) >>> # doctest: +SKIP("Random output") Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[-0.29270014, -0.02925120, -1.07807338], [ 1.19966674, -0.46673676, -0.18050613]]) >>> # doctest: -SKIP >>> # example 2: attr shape is a list which contains Tensor. >>> dim1 = paddle.to_tensor(2, 'int64') >>> dim2 = paddle.to_tensor(3, 'int32') >>> out2 = paddle.randn(shape=[dim1, dim2, 2]) >>> print(out2) >>> # doctest: +SKIP("Random output") Tensor(shape=[2, 3, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[[-0.26019713, 0.54994684], [ 0.46403214, -1.41178775], [-0.15682915, -0.26639181]], [[ 0.01364388, -2.81676364], [ 0.86996621, 0.07524570], [ 0.21443737, 0.90938759]]]) >>> # doctest: -SKIP >>> # example 3: attr shape is a Tensor, the data type must be int64 or int32. >>> shape_tensor = paddle.to_tensor([2, 3]) >>> out3 = paddle.randn(shape_tensor) >>> print(out3) >>> # doctest: +SKIP("Random output") Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 0.57575506, -1.60349274, -0.27124876], [ 1.08381045, 0.81270242, -0.26763600]]) >>> # doctest: -SKIP )rWrVr-r-r.randns =rXcCs8ts@t|dtttfdt|dtttfdt|tr't|jdddgddt|tr7t|jdddgdd|dur@t|dt|trrt|trc|j|jkrWt ||j}t |}t ||}nt|}t t ||j|}nt|trt|}t t ||j|}nt||||d S|||}tsd |_|S) as Returns a Tensor filled with random values sampled from a normal distribution with ``mean`` and ``std`` (standard deviation) . If ``mean`` is a Tensor, the output Tensor has the same shape and data type as ``mean``. If ``mean`` is not a Tensor and ``std`` is a Tensor, the output Tensor has the same shape and data type as ``std``. If ``mean`` and ``std`` are not a Tensor, the output Tensor has the same shape as ``shape``, with data type float32. If ``mean`` and ``std`` are Tensor, the num of elements of ``mean`` and ``std`` should be the same. Args: mean (float|Tensor, optional): The mean of the output Tensor's normal distribution. If ``mean`` is float, all elements of the output Tensor shared the same mean. If ``mean`` is a Tensor(data type supports float32, float64), it has per-element means. Default is 0.0 std (float|Tensor, optional): The standard deviation of the output Tensor's normal distribution. If ``std`` is float, all elements of the output Tensor shared the same standard deviation. If ``std`` is a Tensor(data type supports float32, float64), it has per-element standard deviations. Defaule is 1.0 shape (tuple|list|Tensor): Shape of the Tensor to be created. The data type is ``int32`` or ``int64`` . If ``shape`` is a list or tuple, each element of it should be integer or 0-D Tensor with shape []. If ``shape`` is an Tensor, it should be an 1-D Tensor which represents a list. If ``mean`` or ``std`` is a Tensor, the shape of the output Tensor is the same as ``mean`` or ``std`` , attr ``shape`` is ignored. Default is None name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`. Returns: A Tensor filled with random values sampled from a normal distribution with ``mean`` and ``std`` . Examples: .. code-block:: python >>> import paddle >>> out1 = paddle.normal(shape=[2, 3]) >>> print(out1) >>> # doctest: +SKIP("Random output") Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[-0.85107994, -0.85490644, -1.35941815], [-0.55500370, 0.20964541, 2.24193954]]) >>> # doctest: -SKIP >>> mean_tensor = paddle.to_tensor([1.0, 2.0, 3.0]) >>> out2 = paddle.normal(mean=mean_tensor) >>> print(out2) >>> # doctest: +SKIP("Random output") Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [1.05411839, 3.71514320, 3.42665267]) >>> # doctest: -SKIP >>> std_tensor = paddle.to_tensor([1.0, 2.0, 3.0]) >>> out3 = paddle.normal(mean=mean_tensor, std=std_tensor) >>> print(out3) >>> # doctest: +SKIP("Random output") Tensor(shape=[3], dtype=float32, place=Place(cpu), stop_gradient=True, [0.48646951, 0.00815189, 3.74022293]) >>> # doctest: -SKIP rBnormalrCrrz@If mean is Tensor, it's data type only support float32, float64.z?If std is Tensor, it's data type only support float32, float64.N)r8rBrCr*T)rr rTrQrrLr rr rGcastr8ZreshaperWrEZ stop_grediant)rBrCr8r*Z mean_shaper,r-r-r.rY6sJ<         rYcCst|||dS)a This is the inplace version of api ``normal``, which returns a Tensor filled with random values sampled from a normal distribution. The output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_tensor_noraml`. Args: x(Tensor): The input tensor to be filled with random values. mean (float|Tensor, optional): The mean of the output Tensor's normal distribution. If ``mean`` is float, all elements of the output Tensor shared the same mean. If ``mean`` is a Tensor(data type supports float32, float64), it has per-element means. Default is 0.0 std (float|Tensor, optional): The standard deviation of the output Tensor's normal distribution. If ``std`` is float, all elements of the output Tensor shared the same standard deviation. If ``std`` is a Tensor(data type supports float32, float64), it has per-element standard deviations. Defaule is 1.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: A Tensor filled with random values sampled from a normal distribution with ``mean`` and ``std`` . Examples: .. code-block:: python >>> import paddle >>> x = paddle.randn([3, 4]) >>> x.normal_() >>> # doctest: +SKIP('random check') >>> print(x) Tensor(shape=[3, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 0.06132207, 1.11349595, 0.41906244, -0.24858207], [-1.85169315, -1.50370061, 1.73954511, 0.13331604], [ 1.66359663, -0.55764782, -0.59911072, -0.57773495]]) )rBrC)rU)rrBrCr*r-r-r.normal_s$r[c Csgd}|durtj}||vrtd||t|tjjs$t |}t r>> import paddle >>> # example 1: >>> # attr shape is a list which doesn't contain Tensor. >>> out1 = paddle.uniform(shape=[3, 4]) >>> print(out1) >>> # doctest: +SKIP("Random output") Tensor(shape=[3, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[ 0.38170254, -0.47945309, 0.39794648, -0.94233936], [-0.85296679, -0.76094693, 0.10565400, 0.59155810], [ 0.11681318, -0.42144555, -0.81596589, 0.62113667]]) >>> # doctest: -SKIP >>> # example 2: >>> # attr shape is a list which contains Tensor. >>> dim1 = paddle.to_tensor(2, 'int64') >>> dim2 = paddle.to_tensor(3, 'int32') >>> out2 = paddle.uniform(shape=[dim1, dim2]) >>> print(out2) >>> # doctest: +SKIP("Random output") Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[-0.00294012, -0.07210171, -0.44236207], [ 0.70089281, 0.21500075, -0.22084606]]) >>> # doctest: -SKIP >>> # example 3: >>> # attr shape is a Tensor, the data type must be int64 or int32. >>> shape_tensor = paddle.to_tensor([2, 3]) >>> out3 = paddle.uniform(shape_tensor) >>> print(out3) >>> # doctest: +SKIP("Random output") Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[-0.60801756, 0.32448411, 0.90269291], [-0.66421294, -0.95218551, -0.51022208]]) >>> # doctest: -SKIP rNz:uniform/rand only supports {}, but the default dtype is {}r8z uniform/randrr;r<)r=r;r<rrDuniformZuniform_randomr)r r!r#r"Tr\)"rGrHrIrJrKrLrrMrNrrrOrPrr\rQrr r r>r?pirOpResultr rT _contain_varget_int_tensor_listrrRrr%r&r'r() r8rr;r<r=r*rSr!r#r+r,r-r-r.r\s~M     r\c Cst||||dddS)aA This is the inplace version of OP ``uniform``, which returns a Tensor filled with random values sampled from a uniform distribution. The output Tensor will be inplaced with input ``x``. Please refer to :ref:`api_paddle_uniform`. Args: x(Tensor): The input tensor to be filled with random values. min(float|int, optional): The lower bound on the range of random values to generate, ``min`` is included in the range. Default is -1.0. max(float|int, optional): The upper bound on the range of random values to generate, ``max`` is excluded in the range. Default is 1.0. seed(int, optional): Random seed used for generating samples. If seed is 0, it will use the seed of the global default generator (which can be set by paddle.seed). Note that if seed is not 0, this operator will always generate the same random numbers every time. 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: The input tensor x filled with random values sampled from a uniform distribution in the range [``min``, ``max``). Examples: .. code-block:: python >>> import paddle >>> # example: >>> x = paddle.ones(shape=[3, 4]) >>> x.uniform_() >>> # doctest: +SKIP("Random output") Tensor(shape=[3, 4], dtype=float32, place=Place(cpu), stop_gradient=True, [[-0.50484276, 0.49580324, 0.33357990, -0.93924278], [ 0.39779735, 0.87677515, -0.24377221, 0.06212139], [-0.92499518, -0.96244860, 0.79210341, -0.78228098]]) >>> # doctest: -SKIP rr6)rZuniform_inplace_)rr;r<r=r*r-r-r.uniform_Ws&rbc Cs~|dur|dkrtd|d|}d}|dur$tjjj}tr#tj}n t|tjjs/t|}t rBt j |}t ||||tStrrt|dttt jjfdt|ddd gdt j |rht j |t}t ||||tSt|dt|ddd gd||krtd |d |i}||d|d }t j j|||dd tdit}|j|d}|jd|d|i|dd|_|S)a Returns a Tensor filled with random integers from a discrete uniform distribution in the range [``low``, ``high``), with ``shape`` and ``dtype``. If ``high`` is None (the default), the range is [0, ``low``). Args: low (int, optional): The lower bound on the range of random values to generate. The ``low`` is included in the range. If ``high`` is None, the range is [0, ``low``). Default is 0. high (int, optional): The upper bound on the range of random values to generate, the ``high`` is excluded in the range. Default is None (see above for behavior if high = None). Default is None. shape (tuple|list|Tensor): Shape of the Tensor to be created. The data type is ``int32`` or ``int64`` . If ``shape`` is a list or tuple, each element of it should be integer or 0-D Tensor with shape []. If ``shape`` is an Tensor, it should be an 1-D Tensor which represents a list. Default is [1]. dtype (str|np.dtype, optional): The data type of the output tensor. Supported data types: int32, int64. If ``dytpe`` is None, the data type is int64. Default is None. 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 filled with random integers from a discrete uniform distribution in the range [``low``, ``high``), with ``shape`` and ``dtype``. Examples: .. code-block:: python >>> import paddle >>> # example 1: >>> # attr shape is a list which doesn't contain Tensor. >>> out1 = paddle.randint(low=-5, high=5, shape=[2, 3]) >>> print(out1) >>> # doctest: +SKIP("Random output") Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[-1, 4, 4], [-2, -5, -2]]) >>> # doctest: -SKIP >>> # example 2: >>> # attr shape is a list which contains Tensor. >>> dim1 = paddle.to_tensor(2, 'int64') >>> dim2 = paddle.to_tensor(3, 'int32') >>> out2 = paddle.randint(low=-5, high=5, shape=[dim1, dim2]) >>> print(out2) >>> # doctest: +SKIP("Random output") Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[-4, -4, 2], [-3, -1, -5]]) >>> # doctest: -SKIP >>> # example 3: >>> # attr shape is a Tensor >>> shape_tensor = paddle.to_tensor([2, 3]) >>> out3 = paddle.randint(low=-5, high=5, shape=shape_tensor) >>> print(out3) >>> # doctest: +SKIP("Random output") Tensor(shape=[2, 3], dtype=int64, place=Place(cpu), stop_gradient=True, [[-1, 4, -3], [ 1, 2, -1]]) >>> # doctest: -SKIP >>> # example 4: >>> # data type is int32 >>> out4 = paddle.randint(low=-5, high=5, shape=[3], dtype='int32') >>> print(out4) >>> # doctest: +SKIP("Random output") Tensor(shape=[3], dtype=int32, place=Place(cpu), stop_gradient=True, [4, 4, 0]) >>> # doctest: -SKIP >>> # example 5: >>> # Input only one parameter >>> # low=0, high=10, shape=[1], dtype='int64' >>> out5 = paddle.randint(10) >>> print(out5) >>> # doctest: +SKIP("Random output") Tensor(shape=[1], dtype=int64, place=Place(cpu), stop_gradient=True, [7]) >>> # doctest: -SKIP Nr@If high is None, low must be greater than 0, but received low = .r8rrint32r2z6randint's low must less then high, but received low = , high = lowhighr=rrDrrrTr$) ValueErrorrrMrNINT64r rrLrrrGrOrPrrrr r>r?r^r_r r`rar rRrr%r&r'r() rhrir8rr*r!r#r+r,r-r-r.rsfU         rc Cs|dur|dkrtd|d|}d}|dur|j}nt|tjjtjfs*t|}t |}||kr=td|d|t rt r[tj |}td|d|d |d dd tjjj }n.t|dtttjjfd t|d gd d tj |r~tj |t}t|||tjt}t||}|St|d t|d gd d d|i}||dtjjjd}tdit} | jtjjjd}| j d|d|i|dd|_!t||}|S)a Returns a Tensor filled with random integers from a discrete uniform distribution in the range [``low``, ``high``), with the same shape as ``x``. (use ``dtype`` if ``dtype`` is not None) If ``high`` is None (the default), the range is [0, ``low``). Args: x (Tensor): The input multi-dimensional tensor which specifies shape. The dtype of ``x`` can be bool, int32, int64, float16, float32, float64. low (int, optional): The lower bound on the range of random values to generate. The ``low`` is included in the range. If ``high`` is None, the range is [0, ``low``). Default is 0. high (int, optional): The upper bound on the range of random values to generate, the ``high`` is excluded in the range. Default is None. If ``high`` is None, the range is [0, ``low``). dtype (str|np.dtype, optional): The data type of the output tensor. Supported data types: bool, int32, int64, float16, float32, float64. If ``dytpe`` is None, the data type is the same as x's data type. Default is None. 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 filled with random integers from a discrete uniform distribution in the range [``low``, ``high``), with ``shape`` and ``dtype``. Examples: .. code-block:: python >>> import paddle >>> # example 1: >>> # dtype is None and the dtype of x is float32 >>> x = paddle.zeros((1,2)).astype("float32") >>> out2 = paddle.randint_like(x, low=-5, high=5) >>> print(out2) >>> # doctest: +SKIP("Random output") Tensor(shape=[1, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[0., 0.]]) >>> # doctest: -SKIP >>> print(out2.dtype) paddle.float32 >>> # example 2: >>> # dtype is None and the dtype of x is float64 >>> x = paddle.zeros((1,2)).astype("float64") >>> out2 = paddle.randint_like(x, low=-5, high=5) >>> print(out2) >>> # doctest: +SKIP("Random output") Tensor(shape=[1, 2], dtype=float64, place=Place(cpu), stop_gradient=True, [[ 4., -5.]]) >>> # doctest: -SKIP >>> print(out2.dtype) paddle.float64 >>> # example 3: >>> # dtype is None and the dtype of x is int32 >>> x = paddle.zeros((1,2)).astype("int32") >>> out3 = paddle.randint_like(x, low=-5, high=5) >>> print(out3) >>> # doctest: +SKIP("Random output") Tensor(shape=[1, 2], dtype=int32, place=Place(cpu), stop_gradient=True, [[ 0, -4]]) >>> # doctest: -SKIP >>> print(out3.dtype) paddle.int32 >>> # example 4: >>> # dtype is None and the dtype of x is int64 >>> x = paddle.zeros((1,2)).astype("int64") >>> out4 = paddle.randint_like(x, low=-5, high=5) >>> print(out4) >>> # doctest: +SKIP("Random output") Tensor(shape=[1, 2], dtype=int64, place=Place(cpu), stop_gradient=True, [[ 4, -3]]) >>> # doctest: -SKIP >>> print(out4.dtype) paddle.int64 >>> # example 5: >>> # dtype is float64 and the dtype of x is float32 >>> x = paddle.zeros((1,2)).astype("float32") >>> out5 = paddle.randint_like(x, low=-5, high=5, dtype="float64") >>> print(out5) >>> # doctest: +SKIP("Random output") Tensor(shape=[1, 2], dtype=float64, place=Place(cpu), stop_gradient=True, [[3., 1.]]) >>> # doctest: -SKIP >>> print(out5.dtype) paddle.float64 >>> # example 6: >>> # dtype is bool and the dtype of x is float32 >>> x = paddle.zeros((1,2)).astype("float32") >>> out6 = paddle.randint_like(x, low=-5, high=5, dtype="bool") >>> print(out6) >>> # doctest: +SKIP("Random output") Tensor(shape=[1, 2], dtype=bool, place=Place(cpu), stop_gradient=True, [[False, True ]]) >>> # doctest: -SKIP >>> print(out6.dtype) paddle.bool >>> # example 7: >>> # dtype is int32 and the dtype of x is float32 >>> x = paddle.zeros((1,2)).astype("float32") >>> out7 = paddle.randint_like(x, low=-5, high=5, dtype="int32") >>> print(out7) >>> # doctest: +SKIP("Random output") Tensor(shape=[1, 2], dtype=int32, place=Place(cpu), stop_gradient=True, [[-2, -2]]) >>> # doctest: -SKIP >>> print(out7.dtype) paddle.int32 >>> # example 8: >>> # dtype is int64 and the dtype of x is float32 >>> x = paddle.zeros((1,2)).astype("float32") >>> out8 = paddle.randint_like(x, low=-5, high=5, dtype="int64") >>> print(out8) >>> # doctest: +SKIP("Random output") Tensor(shape=[1, 2], dtype=int64, place=Place(cpu), stop_gradient=True, [[-5, 4]]) >>> # doctest: -SKIP >>> print(out8.dtype) paddle.int64 >>> # example 9: >>> # dtype is int64 and the dtype of x is bool >>> x = paddle.zeros((1,2)).astype("bool") >>> out9 = paddle.randint_like(x, low=-5, high=5, dtype="int64") >>> print(out9) >>> # doctest: +SKIP("Random output") Tensor(shape=[1, 2], dtype=int64, place=Place(cpu), stop_gradient=True, [[ 1, -2]]) >>> # doctest: -SKIP >>> print(out9.dtype) paddle.int64 Nrrcrdz;randint_like's low must less then high, but received low = rfr8rhrir=r randint_like)boolrrrrer2Z ShapeTensorrgrrrrTr$)"rjrrLrrMrNrrrGr8rrrOrPrrrkr r>r?r^r_r r`rarrrZr rr%r&r'r() rrhrirr*r8r,r!r#r+r-r-r.rl s          rlr2cCst|tjjs t|}trt||tS|dkrt dt |dgddt d it }| |}||dd}|jdid|i|d d |_|S) a Returns a 1-D Tensor filled with random permutation values from 0 to n-1, with ``dtype``. Args: n (int): The upper bound (exclusive), and it should be greater than 0. dtype (str|np.dtype, optional): The data type of the output Tensor. Supported data types: int32, int64, float32, float64. Default is int64. 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 filled with random permutation values from 0 to n-1, with ``dtype``. Examples: .. code-block:: python >>> import paddle >>> out1 = paddle.randperm(5) >>> print(out1) >>> # doctest: +SKIP("Random output") Tensor(shape=[5], dtype=int64, place=Place(cpu), stop_gradient=True, [3, 0, 1, 4, 2]) >>> #doctest: -SKIP >>> out2 = paddle.randperm(7, 'int32') >>> print(out2) >>> # doctest: +SKIP("Random output") Tensor(shape=[7], dtype=int32, place=Place(cpu), stop_gradient=True, [3, 2, 0, 6, 5, 4, 1]) >>> #doctest: -SKIP r0z4The input n should be greater than 0 in randperm op.r)r2rerrrandpermr)nrr=rrTN)rn)rLrrMrNrrrrnrrjr rr%r&r'r()rorr*r+r,r#r-r-r.rns&&    rncCst||dd|dS)a Returns a Tensor filled with random values sampled from a uniform distribution in the range [0, 1), with ``shape`` and ``dtype``. Args: shape (tuple|list|Tensor): Shape of the Tensor to be created. The data type is ``int32`` or ``int64`` . If ``shape`` is a list or tuple, each element of it should be integer or 0-D Tensor with shape []. If ``shape`` is an Tensor, it should be an 1-D Tensor which represents a list. dtype (str|np.dtype, optional): The data type of the output Tensor. Supported data types: float32, float64. Default is None, use global default dtype (see :ref:`get_default_dtype` for details). 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 filled with random values sampled from a uniform distribution in the range [0, 1), with ``shape`` and ``dtype``. Examples: .. code-block:: python >>> import paddle >>> # example 1: attr shape is a list which doesn't contain Tensor. >>> out1 = paddle.rand(shape=[2, 3]) >>> print(out1) >>> # doctest: +SKIP("Random output") Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[0.68532258, 0.69431782, 0.44835982], [0.13204314, 0.48128194, 0.36574543]]) >>> # doctest: -SKIP >>> # example 2: attr shape is a list which contains Tensor. >>> dim1 = paddle.to_tensor(2, 'int64') >>> dim2 = paddle.to_tensor(3, 'int32') >>> out2 = paddle.rand(shape=[dim1, dim2, 2]) >>> print(out2) >>> # doctest: +SKIP("Random output") Tensor(shape=[2, 3, 2], dtype=float32, place=Place(cpu), stop_gradient=True, [[[0.62102991, 0.45255184], [0.81386960, 0.22463219], [0.87946558, 0.28097662]], [[0.36565998, 0.63203937], [0.58640617, 0.92696166], [0.85060406, 0.38138932]]]) >>> # doctest: -SKIP >>> # example 3: attr shape is a Tensor, the data type must be int64 or int32. >>> shape_tensor = paddle.to_tensor([2, 3]) >>> out3 = paddle.rand(shape_tensor) >>> print(out3) >>> # doctest: +SKIP("Random output") Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[0.77650446, 0.12870903, 0.05153799], [0.27029657, 0.03963696, 0.42487794]]) >>> # doctest: -SKIP rAr6)r;r<r*r]rVr-r-r.rand.s>> import paddle >>> paddle.set_device('cpu') >>> paddle.seed(100) >>> x = paddle.empty([2,3]) >>> x.exponential_() >>> # doctest: +SKIP("Random output") Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=True, [[0.80643415, 0.23211166, 0.01169797], [0.72520679, 0.45208144, 0.30234432]]) >>> # doctest: -SKIP r)rrrr exponentialrrlambdarN)rq)rr exponential_rrr%r')rZlamr*r+r-r-r.rsms#  rs)N)r0FN)rrrr5r6r)rAr6rNN)rAr6rN)NN)rAr6NN)rAr6N)Nr5r6rN)r5r6rN)rNNN)r2N)r6N))rGrrZpaddle.base.frameworkrZpaddle.base.libpaddlerZpaddle.common_ops_importrZpaddle.frameworkrrr Zbase.data_feederr r r rrHrrrr__all__rr/r1r7rErUrWrXrYr[r\rbrrlrnrprsr-r-r-r.sL     > .Q eG  ! B @g  & (  e >?