diff --git a/framework/api/nn/test_birnn.py b/framework/api/nn/test_birnn.py
new file mode 100644
index 0000000000..45d5f8a52a
--- /dev/null
+++ b/framework/api/nn/test_birnn.py
@@ -0,0 +1,365 @@
+#!/bin/env python
+# -*- coding: utf-8 -*-
+# encoding=utf-8 vi:ts=4:sw=4:expandtab:ft=python
+"""
+paddle.nn.RNN float32测试
+"""
+import copy
+
+from apibase import APIBase, compare
+import paddle
+import pytest
+import numpy as np
+
+from rnn_numpy import SimpleRNNCell, BiRNN
+
+
+class TestBiRNN(APIBase):
+ """
+ test RNN float32
+ """
+
+ def hook(self):
+ """
+ implement
+ """
+ self.types = [np.float32]
+ self.seed = 100
+ self.delta = 0.0001
+ self.forward_kwargs = {} # 前向传播参数
+ paddle.set_default_dtype("float32")
+
+ def _static_forward(self, res, data=None, **kwargs):
+ """
+ _static_forward
+ """
+
+ main_program = paddle.static.Program()
+ startup_program = paddle.static.Program()
+ main_program.random_seed = self.seed
+
+ cell_fw = kwargs["cell_fw"]
+ cell_bw = kwargs["cell_bw"]
+
+ with paddle.utils.unique_name.guard():
+ with paddle.static.program_guard(main_program=main_program, startup_program=startup_program):
+ if data is not None:
+ data = data.astype(self.dtype)
+ self.data = paddle.static.data(name="data", shape=data.shape, dtype=self.dtype)
+ self.data.stop_gradient = False
+ data = dict({"data": data}, **kwargs)
+
+ static_cell_fw = paddle.nn.SimpleRNNCell(cell_fw.input_size, cell_fw.hidden_size)
+ static_cell_bw = paddle.nn.SimpleRNNCell(cell_bw.input_size, cell_bw.hidden_size)
+
+ parameters_fw = {}
+ for k, v in kwargs["cell_fw"].named_parameters():
+ parameters_fw[k] = v
+
+ parameters_bw = {}
+ for k, v in kwargs["cell_bw"].named_parameters():
+ parameters_bw[k] = v
+
+ obj = self.func(
+ cell_fw=static_cell_fw, cell_bw=static_cell_bw, time_major=self.kwargs.get("time_major", False)
+ )
+
+ output, h = obj(self.data)
+
+ if self.enable_backward:
+ loss = paddle.mean(output)
+ g = paddle.static.gradients(loss, self.data)
+ exe = paddle.static.Executor(self.place)
+ exe.run(startup_program)
+
+ for k, v in static_cell_fw.named_parameters():
+ v.set_value(parameters_fw[k])
+ for k, v in static_cell_bw.named_parameters():
+ v.set_value(parameters_bw[k])
+
+ res = exe.run(main_program, feed=data, fetch_list=[output, h, g], return_numpy=True)
+ grad = {"data": res[3]}
+ return res[0], grad
+ else:
+ exe = paddle.static.Executor(self.place)
+ exe.run(startup_program)
+
+ for k, v in static_cell_fw.named_parameters():
+ v.set_value(parameters_fw[k])
+ for k, v in static_cell_bw.named_parameters():
+ v.set_value(parameters_bw[k])
+
+ res = exe.run(main_program, feed=data, fetch_list=[output, h], return_numpy=True)
+ return res[0]
+
+ def _dygraph_forward(self):
+ """
+ _dygraph_forward
+ """
+ cell_fw = copy.deepcopy(self.kwargs.get("cell_fw"))
+ cell_bw = copy.deepcopy(self.kwargs.get("cell_bw"))
+ obj = self.func(cell_fw=cell_fw, cell_bw=cell_bw, time_major=self.kwargs.get("time_major", False))
+ res = obj(
+ self.data,
+ initial_states=self.forward_kwargs.get("initial_states", None),
+ sequence_length=self.forward_kwargs.get("sequence_length", None),
+ )
+ return res[0]
+
+
+obj = TestBiRNN(paddle.nn.BiRNN)
+
+
+class TestBiRNN64(TestBiRNN):
+ """
+ test RNN float64
+ """
+
+ def hook(self):
+ """
+ implement
+ """
+ self.types = [np.float64]
+ self.seed = 100
+ self.delta = 0.0001
+ self.forward_kwargs = {} # 前向传播参数
+ paddle.set_default_dtype("float64")
+
+
+obj64 = TestBiRNN64(paddle.nn.BiRNN)
+
+
+def copy_cell_params(np_cell, paddle_cell, dtype="float32"):
+ """
+ 将np_cell的参数复制到paddle_cell中
+ """
+ paddle.disable_static()
+ state = np_cell.parameters
+ for k, v in paddle_cell.named_parameters():
+ t = state[k].astype(dtype)
+ v.set_value(t)
+ return paddle_cell
+
+
+def create_cell(input_size, hidden_size, dtype="float32"):
+ """
+ 创建RNNCell，保证numpy版本和Paddle初始化参数相同。
+ """
+ np_cell_fw = SimpleRNNCell(input_size, hidden_size)
+ np_cell_bw = SimpleRNNCell(input_size, hidden_size)
+ paddle_cell_fw = paddle.nn.SimpleRNNCell(input_size, hidden_size)
+ paddle_cell_bw = paddle.nn.SimpleRNNCell(input_size, hidden_size)
+
+ paddle_cell_fw = copy_cell_params(np_cell_fw, paddle_cell_fw, dtype)
+ paddle_cell_bw = copy_cell_params(np_cell_bw, paddle_cell_bw, dtype)
+
+ return np_cell_fw, np_cell_bw, paddle_cell_fw, paddle_cell_bw
+
+
+@pytest.mark.api_nn_RNN_vartype
+def test_rnn_base():
+ """
+ base测试，包括动态度、静态图、cpu/gpu，grad，动态静态图的结果一致性
+ """
+ paddle.set_default_dtype("float32")
+ np.random.seed(obj.seed)
+ inputs = np.random.random((3, 3, 4))
+ np_cell_fw, np_cell_bw, paddle_cell_fw, paddle_cell_bw = create_cell(4, 8)
+ rnn = BiRNN(cell_fw=np_cell_fw, cell_bw=np_cell_bw)
+ res_outputs = rnn(inputs)[0]
+ res = res_outputs.astype("float32")
+ obj.base(res, data=inputs, cell_fw=paddle_cell_fw, cell_bw=paddle_cell_bw)
+
+
+@pytest.mark.api_nn_RNN_parameters
+def test_rnn1():
+ """
+ float32默认参数测试。
+ time_major=False,
+ RnnCell size = (16, 32)
+ """
+ paddle.set_default_dtype("float32")
+ paddle.disable_static()
+ # numpy
+ np.random.seed(obj.seed)
+ inputs = np.random.random((10, 8, 16))
+ np_cell_fw, np_cell_bw, paddle_cell_fw, paddle_cell_bw = create_cell(16, 32)
+ rnn = BiRNN(cell_fw=np_cell_fw, cell_bw=np_cell_bw)
+ res_outputs = rnn(inputs)[0]
+ res = res_outputs.astype("float32")
+ obj.run(res, data=inputs, cell_fw=paddle_cell_fw, cell_bw=paddle_cell_bw)
+
+
+@pytest.mark.api_nn_RNN_parameters
+def test_rnn2():
+ """
+ time_major=True
+ """
+ paddle.set_default_dtype("float32")
+ paddle.disable_static()
+ # numpy
+ np.random.seed(obj.seed)
+ inputs = np.random.random((10, 4, 128))
+ np_cell_fw, np_cell_bw, paddle_cell_fw, paddle_cell_bw = create_cell(128, 32)
+ rnn = BiRNN(cell_fw=np_cell_fw, cell_bw=np_cell_bw, time_major=True)
+ res_outputs = rnn(inputs)[0]
+ res = res_outputs.astype("float32")
+ obj.run(res, data=inputs, cell_fw=paddle_cell_fw, cell_bw=paddle_cell_bw, time_major=True)
+
+
+def test_rnn3():
+ """
+ 带初始化状态测试, 带有initial_states
+ """
+ dtype = "float32"
+ paddle.set_default_dtype(dtype)
+ paddle.disable_static()
+ # numpy
+ np.random.seed(obj.seed)
+ inputs = np.random.random((10, 8, 16))
+ initial_states0 = np.random.random((10, 32))
+ initial_states1 = np.random.random((10, 32))
+ initial_states = [initial_states0, initial_states1]
+ np_cell_fw, np_cell_bw, paddle_cell_fw, paddle_cell_bw = create_cell(16, 32, dtype=dtype)
+ np_rnn = BiRNN(cell_fw=np_cell_fw, cell_bw=np_cell_bw)
+ np_outputs = np_rnn(inputs, initial_states=initial_states)[0].astype(dtype)
+
+ paddle_rnn = paddle.nn.BiRNN(cell_fw=paddle_cell_fw, cell_bw=paddle_cell_bw)
+ initial_states = [paddle.to_tensor(t, dtype=dtype) for t in initial_states]
+ paddle_outputs = paddle_rnn(paddle.to_tensor(inputs, dtype=dtype), initial_states=initial_states)[0]
+
+ compare(expect=np_outputs, result=paddle_outputs.numpy(), delta=obj.delta, rtol=obj.rtol)
+
+
+@pytest.mark.api_nn_RNN_parameters
+def test_rnn4():
+ """
+ float32 异常测试，fw_cell和bw_cell尺寸不同
+ """
+ paddle.set_default_dtype("float32")
+ paddle.disable_static()
+ # numpy
+ np.random.seed(obj64.seed)
+ inputs = np.random.random((10, 4, 128))
+
+ paddle_cell_fw = paddle.nn.SimpleRNNCell(4, 16)
+ paddle_cell_bw = paddle.nn.SimpleRNNCell(8, 16)
+
+ obj.exception(etype=ValueError, mode="python", data=inputs, cell_fw=paddle_cell_fw, cell_bw=paddle_cell_bw)
+
+
+@pytest.mark.api_nn_RNN_vartype
+def test_rnn_base_64():
+ """
+ float64 base测试，包括动态度、静态图、cpu/gpu，grad，动态静态图的结果一致性
+ """
+ paddle.disable_static()
+ paddle.set_default_dtype("float64")
+ np.random.seed(obj64.seed)
+ inputs = np.random.random((3, 3, 4))
+ np_cell_fw, np_cell_bw, paddle_cell_fw, paddle_cell_bw = create_cell(4, 8, dtype="float64")
+ rnn = BiRNN(cell_fw=np_cell_fw, cell_bw=np_cell_bw)
+ res_outputs = rnn(inputs)[0]
+ res = res_outputs.astype(np.float64)
+ obj64.base(res, data=inputs, cell_fw=paddle_cell_fw, cell_bw=paddle_cell_bw)
+
+
+@pytest.mark.api_nn_RNN_parameters
+def test_rnn1_64():
+ """
+ float64默认参数测试。
+ time_major=False
+ RnnCell size = (16, 32)
+ """
+ paddle.set_default_dtype("float64")
+ paddle.disable_static()
+ # numpy
+ np.random.seed(obj64.seed)
+ inputs = np.random.random((10, 8, 16))
+ np_cell_fw, np_cell_bw, paddle_cell_fw, paddle_cell_bw = create_cell(16, 32, dtype="float64")
+ rnn = BiRNN(cell_fw=np_cell_fw, cell_bw=np_cell_bw)
+ res_outputs = rnn(inputs)[0]
+ res = res_outputs.astype(np.float64)
+ obj64.run(res, data=inputs, cell_fw=paddle_cell_fw, cell_bw=paddle_cell_bw)
+
+
+@pytest.mark.api_nn_RNN_parameters
+def test_rnn2_64():
+ """
+ time_major=True
+ """
+ paddle.set_default_dtype("float64")
+ paddle.disable_static()
+ # numpy
+ np.random.seed(obj64.seed)
+ inputs = np.random.random((10, 4, 128))
+ np_cell_fw, np_cell_bw, paddle_cell_fw, paddle_cell_bw = create_cell(128, 32, dtype="float64")
+ rnn = BiRNN(cell_fw=np_cell_fw, cell_bw=np_cell_bw, time_major=True)
+ res_outputs = rnn(inputs)[0]
+ res = res_outputs.astype(np.float64)
+ obj64.run(res, data=inputs, cell_fw=paddle_cell_fw, cell_bw=paddle_cell_bw, time_major=True)
+
+
+def test_rnn3_64():
+ """
+ 带初始化状态测试, 带有initial_states, time_major=False
+ """
+ dtype = "float64"
+ paddle.set_default_dtype(dtype)
+ paddle.disable_static()
+ # numpy
+ np.random.seed(obj.seed)
+ inputs = np.random.random((10, 8, 16))
+ initial_states0 = np.random.random((10, 32))
+ initial_states1 = np.random.random((10, 32))
+ initial_states = [initial_states0, initial_states1]
+ np_cell_fw, np_cell_bw, paddle_cell_fw, paddle_cell_bw = create_cell(16, 32, dtype=dtype)
+ np_rnn = BiRNN(cell_fw=np_cell_fw, cell_bw=np_cell_bw)
+ np_outputs = np_rnn(inputs, initial_states=initial_states)[0].astype(dtype)
+
+ paddle_rnn = paddle.nn.BiRNN(cell_fw=paddle_cell_fw, cell_bw=paddle_cell_bw)
+ initial_states = [paddle.to_tensor(t, dtype=dtype) for t in initial_states]
+ paddle_outputs = paddle_rnn(paddle.to_tensor(inputs, dtype=dtype), initial_states=initial_states)[0]
+
+ compare(expect=np_outputs, result=paddle_outputs.numpy(), delta=obj.delta, rtol=obj.rtol)
+
+
+def test_rnn3_64():
+ """
+ 带初始化状态测试, 带有initial_states，time_major=False
+ """
+ dtype = "float64"
+ paddle.set_default_dtype(dtype)
+ paddle.disable_static()
+ # numpy
+ np.random.seed(obj.seed)
+ inputs = np.random.random((10, 8, 16))
+ initial_states0 = np.random.random((10, 32))
+ initial_states1 = np.random.random((10, 32))
+ initial_states = [initial_states0, initial_states1]
+ np_cell_fw, np_cell_bw, paddle_cell_fw, paddle_cell_bw = create_cell(16, 32, dtype=dtype)
+ np_rnn = BiRNN(cell_fw=np_cell_fw, cell_bw=np_cell_bw)
+ np_outputs = np_rnn(inputs, initial_states=initial_states)[0].astype(dtype)
+
+ paddle_rnn = paddle.nn.BiRNN(cell_fw=paddle_cell_fw, cell_bw=paddle_cell_bw)
+ initial_states = [paddle.to_tensor(t, dtype=dtype) for t in initial_states]
+ paddle_outputs = paddle_rnn(paddle.to_tensor(inputs, dtype=dtype), initial_states=initial_states)[0]
+
+ compare(expect=np_outputs, result=paddle_outputs.numpy(), delta=obj.delta, rtol=obj.rtol)
+
+
+@pytest.mark.api_nn_RNN_parameters
+def test_rnn4_64():
+ """
+ float64 异常测试，fw_cell和bw_cell尺寸不同
+ """
+ paddle.set_default_dtype("float64")
+ paddle.disable_static()
+ # numpy
+ np.random.seed(obj64.seed)
+ inputs = np.random.random((10, 4, 128))
+
+ paddle_cell_fw = paddle.nn.SimpleRNNCell(4, 16)
+ paddle_cell_bw = paddle.nn.SimpleRNNCell(8, 16)
+
+ obj.exception(etype=ValueError, mode="python", data=inputs, cell_fw=paddle_cell_fw, cell_bw=paddle_cell_bw)