class_docstr: Two-dimensional dilated convolutional layer.
  
  This link wraps the :func:`~chainer.functions.dilated_convolution_2d`
  function and holds the filter weight and bias vector as parameters.
  
  .. note::
     You can also define a dilated convolutional layer by passing ``dilate``
     argument to :class:`chainer.links.Convolution2D`.
     The functionality is the same.
  
  Args:
      in_channels (int or None): Number of channels of input arrays.
          If ``None``, parameter initialization will be deferred until the
          first forward data pass at which time the size will be determined.
      out_channels (int): Number of channels of output arrays.
      ksize (int or pair of ints): Size of filters (a.k.a. kernels).
          ``ksize=k`` and ``ksize=(k, k)`` are equivalent.
      stride (int or pair of ints): Stride of filter applications.
          ``stride=s`` and ``stride=(s, s)`` are equivalent.
      pad (int or pair of ints): Spatial padding width for input arrays.
          ``pad=p`` and ``pad=(p, p)`` are equivalent.
      dilate (int or pair of ints): Dilation factor of filter applications.
          ``dilate=d`` and ``dilate=(d, d)`` are equivalent.
      nobias (bool): If ``True``, then this link does not use the bias term.
      initialW (:ref:`initializer <initializer>`): Initializer to
          initialize the weight. When it is :class:`numpy.ndarray`,
          its ``ndim`` should be 4.
      initial_bias (:ref:`initializer <initializer>`): Initializer to
          initialize the bias. If ``None``, the bias will be initialized to
          zero. When it is :class:`numpy.ndarray`, its ``ndim`` should be 1.
  
  .. seealso::
     See :func:`chainer.functions.dilated_convolution_2d`
     for the definition of two-dimensional dilated convolution.
  
  Attributes:
      W (~chainer.Variable): Weight parameter.
      b (~chainer.Variable): Bias parameter.
  
  .. admonition:: Example
  
      There are several ways to make a DilatedConvolution2D link.
  
      Let an input vector ``x`` be:
  
      >>> x = np.arange(1 * 3 * 10 * 10, dtype=np.float32).reshape(1, 3, 10, 10)
  
      1. Give the first three arguments explicitly:
  
          >>> l = L.DilatedConvolution2D(3, 7, 5)
          >>> y = l(x)
          >>> y.shape
          (1, 7, 6, 6)
  
      2. Omit ``in_channels`` or fill it with ``None``:
  
          The below two cases are the same.
  
          >>> l = L.DilatedConvolution2D(7, 5)
          >>> y = l(x)
          >>> y.shape
          (1, 7, 6, 6)
  
          >>> l = L.DilatedConvolution2D(None, 7, 5)
          >>> y = l(x)
          >>> y.shape
          (1, 7, 6, 6)
  
          When you omit the first argument, you need to specify the other
          subsequent arguments from ``stride`` as keyword auguments. So the
          below two cases are the same.
  
          >>> l = L.DilatedConvolution2D(None, 7, 5, 1, 0, 2)
          >>> y = l(x)
          >>> y.shape
          (1, 7, 2, 2)
  
          >>> l = L.DilatedConvolution2D(7, 5, stride=1, pad=0, dilate=2)
          >>> y = l(x)
          >>> y.shape
          (1, 7, 2, 2)
code: def _initialize_params(self, in_channels):
      kh, kw = _pair(self.ksize)
      W_shape = (self.out_channels, in_channels, kh, kw)
      self.W.initialize(W_shape)
  
file_path: chainer/chainer/links/connection/dilated_convolution_2d.py
imports: from chainer.functions.connection import dilated_convolution_2d
  from chainer import initializers
  from chainer import link
  from chainer import variable
label_desc: Use image node_id 2 for calling the DilatedConvolution2D obj's underlying member method code with example usage: obj._initialize_params(in_channels) without return types