class_docstr: ConvLayer parameter object.
  This then is passed as an argument to all the convolution operations.
  
  N: Number of images in mini-batch
  C: Number of input feature maps
  K: Number of output feature maps
  
  D: Depth  of input image
  H: Height of input image
  W: Width  of input image
  
  T: Depth  of filter kernel
  R: Height of filter kernel
  S: Width  of filter kernel
  
  padding: amount of zero-padding around the given edge
  strides: factor to step the filters by in a given direction
  dilation: dilation factor for each dimension
code: def update_conv(
      self, I, E, U, alpha=1.0, beta=0.0, grad_bias=None, layer_op=None
  ):
      C = self.C
      K, M, P, Q, N = self.dimO
  
      I = I._tensor.reshape(self.dimI)
      E = E._tensor.reshape(self.dimO)
      U = U._tensor.reshape(self.dimF)
  
      if grad_bias is not None:
          grad = E.reshape((K, -1))
          grad_bias[:] = np.sum(grad, axis=1)
  
      # 1x1 conv can be cast as a simple dot operation
      if self.dot:
          # CxK = CxHWN . KxHWN.T
          I = I.reshape((C, -1))
          E = E.reshape((K, -1)).T
          if beta:
              U[:] = alpha * np.dot(I, E).reshape(U.shape) + beta * U
          else:
              U[:] = alpha * np.dot(I, E).reshape(U.shape)
          return
  
      if beta:
          U *= beta
      else:
          U.fill(0.0)
  
      for m in range(M):
          sliceT, sliceD, tlen = self.mSlice[m]
          for p in range(P):
              sliceR, sliceH, rlen = self.pSlice[p]
              for q in range(Q):
                  sliceS, sliceW, slen = self.qSlice[q]
  
                  slicedI = I[:, sliceD, sliceH, sliceW].reshape(
                      (-1, N)
                  )
                  slicedE = E[:, m, p, q]
                  update = np.dot(slicedI, slicedE.T).reshape(
                      (C, tlen, rlen, slen, K)
                  )
                  if alpha == 1.0:
                      U[:, sliceT, sliceR, sliceS] += update
                  else:
                      U[:, sliceT, sliceR, sliceS] += alpha * update
  
imports: from __future__ import division
  from builtins import object
  import math
  from operator import mul
  import numpy
  from functools import reduce
label_desc: Use image node_id 9 for calling the ConvLayer obj's underlying member method code with example usage: obj.update_conv(I, E, U, alpha, beta, grad_bias, layer_op) without return types