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