[IPU] update ipu unittests p0 (#39707)

* update ipu UTs part0 * rename UT * sync api changes * update uts for new api * use_ipumodel() as classmethod

Author: gglin001

python/paddle/fluid/tests/unittests/ipu/ernie_training.py

@@ -12,17 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import os
 import random
 import unittest
-
 import numpy as np
-from paddle.fluid.tests.unittests.op_test import _set_use_system_allocator
-from typing import Optional
-import paddle.fluid.compiler as compiler
-
-SEED = 2021
+from enum import Enum
 
-ipu_compiler_ref: Optional[compiler.IPUCompiledProgram] = None
+import paddle
+import paddle.static
 
 map_np_dtype_to_fluid_dtype = {
  'bool': "bool",
@@ -36,36 +33,84 @@
 }
 
 
+class ExecutionMode(Enum):
+ CPU_FP32 = 1
+ IPU_FP32 = 2
+ # enable_fp16 through ipu_strategy.enable_fp16
+ IPU_POPART_FP16 = 3
+
+ def __lt__(self, other):
+ return self.value < other.value
+
+ def __gt__(self, other):
+ return self.value > other.value
+
+
 def np_dtype_to_fluid_str(dtype: np.dtype) -> str:
  return map_np_dtype_to_fluid_dtype[dtype.name]
 
 
 class IPUOpTest(unittest.TestCase):
  @classmethod
  def setUpClass(cls):
+ # Get random seeds
  cls._np_rand_state = np.random.get_state()
  cls._py_rand_state = random.getstate()
 
- cls.SEED = SEED
+ cls.SEED = 2021
  np.random.seed(cls.SEED)
  random.seed(cls.SEED)
 
- cls._use_system_allocator = _set_use_system_allocator(True)
+ # Enable paddle static graph mode
+ paddle.enable_static()
 
  @classmethod
  def tearDownClass(cls):
  """Restore random seeds"""
  np.random.set_state(cls._np_rand_state)
  random.setstate(cls._py_rand_state)
 
- _set_use_system_allocator(cls._use_system_allocator)
- # unittest will to trigger IPUCompiledProgram.__del__ automatically
- global ipu_compiler_ref
- ipu_compiler_ref is not None and ipu_compiler_ref.clean()
+ @classmethod
+ def use_ipumodel(cls):
+ if 'POPLAR_IPUMODEL' not in os.environ:
+ return False
+ else:
+ flag = os.environ['POPLAR_IPUMODEL']
+ if flag.upper() in ['1', "TRUE"]:
+ return True
 
  def set_atol(self):
- self.atol = 1e-5
+ self.atol = 1e-10
+ self.rtol = 1e-6
+ self.atol_fp16 = 1e-3
+ self.rtol_fp16 = 1e-3
 
  def set_training(self):
  self.is_training = False
  self.epoch = 1
+
+ def check(self, outputs, check_shape=False):
+ cpu_fp32 = outputs[ExecutionMode.CPU_FP32]
+ ipu_fp32 = outputs[ExecutionMode.IPU_FP32]
+ max_diff = np.abs(cpu_fp32 - ipu_fp32).max()
+ fp32_flag = np.allclose(
+ cpu_fp32, ipu_fp32, rtol=self.rtol, atol=self.atol)
+ self.assertTrue(fp32_flag, "max diff is %f" % (max_diff))
+
+ if check_shape:
+ self.assertTrue(cpu_fp32.shape == ipu_fp32.shape)
+
+ ipu_popart_fp16 = None
+ if ExecutionMode.IPU_POPART_FP16 in outputs.keys():
+ ipu_popart_fp16 = outputs[ExecutionMode.IPU_POPART_FP16]
+ max_diff = np.abs(ipu_popart_fp16.astype(np.float32) -
+ cpu_fp32).max()
+ fp16_flag = np.allclose(
+ ipu_popart_fp16.astype(np.float32),
+ cpu_fp32,
+ rtol=self.rtol_fp16,
+ atol=self.atol_fp16)
+ self.assertTrue(fp16_flag, "max diff is %f" % (max_diff))
+
+ if check_shape:
+ self.assertTrue(ipu_popart_fp16.shape == cpu_fp32.shape)

python/paddle/fluid/tests/unittests/ipu/op_test_ipu.py

@@ -0,0 +1,133 @@
+# Copyright (c) 2022 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 unittest
+
+import numpy as np
+import paddle
+import paddle.nn.functional as F
+import paddle.static
+from paddle.fluid.tests.unittests.ipu.op_test_ipu import (ExecutionMode,
+ IPUOpTest)
+
+
+@unittest.skipIf(not paddle.is_compiled_with_ipu(),
+ "core is not compiled with IPU")
+class TestRelu(IPUOpTest):
+ def setUp(self):
+ self.set_atol()
+ self.set_test_op()
+ self.set_training()
+ self.set_data_feed()
+ self.set_feed_attr()
+
+ @property
+ def fp16_enabled(self):
+ return True
+
+ def set_test_op(self):
+ self.op = paddle.fluid.layers.relu
+ self.op_attrs = {}
+
+ def set_data_feed(self):
+ data = np.random.uniform(size=[1, 3, 10, 10])
+ self.feed_fp32 = {'in_0': data.astype(np.float32)}
+ self.feed_fp16 = {'in_0': data.astype(np.float16)}
+
+ def set_feed_attr(self):
+ self.feed_shape = [x.shape for x in self.feed_fp32.values()]
+ self.feed_list = list(self.feed_fp32.keys())
+
+ def _test_base(self, exec_mode):
+ scope = paddle.static.Scope()
+ main_prog = paddle.static.Program()
+ startup_prog = paddle.static.Program()
+ main_prog.random_seed = self.SEED
+ startup_prog.random_seed = self.SEED
+
+ with paddle.static.scope_guard(scope):
+ with paddle.static.program_guard(main_prog, startup_prog):
+ x = paddle.static.data(
+ name=self.feed_list[0],
+ shape=self.feed_shape[0],
+ dtype='float32')
+
+ out = self.op(x, **self.op_attrs)
+
+ fetch_list = [out.name]
+
+ if exec_mode == ExecutionMode.CPU_FP32:
+ place = paddle.CPUPlace()
+ else:
+ place = paddle.IPUPlace()
+
+ exe = paddle.static.Executor(place)
+ exe.run(startup_prog)
+
+ if exec_mode != ExecutionMode.CPU_FP32:
+ feed_list = self.feed_list
+ ipu_strategy = paddle.static.IpuStrategy()
+
+ ipu_strategy.set_graph_config(is_training=self.is_training)
+ if exec_mode == ExecutionMode.IPU_POPART_FP16:
+ ipu_strategy.set_precision_config(enable_fp16=True)
+ program = paddle.static.IpuCompiledProgram(
+ main_prog,
+ ipu_strategy=ipu_strategy).compile(feed_list, fetch_list)
+ else:
+ program = main_prog
+
+ feed = self.feed_fp32
+ if exec_mode > ExecutionMode.IPU_FP32:
+ feed = self.feed_fp16
+
+ result = exe.run(program, feed=feed, fetch_list=fetch_list)
+ return result[0]
+
+ def test(self):
+ output_dict = {}
+ for mode in ExecutionMode:
+ if mode > ExecutionMode.IPU_FP32 and not self.fp16_enabled:
+ break
+ output_dict[mode] = self._test_base(mode).flatten()
+
+ self.check(output_dict)
+
+
+class TestTanh(TestRelu):
+ def set_test_op(self):
+ self.op = F.tanh
+ self.op_attrs = {}
+
+
+class TestLog(TestRelu):
+ def set_test_op(self):
+ self.op = paddle.fluid.layers.log
+ self.op_attrs = {}
+
+
+class TestSigmoid(TestRelu):
+ def set_test_op(self):
+ self.op = F.sigmoid
+ self.op_attrs = {}
+
+
+class TestSqrt(TestRelu):
+ def set_test_op(self):
+ self.op = paddle.fluid.layers.sqrt
+ self.op_attrs = {}
+
+
+if __name__ == "__main__":
+ unittest.main()

python/paddle/fluid/tests/unittests/ipu/test_activation_x_op_ipu.py

@@ -0,0 +1,117 @@
+# Copyright (c) 2022 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 unittest
+
+import numpy as np
+import paddle
+import paddle.static
+from paddle.fluid.tests.unittests.ipu.op_test_ipu import (ExecutionMode,
+ IPUOpTest)
+
+
+@unittest.skipIf(not paddle.is_compiled_with_ipu(),
+ "core is not compiled with IPU")
+class TestBase(IPUOpTest):
+ def setUp(self):
+ self.set_atol()
+ self.set_training()
+ self.set_data_feed()
+ self.set_feed_attr()
+ self.set_op_attrs()
+
+ @property
+ def fp16_enabled(self):
+ return True
+
+ def set_data_feed(self):
+ data = np.random.uniform(size=[10, 1000])
+ self.feed_fp32 = {"in_0": data.astype(np.float32)}
+ self.feed_fp16 = {"in_0": data.astype(np.float16)}
+
+ def set_feed_attr(self):
+ self.feed_shape = [x.shape for x in self.feed_fp32.values()]
+ self.feed_list = list(self.feed_fp32.keys())
+ self.feed_dtype = [x.dtype for x in self.feed_fp32.values()]
+
+ def set_op_attrs(self):
+ self.attrs = {"axis": -1}
+
+ def _test_base(self, exec_mode):
+ scope = paddle.static.Scope()
+ main_prog = paddle.static.Program()
+ startup_prog = paddle.static.Program()
+ main_prog.random_seed = self.SEED
+ startup_prog.random_seed = self.SEED
+
+ with paddle.static.scope_guard(scope):
+ with paddle.static.program_guard(main_prog, startup_prog):
+ x = paddle.static.data(
+ name=self.feed_list[0],
+ shape=self.feed_shape[0],
+ dtype='float32')
+
+ out = paddle.fluid.layers.argmax(x, **self.attrs)
+
+ fetch_list = [out.name]
+
+ if exec_mode == ExecutionMode.CPU_FP32:
+ place = paddle.CPUPlace()
+ else:
+ place = paddle.IPUPlace()
+
+ exe = paddle.static.Executor(place)
+ exe.run(startup_prog)
+
+ if exec_mode != ExecutionMode.CPU_FP32:
+ feed_list = self.feed_list
+ ipu_strategy = paddle.static.IpuStrategy()
+ ipu_strategy.set_graph_config(is_training=self.is_training)
+ if exec_mode == ExecutionMode.IPU_POPART_FP16:
+ ipu_strategy.set_precision_config(enable_fp16=True)
+ program = paddle.static.IpuCompiledProgram(
+ main_prog,
+ ipu_strategy=ipu_strategy).compile(feed_list, fetch_list)
+ else:
+ program = main_prog
+
+ feed = self.feed_fp32
+ if exec_mode > ExecutionMode.IPU_FP32:
+ feed = self.feed_fp16
+
+ result = exe.run(program, feed=feed, fetch_list=fetch_list)
+ return result[0].astype(np.int32)
+
+ def test_base(self):
+ output_dict_fp32 = {}
+ output_dict_fp16 = {}
+ for mode in ExecutionMode:
+ if mode > ExecutionMode.IPU_FP32 and not self.fp16_enabled:
+ break
+
+ if mode > ExecutionMode.IPU_FP32:
+ output_dict_fp16[mode] = self._test_base(mode).flatten()
+ else:
+ output_dict_fp32[mode] = self._test_base(mode).flatten()
+
+ self.check(output_dict_fp32)
+
+
+class TestCase1(TestBase):
+ def set_op_attrs(self):
+ self.attrs = {"axis": 0}
+
+
+if __name__ == "__main__":
+ unittest.main()