class_docstr: Average pooling over a set of N-dimensional planes.
  
  .. warning::
  
      This feature is experimental. The interface can change in the future.
code: def forward_gpu(self, inputs):
      if chainer.should_use_cudnn(">=auto") and 2 <= self.ndim <= 3:
          # With cuDNN v3 or greater, use cuDNN implementation for inputs
          # with spatial dimensions of two or more.
          return self.forward_cudnn(inputs)
  
      ndim = self.ndim
      ksize = self.ksize
      stride = self.stride
      pad = self.pad
      pad_value = self.pad_value
      cover_all = self.cover_all
  
      (x,) = inputs
      in_shape = x.shape
      in_dtype = x.dtype
  
      n, c = in_shape[:2]
      idims = in_shape[2:]
      odims = tuple(
          conv.get_conv_outsize(d, k, s, p, cover_all=cover_all)
          for (d, k, s, p) in six.moves.zip(idims, ksize, stride, pad)
      )
      # (n, c, y_1, y_2, ..., y_N)
      y_shape = (n, c) + odims
      y = cuda.cupy.empty(y_shape, dtype=x.dtype)
      if pad_value is None:
          coeff = self._get_pooling_width(cuda.cupy, idims, x.dtype)
          coeff = cuda.cupy.reciprocal(coeff, out=coeff)
      else:
          assert pad_value == 0
          coeff = 1.0 / functools.reduce(operator.mul, ksize)
  
      (
          in_params,
          out_params,
          operation,
          name,
      ) = average_pooling_nd_kernel.AveragePoolingNDKernelForward.generate(
          ndim
      )
      cuda.elementwise(in_params, out_params, operation, name)(
          x.reduced_view(),
          *(idims + odims + ksize + stride + pad + (coeff, y)),
      )
  
      self.coeff = coeff
      self._in_shape = in_shape
      self._in_dtype = in_dtype
      return (y,)
  
imports: import functools
  import operator
  import numpy
  import six
  import chainer
  from chainer import backend
  from chainer.backends import cuda
  from chainer import function_node
  from chainer.functions.pooling import average_pooling_nd_kernel
  from chainer.functions.pooling import pooling_nd
  from chainer.utils import conv
  from chainer.utils import conv_nd
  import chainerx
label_desc: Use image node_id 5 for calling the AveragePoolingND obj's underlying member method code with example usage: obj.forward_gpu(inputs) and returns: y, self