code: # Copyright (c) 2021 PaddlePaddle 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.
  
  import paddle.fluid.core as core
  import paddle.fluid.eager.eager_tensor_patch_methods as eager_tensor_patch_methods
  import paddle
  import numpy as np
  from paddle.fluid.framework import _test_eager_guard, EagerParamBase, _in_eager_mode
  from paddle.fluid.data_feeder import convert_dtype
  import unittest
  import copy
  
  
  class EagerScaleTestCase(unittest.TestCase):
      def test_scale_base(self):
          with _test_eager_guard():
              paddle.set_device("cpu")
              arr = np.ones([4, 16, 16, 32]).astype('float32')
              tensor = paddle.to_tensor(arr, 'float32', core.CPUPlace())
              print(tensor)
              tensor = core.eager.scale(tensor, 2.0, 0.9, True, False)
              for i in range(0, 100):
                  tensor = core.eager.scale(tensor, 2.0, 0.9, True, False)
              print(tensor)
              self.assertEqual(tensor.shape, [4, 16, 16, 32])
              self.assertEqual(tensor.stop_gradient, True)
  
      def test_retain_grad_and_run_backward(self):
          with _test_eager_guard():
              paddle.set_device("cpu")
  
              input_data = np.ones([4, 16, 16, 32]).astype('float32')
              data_eager = paddle.to_tensor(input_data, 'float32',
                                            core.CPUPlace(), False)
  
              grad_data = np.ones([4, 16, 16, 32]).astype('float32')
              grad_eager = paddle.to_tensor(grad_data, 'float32', core.CPUPlace())
  
              data_eager.retain_grads()
  
              out_eager = core.eager.scale(data_eager, 1.0, 0.9, True, True)
              self.assertFalse(data_eager.grad._is_initialized())
              out_eager.backward(grad_eager, False)
              self.assertTrue(data_eager.grad._is_initialized())
              self.assertTrue(np.array_equal(data_eager.grad.numpy(), input_data))
  
      def test_retain_grad_and_run_backward_raises(self):
          with _test_eager_guard():
              paddle.set_device("cpu")
  
              input_data = np.ones([4, 16, 16, 32]).astype('float32')
              data_eager = paddle.to_tensor(input_data, 'float32',
                                            core.CPUPlace(), False)
  
              grad_data = np.ones([4, 16, 16, 32]).astype('float32')
              grad_data2 = np.ones([4, 16]).astype('float32')
              grad_eager = paddle.to_tensor(grad_data, 'float32', core.CPUPlace())
              grad_eager2 = paddle.to_tensor(grad_data2, 'float32',
                                             core.CPUPlace())
  
              data_eager.retain_grads()
  
              out_eager = core.eager.scale(data_eager, 1.0, 0.9, True, True)
              self.assertFalse(data_eager.grad._is_initialized())
              with self.assertRaisesRegexp(
                      AssertionError,
                      "The type of grad_tensor must be paddle.Tensor"):
                  out_eager.backward(grad_data, False)
  
              with self.assertRaisesRegexp(
                      AssertionError,
                      "Tensor shape not match, Tensor of grad_tensor /*"):
                  out_eager.backward(grad_eager2, False)
  
  
  class EagerDtypeTestCase(unittest.TestCase):
      def check_to_tesnsor_and_numpy(self, dtype, proto_dtype):
          with _test_eager_guard():
              arr = np.random.random([4, 16, 16, 32]).astype(dtype)
              tensor = paddle.to_tensor(arr, dtype)
              self.assertEqual(tensor.dtype, proto_dtype)
              self.assertTrue(np.array_equal(arr, tensor.numpy()))
  
      def test_dtype_base(self):
          print("Test_dtype")
          self.check_to_tesnsor_and_numpy('bool', core.VarDesc.VarType.BOOL)
          self.check_to_tesnsor_and_numpy('int8', core.VarDesc.VarType.INT8)
          self.check_to_tesnsor_and_numpy('uint8', core.VarDesc.VarType.UINT8)
          self.check_to_tesnsor_and_numpy('int16', core.VarDesc.VarType.INT16)
          self.check_to_tesnsor_and_numpy('int32', core.VarDesc.VarType.INT32)
          self.check_to_tesnsor_and_numpy('int64', core.VarDesc.VarType.INT64)
          self.check_to_tesnsor_and_numpy('float16', core.VarDesc.VarType.FP16)
          self.check_to_tesnsor_and_numpy('float32', core.VarDesc.VarType.FP32)
          self.check_to_tesnsor_and_numpy('float64', core.VarDesc.VarType.FP64)
          self.check_to_tesnsor_and_numpy('complex64',
                                          core.VarDesc.VarType.COMPLEX64)
          self.check_to_tesnsor_and_numpy('complex128',
                                          core.VarDesc.VarType.COMPLEX128)
  
  
  class EagerTensorPropertiesTestCase(unittest.TestCase):
      def constructor(self, place):
          egr_tensor = core.eager.EagerTensor()
          self.assertEqual(egr_tensor.persistable, False)
          self.assertTrue("generated" in egr_tensor.name)
          self.assertEqual(egr_tensor.shape, [])
          self.assertEqual(egr_tensor.dtype, core.VarDesc.VarType.FP32)
          self.assertEqual(egr_tensor.stop_gradient, True)
  
          egr_tensor0 = core.eager.EagerTensor(
              core.VarDesc.VarType.FP32, [4, 16, 16, 32], "test_eager_tensor",
              core.VarDesc.VarType.LOD_TENSOR, True)
          self.assertEqual(egr_tensor0.persistable, True)
          self.assertEqual(egr_tensor0.name, "test_eager_tensor")
          self.assertEqual(egr_tensor0.shape, [4, 16, 16, 32])
          self.assertEqual(egr_tensor0.dtype, core.VarDesc.VarType.FP32)
  
          arr0 = np.random.rand(4, 16, 16, 32).astype('float32')
          egr_tensor1 = core.eager.EagerTensor(arr0, place, True, False,
                                               "numpy_tensor1", False)
          self.assertEqual(egr_tensor1.persistable, True)
          self.assertEqual(egr_tensor1.name, "numpy_tensor1")
          self.assertEqual(egr_tensor1.shape, [4, 16, 16, 32])
          self.assertEqual(egr_tensor1.dtype, core.VarDesc.VarType.FP32)
          self.assertEqual(egr_tensor1.stop_gradient, False)
          self.assertTrue(egr_tensor1.place._equals(place))
          self.assertTrue(np.array_equal(egr_tensor1.numpy(), arr0))
  
          arr1 = np.random.randint(100, size=(4, 16, 16, 32), dtype=np.int64)
          egr_tensor2 = core.eager.EagerTensor(arr1, place, False, True,
                                               "numpy_tensor2", True)
          self.assertEqual(egr_tensor2.persistable, False)
          self.assertEqual(egr_tensor2.name, "numpy_tensor2")
          self.assertEqual(egr_tensor2.shape, [4, 16, 16, 32])
          self.assertEqual(egr_tensor2.dtype, core.VarDesc.VarType.INT64)
          self.assertEqual(egr_tensor2.stop_gradient, True)
          self.assertTrue(egr_tensor2.place._equals(place))
          self.assertTrue(np.array_equal(egr_tensor2.numpy(), arr1))
  
          arr2 = np.random.rand(4, 16, 16, 32, 64).astype('float32')
          egr_tensor3 = core.eager.EagerTensor(arr2)
          self.assertEqual(egr_tensor3.persistable, False)
          self.assertTrue("generated_tensor" in egr_tensor3.name)
          self.assertEqual(egr_tensor3.shape, [4, 16, 16, 32, 64])
          self.assertEqual(egr_tensor3.dtype, core.VarDesc.VarType.FP32)
          self.assertEqual(egr_tensor3.stop_gradient, True)
          self.assertTrue(
              egr_tensor3.place._equals(
                  paddle.fluid.framework._current_expected_place()))
          self.assertTrue(np.array_equal(egr_tensor3.numpy(), arr2))
  
          egr_tensor3.stop_gradient = False
          egr_tensor4 = core.eager.EagerTensor(egr_tensor3)
          self.assertEqual(egr_tensor4.persistable, False)
          self.assertTrue("generated_tensor" in egr_tensor4.name)
          self.assertEqual(egr_tensor4.shape, egr_tensor3.shape)
          self.assertEqual(egr_tensor4.dtype, egr_tensor3.dtype)
          self.assertEqual(egr_tensor4.stop_gradient, True)
          self.assertTrue(
              egr_tensor4.place._equals(
                  paddle.fluid.framework._current_expected_place()))
          self.assertTrue(
              np.array_equal(egr_tensor4.numpy(), egr_tensor3.numpy()))
  
          arr4 = np.random.rand(4, 16, 16, 32).astype('float32')
          egr_tensor5 = core.eager.EagerTensor(arr4, place)
          self.assertEqual(egr_tensor5.persistable, False)
          self.assertTrue("generated_tensor" in egr_tensor5.name)
          self.assertEqual(egr_tensor5.shape, [4, 16, 16, 32])
          self.assertEqual(egr_tensor5.dtype, core.VarDesc.VarType.FP32)
          self.assertEqual(egr_tensor5.stop_gradient, True)
          self.assertTrue(egr_tensor5.place._equals(place))
          self.assertTrue(np.array_equal(egr_tensor5.numpy(), arr4))
  
          egr_tensor6 = core.eager.EagerTensor(egr_tensor5, core.CPUPlace())
          self.assertEqual(egr_tensor6.persistable, False)
          self.assertTrue("generated_tensor" in egr_tensor6.name)
          self.assertEqual(egr_tensor6.shape, [4, 16, 16, 32])
          self.assertEqual(egr_tensor6.dtype, core.VarDesc.VarType.FP32)
          self.assertEqual(egr_tensor6.stop_gradient, True)
          self.assertEqual(egr_tensor6.place.is_cpu_place(), True)
          self.assertTrue(
              np.array_equal(egr_tensor6.numpy(), egr_tensor5.numpy()))
  
          egr_tensor7 = core.eager.EagerTensor(arr4, place, True)
          self.assertEqual(egr_tensor7.persistable, True)
          self.assertTrue("generated_tensor" in egr_tensor7.name)
          self.assertEqual(egr_tensor7.shape, [4, 16, 16, 32])
          self.assertEqual(egr_tensor7.dtype, core.VarDesc.VarType.FP32)
          self.assertEqual(egr_tensor7.stop_gradient, True)
          self.assertTrue(egr_tensor7.place._equals(place))
          self.assertTrue(np.array_equal(egr_tensor7.numpy(), arr4))
  
          egr_tensor8 = core.eager.EagerTensor(egr_tensor6, place, "egr_tensor8")
          self.assertEqual(egr_tensor8.persistable, False)
          self.assertEqual(egr_tensor8.name, "egr_tensor8")
          self.assertEqual(egr_tensor8.shape, [4, 16, 16, 32])
          self.assertEqual(egr_tensor8.dtype, core.VarDesc.VarType.FP32)
          self.assertEqual(egr_tensor8.stop_gradient, True)
          self.assertTrue(egr_tensor8.place._equals(place))
          self.assertTrue(
              np.array_equal(egr_tensor8.numpy(), egr_tensor5.numpy()))
  
          egr_tensor9 = core.eager.EagerTensor(arr4, place, True, True)
          self.assertEqual(egr_tensor9.persistable, True)
          self.assertTrue("generated_tensor" in egr_tensor9.name)
          self.assertEqual(egr_tensor9.shape, [4, 16, 16, 32])
          self.assertEqual(egr_tensor9.dtype, core.VarDesc.VarType.FP32)
          self.assertEqual(egr_tensor9.stop_gradient, True)
          self.assertTrue(egr_tensor9.place._equals(place))
          self.assertTrue(np.array_equal(egr_tensor9.numpy(), arr4))
  
          x = np.random.rand(3, 3).astype('float32')
          t = paddle.fluid.Tensor()
          t.set(x, paddle.fluid.CPUPlace())
          egr_tensor10 = core.eager.EagerTensor(t, place)
          self.assertEqual(egr_tensor10.persistable, False)
          self.assertTrue("generated_tensor" in egr_tensor10.name)
          self.assertEqual(egr_tensor10.shape, [3, 3])
          self.assertEqual(egr_tensor10.dtype, core.VarDesc.VarType.FP32)
          self.assertEqual(egr_tensor10.stop_gradient, True)
          self.assertTrue(egr_tensor10.place._equals(place))
          self.assertTrue(np.array_equal(egr_tensor10.numpy(), x))
  
          egr_tensor11 = core.eager.EagerTensor(t, place, "framework_constructed")
          self.assertEqual(egr_tensor11.persistable, False)
          self.assertTrue("framework_constructed" in egr_tensor11.name)
          self.assertEqual(egr_tensor11.shape, [3, 3])
          self.assertEqual(egr_tensor11.dtype, core.VarDesc.VarType.FP32)
          self.assertEqual(egr_tensor11.stop_gradient, True)
          self.assertTrue(egr_tensor11.place._equals(place))
          self.assertTrue(np.array_equal(egr_tensor11.numpy(), x))
  
          egr_tensor12 = core.eager.EagerTensor(t)
          self.assertEqual(egr_tensor12.persistable, False)
          self.assertTrue("generated_tensor" in egr_tensor12.name)
          self.assertEqual(egr_tensor12.shape, [3, 3])
          self.assertEqual(egr_tensor12.dtype, core.VarDesc.VarType.FP32)
          self.assertEqual(egr_tensor12.stop_gradient, True)
          self.assertTrue(egr_tensor12.place._equals(paddle.fluid.CPUPlace()))
          self.assertTrue(np.array_equal(egr_tensor12.numpy(), x))
  
          with self.assertRaisesRegexp(
                  ValueError, "The shape of Parameter should not be None"):
              eager_param = EagerParamBase(shape=None, dtype="float32")
  
          with self.assertRaisesRegexp(
                  ValueError, "The dtype of Parameter should not be None"):
              eager_param = EagerParamBase(shape=[1, 1], dtype=None)
  
          with self.assertRaisesRegexp(
                  ValueError,
                  "The dimensions of shape for Parameter must be greater than 0"):
              eager_param = EagerParamBase(shape=[], dtype="float32")
  
          with self.assertRaisesRegexp(
                  ValueError,
                  "Each dimension of shape for Parameter must be greater than 0, but received /*"
          ):
              eager_param = EagerParamBase(shape=[-1], dtype="float32")
  
          eager_param = EagerParamBase(shape=[1, 1], dtype="float32")
          self.assertTrue(eager_param.trainable)
          eager_param.trainable = False
          self.assertFalse(eager_param.trainable)
          with self.assertRaisesRegexp(
                  ValueError,
                  "The type of trainable MUST be bool, but the type is /*"):
              eager_param.trainable = "False"
  
      def test_constructor(self):
          print("Test_constructor")
          paddle.set_device("cpu")
          place_list = [core.CPUPlace()]
          if core.is_compiled_with_cuda():
              place_list.append(core.CUDAPlace(0))
          with _test_eager_guard():
              for p in place_list:
                  self.constructor(p)
  
      def test_copy_and_copy_to(self):
          print("Test_copy_and_copy_to")
          with _test_eager_guard():
              paddle.set_device("cpu")
              arr = np.ones([4, 16, 16, 32]).astype('float32')
              arr1 = np.zeros([4, 16]).astype('float32')
              arr2 = np.ones([4, 16, 16, 32]).astype('float32') + np.ones(
                  [4, 16, 16, 32]).astype('float32')
              tensor = paddle.to_tensor(arr, core.VarDesc.VarType.FP32,
                                        core.CPUPlace())
              self.assertEqual(tensor.stop_gradient, True)
              tensor.stop_gradient = False
              print("Set persistable")
              tensor.persistable = False
              tensor1 = paddle.to_tensor(arr1, core.VarDesc.VarType.FP32,
                                         core.CPUPlace())
              tensor1.persistable = True
              self.assertEqual(tensor1.stop_gradient, True)
              self.assertTrue(np.array_equal(tensor.numpy(), arr))
              print("Test copy_")
              tensor.copy_(tensor1, True)
              self.assertEqual(tensor.persistable, True)
              self.assertEqual(tensor.shape, [4, 16])
              self.assertEqual(tensor.dtype, core.VarDesc.VarType.FP32)
              self.assertTrue(np.array_equal(tensor.numpy(), arr1))
  
              print("Test _copy_to")
              tensor2 = paddle.to_tensor(arr2, core.VarDesc.VarType.FP32,
                                         core.CPUPlace())
              self.assertTrue(np.array_equal(tensor2.numpy(), arr2))
              self.assertTrue(tensor2.place.is_cpu_place())
              tensor2.persistable = True
              tensor2.stop_gradient = False
              if core.is_compiled_with_cuda():
                  tensor3 = tensor2._copy_to(True, core.CUDAPlace(0))
                  self.assertTrue(np.array_equal(tensor3.numpy(), arr2))
                  self.assertTrue(tensor3.persistable, True)
                  self.assertTrue(tensor3.stop_gradient, True)
                  self.assertTrue(tensor3.place.is_gpu_place())
              else:
                  tensor3 = tensor2._copy_to(True, core.CPUPlace())
                  self.assertTrue(np.array_equal(tensor3.numpy(), arr2))
                  self.assertTrue(tensor3.persistable, True)
                  self.assertTrue(tensor3.stop_gradient, True)
                  self.assertTrue(tensor3.place.is_cpu_place())
  
      def test_properties(self):
          print("Test_properties")
          with _test_eager_guard():
              paddle.set_device("cpu")
              arr = np.ones([4, 16, 16, 32]).astype('float32')
              tensor = paddle.to_tensor(arr, core.VarDesc.VarType.FP32,
                                        core.CPUPlace())
              self.assertEqual(tensor.shape, [4, 16, 16, 32])
              tensor.name = 'tensor_name_test'
              self.assertEqual(tensor.name, 'tensor_name_test')
              self.assertEqual(tensor.persistable, False)
              tensor.persistable = True
              self.assertEqual(tensor.persistable, True)
              tensor.persistable = False
              self.assertEqual(tensor.persistable, False)
              self.assertTrue(tensor.place.is_cpu_place())
              self.assertEqual(tensor._place_str, 'CPUPlace')
              self.assertEqual(tensor.stop_gradient, True)
              tensor.stop_gradient = False
              self.assertEqual(tensor.stop_gradient, False)
              tensor.stop_gradient = True
              self.assertEqual(tensor.stop_gradient, True)
  
      def test_global_properties(self):
          print("Test_global_properties")
          self.assertFalse(core._in_eager_mode())
          with _test_eager_guard():
              self.assertTrue(core._in_eager_mode())
          self.assertFalse(core._in_eager_mode())
  
      def test_place_guard(self):
          core._enable_eager_mode()
          if core.is_compiled_with_cuda():
              paddle.set_device("gpu:0")
              with paddle.fluid.framework._dygraph_place_guard(core.CPUPlace()):
                  self.assertTrue(core.eager._get_expected_place().is_cpu_place())
          else:
              paddle.set_device("cpu")
              with paddle.fluid.framework._dygraph_place_guard(core.CPUPlace()):
                  self.assertTrue(core.eager._get_expected_place().is_cpu_place())
          core._disable_eager_mode()
  
  
  class EagerParamBaseUsageTestCase(unittest.TestCase):
      def test_print(self):
          with _test_eager_guard():
              linear = paddle.nn.Linear(3, 3, bias_attr=False)
              print(linear.weight)
  
      def test_copy(self):
          with _test_eager_guard():
              linear = paddle.nn.Linear(1, 3)
              linear_copy = copy.deepcopy(linear)
              linear_copy2 = linear.weight._copy_to(core.CPUPlace(), True)
              self.assertTrue(
                  np.array_equal(linear.weight.numpy(),
                                 linear_copy.weight.numpy()))
              self.assertTrue(
                  np.array_equal(linear.weight.numpy(), linear_copy2.numpy()))
  
      def func_fp16_initilaizer(self):
          paddle.set_default_dtype("float16")
          linear1 = paddle.nn.Linear(1, 3, bias_attr=False)
          linear2 = paddle.nn.Linear(
              1,
              3,
              bias_attr=False,
              weight_attr=paddle.fluid.initializer.Uniform())
          linear3 = paddle.nn.Linear(
              1,
              3,
              bias_attr=False,
              weight_attr=paddle.fluid.initializer.TruncatedNormalInitializer())
          linear4 = paddle.nn.Linear(
              1,
              3,
              bias_attr=False,
              weight_attr=paddle.fluid.initializer.MSRAInitializer())
          res = [
              linear1.weight.numpy(), linear2.weight.numpy(),
              linear3.weight.numpy(), linear4.weight.numpy()
          ]
          paddle.set_default_dtype("float32")
          return res
  
      def test_fp16_initializer(self):
          res1 = list()
          res2 = list()
          paddle.seed(102)
          paddle.framework.random._manual_program_seed(102)
          with _test_eager_guard():
              res1 = self.func_fp16_initilaizer()
          res2 = self.func_fp16_initilaizer()
  
          for i in range(len(res1)):
              self.assertTrue(np.array_equal(res1[i], res2[i]))
  
      def func_layer_helper_base(self, value):
          base = paddle.fluid.layer_helper_base.LayerHelperBase("test_layer",
                                                                "test_layer")
          return base.to_variable(value).numpy()
  
      def func_base_to_variable(self, value):
          paddle.fluid.dygraph.base.to_variable(value)
  
      def test_to_variable(self):
          value = np.random.rand(4, 16, 16, 32).astype('float32')
          res1 = None
          res3 = None
          with _test_eager_guard():
              res1 = self.func_layer_helper_base(value)
              res3 = self.func_base_to_variable(value)
          res2 = self.func_layer_helper_base(value)
          res4 = self.func_base_to_variable(value)
          self.assertTrue(np.array_equal(res1, res2))
          self.assertTrue(np.array_equal(res3, res4))
  
      def test_backward_with_single_tensor(self):
          arr4 = np.random.rand(4, 16, 16, 32).astype('float32')
          egr_tensor12 = core.eager.EagerTensor(arr4, core.CPUPlace())
          egr_tensor12.retain_grads()
          arr = np.ones([4, 16, 16, 32]).astype('float32')
          self.assertEqual(egr_tensor12.persistable, False)
          self.assertTrue("generated_tensor" in egr_tensor12.name)
          self.assertEqual(egr_tensor12.shape, [4, 16, 16, 32])
          self.assertEqual(egr_tensor12.dtype, core.VarDesc.VarType.FP32)
          self.assertEqual(egr_tensor12.stop_gradient, True)
          self.assertTrue(egr_tensor12.place._equals(paddle.fluid.CPUPlace()))
          self.assertTrue(np.array_equal(egr_tensor12.numpy(), arr4))
          self.assertTrue(np.array_equal(egr_tensor12.gradient(), None))
          egr_tensor12.backward()
          self.assertTrue(np.array_equal(egr_tensor12.gradient(), arr))
  
  
  class EagerGuardTestCase(unittest.TestCase):
      def test__test_eager_guard(self):
          tracer = paddle.fluid.dygraph.tracer.Tracer()
          with _test_eager_guard(tracer):
              self.assertTrue(_in_eager_mode())
  
  
  if __name__ == "__main__":
      unittest.main()
  
apis: numpy.ones numpy.zeros numpy.random.random numpy.random.rand numpy.array_equal numpy.random.randint