main body (of a book)
The most important thing in a CNN is the parameters, including W,b. Our ultimate goal in training a CNN is to get the best parameters so that the objective function achieves the minimum value. The initialization of the parameters is equally important, so fine-tuning has received a lot of attention. So what methods does tf provide to initialize the parameters, and can we do it ourselves?
All initialization method definitions
# 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
#
# /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 often used for initializing tensors.
All variable initializers returned by functions in this file should have the
following signature:
def _initializer(shape, dtype=dtypes.float32, partition_info=None):
Args:
shape: List of `int` representing the shape of the output `Tensor`. Some
initializers may also be able to accept a `Tensor`.
dtype: (Optional) Type of the output `Tensor`.
partition_info: (Optional) variable_scope._PartitionInfo object holding
additional information about how the variable is partitioned. May be
`None` if the variable is not partitioned.
Returns:
A `Tensor` of type `dtype` and `shape`.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import math
from import constant_op
from import dtypes
from import array_ops
from import linalg_ops
from 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):
= dtype
def __call__(self, shape, dtype=None, partition_info=None):
if dtype is None:
dtype =
return constant_op.constant(False if dtype is else 0,
dtype=dtype, shape=shape)
class Ones(Initializer):
"""Initializer that generates tensors initialized to 1."""
def __init__(self, dtype=dtypes.float32):
= dtype
def __call__(self, shape, dtype=None, partition_info=None):
if dtype is None:
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 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 = (value)
>>> # value = ([2, 4])
>>> init = tf.constant_initializer(value)
>>> print('fitting shape:')
>>> with ():
>>> x = tf.get_variable('x', shape=[2, 4], initializer=init)
>>> ()
>>> print(())
fitting shape:
[[ 0. 1. 2. 3.]
[ 4. 5. 6. 7.]]
>>> print('larger shape:')
>>> with ():
>>> x = tf.get_variable('x', shape=[3, 4], initializer=init)
>>> ()
>>> print(())
larger shape:
[[ 0. 1. 2. 3.]
[ 4. 5. 6. 7.]
[ 7. 7. 7. 7.]]
>>> print('smaller shape:')
>>> with ():
>>> 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 ():
>>> x = tf.get_variable('x', shape=[3, 4], initializer=init_verify)
TypeError: Expected Tensor's shape: (3, 4), got (8,).
```
"""
def __init__(self, value=0, dtype=dtypes.float32, verify_shape=False):
= value
= dtype
self.verify_shape = verify_shape
def __call__(self, shape, dtype=None, partition_info=None):
if dtype is None:
dtype =
return constant_op.constant(, 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):
= minval
= maxval
= seed
= dtype
def __call__(self, shape, dtype=None, partition_info=None):
if dtype is None:
dtype =
return random_ops.random_uniform(shape, , ,
dtype, 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):
= mean
= stddev
= seed
= _assert_float_dtype(dtype)
def __call__(self, shape, dtype=None, partition_info=None):
if dtype is None:
dtype =
return random_ops.random_normal(shape, , ,
dtype, 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):
= mean
= stddev
= seed
= _assert_float_dtype(dtype)
def __call__(self, shape, dtype=None, partition_info=None):
if dtype is None:
dtype =
return random_ops.truncated_normal(shape, , ,
dtype, 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 = [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](/abs/1412.6558)
([pdf](/pdf/1412.)) for deeper motivation, experiments
and the calculation of constants. In section 2.3 there, the constants were
numerically computed: for a linear layer it's 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):
= factor
= seed
= _assert_float_dtype(dtype)
def __call__(self, shape, dtype=None, partition_info=None):
if dtype is None:
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 = (3 / input_size) *
return random_ops.random_uniform(shape, -max_val, max_val,
dtype, 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 = ()
if distribution not in {"normal", "uniform"}:
raise ValueError("Invalid `distribution` argument:", distribution)
= scale
= mode
= distribution
= seed
= _assert_float_dtype(dtype)
def __call__(self, shape, dtype=None, partition_info=None):
if dtype is None:
dtype =
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 == "fan_in":
scale /= max(1., fan_in)
elif == "fan_out":
scale /= max(1., fan_out)
else:
scale /= max(1., (fan_in + fan_out) / 2.)
if == "normal":
stddev = (scale)
return random_ops.truncated_normal(shape, 0.0, stddev,
dtype, seed=)
else:
limit = (3.0 * scale)
return random_ops.random_uniform(shape, -limit, limit,
dtype, 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):
= gain
= _assert_float_dtype(dtype)
= seed
def __call__(self, shape, dtype=None, partition_info=None):
if dtype is None:
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=)
# 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 * 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: /proceedings/papers/v9/glorot10a/
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: /proceedings/papers/v9/glorot10a/
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()
It can also be abbreviated as ()
Initialized to a constant, this is very useful, usually the bias term is initialized with it.
Two initialization methods derived from it:
a, tf.zeros_initializer(), can also be abbreviated as ()
b, tf.ones_initializer(), can also be abbreviated as ()
Example: in a convolutional layer, the bias term b is initialized to 0. There are various ways to write this:
conv1 = .conv2d(batch_images,
filters=64,
kernel_size=7,
strides=2,
activation=,
kernel_initializer=(stddev=0.01)
bias_initializer=(0),
)Or:
bias_initializer=tf.constant_initializer(0)
Or:
bias_initializer=tf.zeros_initializer()
Or:
bias_initializer=()
Example: how to initialize W to a Laplace operator?
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()
Or abbreviated as ()
Generate truncated normally distributed random numbers, this initialization method seems to be used more in tf.
It has four parameters (mean=0.0, stddev=1.0, seed=None, dtype=dtypes.float32), which are used to specify the mean, standard deviation, seed of the random number and the data type of the random number respectively, and generally only one parameter, stddev, needs to be set.
Example:
conv1 = .conv2d(batch_images,
filters=64,
kernel_size=7,
strides=2,
activation=,
kernel_initializer=(stddev=0.01)
bias_initializer=(0),
)Or:
conv1 = .conv2d(batch_images,
filters=64,
kernel_size=7,
strides=2,
activation=,
kernel_initializer=tf.truncated_normal_initializer(stddev=0.01)
bias_initializer=tf.zero_initializer(),
)3、tf.random_normal_initializer()
can be abbreviated as ()
Generate standard normally distributed random numbers with the same parameters as truncated_normal_initializer.
4、random_uniform_initializer = RandomUniform()
can be abbreviated as ()
Generates uniformly distributed random numbers with four parameters (minval=0, maxval=None, seed=None, dtype=dtypes.float32), which are used to specify the minimum value, the maximum value, the random number seed, and the type, respectively.
5、tf.uniform_unit_scaling_initializer()
can be abbreviated as ()
Pretty much the same as the uniform distribution, except that this initialization method doesn't need to specify a min-max value, it's calculated. The parameters are (factor=1.0, seed=None, dtype=dtypes.float32)
max_val = (3 / input_size) * factor
Here input_size is the dimension of the input data, suppose the input is x, the operation is x * W, then input_size= [0]
It has a distribution interval of [ -max_val, max_val]
6、tf.variance_scaling_initializer()
can be abbreviated as ()
Parameters are (scale=1.0,mode="fan_in",distribution="normal",seed=None, dtype=dtypes.float32)
scale: Scale (positive floating point)
mode: One of "fan_in", "fan_out", "fan_avg" for the value of standard deviation stddev.
distribution: Distribution type, one of "normal" or "uniform".
When distribution="normal", generates a truncated normal distribution of random numbers, where stddev = sqrt(scale / n) and n is calculated with respect to the mode parameter.
- If mode = "fan_in", n is the number of nodes in the input cell;
- If mode = "fan_out", n is the number of nodes in the output cell;
- If mode = "fan_avg",n is the average of the number of input and output cell nodes.
When distribution="uniform" , generate uniformly distributed random numbers, assuming the distribution interval is [-limit, limit], then
limit = sqrt(3 * scale / n)
7、tf.orthogonal_initializer()
Abbreviated as ()
Generate random numbers of orthogonal matrices.
When the parameters to be generated are 2-dimensional, this orthogonal matrix is derived from a uniformly distributed matrix of random numbers decomposed by SVD.
8、tf.glorot_uniform_initializer()
Also called Xavier uniform initializer, the data is initialized by a uniform distribution.
Assuming that the interval of the uniform distribution is [-limit, limit],the
limit=sqrt(6 / (fan_in + fan_out))
where fan_in and fan_out denote the number of nodes in the input cell and the number of nodes in the output cell, respectively.
9、glorot_normal_initializer（）
Also known as the Xavier normal initializer. The data is initialized by a truncated normal distribution.
stddev = sqrt(2 / (fan_in + fan_out))
where fan_in and fan_out denote the number of nodes in the input cell and the number of nodes in the output cell, respectively.
This is the detailed content of python deep learning tensorflow1.0 parameter initialization initializer, more information about python tensorflow1.0 parameter initializer, please pay attention to my other related articles!