Tensorflow专题1：生成随机数

随机数函数 tf.random_normal & tf.random_uniform & tf.truncated_normal & tf.random_shuffle

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： 操作的名称(可选)

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，如果数据为整形则必须指定。

tf.truncated_normal

截断的正态分布函数。生成的值遵循一个正态分布，但如果生成的值大于平均值2个标准偏差的值则丢弃重新选择。
故，只取横轴区间（μ-2σ，μ+2σ）内的值，面积为95.449974%

truncated_normal(  
    shape,#一个一维整数张量或Python数组。代表张量的形状。  
    mean=0.0,#数据类型为dtype的张量值或Python值。是正态分布的均值。  
    stddev=1.0,#数据类型为dtype的张量值或Python值。是正态分布的标准差  
    dtype=tf.float32,#输出的数据类型。  
    seed=None,#一个Python整数。是随机种子。  
    name=None#操作的名称(可选)  
)

tf.random_shuffle

沿着要被洗牌的张量的第一个维度，随机打乱。

random_shuffle(  
    value,# 要被洗牌的张量  
    seed=None,  
    name=None  
)

即下面这种效果：

[[1, 2],       [[5, 6],  
 [3, 4],  ==>   [1, 2],  
 [5, 6]]        [3, 4]]

附录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)