text: # Copyright 2018 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.
  # ==============================================================================
  """Tests for initializers in init_ops."""
  
  from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  
  import numpy as np
  
  from tensorflow.core.protobuf import config_pb2
  from tensorflow.python.client import session
  from tensorflow.python.eager import context
  from tensorflow.python.framework import ops
  from tensorflow.python.ops import init_ops
  from tensorflow.python.ops import resource_variable_ops
  from tensorflow.python.ops import variable_scope
  from tensorflow.python.ops import variables
  from tensorflow.python.platform import test
  
  
  class InitializersTest(test.TestCase):
  
    def _runner(self,
                init,
                shape,
                target_mean=None,
                target_std=None,
                target_max=None,
                target_min=None):
      variable = resource_variable_ops.ResourceVariable(init(shape))
      if context.executing_eagerly():
        output = variable.numpy()
      else:
        sess = ops.get_default_session()
        sess.run(variable.initializer)
        output = sess.run(variable)
      lim = 3e-2
      if target_std is not None:
        self.assertGreater(lim, abs(output.std() - target_std))
      if target_mean is not None:
        self.assertGreater(lim, abs(output.mean() - target_mean))
      if target_max is not None:
        self.assertGreater(lim, abs(output.max() - target_max))
      if target_min is not None:
        self.assertGreater(lim, abs(output.min() - target_min))
  
    def test_uniform(self):
      tensor_shape = (9, 6, 7)
      with self.cached_session():
        self._runner(
            init_ops.RandomUniform(minval=-1, maxval=1, seed=124),
            tensor_shape,
            target_mean=0.,
            target_max=1,
            target_min=-1)
  
    def test_normal(self):
      tensor_shape = (8, 12, 99)
      with self.cached_session():
        self._runner(
            init_ops.RandomNormal(mean=0, stddev=1, seed=153),
            tensor_shape,
            target_mean=0.,
            target_std=1)
  
    def test_truncated_normal(self):
      tensor_shape = (12, 99, 7)
      with self.cached_session():
        self._runner(
            init_ops.TruncatedNormal(mean=0, stddev=1, seed=126),
            tensor_shape,
            target_mean=0.,
            target_max=2,
            target_min=-2)
  
    def test_constant(self):
      tensor_shape = (5, 6, 4)
      with self.cached_session():
        self._runner(
            init_ops.Constant(2),
            tensor_shape,
            target_mean=2,
            target_max=2,
            target_min=2)
  
    def test_lecun_uniform(self):
      tensor_shape = (5, 6, 4, 2)
      with self.cached_session():
        fan_in, _ = init_ops._compute_fans(tensor_shape)
        std = np.sqrt(1. / fan_in)
        self._runner(
            init_ops.lecun_uniform(seed=123),
            tensor_shape,
            target_mean=0.,
            target_std=std)
  
    def test_glorot_uniform_initializer(self):
      tensor_shape = (5, 6, 4, 2)
      with self.cached_session():
        fan_in, fan_out = init_ops._compute_fans(tensor_shape)
        std = np.sqrt(2. / (fan_in + fan_out))
        self._runner(
            init_ops.glorot_uniform_initializer(seed=123),
            tensor_shape,
            target_mean=0.,
            target_std=std)
  
    def test_he_uniform(self):
      tensor_shape = (5, 6, 4, 2)
      with self.cached_session():
        fan_in, _ = init_ops._compute_fans(tensor_shape)
        std = np.sqrt(2. / fan_in)
        self._runner(
            init_ops.he_uniform(seed=123),
            tensor_shape,
            target_mean=0.,
            target_std=std)
  
    def test_lecun_normal(self):
      tensor_shape = (5, 6, 4, 2)
      with self.cached_session():
        fan_in, _ = init_ops._compute_fans(tensor_shape)
        std = np.sqrt(1. / fan_in)
        self._runner(
            init_ops.lecun_normal(seed=123),
            tensor_shape,
            target_mean=0.,
            target_std=std)
  
    def test_glorot_normal_initializer(self):
      tensor_shape = (5, 6, 4, 2)
      with self.cached_session():
        fan_in, fan_out = init_ops._compute_fans(tensor_shape)
        std = np.sqrt(2. / (fan_in + fan_out))
        self._runner(
            init_ops.glorot_normal_initializer(seed=123),
            tensor_shape,
            target_mean=0.,
            target_std=std)
  
    def test_he_normal(self):
      tensor_shape = (5, 6, 4, 2)
      with self.cached_session():
        fan_in, _ = init_ops._compute_fans(tensor_shape)
        std = np.sqrt(2. / fan_in)
        self._runner(
            init_ops.he_normal(seed=123),
            tensor_shape,
            target_mean=0.,
            target_std=std)
  
    def test_Orthogonal(self):
      tensor_shape = (20, 20)
      with self.cached_session():
        self._runner(init_ops.Orthogonal(seed=123), tensor_shape, target_mean=0.)
  
    def testVariablePlacementWithOrthogonalInitializer(self):
      if not context.context().num_gpus():
        self.skipTest('No devices other than CPUs found')
      with ops.Graph().as_default() as g:
        with ops.device('gpu:0'):
          variable_scope.get_variable(
              name='v', shape=[8, 2], initializer=init_ops.Orthogonal)
          variable_scope.get_variable(
              name='w', shape=[8, 2], initializer=init_ops.RandomNormal)
        run_metadata = config_pb2.RunMetadata()
        run_options = config_pb2.RunOptions(
            trace_level=config_pb2.RunOptions.FULL_TRACE)
        config = config_pb2.ConfigProto(
            allow_soft_placement=False, log_device_placement=True)
  
        # Note: allow_soft_placement=False will fail whenever we cannot satisfy
        # the colocation constraints.
        with session.Session(config=config, graph=g) as sess:
          sess.run(
              variables.global_variables_initializer(),
              options=run_options,
              run_metadata=run_metadata)
  
    def test_eager_orthogonal_gpu(self):
      if not context.context().num_gpus():
        self.skipTest('No devices other than CPUs found')
      with context.eager_mode():
        v = variable_scope.get_variable(
            name='v', shape=[8, 2], initializer=init_ops.Orthogonal)
        w = variable_scope.get_variable(
            name='w', shape=[8, 2], initializer=init_ops.RandomNormal)
        self.assertTrue('GPU' in v.handle.device)
        self.assertTrue('GPU' in w.handle.device)
  
    def test_Identity(self):
      with self.cached_session():
        tensor_shape = (3, 4, 5)
        with self.assertRaises(ValueError):
          self._runner(
              init_ops.Identity(),
              tensor_shape,
              target_mean=1. / tensor_shape[0],
              target_max=1.)
  
        tensor_shape = (3, 3)
        self._runner(
            init_ops.Identity(),
            tensor_shape,
            target_mean=1. / tensor_shape[0],
            target_max=1.)
  
    def test_Zeros(self):
      tensor_shape = (4, 5)
      with self.cached_session():
        self._runner(
            init_ops.Zeros(), tensor_shape, target_mean=0., target_max=0.)
  
    def test_Ones(self):
      tensor_shape = (4, 5)
      with self.cached_session():
        self._runner(init_ops.Ones(), tensor_shape, target_mean=1., target_max=1.)
  
  
  if __name__ == '__main__':
    test.main()
  