python+tensorflow,tensorflow1.15对应python

  python+tensorflow,tensorflow1.15对应python

  这篇文章主要为大家介绍了大蟒深度学习张量流1.0参数初始化初始化程序示例详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪

  

目录
正文所有初始化方法定义1、tf.constant_initializer()2、tf。truncated _ normal _ initializer()3、TF。random _ normal _ initializer()4、random _ uniform _ initializer=随机一致()5、TF。uniform _ unit _ scaling _ initializer()6、TFvariance _ scaling _ initializer()7、tf.orthogonal_initializer()8、tf。glorot _ uniform _ initializer()9、glorot_normal_initializer()

  

正文

  美国有线新闻网;卷积神经网络中最重要的就是参数了,包括w,b。我们训练美国有线新闻网;卷积神经网络的最终目的就是得到最好的参数,使得目标函数取得最小值。参数的初始化也同样重要,因此微调受到很多人的重视,那么法国南部(法国南部领地的缩写)提供了哪些初始化参数的方法呢,我们能不能自己进行初始化呢?

  

所有初始化方法定义

  #版权所有2015张量流作者。保留所有权利。

  #

  #根据街头流氓许可证2.0版("许可证")获得许可;

  #除非符合许可证的规定,否则您不得使用本文件。

  #您可以从以下网址获得许可证副本

  #

  # http://www.apache.org/licenses/LICENSE-2.0

  #

  #除非适用法律要求或书面同意,否则软件

  #根据许可证分发是基于"原样"分发,

  #没有任何明示或暗示的保证或条件。

  #有关管理权限的特定语言,请参见许可证

  #许可证下的限制。

  #==============================================================================

  通常用于初始化张量的操作。

  该文件中函数返回的所有变量初始值设定项都应该具有

  以下签名:

  def _initializer(shape,dtype=dtypes.float32,partition_info=None):

  Args:

  形状:列表中的int 表示输出张量的形状。一些

  初始化器也可以接受一个"张量"。

  数据类型:(可选)输出张量的类型。

  partition_info:(可选)变量范围. PartitionInfo对象保持

  关于变量如何分区的附加信息。也许

  如果变量未分区,则为"无"。

  返回:

  "数据类型"和“沙”类型的"张量"

  pe`.

  """

  from __future__ import absolute_import

  from __future__ import division

  from __future__ import print_function

  import math

  from tensorflow.python.framework import constant_op

  from tensorflow.python.framework import dtypes

  from tensorflow.python.ops import array_ops

  from tensorflow.python.ops import linalg_ops

  from tensorflow.python.ops import random_ops

  class Initializer(object):

   """Initializer base class: all initializers inherit from this class.

   """

   def __call__(self, shape, dtype=None, partition_info=None):

   raise NotImplementedError

  class Zeros(Initializer):

   """Initializer that generates tensors initialized to 0."""

   def __init__(self, dtype=dtypes.float32):

   self.dtype = dtype

   def __call__(self, shape, dtype=None, partition_info=None):

   if dtype is None:

   dtype = self.dtype

   return constant_op.constant(False if dtype is dtypes.bool else 0,

   dtype=dtype, shape=shape)

  class Ones(Initializer):

   """Initializer that generates tensors initialized to 1."""

   def __init__(self, dtype=dtypes.float32):

   self.dtype = dtype

   def __call__(self, shape, dtype=None, partition_info=None):

   if dtype is None:

   dtype = self.dtype

   return constant_op.constant(1, dtype=dtype, shape=shape)

  class Constant(Initializer):

   """Initializer that generates tensors with constant values.

   The resulting tensor is populated with values of type `dtype`, as

   specified by arguments `value` following the desired `shape` of the

   new tensor (see examples below).

   The argument `value` can be a constant value, or a list of values of type

   `dtype`. If `value` is a list, then the length of the list must be less

   than or equal to the number of elements implied by the desired shape of the

   tensor. In the case where the total number of elements in `value` is less

   than the number of elements required by the tensor shape, the last element

   in `value` will be used to fill the remaining entries. If the total number of

   elements in `value` is greater than the number of elements required by the

   tensor shape, the initializer will raise a `ValueError`.

   Args:

   value: A Python scalar, list of values, or a N-dimensional numpy array. All

   elements of the initialized variable will be set to the corresponding

   value in the `value` argument.

   dtype: The data type.

   verify_shape: Boolean that enables verification of the shape of `value`. If

   `True`, the initializer will throw an error if the shape of `value` is not

   compatible with the shape of the initialized tensor.

   Examples:

   The following example can be rewritten using a numpy.ndarray instead

   of the `value` list, even reshaped, as shown in the two commented lines

   below the `value` list initialization.

   ```python

   >>> import numpy as np

   >>> import tensorflow as tf

   >>> value = [0, 1, 2, 3, 4, 5, 6, 7]

   >>> # value = np.array(value)

   >>> # value = value.reshape([2, 4])

   >>> init = tf.constant_initializer(value)

   >>> print(fitting shape:)

   >>> with tf.Session():

   >>> x = tf.get_variable(x, shape=[2, 4], initializer=init)

   >>> x.initializer.run()

   >>> print(x.eval())

   fitting shape:

   [[ 0. 1. 2. 3.]

   [ 4. 5. 6. 7.]]

   >>> print(larger shape:)

   >>> with tf.Session():

   >>> x = tf.get_variable(x, shape=[3, 4], initializer=init)

   >>> x.initializer.run()

   >>> print(x.eval())

   larger shape:

   [[ 0. 1. 2. 3.]

   [ 4. 5. 6. 7.]

   [ 7. 7. 7. 7.]]

   >>> print(smaller shape:)

   >>> with tf.Session():

   >>> x = tf.get_variable(x, shape=[2, 3], initializer=init)

   ValueError: Too many elements provided. Needed at most 6, but received 8

   >>> print(shape verification:)

   >>> init_verify = tf.constant_initializer(value, verify_shape=True)

   >>> with tf.Session():

   >>> x = tf.get_variable(x, shape=[3, 4], initializer=init_verify)

   TypeError: Expected Tensors shape: (3, 4), got (8,).

   ```

   """

   def __init__(self, value=0, dtype=dtypes.float32, verify_shape=False):

   self.value = value

   self.dtype = dtype

   self.verify_shape = verify_shape

   def __call__(self, shape, dtype=None, partition_info=None):

   if dtype is None:

   dtype = self.dtype

   return constant_op.constant(self.value, dtype=dtype, shape=shape,

   verify_shape=self.verify_shape)

  class RandomUniform(Initializer):

   """Initializer that generates tensors with a uniform distribution.

   Args:

   minval: A python scalar or a scalar tensor. Lower bound of the range

   of random values to generate.

   maxval: A python scalar or a scalar tensor. Upper bound of the range

   of random values to generate. Defaults to 1 for float types.

   seed: A Python integer. Used to create random seeds. See

   @{tf.set_random_seed}

   for behavior.

   dtype: The data type.

   """

   def __init__(self, minval=0, maxval=None, seed=None, dtype=dtypes.float32):

   self.minval = minval

   self.maxval = maxval

   self.seed = seed

   self.dtype = dtype

   def __call__(self, shape, dtype=None, partition_info=None):

   if dtype is None:

   dtype = self.dtype

   return random_ops.random_uniform(shape, self.minval, self.maxval,

   dtype, seed=self.seed)

  class RandomNormal(Initializer):

   """Initializer that generates tensors with a normal distribution.

   Args:

   mean: a python scalar or a scalar tensor. Mean of the random values

   to generate.

   stddev: a python scalar or a scalar tensor. Standard deviation of the

   random values to generate.

   seed: A Python integer. Used to create random seeds. See

   @{tf.set_random_seed}

   for behavior.

   dtype: The data type. Only floating point types are supported.

   """

   def __init__(self, mean=0.0, stddev=1.0, seed=None, dtype=dtypes.float32):

   self.mean = mean

   self.stddev = stddev

   self.seed = seed

   self.dtype = _assert_float_dtype(dtype)

   def __call__(self, shape, dtype=None, partition_info=None):

   if dtype is None:

   dtype = self.dtype

   return random_ops.random_normal(shape, self.mean, self.stddev,

   dtype, seed=self.seed)

  class TruncatedNormal(Initializer):

   """Initializer that generates a truncated normal distribution.

   These values are similar to values from a `random_normal_initializer`

   except that values more than two standard deviations from the mean

   are discarded and re-drawn. This is the recommended initializer for

   neural network weights and filters.

   Args:

   mean: a python scalar or a scalar tensor. Mean of the random values

   to generate.

   stddev: a python scalar or a scalar tensor. Standard deviation of the

   random values to generate.

   seed: A Python integer. Used to create random seeds. See

   @{tf.set_random_seed}

   for behavior.

   dtype: The data type. Only floating point types are supported.

   """

   def __init__(self, mean=0.0, stddev=1.0, seed=None, dtype=dtypes.float32):

   self.mean = mean

   self.stddev = stddev

   self.seed = seed

   self.dtype = _assert_float_dtype(dtype)

   def __call__(self, shape, dtype=None, partition_info=None):

   if dtype is None:

   dtype = self.dtype

   return random_ops.truncated_normal(shape, self.mean, self.stddev,

   dtype, seed=self.seed)

  class UniformUnitScaling(Initializer):

   """Initializer that generates tensors without scaling variance.

   When initializing a deep network, it is in principle advantageous to keep

   the scale of the input variance constant, so it does not explode or diminish

   by reaching the final layer. If the input is `x` and the operation `x * W`,

   and we want to initialize `W` uniformly at random, we need to pick `W` from

   [-sqrt(3) / sqrt(dim), sqrt(3) / sqrt(dim)]

   to keep the scale intact, where `dim = W.shape[0]` (the size of the input).

   A similar calculation for convolutional networks gives an analogous result

   with `dim` equal to the product of the first 3 dimensions. When

   nonlinearities are present, we need to multiply this by a constant `factor`.

   See [Sussillo et al., 2014](https://arxiv.org/abs/1412.6558)

   ([pdf](http://arxiv.org/pdf/1412.6558.pdf)) for deeper motivation, experiments

   and the calculation of constants. In section 2.3 there, the constants were

   numerically computed: for a linear layer its 1.0, relu: ~1.43, tanh: ~1.15.

   Args:

   factor: Float. A multiplicative factor by which the values will be scaled.

   seed: A Python integer. Used to create random seeds. See

   @{tf.set_random_seed}

   for behavior.

   dtype: The data type. Only floating point types are supported.

   """

   def __init__(self, factor=1.0, seed=None, dtype=dtypes.float32):

   self.factor = factor

   self.seed = seed

   self.dtype = _assert_float_dtype(dtype)

   def __call__(self, shape, dtype=None, partition_info=None):

   if dtype is None:

   dtype = self.dtype

   scale_shape = shape

   if partition_info is not None:

   scale_shape = partition_info.full_shape

   input_size = 1.0

   # Estimating input size is not possible to do perfectly, but we try.

   # The estimate, obtained by multiplying all dimensions but the last one,

   # is the right thing for matrix multiply and convolutions (see above).

   for dim in scale_shape[:-1]:

   input_size *= float(dim)

   # Avoid errors when initializing zero-size tensors.

   input_size = max(input_size, 1.0)

   max_val = math.sqrt(3 / input_size) * self.factor

   return random_ops.random_uniform(shape, -max_val, max_val,

   dtype, seed=self.seed)

  class VarianceScaling(Initializer):

   """Initializer capable of adapting its scale to the shape of weights tensors.

   With `distribution="normal"`, samples are drawn from a truncated normal

   distribution centered on zero, with `stddev = sqrt(scale / n)`

   where n is:

   - number of input units in the weight tensor, if mode = "fan_in"

   - number of output units, if mode = "fan_out"

   - average of the numbers of input and output units, if mode = "fan_avg"

   With `distribution="uniform"`, samples are drawn from a uniform distribution

   within [-limit, limit], with `limit = sqrt(3 * scale / n)`.

   Arguments:

   scale: Scaling factor (positive float).

   mode: One of "fan_in", "fan_out", "fan_avg".

   distribution: Random distribution to use. One of "normal", "uniform".

   seed: A Python integer. Used to create random seeds. See

   @{tf.set_random_seed}

   for behavior.

   dtype: The data type. Only floating point types are supported.

   Raises:

   ValueError: In case of an invalid value for the "scale", mode" or

   "distribution" arguments.

   """

   def __init__(self, scale=1.0,

   mode="fan_in",

   distribution="normal",

   seed=None,

   dtype=dtypes.float32):

   if scale <= 0.:

   raise ValueError("`scale` must be positive float.")

   if mode not in {"fan_in", "fan_out", "fan_avg"}:

   raise ValueError("Invalid `mode` argument:", mode)

   distribution = distribution.lower()

   if distribution not in {"normal", "uniform"}:

   raise ValueError("Invalid `distribution` argument:", distribution)

   self.scale = scale

   self.mode = mode

   self.distribution = distribution

   self.seed = seed

   self.dtype = _assert_float_dtype(dtype)

   def __call__(self, shape, dtype=None, partition_info=None):

   if dtype is None:

   dtype = self.dtype

   scale = self.scale

   scale_shape = shape

   if partition_info is not None:

   scale_shape = partition_info.full_shape

   fan_in, fan_out = _compute_fans(scale_shape)

   if self.mode == "fan_in":

   scale /= max(1., fan_in)

   elif self.mode == "fan_out":

   scale /= max(1., fan_out)

   else:

   scale /= max(1., (fan_in + fan_out) / 2.)

   if self.distribution == "normal":

   stddev = math.sqrt(scale)

   return random_ops.truncated_normal(shape, 0.0, stddev,

   dtype, seed=self.seed)

   else:

   limit = math.sqrt(3.0 * scale)

   return random_ops.random_uniform(shape, -limit, limit,

   dtype, seed=self.seed)

  class Orthogonal(Initializer):

   """Initializer that generates an orthogonal matrix.

   If the shape of the tensor to initialize is two-dimensional, i is initialized

   with an orthogonal matrix obtained from the singular value decomposition of a

   matrix of uniform random numbers.

   If the shape of the tensor to initialize is more than two-dimensional,

   a matrix of shape `(shape[0] * ... * shape[n - 2], shape[n - 1])`

   is initialized, where `n` is the length of the shape vector.

   The matrix is subsequently reshaped to give a tensor of the desired shape.

   Args:

   gain: multiplicative factor to apply to the orthogonal matrix

   dtype: The type of the output.

   seed: A Python integer. Used to create random seeds. See

   @{tf.set_random_seed}

   for behavior.

   """

   def __init__(self, gain=1.0, dtype=dtypes.float32, seed=None):

   self.gain = gain

   self.dtype = _assert_float_dtype(dtype)

   self.seed = seed

   def __call__(self, shape, dtype=None, partition_info=None):

   if dtype is None:

   dtype = self.dtype

   # Check the shape

   if len(shape) < 2:

   raise ValueError("The tensor to initialize must be "

   "at least two-dimensional")

   # Flatten the input shape with the last dimension remaining

   # its original shape so it works for conv2d

   num_rows = 1

   for dim in shape[:-1]:

   num_rows *= dim

   num_cols = shape[-1]

   flat_shape = (num_rows, num_cols)

   # Generate a random matrix

   a = random_ops.random_uniform(flat_shape, dtype=dtype, seed=self.seed)

   # Compute the svd

   _, u, v = linalg_ops.svd(a, full_matrices=False)

   # Pick the appropriate singular value decomposition

   if num_rows > num_cols:

   q = u

   else:

   # Tensorflow departs from numpy conventions

   # such that we need to transpose axes here

   q = array_ops.transpose(v)

   return self.gain * array_ops.reshape(q, shape)

  # Aliases.

  # pylint: disable=invalid-name

  zeros_initializer = Zeros

  ones_initializer = Ones

  constant_initializer = Constant

  random_uniform_initializer = RandomUniform

  random_normal_initializer = RandomNormal

  truncated_normal_initializer = TruncatedNormal

  uniform_unit_scaling_initializer = UniformUnitScaling

  variance_scaling_initializer = VarianceScaling

  orthogonal_initializer = Orthogonal

  # pylint: enable=invalid-name

  def glorot_uniform_initializer(seed=None, dtype=dtypes.float32):

   """The Glorot uniform initializer, also called Xavier uniform initializer.

   It draws samples from a uniform distribution within [-limit, limit]

   where `limit` is `sqrt(6 / (fan_in + fan_out))`

   where `fan_in` is the number of input units in the weight tensor

   and `fan_out` is the number of output units in the weight tensor.

   Reference: http://jmlr.org/proceedings/papers/v9/glorot10a/glorot10a.pdf

   Arguments:

   seed: A Python integer. Used to create random seeds. See

   @{tf.set_random_seed}

   for behavior.

   dtype: The data type. Only floating point types are supported.

   Returns:

   An initializer.

   """

   return variance_scaling_initializer(scale=1.0,

   mode="fan_avg",

   distribution="uniform",

   seed=seed,

   dtype=dtype)

  def glorot_normal_initializer(seed=None, dtype=dtypes.float32):

   """The Glorot normal initializer, also called Xavier normal initializer.

   It draws samples from a truncated normal distribution centered on 0

   with `stddev = sqrt(2 / (fan_in + fan_out))`

   where `fan_in` is the number of input units in the weight tensor

   and `fan_out` is the number of output units in the weight tensor.

   Reference: http://jmlr.org/proceedings/papers/v9/glorot10a/glorot10a.pdf

   Arguments:

   seed: A Python integer. Used to create random seeds. See

   @{tf.set_random_seed}

   for behavior.

   dtype: The data type. Only floating point types are supported.

   Returns:

   An initializer.

   """

   return variance_scaling_initializer(scale=1.0,

   mode="fan_avg",

   distribution="normal",

   seed=seed,

   dtype=dtype)

  # Utility functions.

  def _compute_fans(shape):

   """Computes the number of input and output units for a weight shape.

   Arguments:

   shape: Integer shape tuple or TF tensor shape.

   Returns:

   A tuple of scalars (fan_in, fan_out).

   """

   if len(shape) < 1: # Just to avoid errors for constants.

   fan_in = fan_out = 1

   elif len(shape) == 1:

   fan_in = fan_out = shape[0]

   elif len(shape) == 2:

   fan_in = shape[0]

   fan_out = shape[1]

   else:

   # Assuming convolution kernels (2D, 3D, or more).

   # kernel shape: (..., input_depth, depth)

   receptive_field_size = 1.

   for dim in shape[:-2]:

   receptive_field_size *= dim

   fan_in = shape[-2] * receptive_field_size

   fan_out = shape[-1] * receptive_field_size

   return fan_in, fan_out

  def _assert_float_dtype(dtype):

   """Validate and return floating point type based on `dtype`.

   `dtype` must be a floating point type.

   Args:

   dtype: The data type to validate.

   Returns:

   Validated type.

   Raises:

   ValueError: if `dtype` is not a floating point type.

   """

   if not dtype.is_floating:

   raise ValueError("Expected floating point type, got %s." % dtype)

   return dtype

  

  

  

1、tf.constant_initializer()

  也可以简写为tf.Constant()

  初始化为常数,这个非常有用,通常偏置项就是用它初始化的。

  由它衍生出的两个初始化方法:

  

a、 tf.zeros_initializer(), 也可以简写为tf.Zeros()

  b、tf.ones_initializer(), 也可以简写为tf.Ones()

  

  例:在卷积层中,将偏置项b初始化为0,则有多种写法:

  

conv1 = tf.layers.conv2d(batch_images, 

   filters=64,

   kernel_size=7,

   strides=2,

   activation=tf.nn.relu,

   kernel_initializer=tf.TruncatedNormal(stddev=0.01)

   bias_initializer=tf.Constant(0),

   )

  或者:

  

bias_initializer=tf.constant_initializer(0)

  或者:

  

bias_initializer=tf.zeros_initializer()

  或者:

  

bias_initializer=tf.Zeros()

  例:如何将W初始化成拉普拉斯算子?

  

value = [1, 1, 1, 1, -8, 1, 1, 1,1]

  init = tf.constant_initializer(value)

  W= tf.get_variable(W, shape=[3, 3], initializer=init)

  

  

2、tf.truncated_normal_initializer()

  或者简写为tf.TruncatedNormal()

  生成截断正态分布的随机数,这个初始化方法好像在tf中用得比较多。

  它有四个参数(mean=0.0,stddev=1.0,seed=None,dtype=dtypes.float32),分别用于指定均值、标准差、随机数种子和随机数的数据类型,一般只需要设置stddev这一个参数就可以了。

  例:

  

conv1 = tf.layers.conv2d(batch_images, 

   filters=64,

   kernel_size=7,

   strides=2,

   activation=tf.nn.relu,

   kernel_initializer=tf.TruncatedNormal(stddev=0.01)

   bias_initializer=tf.Constant(0),

   )

  或者:

  

conv1 = tf.layers.conv2d(batch_images, 

   filters=64,

   kernel_size=7,

   strides=2,

   activation=tf.nn.relu,

   kernel_initializer=tf.truncated_normal_initializer(stddev=0.01)

   bias_initializer=tf.zero_initializer(),

   )

  

  

3、tf.random_normal_initializer()

  可简写为 tf.RandomNormal()

  生成标准正态分布的随机数,参数和truncated_normal_initializer一样。

  

  

4、random_uniform_initializer= RandomUniform()

  可简写为tf.RandomUniform()

  生成均匀分布的随机数,参数有四个(minval=0,maxval=None,seed=None,dtype=dtypes.float32),分别用于指定最小值,最大值,随机数种子和类型。

  

  

5、tf.uniform_unit_scaling_initializer()

  可简写为tf.UniformUnitScaling()

  和均匀分布差不多,只是这个初始化方法不需要指定最小最大值,是通过计算出来的。参数为(factor=1.0,seed=None,dtype=dtypes.float32)

  

max_val = math.sqrt(3 / input_size) * factor

  这里的input_size是指输入数据的维数,假设输入为x, 运算为x * W,则input_size=W.shape[0]

  它的分布区间为[ -max_val, max_val]

  

  

6、tf.variance_scaling_initializer()

  可简写为tf.VarianceScaling()

  

参数为(scale=1.0,mode="fan_in",distribution="normal",seed=None,dtype=dtypes.float32)

  

  scale: 缩放尺度(正浮点数)

  mode:"fan_in", "fan_out", "fan_avg"中的一个,用于计算标准差stddev的值。

  distribution:分布类型,"normal"或uniform"中的一个。

  当distribution="normal"的时候,生成truncated normaldistribution(截断正态分布)的随机数,其中stddev = sqrt(scale / n),n的计算与mode参数有关。

  

  • 如果mode = "fan_in", n为输入单元的结点数;
  • 如果mode = "fan_out",n为输出单元的结点数;
  • 如果mode = "fan_avg",n为输入和输出单元结点数的平均值。

  当distribution="uniform的时候 ,生成均匀分布的随机数,假设分布区间为[-limit, limit],则

  

limit = sqrt(3 * scale / n)

  

  

  

7、tf.orthogonal_initializer()

  简写为tf.Orthogonal()

  生成正交矩阵的随机数。

  当需要生成的参数是2维时,这个正交矩阵是由均匀分布的随机数矩阵经过SVD分解而来。

  

  

8、tf.glorot_uniform_initializer()

  也称之为Xavier uniform initializer,由一个均匀分布(uniform distribution)来初始化数据。

  假设均匀分布的区间是[-limit, limit],则

  

limit=sqrt(6 / (fan_in + fan_out))

  

  其中的fan_in和fan_out分别表示输入单元的结点数和输出单元的结点数。

  

  

9、glorot_normal_initializer()

  也称之为Xavier normal initializer. 由一个truncated normal distribution来初始化数据.

  

stddev = sqrt(2 / (fan_in + fan_out))

  

  其中的fan_in和fan_out分别表示输入单元的结点数和输出单元的结点数。

  以上就是python深度学习tensorflow1.0参数初始化initializer的详细内容,更多关于python tensorflow1.0参数initializer的资料请关注盛行IT软件开发工作室其它相关文章!

郑重声明:本文由网友发布,不代表盛行IT的观点,版权归原作者所有,仅为传播更多信息之目的,如有侵权请联系,我们将第一时间修改或删除,多谢。

留言与评论(共有 条评论)
   
验证码: