code: def test_dconv_rand(backend_default, rand_convargs, deltas_buffer):
      (
          indim,
          nifm,
          fshape,
          nofm,
          batch_size,
          rngmax,
          w_rng,
      ) = rand_convargs
      if isinstance(
          NervanaObject.be, NervanaGPU
      ) and NervanaObject.be.compute_capability < (5, 0):
          if nofm % 4 != 0:
              pytest.skip(
                  msg="C dim must be a multiple of 4 for Kepler bprop kernel"
              )
      NervanaObject.be.bsz = batch_size
      dtypeu = np.float32
      inp_rng = [0.0, rngmax]
  
      init_unif = Uniform(low=w_rng[0], high=w_rng[1])
      inshape = (indim, indim, nifm)
      insize = np.prod(inshape)
  
      # generate neon deconv layer
      # need to switch to nofm here...
      neon_layer = Deconvolution(
          fshape=(fshape, fshape, nofm),
          strides=1,
          padding=0,
          init=init_unif,
      )
      insize = np.prod(inshape)
  
      # generate reference deconv layer
      ref_layer = DeconvRefLayer(
          1,
          batch_size,
          identity,
          inshape[0],
          inshape[1:3],
          (fshape, fshape),
          nofm,
          1,
          dtypeu,
      )
  
      # setup input in range inp_rng
      inpa = np.random.random((insize, batch_size))
      inpa *= inp_rng[1] - inp_rng[0]
      inpa += inp_rng[0]
      inpa = inpa.astype(dtypeu)
      inp = neon_layer.be.array(inpa)
      inp.lshape = inshape
  
      # run fprop on neon
      neon_layer.configure(inshape)
      neon_layer.prev_layer = True
      neon_layer.allocate()
      neon_out = neon_layer.fprop(inp).get()
  
      neon_layer.allocate_deltas(deltas_buffer)
      deltas_buffer.allocate_buffers()
      neon_layer.set_deltas(deltas_buffer)
  
      # pull neon weights into ref layer weights
      ref_layer.weights = neon_layer.W.get().T
      ref_out = np.copy(ref_layer.berror)
  
      # estimate the numerical precision
      ref_layer.fprop(inpa.T, permute=True)
      ref_out2 = ref_layer.berror
      atol = 10 * np.max(np.abs(ref_out - ref_out2))
      assert allclose_with_out(
          ref_out.T, neon_out, atol=atol, rtol=0.0
      ), "%e %e" % (np.max(np.abs(ref_out.T - neon_out)), atol)
  
      # generate err array
      erra = np.random.random(neon_out.shape)
      erra *= inp_rng[1] - inp_rng[0]
      erra += inp_rng[0]
      erra = erra.astype(dtypeu)
  
file_path: neon/tests/test_deconv_layer.py
imports: import itertools
  import numpy
  import pytest
  from neon import NervanaObject
  from neon.layers import Deconvolution
  from neon.initializers import Uniform
  from utils import allclose_with_out
label_desc: Use image node_id 4 for calling a global function with example usage: test_dconv_rand(backend_default, rand_convargs, deltas_buffer) without return types