转载:https://blog.csdn.net/tz_zs/article/details/75948350
tf.random_normal
从正态分布中输出随机值。
.
random_normal(shape,mean=0.0,stddev=1.0,dtype=tf.float32,seed=None,name=None)
.
- shape:一个一维整数张量或Python数组。代表张量的形状。
- mean:数据类型为dtype的张量值或Python值。是正态分布的均值。
- stddev:数据类型为dtype的张量值或Python值。是正态分布的标准差。
- dtype: 输出的数据类型。
- seed:一个Python整数。是随机种子。
- name: 操作的名称(可选)
官网api地址:https://www.tensorflow.org/versions/r1.3/api_docs/python/tf/random_normal
tf.random_uniform
从均匀分布中返回随机值。
.
-
random_uniform(
-
shape,
# 生成的张量的形状
-
minval=
0,
-
maxval=
None,
-
dtype=tf.float32,
-
seed=
None,
-
name=
None
-
)
.
返回值的范围默认是0到1的左闭右开区间,即[0,1)。minval为指定最小边界,默认为1。maxval为指定的最大边界,如果是数据浮点型则默认为1,如果数据为整形则必须指定。
官网api地址:https://www.tensorflow.org/api_docs/python/tf/random_uniform
tf.truncated_normal
截断的正态分布函数。生成的值遵循一个正态分布,但不会大于平均值2个标准差。
.
-
truncated_normal(
-
shape,
#一个一维整数张量或Python数组。代表张量的形状。
-
mean=
0.0,
#数据类型为dtype的张量值或Python值。是正态分布的均值。
-
stddev=
1.0,
#数据类型为dtype的张量值或Python值。是正态分布的标准差
-
dtype=tf.float32,
#输出的数据类型。
-
seed=
None,
#一个Python整数。是随机种子。
-
name=
None
#操作的名称(可选)
-
)
.
官网api地址:https://www.tensorflow.org/api_docs/python/tf/truncated_normal
tf.random_shuffle
沿着要被洗牌的张量的第一个维度,随机打乱。
.
-
random_shuffle(
-
value,
# 要被洗牌的张量
-
seed=
None,
-
name=
None
-
)
即下面这种效果:
.
-
[[
1,
2], [[
5,
6],
-
[
3,
4], ==> [
1,
2],
-
[
5,
6]] [
3,
4]]
.
官网api地址: https://www.tensorflow.org/api_docs/python/tf/random_shuffle
附录1:生成随机数的操作的源码random_ops.py
.
-
# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
-
#
-
# Licensed under the Apache License, Version 2.0 (the "License");
-
# you may not use this file except in compliance with the License.
-
# You may obtain a copy of the License at
-
#
-
# http://www.apache.org/licenses/LICENSE-2.0
-
#
-
# Unless required by applicable law or agreed to in writing, software
-
# distributed under the License is distributed on an "AS IS" BASIS,
-
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-
# See the License for the specific language governing permissions and
-
# limitations under the License.
-
# ==============================================================================
-
"""Operations for generating random numbers."""
-
-
from __future__
import absolute_import
-
from __future__
import division
-
from __future__
import print_function
-
-
import numpy
as np
-
from tensorflow.python.framework
import dtypes
-
from tensorflow.python.framework
import ops
-
from tensorflow.python.framework
import random_seed
-
from tensorflow.python.ops
import array_ops
-
from tensorflow.python.ops
import control_flow_ops
-
from tensorflow.python.ops
import gen_random_ops
-
from tensorflow.python.ops
import math_ops
-
# go/tf-wildcard-import
-
# pylint: disable=wildcard-import
-
from tensorflow.python.ops.gen_random_ops
import *
-
-
# pylint: enable=wildcard-import
-
-
-
def _ShapeTensor(shape):
-
"""Convert to an int32 or int64 tensor, defaulting to int32 if empty."""
-
if isinstance(shape, (tuple, list))
and
not shape:
-
dtype = dtypes.int32
-
else:
-
dtype =
None
-
return ops.convert_to_tensor(shape, dtype=dtype, name=
"shape")
-
-
-
# pylint: disable=protected-access
-
def random_normal(shape,
-
mean=0.0,
-
stddev=1.0,
-
dtype=dtypes.float32,
-
seed=None,
-
name=None):
-
"""Outputs random values from a normal distribution.
-
-
Args:
-
shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
-
mean: A 0-D Tensor or Python value of type `dtype`. The mean of the normal
-
distribution.
-
stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation
-
of the normal distribution.
-
dtype: The type of the output.
-
seed: A Python integer. Used to create a random seed for the distribution.
-
See
-
@{tf.set_random_seed}
-
for behavior.
-
name: A name for the operation (optional).
-
-
Returns:
-
A tensor of the specified shape filled with random normal values.
-
"""
-
with ops.name_scope(name,
"random_normal", [shape, mean, stddev])
as name:
-
shape_tensor = _ShapeTensor(shape)
-
mean_tensor = ops.convert_to_tensor(mean, dtype=dtype, name=
"mean")
-
stddev_tensor = ops.convert_to_tensor(stddev, dtype=dtype, name=
"stddev")
-
seed1, seed2 = random_seed.get_seed(seed)
-
rnd = gen_random_ops._random_standard_normal(
-
shape_tensor, dtype, seed=seed1, seed2=seed2)
-
mul = rnd * stddev_tensor
-
value = math_ops.add(mul, mean_tensor, name=name)
-
return value
-
-
-
ops.NotDifferentiable(
"RandomStandardNormal")
-
-
-
def parameterized_truncated_normal(shape,
-
means=0.0,
-
stddevs=1.0,
-
minvals=-2.0,
-
maxvals=2.0,
-
dtype=dtypes.float32,
-
seed=None,
-
name=None):
-
"""Outputs random values from a truncated normal distribution.
-
-
The generated values follow a normal distribution with specified mean and
-
standard deviation, except that values whose magnitude is more than 2 standard
-
deviations from the mean are dropped and re-picked.
-
-
Args:
-
shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
-
means: A 0-D Tensor or Python value of type `dtype`. The mean of the
-
truncated normal distribution.
-
stddevs: A 0-D Tensor or Python value of type `dtype`. The standard
-
deviation of the truncated normal distribution.
-
minvals: A 0-D Tensor or Python value of type `dtype`. The minimum value of
-
the truncated normal distribution.
-
maxvals: A 0-D Tensor or Python value of type `dtype`. The maximum value of
-
the truncated normal distribution.
-
dtype: The type of the output.
-
seed: A Python integer. Used to create a random seed for the distribution.
-
See
-
@{tf.set_random_seed}
-
for behavior.
-
name: A name for the operation (optional).
-
-
Returns:
-
A tensor of the specified shape filled with random truncated normal values.
-
"""
-
with ops.name_scope(name,
"parameterized_truncated_normal",
-
[shape, means, stddevs, minvals, maxvals])
as name:
-
shape_tensor = _ShapeTensor(shape)
-
means_tensor = ops.convert_to_tensor(means, dtype=dtype, name=
"means")
-
stddevs_tensor = ops.convert_to_tensor(stddevs, dtype=dtype, name=
"stddevs")
-
minvals_tensor = ops.convert_to_tensor(minvals, dtype=dtype, name=
"minvals")
-
maxvals_tensor = ops.convert_to_tensor(maxvals, dtype=dtype, name=
"maxvals")
-
seed1, seed2 = random_seed.get_seed(seed)
-
rnd = gen_random_ops._parameterized_truncated_normal(
-
shape_tensor,
-
means_tensor,
-
stddevs_tensor,
-
minvals_tensor,
-
maxvals_tensor,
-
seed=seed1,
-
seed2=seed2)
-
return rnd
-
-
-
def truncated_normal(shape,
-
mean=0.0,
-
stddev=1.0,
-
dtype=dtypes.float32,
-
seed=None,
-
name=None):
-
"""Outputs random values from a truncated normal distribution.
-
-
The generated values follow a normal distribution with specified mean and
-
standard deviation, except that values whose magnitude is more than 2 standard
-
deviations from the mean are dropped and re-picked.
-
-
Args:
-
shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
-
mean: A 0-D Tensor or Python value of type `dtype`. The mean of the
-
truncated normal distribution.
-
stddev: A 0-D Tensor or Python value of type `dtype`. The standard deviation
-
of the truncated normal distribution.
-
dtype: The type of the output.
-
seed: A Python integer. Used to create a random seed for the distribution.
-
See
-
@{tf.set_random_seed}
-
for behavior.
-
name: A name for the operation (optional).
-
-
Returns:
-
A tensor of the specified shape filled with random truncated normal values.
-
"""
-
with ops.name_scope(name,
"truncated_normal", [shape, mean, stddev])
as name:
-
shape_tensor = _ShapeTensor(shape)
-
mean_tensor = ops.convert_to_tensor(mean, dtype=dtype, name=
"mean")
-
stddev_tensor = ops.convert_to_tensor(stddev, dtype=dtype, name=
"stddev")
-
seed1, seed2 = random_seed.get_seed(seed)
-
rnd = gen_random_ops._truncated_normal(
-
shape_tensor, dtype, seed=seed1, seed2=seed2)
-
mul = rnd * stddev_tensor
-
value = math_ops.add(mul, mean_tensor, name=name)
-
return value
-
-
-
ops.NotDifferentiable(
"ParameterizedTruncatedNormal")
-
ops.NotDifferentiable(
"TruncatedNormal")
-
-
-
def random_uniform(shape,
-
minval=0,
-
maxval=None,
-
dtype=dtypes.float32,
-
seed=None,
-
name=None):
-
"""Outputs random values from a uniform distribution.
-
-
The generated values follow a uniform distribution in the range
-
`[minval, maxval)`. The lower bound `minval` is included in the range, while
-
the upper bound `maxval` is excluded.
-
-
For floats, the default range is `[0, 1)`. For ints, at least `maxval` must
-
be specified explicitly.
-
-
In the integer case, the random integers are slightly biased unless
-
`maxval - minval` is an exact power of two. The bias is small for values of
-
`maxval - minval` significantly smaller than the range of the output (either
-
`2**32` or `2**64`).
-
-
Args:
-
shape: A 1-D integer Tensor or Python array. The shape of the output tensor.
-
minval: A 0-D Tensor or Python value of type `dtype`. The lower bound on the
-
range of random values to generate. Defaults to 0.
-
maxval: A 0-D Tensor or Python value of type `dtype`. The upper bound on
-
the range of random values to generate. Defaults to 1 if `dtype` is
-
floating point.
-
dtype: The type of the output: `float32`, `float64`, `int32`, or `int64`.
-
seed: A Python integer. Used to create a random seed for the distribution.
-
See @{tf.set_random_seed}
-
for behavior.
-
name: A name for the operation (optional).
-
-
Returns:
-
A tensor of the specified shape filled with random uniform values.
-
-
Raises:
-
ValueError: If `dtype` is integral and `maxval` is not specified.
-
"""
-
dtype = dtypes.as_dtype(dtype)
-
if maxval
is
None:
-
if dtype.is_integer:
-
raise ValueError(
"Must specify maxval for integer dtype %r" % dtype)
-
maxval =
1
-
with ops.name_scope(name,
"random_uniform", [shape, minval, maxval])
as name:
-
shape = _ShapeTensor(shape)
-
minval = ops.convert_to_tensor(minval, dtype=dtype, name=
"min")
-
maxval = ops.convert_to_tensor(maxval, dtype=dtype, name=
"max")
-
seed1, seed2 = random_seed.get_seed(seed)
-
if dtype.is_integer:
-
return gen_random_ops._random_uniform_int(
-
shape, minval, maxval, seed=seed1, seed2=seed2, name=name)
-
else:
-
rnd = gen_random_ops._random_uniform(
-
shape, dtype, seed=seed1, seed2=seed2)
-
return math_ops.add(rnd * (maxval - minval), minval, name=name)
-
-
-
ops.NotDifferentiable(
"RandomUniform")
-
-
-
def random_shuffle(value, seed=None, name=None):
-
"""Randomly shuffles a tensor along its first dimension.
-
-
The tensor is shuffled along dimension 0, such that each `value[j]` is mapped
-
to one and only one `output[i]`. For example, a mapping that might occur for a
-
3x2 tensor is:
-
-
```python
-
[[1, 2], [[5, 6],
-
[3, 4], ==> [1, 2],
-
[5, 6]] [3, 4]]
-
```
-
-
Args:
-
value: A Tensor to be shuffled.
-
seed: A Python integer. Used to create a random seed for the distribution.
-
See
-
@{tf.set_random_seed}
-
for behavior.
-
name: A name for the operation (optional).
-
-
Returns:
-
A tensor of same shape and type as `value`, shuffled along its first
-
dimension.
-
"""
-
seed1, seed2 = random_seed.get_seed(seed)
-
return gen_random_ops._random_shuffle(
-
value, seed=seed1, seed2=seed2, name=name)
-
-
-
def random_crop(value, size, seed=None, name=None):
-
"""Randomly crops a tensor to a given size.
-
-
Slices a shape `size` portion out of `value` at a uniformly chosen offset.
-
Requires `value.shape >= size`.
-
-
If a dimension should not be cropped, pass the full size of that dimension.
-
For example, RGB images can be cropped with
-
`size = [crop_height, crop_width, 3]`.
-
-
Args:
-
value: Input tensor to crop.
-
size: 1-D tensor with size the rank of `value`.
-
seed: Python integer. Used to create a random seed. See
-
@{tf.set_random_seed}
-
for behavior.
-
name: A name for this operation (optional).
-
-
Returns:
-
A cropped tensor of the same rank as `value` and shape `size`.
-
"""
-
# TODO(shlens): Implement edge case to guarantee output size dimensions.
-
# If size > value.shape, zero pad the result so that it always has shape
-
# exactly size.
-
with ops.name_scope(name,
"random_crop", [value, size])
as name:
-
value = ops.convert_to_tensor(value, name=
"value")
-
size = ops.convert_to_tensor(size, dtype=dtypes.int32, name=
"size")
-
shape = array_ops.shape(value)
-
check = control_flow_ops.Assert(
-
math_ops.reduce_all(shape >= size),
-
[
"Need value.shape >= size, got ", shape, size],
-
summarize=
1000)
-
shape = control_flow_ops.with_dependencies([check], shape)
-
limit = shape - size +
1
-
offset = random_uniform(
-
array_ops.shape(shape),
-
dtype=size.dtype,
-
maxval=size.dtype.max,
-
seed=seed) % limit
-
return array_ops.slice(value, offset, size, name=name)
-
-
-
def multinomial(logits, num_samples, seed=None, name=None):
-
"""Draws samples from a multinomial distribution.
-
-
Example:
-
-
```python
-
# samples has shape [1, 5], where each value is either 0 or 1 with equal
-
# probability.
-
samples = tf.multinomial(tf.log([[10., 10.]]), 5)
-
```
-
-
Args:
-
logits: 2-D Tensor with shape `[batch_size, num_classes]`. Each slice
-
`[i, :]` represents the log-odds for all classes.
-
num_samples: 0-D. Number of independent samples to draw for each row slice.
-
seed: A Python integer. Used to create a random seed for the distribution.
-
See
-
@{tf.set_random_seed}
-
for behavior.
-
name: Optional name for the operation.
-
-
Returns:
-
The drawn samples of shape `[batch_size, num_samples]`.
-
"""
-
with ops.name_scope(name,
"multinomial", [logits]):
-
logits = ops.convert_to_tensor(logits, name=
"logits")
-
seed1, seed2 = random_seed.get_seed(seed)
-
return gen_random_ops.multinomial(
-
logits, num_samples, seed=seed1, seed2=seed2)
-
-
-
ops.NotDifferentiable(
"Multinomial")
-
-
-
def random_gamma(shape,
-
alpha,
-
beta=None,
-
dtype=dtypes.float32,
-
seed=None,
-
name=None):
-
"""Draws `shape` samples from each of the given Gamma distribution(s).
-
-
`alpha` is the shape parameter describing the distribution(s), and `beta` is
-
the inverse scale parameter(s).
-
-
Example:
-
-
samples = tf.random_gamma([10], [0.5, 1.5])
-
# samples has shape [10, 2], where each slice [:, 0] and [:, 1] represents
-
# the samples drawn from each distribution
-
-
samples = tf.random_gamma([7, 5], [0.5, 1.5])
-
# samples has shape [7, 5, 2], where each slice [:, :, 0] and [:, :, 1]
-
# represents the 7x5 samples drawn from each of the two distributions
-
-
samples = tf.random_gamma([30], [[1.],[3.],[5.]], beta=[[3., 4.]])
-
# samples has shape [30, 3, 2], with 30 samples each of 3x2 distributions.
-
-
Note: Because internal calculations are done using `float64` and casting has
-
`floor` semantics, we must manually map zero outcomes to the smallest
-
possible positive floating-point value, i.e., `np.finfo(dtype).tiny`. This
-
means that `np.finfo(dtype).tiny` occurs more frequently than it otherwise
-
should. This bias can only happen for small values of `alpha`, i.e.,
-
`alpha << 1` or large values of `beta`, i.e., `beta >> 1`.
-
-
Args:
-
shape: A 1-D integer Tensor or Python array. The shape of the output samples
-
to be drawn per alpha/beta-parameterized distribution.
-
alpha: A Tensor or Python value or N-D array of type `dtype`. `alpha`
-
provides the shape parameter(s) describing the gamma distribution(s) to
-
sample. Must be broadcastable with `beta`.
-
beta: A Tensor or Python value or N-D array of type `dtype`. Defaults to 1.
-
`beta` provides the inverse scale parameter(s) of the gamma
-
distribution(s) to sample. Must be broadcastable with `alpha`.
-
dtype: The type of alpha, beta, and the output: `float16`, `float32`, or
-
`float64`.
-
seed: A Python integer. Used to create a random seed for the distributions.
-
See
-
@{tf.set_random_seed}
-
for behavior.
-
name: Optional name for the operation.
-
-
Returns:
-
samples: a `Tensor` of shape `tf.concat(shape, tf.shape(alpha + beta))`
-
with values of type `dtype`.
-
"""
-
with ops.name_scope(name,
"random_gamma", [shape, alpha, beta]):
-
shape = ops.convert_to_tensor(shape, name=
"shape", dtype=dtypes.int32)
-
alpha = ops.convert_to_tensor(alpha, name=
"alpha", dtype=dtype)
-
beta = ops.convert_to_tensor(
-
beta
if beta
is
not
None
else
1, name=
"beta", dtype=dtype)
-
alpha_broadcast = alpha + array_ops.zeros_like(beta)
-
seed1, seed2 = random_seed.get_seed(seed)
-
return math_ops.maximum(
-
np.finfo(dtype.as_numpy_dtype).tiny,
-
gen_random_ops._random_gamma(
-
shape, alpha_broadcast, seed=seed1, seed2=seed2) / beta)
-
-
ops.NotDifferentiable(
"RandomGamma")
-
-
-
def random_poisson(lam, shape, dtype=dtypes.float32, seed=None, name=None):
-
"""Draws `shape` samples from each of the given Poisson distribution(s).
-
-
`lam` is the rate parameter describing the distribution(s).
-
-
Example:
-
-
samples = tf.random_poisson([0.5, 1.5], [10])
-
# samples has shape [10, 2], where each slice [:, 0] and [:, 1] represents
-
# the samples drawn from each distribution
-
-
samples = tf.random_poisson([12.2, 3.3], [7, 5])
-
# samples has shape [7, 5, 2], where each slice [:, :, 0] and [:, :, 1]
-
# represents the 7x5 samples drawn from each of the two distributions
-
-
Args:
-
lam: A Tensor or Python value or N-D array of type `dtype`.
-
`lam` provides the rate parameter(s) describing the poisson
-
distribution(s) to sample.
-
shape: A 1-D integer Tensor or Python array. The shape of the output samples
-
to be drawn per "rate"-parameterized distribution.
-
dtype: The type of `lam` and the output: `float16`, `float32`, or
-
`float64`.
-
seed: A Python integer. Used to create a random seed for the distributions.
-
See
-
@{tf.set_random_seed}
-
for behavior.
-
name: Optional name for the operation.
-
-
Returns:
-
samples: a `Tensor` of shape `tf.concat(shape, tf.shape(lam))` with
-
values of type `dtype`.
-
"""
-
with ops.name_scope(name,
"random_poisson", [lam, shape]):
-
lam = ops.convert_to_tensor(lam, name=
"lam", dtype=dtype)
-
shape = ops.convert_to_tensor(shape, name=
"shape", dtype=dtypes.int32)
-
seed1, seed2 = random_seed.get_seed(seed)
-
return gen_random_ops._random_poisson(shape, lam, seed=seed1, seed2=seed2)
.