code: def test_pack_padded_long_sequence_forward_backward(
      total_length,
      padding_value,
      batch_first,
      shapes,
      seed,
      ctx,
      func_name,
  ):
      if not func_name.endswith("Cuda"):
          pytest.skip(
              "PackPaddedSequence tests except for Cuda for very long sequence skips."
          )
  
      from nbla_test_utils import function_tester
  
      rng = np.random.RandomState(seed)
  
      sequences = [
          rng.randn(*shape).astype(np.float32) for shape in shapes
      ]
      padded_sequence = pad_sequence(sequences, batch_first)
      lengths = np.array([seq.shape[0] for seq in sequences])
      inputs = [padded_sequence, lengths]
      func_args0 = [batch_first]
      func_args1 = [batch_first, padding_value, total_length]
      insert_identity = [True, False]
  
      # Forward
      function_tester(
          rng,
          F.pack_padded_sequence,
          ref_pack_padded_sequence,
          inputs,
          ctx=ctx,
          func_name=func_name,
          func_args=func_args0,
          backward=[False, False],
          atol_f=1e-3,
          atol_b=1e-2,
          insert_identity=insert_identity,
      )
  
      # Backward
      import nnabla as nn
  
      padded_sequence0 = nn.Variable.from_numpy_array(inputs[0]).apply(
          need_grad=True
      )
      lengths = nn.Variable.from_numpy_array(inputs[1])
      with nn.context_scope(ctx), nn.auto_forward():
          # Pack backward
          padded_sequence0.g = rng.randn(*padded_sequence0.shape)
          packed_sequence0, batch_sizes = F.pack_padded_sequence(
              padded_sequence0, lengths, *func_args0
          )
          g = rng.randn(*packed_sequence0.shape)
          packed_sequence0.g = g
          packed_sequence0.parent.backward(
              [padded_sequence0, lengths],
              [packed_sequence0, batch_sizes],
              [False, False],
          )
          # Unpack
          packed_sequence1 = nn.Variable.from_numpy_array(g)
          padded_sequence1, lengths = F.pad_packed_sequence(
              packed_sequence1, batch_sizes, *func_args1
          )
          # Compare w/o accum
          np.testing.assert_allclose(
              padded_sequence0.g.flatten(),
              padded_sequence1.d.flatten()[
                  : np.prod(padded_sequence0.shape)
              ],
              atol=1e-4,
              err_msg="{} test (w/o accum) with long sequence failed.".format(
                  func_name
              ),
          )
          # Compare w/ accum
          packed_sequence0.parent.backward(
              [padded_sequence0, lengths],
              [packed_sequence0, batch_sizes],
              [True, False],
          )
          np.testing.assert_allclose(
              padded_sequence0.g.flatten() / 2,
              padded_sequence1.d.flatten()[
                  : np.prod(padded_sequence0.shape)
              ],
              atol=1e-4,
              err_msg="{} test (w/ accum) with long sequence failed.".format(
                  func_name
              ),
          )
  
file_path: nnabla/python/test/function/test_pack_padded_sequence.py
imports: import pytest
  import numpy
  import nnabla.functions
  from nbla_test_utils import list_context
  from refs import pad_sequence
label_desc: Use image node_id 4 for calling a global function with example usage: test_pack_padded_long_sequence_forward_backward(total_length, padding_value, batch_first, shapes, seed, ctx, func_name) without return types