def f_conv(self, x, spec, in_dim, weight_name):
layer_type, dims = spec
num_filters = dims[0]
filter_size = (dims[1], dims[1])
stride = (dims[2], dims[2])
bm = 'full' if 'convf' in layer_type else 'valid'
num_channels = in_dim[0]
W = self.weight(
self.rand_init_conv((num_filters, num_channels) + filter_size),
weight_name)
if stride != (1, 1):
f = GpuCorrMM(subsample=stride, border_mode=bm, pad=(0, 0))
y = f(gpu_contiguous(x), gpu_contiguous(W))
else:
assert self.p.batch_size == self.p.valid_batch_size
y = conv2d(x,
W,
image_shape=(2 * self.p.batch_size, ) + in_dim,
filter_shape=((num_filters, num_channels) +
filter_size),
border_mode=bm)
output_size = (
(num_filters, ) +
ConvOp.getOutputShape(in_dim[1:], filter_size, stride, bm))
return y, output_size
def __init__(self,
incoming,
num_filters,
filter_size,
stride=(1, 1),
pad=0,
untie_biases=False,
W=init.GlorotUniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.rectify,
flip_filters=False,
**kwargs):
super(Conv2DMMLayer, self).__init__(incoming,
num_filters,
filter_size,
stride,
pad,
untie_biases,
W,
b,
nonlinearity,
flip_filters,
n=2,
**kwargs)
border_mode = 'half' if self.pad == 'same' else self.pad
self.corr_mm_op = GpuCorrMM(subsample=self.stride,
border_mode=border_mode)
def __init__(self,
filters,
batch_size,
input_space,
output_axes=('b', 'c', 0, 1),
subsample=(1, 1),
pad=(1, 1),
border_mode='valid',
filters_shape=None,
message=''):
assert batch_size is None or batch_size > 0
self.input_space = input_space
self.output_axes = output_axes
self._pad = pad
super(CorrMM2D, self).__init__(
filters=filters,
img_shape=(batch_size, input_space.num_channels,
input_space.shape[0], input_space.shape[1]),
subsample=subsample,
border_mode=border_mode,
filters_shape=filters.get_value(borrow=True).shape,
message=message)
self.conv_op = GpuCorrMM(subsample=self._subsample,
border_mode=border_mode,
pad=pad)
def __init__(self,
input_layer,
num_filters,
filter_size,
strides=(1, 1),
border_mode=None,
untie_biases=False,
W=init.Uniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.rectify,
pad=None,
flip_filters=False):
super(Conv2DMMLayer, self).__init__(input_layer)
if nonlinearity is None:
self.nonlinearity = nonlinearities.identity
else:
self.nonlinearity = nonlinearity
self.num_filters = num_filters
self.filter_size = filter_size
self.strides = strides
self.untie_biases = untie_biases
self.flip_filters = flip_filters
if border_mode is not None and pad is not None:
raise RuntimeError(
"You cannot specify both 'border_mode' and 'pad'. To avoid ambiguity, please specify only one of them."
)
elif border_mode is None and pad is None:
# no option specified, default to valid mode
self.pad = (0, 0)
elif border_mode is not None:
if border_mode == 'valid':
self.pad = (0, 0)
elif border_mode == 'full':
self.pad = (self.filter_size[0] - 1, self.filter_size[1] - 1)
elif border_mode == 'same':
# only works for odd filter size, but the even filter size case is probably not worth supporting.
self.pad = ((self.filter_size[0] - 1) // 2,
(self.filter_size[1] - 1) // 2)
else:
raise RuntimeError(
"Unsupported border_mode for Conv2DMMLayer: %s" %
border_mode)
else:
self.pad = pad
self.W = self.create_param(W, self.get_W_shape())
if b is None:
self.b = None
elif self.untie_biases:
output_shape = self.get_output_shape()
self.b = self.create_param(
b, (num_filters, output_shape[2], output_shape[3]))
else:
self.b = self.create_param(b, (num_filters, ))
self.corr_mm_op = GpuCorrMM(subsample=self.strides, pad=self.pad)
def __init__(self,
incoming,
num_filters,
filter_size,
stride=(1, 1),
pad=0,
untie_biases=False,
W=init.GlorotUniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.rectify,
flip_filters=False,
**kwargs):
super(Conv2DMMLayer, self).__init__(incoming, **kwargs)
if nonlinearity is None:
self.nonlinearity = nonlinearities.identity
else:
self.nonlinearity = nonlinearity
self.num_filters = num_filters
self.filter_size = as_tuple(filter_size, 2)
self.stride = as_tuple(stride, 2)
self.untie_biases = untie_biases
self.flip_filters = flip_filters
if pad == 'valid':
self.pad = (0, 0)
elif pad == 'full':
self.pad = (self.filter_size[0] - 1, self.filter_size[1] - 1)
elif pad == 'same':
if any(s % 2 == 0 for s in self.filter_size):
raise NotImplementedError(
'`same` padding requires odd filter size.')
self.pad = (self.filter_size[0] // 2, self.filter_size[1] // 2)
else:
self.pad = as_tuple(pad, 2, int)
self.W = self.add_param(W, self.get_W_shape(), name="W")
if b is None:
self.b = None
else:
if self.untie_biases:
biases_shape = (num_filters, self.output_shape[2],
self.output_shape[3])
else:
biases_shape = (num_filters, )
self.b = self.add_param(b,
biases_shape,
name="b",
regularizable=False)
self.corr_mm_op = GpuCorrMM(subsample=self.stride,
border_mode=self.pad)
def __init__(self,
incoming,
num_filters,
filter_size,
stride=(1, 1),
pad=0,
untie_biases=False,
W=init.GlorotUniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.rectify,
flip_filters=False,
**kwargs):
super(Conv2DMMLayer, self).__init__(incoming, **kwargs)
if nonlinearity is None:
self.nonlinearity = nonlinearities.identity
else:
self.nonlinearity = nonlinearity
self.num_filters = num_filters
self.filter_size = as_tuple(filter_size, 2)
self.stride = as_tuple(stride, 2)
self.untie_biases = untie_biases
self.flip_filters = flip_filters
if pad == 'valid':
self.pad = (0, 0)
elif pad == 'full':
self.pad = (self.filter_size[0] - 1, self.filter_size[1] - 1)
elif pad == 'same':
# only works for odd filter size, but the even filter size case
# is probably not worth supporting.
self.pad = ((self.filter_size[0] - 1) // 2,
(self.filter_size[1] - 1) // 2)
else:
self.pad = as_tuple(pad, 2, int)
self.W = self.add_param(W, self.get_W_shape(), name="W")
if b is None:
self.b = None
else:
if self.untie_biases:
biases_shape = (num_filters, self.output_shape[2],
self.output_shape[3])
else:
biases_shape = (num_filters, )
self.b = self.add_param(b,
biases_shape,
name="b",
regularizable=False)
self.corr_mm_op = GpuCorrMM(subsample=self.stride,
border_mode=self.pad)
def __init__(self, incoming, num_filters, filter_size, stride=(1, 1),
border_mode=None, untie_biases=False, W=init.GlorotUniform(),
b=init.Constant(0.), nonlinearity=nonlinearities.rectify,
pad=None, flip_filters=False, **kwargs):
super(Conv2DMMLayer, self).__init__(incoming, **kwargs)
if nonlinearity is None:
self.nonlinearity = nonlinearities.identity
else:
self.nonlinearity = nonlinearity
self.num_filters = num_filters
self.filter_size = as_tuple(filter_size, 2)
self.stride = as_tuple(stride, 2)
self.untie_biases = untie_biases
self.flip_filters = flip_filters
if border_mode is not None and pad is not None:
raise RuntimeError("You cannot specify both 'border_mode' and "
"'pad'. To avoid ambiguity, please specify "
"only one of them.")
elif border_mode is None and pad is None:
# no option specified, default to valid mode
self.pad = (0, 0)
elif border_mode is not None:
if border_mode == 'valid':
self.pad = (0, 0)
elif border_mode == 'full':
self.pad = (self.filter_size[0] - 1, self.filter_size[1] - 1)
elif border_mode == 'same':
# only works for odd filter size, but the even filter size case
# is probably not worth supporting.
self.pad = ((self.filter_size[0] - 1) // 2,
(self.filter_size[1] - 1) // 2)
else:
raise RuntimeError("Invalid border mode: '%s'" % border_mode)
else:
self.pad = as_tuple(pad, 2)
self.W = self.add_param(W, self.get_W_shape(), name="W")
if b is None:
self.b = None
else:
if self.untie_biases:
biases_shape = (num_filters, self.output_shape[2],
self.output_shape[3])
else:
biases_shape = (num_filters,)
self.b = self.add_param(b, biases_shape, name="b",
regularizable=False)
self.corr_mm_op = GpuCorrMM(subsample=self.stride, pad=self.pad)
def __init__(self, input, image_shape, filter_shape, convstride, padsize,
group, poolsize, poolstride, bias_init, lrn=False,
lib_conv='cudnn',
verbose=False
):
'''
lib_conv can be cudnn (recommended)or cudaconvnet
'''
self.filter_size = filter_shape
self.convstride = convstride
self.padsize = padsize
self.poolsize = poolsize
self.poolstride = poolstride
self.channel = image_shape[0]
self.lrn = lrn
self.lib_conv = lib_conv
self.verbose = verbose
assert group in [1, 2]
self.filter_shape = np.asarray(filter_shape)
self.image_shape = np.asarray(image_shape)
if self.lrn:
self.lrn_func = CrossChannelNormalization()
if group == 1:
self.W = Weight(self.filter_shape)
self.b = Weight(self.filter_shape[3], bias_init, std=0)
else:
self.filter_shape[0] = self.filter_shape[0] / 2
self.filter_shape[3] = self.filter_shape[3] / 2
self.image_shape[0] = self.image_shape[0] / 2
self.image_shape[3] = self.image_shape[3] / 2
self.W0 = Weight(self.filter_shape)
self.W1 = Weight(self.filter_shape)
self.b0 = Weight(self.filter_shape[3], bias_init, std=0)
self.b1 = Weight(self.filter_shape[3], bias_init, std=0)
if lib_conv == 'cudaconvnet':
self.conv_op = FilterActs(pad=self.padsize, stride=self.convstride,
partial_sum=1)
from theano.sandbox.cuda.basic_ops import gpu_contiguous
# Conv
if group == 1:
contiguous_input = gpu_contiguous(input)
contiguous_filters = gpu_contiguous(self.W.val)
conv_out = self.conv_op(contiguous_input, contiguous_filters)
conv_out = conv_out + self.b.val.dimshuffle(0, 'x', 'x', 'x')
else:
contiguous_input0 = gpu_contiguous(
input[:self.channel / 2, :, :, :])
contiguous_filters0 = gpu_contiguous(self.W0.val)
conv_out0 = self.conv_op(
contiguous_input0, contiguous_filters0)
conv_out0 = conv_out0 + \
self.b0.val.dimshuffle(0, 'x', 'x', 'x')
contiguous_input1 = gpu_contiguous(
input[self.channel / 2:, :, :, :])
contiguous_filters1 = gpu_contiguous(self.W1.val)
conv_out1 = self.conv_op(
contiguous_input1, contiguous_filters1)
conv_out1 = conv_out1 + \
self.b1.val.dimshuffle(0, 'x', 'x', 'x')
conv_out = T.concatenate([conv_out0, conv_out1], axis=0)
# ReLu
conv_out = gpu_contiguous(conv_out)
self.output = T.maximum(conv_out, 0)
# Pooling
if self.poolsize != 1:
self.pool_op = MaxPool(ds=poolsize, stride=poolstride)
self.output = self.pool_op(self.output)
elif lib_conv == 'corrmm':
from theano.sandbox.cuda.basic_ops import gpu_contiguous
from theano.sandbox.cuda.blas import GpuCorrMM
border_mode = 'half' if padsize == (filter_shape[1]-1)/2 else (padsize, padsize)
self.corr_mm_op = GpuCorrMM(subsample=(convstride,convstride),
border_mode=border_mode)
flip_filters=True
input_shuffled = input.dimshuffle(3, 0, 1, 2) # c01b to bc01
if group==1:
filters = self.W.val.dimshuffle(3, 0, 1, 2)
if flip_filters:
filters = filters[:, :, ::-1, ::-1] # flip top-down, left-right
contiguous_filters = gpu_contiguous(filters)
contiguous_input = gpu_contiguous(input_shuffled)
conv_out = self.corr_mm_op(contiguous_input, contiguous_filters)
conv_out = conv_out + self.b.val.dimshuffle('x', 0, 'x', 'x')
else:
W0_shuffled = \
self.W0.val.dimshuffle(3, 0, 1, 2) # c01b to bc01
if flip_filters:
W0_shuffled = W0_shuffled[:, :, ::-1, ::-1]
contiguous_filters0 = gpu_contiguous(W0_shuffled)
contiguous_input0 = gpu_contiguous(input_shuffled[:, :self.channel / 2,:, :])
conv_out0 = self.corr_mm_op(contiguous_input0, contiguous_filters0)
conv_out0 = conv_out0 + \
self.b0.val.dimshuffle('x', 0, 'x', 'x')
W1_shuffled = \
self.W1.val.dimshuffle(3, 0, 1, 2) # c01b to bc01
if flip_filters:
W1_shuffled = W1_shuffled[:, :, ::-1, ::-1]
contiguous_filters1 = gpu_contiguous(W1_shuffled)
contiguous_input1 = gpu_contiguous(input_shuffled[:, self.channel / 2:,:, :])
conv_out1 = self.corr_mm_op(contiguous_input1, contiguous_filters1)
conv_out1 = conv_out1 + \
self.b1.val.dimshuffle('x', 0, 'x', 'x')
conv_out = T.concatenate([conv_out0, conv_out1], axis=1)
# ReLu
self.output = T.maximum(conv_out, 0)
# Pooling
if self.poolsize != 1:
from theano.tensor.signal import downsample
self.output = downsample.max_pool_2d(self.output,
ds=(poolsize,poolsize),
st=(poolstride,poolstride),
ignore_border=False,
padding=(0,0),
mode='max',
)
self.output = self.output.dimshuffle(1, 2, 3, 0) # bc01 to c01b
elif lib_conv == 'cudnn':
input_shuffled = input.dimshuffle(3, 0, 1, 2) # c01b to bc01
# in01out to outin01
# print image_shape_shuffled
# print filter_shape_shuffled
if group == 1:
W_shuffled = self.W.val.dimshuffle(3, 0, 1, 2) # c01b to bc01
conv_out = dnn.dnn_conv(img=input_shuffled,
kerns=W_shuffled,
subsample=(convstride, convstride),
border_mode=padsize,
)
conv_out = conv_out + self.b.val.dimshuffle('x', 0, 'x', 'x')
else:
W0_shuffled = \
self.W0.val.dimshuffle(3, 0, 1, 2) # c01b to bc01
conv_out0 = \
dnn.dnn_conv(img=input_shuffled[:, :self.channel / 2,
:, :],
kerns=W0_shuffled,
subsample=(convstride, convstride),
border_mode=padsize,
)
conv_out0 = conv_out0 + \
self.b0.val.dimshuffle('x', 0, 'x', 'x')
W1_shuffled = \
self.W1.val.dimshuffle(3, 0, 1, 2) # c01b to bc01
conv_out1 = \
dnn.dnn_conv(img=input_shuffled[:, self.channel / 2:,
:, :],
kerns=W1_shuffled,
subsample=(convstride, convstride),
border_mode=padsize,
)
conv_out1 = conv_out1 + \
self.b1.val.dimshuffle('x', 0, 'x', 'x')
conv_out = T.concatenate([conv_out0, conv_out1], axis=1)
# ReLu
self.output = T.maximum(conv_out, 0)
# Pooling
if self.poolsize != 1:
self.output = dnn.dnn_pool(self.output,
ws=(poolsize, poolsize),
stride=(poolstride, poolstride))
self.output = self.output.dimshuffle(1, 2, 3, 0) # bc01 to c01b
else:
NotImplementedError("lib_conv can only be cudaconvnet or cudnn")
# LRN
if self.lrn:
# lrn_input = gpu_contiguous(self.output)
self.output = self.lrn_func(self.output)
if group == 1:
self.params = [self.W.val, self.b.val]
self.weight_type = ['W', 'b']
else:
self.params = [self.W0.val, self.b0.val, self.W1.val, self.b1.val]
self.weight_type = ['W', 'b', 'W', 'b']
if self.verbose:
print "conv ({}) layer with shape_in: {}".format(lib_conv,
str(image_shape))