code: def test_deconvolution_2d_double_backward(
      inshape,
      kernel,
      outmaps,
      pad,
      stride,
      dilation,
      group,
      with_bias,
      channel_last,
      output_padding,
      base_axis,
      seed,
      ctx,
      func_name,
  ):
      from nbla_test_utils import (
          function_tester,
          backward_function_tester,
          grad_function_forward_function_output,
      )
      from nnabla.backward_function.deconvolution import (
          DeconvolutionDataGrad,
          DeconvolutionFilterGrad,
      )
  
      if channel_last and not func_name.endswith("Cudnn"):
          pytest.skip(
              "channel_last=True is only supported in CUDNN backend."
          )
      inmaps = inshape[base_axis]
      if channel_last:
          t = refs.ChannelLastToFirstTranspose(
              len(inshape), len(kernel)
          )
          inshape = tuple(inshape[i] for i in t.inv_axes)
      rng = np.random.RandomState(seed)
      i = np.clip(rng.randn(*inshape).astype(np.float32), -0.5, 0.5)
      kshape = (inmaps,) + (outmaps // group,) + kernel
      if channel_last:
          t = refs.ChannelLastToFirstTranspose(len(kshape), len(kernel))
          kshape = tuple(kshape[i] for i in t.inv_axes)
      k = np.clip(rng.randn(*kshape).astype(np.float32), -0.5, 0.5)
      b = None
      if with_bias:
          b = np.clip(rng.randn(outmaps).astype(np.float32), -0.5, 0.5)
      inputs = [i, k, b]
      func_args = [
          base_axis,
          pad,
          stride,
          dilation,
          group,
          channel_last,
          output_padding,
      ]
      # Deconvolution
      backward_function_tester(
          rng,
          F.deconvolution,
          inputs,
          func_args=func_args,
          ctx=ctx,
          atol_accum=1e-1,
      )
  
      # DataGrad
      df, y = grad_function_forward_function_output(
          DeconvolutionDataGrad,
          F.deconvolution,
          ctx,
          inputs,
          *func_args,
      )
      df.xshape = i.shape
      ginputs = [rng.randn(*y.shape), k]
      backward_function_tester(
          rng,
          df,
          ginputs,
          ctx=ctx,
          atol_accum=1e-1,
          non_accum_check=True,
      )
  
      # FilterGrad
      df, y = grad_function_forward_function_output(
          DeconvolutionFilterGrad,
          F.deconvolution,
          ctx,
          inputs,
          *func_args,
      )
      df.wshape = k.shape
      ginputs = [rng.randn(*y.shape), i]
      backward_function_tester(
          rng,
          df,
          ginputs,
          func_args=[],
          ctx=ctx,
          atol_accum=1e-1,
          non_accum_check=True,
      )
  
file_path: nnabla/python/test/function/test_deconvolution.py
imports: from __future__ import division
  import pytest
  import numpy
  import nnabla.functions
  import refs
  from nbla_test_utils import list_context
label_desc: Use image node_id 3 for calling a global function with example usage: test_deconvolution_2d_double_backward(inshape, kernel, outmaps, pad, stride, dilation, group, with_bias, channel_last, output_padding, base_axis, seed, ctx, func_name) without return types