code: def forward(self, inputs):
      if inputs[0].shape[1] % self.groups != 0:
          raise ValueError(
              "The number of channels {} is not divisible by "
              "'groups' argument {}.".format(
                  inputs[0].shape[1], self.groups
              )
          )
  
      xp = backend.get_array_module(*inputs)
      if xp is cuda.cupy and chainer.should_use_cudnn(">=auto", 5000):
          return self.forward_cudnn(inputs)
  
      self.retain_inputs((0, 1))
      x, gamma, beta = inputs
  
      interm_dtype = numpy.promote_types(x.dtype, gamma.dtype)
  
      gamma = gamma.astype(interm_dtype, copy=False)
      beta = beta.astype(interm_dtype, copy=False)
  
      orig_shape = x.shape
      batch_size, channels = orig_shape[:2]
      groups = self.groups
      reduced_shape = (batch_size * groups, -1)
      x = x.reshape(reduced_shape)
  
      self.mean = x.mean(axis=1, dtype=interm_dtype)
      x_hat = x - self.mean[:, None]
      var = (x_hat * x_hat).mean(axis=1)
      var += self.eps
      self.inv_std = var
      del var
      xp.sqrt(self.inv_std, out=self.inv_std)
      xp.reciprocal(self.inv_std, out=self.inv_std)
      x_hat *= self.inv_std[:, None]
  
      y = x_hat.reshape((batch_size, channels, -1))
      y *= gamma[:, None]
      y += beta[:, None]
  
      y = y.reshape(orig_shape)
      return (y.astype(x.dtype, copy=False),)
  
imports: import numpy
  import chainer
  from chainer import backend
  from chainer.backends import cuda
  from chainer import configuration
  from chainer import function_node
  from chainer.utils import type_check
label_desc: Use image node_id 3 for calling the GroupNormalization obj's underlying member method code with example usage: obj.forward(inputs) and returns: y, self