Source code for chainer.links.connection.convolution_2d

import math

from chainer import cuda
from chainer.functions.connection import convolution_2d
from chainer import initializers
from chainer import link

[docs]class Convolution2D(link.Link): """Two-dimensional convolutional layer. This link wraps the :func:`~chainer.functions.convolution_2d` function and holds the filter weight and bias vector as parameters. 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. wscale (float): Scaling factor of the initial weight. bias (float): Initial bias value. nobias (bool): If ``True``, then this link does not use the bias term. use_cudnn (bool): If ``True``, then this link uses cuDNN if available. initialW (4-D array): Initial weight value. If ``None``, then this function uses Gaussian distribution scaled by ``w_scale`` to initialize weight. May also be a callable that takes ``numpy.ndarray`` or ``cupy.ndarray`` and edits its value. initial_bias (1-D array): Initial bias value. If ``None``, then this function uses ``bias`` to initialize bias. May also be a callable that takes ``numpy.ndarray`` or ``cupy.ndarray`` and edits its value. deterministic (bool): The output of this link can be non-deterministic when it uses cuDNN. If this option is ``True``, then it forces cuDNN to use a deterministic algorithm. This option is only available for cuDNN version >= v4. .. seealso:: See :func:`chainer.functions.convolution_2d` for the definition of two-dimensional convolution. Attributes: W (~chainer.Variable): Weight parameter. b (~chainer.Variable): Bias parameter. """ def __init__(self, in_channels, out_channels, ksize, stride=1, pad=0, wscale=1, bias=0, nobias=False, use_cudnn=True, initialW=None, initial_bias=None, deterministic=False): super(Convolution2D, self).__init__() self.ksize = ksize self.stride = _pair(stride) self.pad = _pair(pad) self.use_cudnn = use_cudnn self.out_channels = out_channels self.deterministic = deterministic # For backward compatibility self.initialW = initialW self.wscale = wscale # For backward compatibility, the scale of weights is proportional to # the square root of wscale. self._W_initializer = initializers._get_initializer( initialW, scale=math.sqrt(wscale)) if in_channels is None: self.add_uninitialized_param('W') else: self._initialize_params(in_channels) if nobias: self.b = None else: if initial_bias is None: initial_bias = bias bias_initilizer = initializers._get_initializer(initial_bias) self.add_param('b', out_channels, initializer=bias_initilizer) def _initialize_params(self, in_channels): kh, kw = _pair(self.ksize) W_shape = (self.out_channels, in_channels, kh, kw) self.add_param('W', W_shape, initializer=self._W_initializer)
[docs] def __call__(self, x): """Applies the convolution layer. Args: x (~chainer.Variable): Input image. Returns: ~chainer.Variable: Output of the convolution. """ if self.has_uninitialized_params: with cuda.get_device_from_id(self._device_id): self._initialize_params(x.shape[1]) return convolution_2d.convolution_2d( x, self.W, self.b, self.stride, self.pad, self.use_cudnn, deterministic=self.deterministic)
def _pair(x): if hasattr(x, '__getitem__'): return x return x, x