code: def test_lrn_large_inp_mkl(backend_mkl, deltas_buffer):
      # adding an extra test with a large inp at 1 location=
      # LRN is not very sensitive to small inputs
      nin = 2
      nifm = 16
      depth = 5
      batch_size = 64
  
      NervanaObject.be.bsz = NervanaObject.be.batch_size = batch_size
      be = NervanaObject.be
  
      shape = (nifm * nin * nin, batch_size)
      shape_full = (nifm, nin, nin, batch_size)
  
      inp_rng = 1.0e5
      epsilon = 10.0
      np.random.seed(1234)
  
      ind_pert = (8, 0, 0, 16)
      ind_pert2 = np.ravel_multi_index(ind_pert[0:3], shape_full[0:3])
      ind_pert = (ind_pert2, ind_pert[-1])
  
      inp = np.zeros(shape)
      inp[ind_pert] = inp_rng
      inpa = be.array(inp)
  
      lshape = shape_full[0:3]
      layer = LRNWithReset(depth=depth, ascale=1.25e-4, bpower=0.75)
  
      layer.configure(lshape)
      if layer.owns_delta:
          layer.prev_layer = True
      layer.allocate()
  
      layer.allocate_deltas(deltas_buffer)
      deltas_buffer.allocate_buffers()
      layer.set_deltas(deltas_buffer)
  
      loss_scale = np.ones(inpa.shape)
      layer.fprop(inpa).get()
      bprop_deltas = layer.bprop(be.array(loss_scale)).get()
      bprop_delta = bprop_deltas[ind_pert]
  
      # pos shift
      inp_p = inp.copy()
      inp_p[ind_pert] += epsilon
      inp_m = inp.copy()
      inp_m[ind_pert] -= epsilon
  
      out_p = layer.fprop(be.array(inp_p)).get()[ind_pert]
      out_m = layer.fprop(be.array(inp_m)).get()[ind_pert]
  
      grad_est = 0.5 / float(epsilon) * (out_p - out_m)
      assert np.abs(grad_est - bprop_delta) < 1e-12
  
file_path: neon/tests/test_gradient_lrn.py
imports: import itertools
  import numpy
  import pytest
  from neon import NervanaObject
  from neon.layers.layer import LRN
  from grad_funcs import general_gradient_comp
label_desc: Use image node_id 5 for calling a global function with example usage: test_lrn_large_inp_mkl(backend_mkl, deltas_buffer) without return types