def test_infer_shape(self):
image = tensor.dtensor4()
maxout = tensor.dtensor4()
gz = tensor.dtensor4()
rng = numpy.random.RandomState(utt.fetch_seed())
maxpoolshps = ((1, 1), (2, 2), (3, 3), (2, 3), (3, 2))
image_val = rng.rand(4, 6, 7, 9)
out_shapes = [[[[4, 6, 7, 9], [4, 6, 7, 9]],
[[4, 6, 3, 4], [4, 6, 4, 5]],
[[4, 6, 2, 3], [4, 6, 3, 3]],
[[4, 6, 3, 3], [4, 6, 4, 3]],
[[4, 6, 2, 4], [4, 6, 3, 5]]],
[[None, None],
[[4, 6, 4, 5], None],
[[4, 6, 3, 3], None],
[[4, 6, 4, 3], None],
[[4, 6, 3, 5], None]],
[[None, None],
[None, None],
[[4, 6, 3, 4], None],
[[4, 6, 4, 4], None],
[None, None]]]
for i, maxpoolshp in enumerate(maxpoolshps):
for j, ignore_border in enumerate([True, False]):
for k, padding in enumerate([(0, 0), (1, 1), (1, 2)]):
if out_shapes[k][i][j] is None:
continue
# checking shapes generated by Pool
self._compile_and_check([image],
[Pool(maxpoolshp,
ignore_border=ignore_border,
padding=padding)(image)],
[image_val], Pool)
# checking shapes generated by MaxPoolGrad
maxout_val = rng.rand(*out_shapes[k][i][j])
gz_val = rng.rand(*out_shapes[k][i][j])
self._compile_and_check([image, maxout, gz],
[MaxPoolGrad(maxpoolshp,
ignore_border=ignore_border,
padding=padding)
(image, maxout, gz)],
[image_val, maxout_val, gz_val],
MaxPoolGrad,
warn=False)
# checking with broadcastable input
image = tensor.tensor(dtype='float64',
broadcastable=(False, False, True, True))
image_val = rng.rand(4, 6, 1, 1)
self._compile_and_check(
[image],
[Pool((2, 2),
ignore_border=True,
padding=(0, 0))(image)],
[image_val], Pool)
def test_DownsampleFactorMaxStride(self):
rng = numpy.random.RandomState(utt.fetch_seed())
maxpoolshps = ((1, 1), (3, 3), (5, 3), (16, 16))
stridesizes = (
(1, 1),
(3, 3),
(5, 7),
)
# generate random images
imval = rng.rand(4, 10, 16, 16)
# The same for each mode
outputshps = (
(4, 10, 16, 16),
(4, 10, 6, 6),
(4, 10, 4, 3),
(4, 10, 16, 16),
(4, 10, 6, 6),
(4, 10, 4, 3),
(4, 10, 14, 14),
(4, 10, 5, 5),
(4, 10, 3, 2),
(4, 10, 14, 14),
(4, 10, 6, 6),
(4, 10, 4, 3),
(4, 10, 12, 14),
(4, 10, 4, 5),
(4, 10, 3, 2),
(4, 10, 12, 14),
(4, 10, 5, 6),
(4, 10, 4, 3),
(4, 10, 1, 1),
(4, 10, 1, 1),
(4, 10, 1, 1),
(4, 10, 1, 1),
(4, 10, 1, 1),
(4, 10, 1, 1),
)
images = tensor.dtensor4()
indx = 0
for mode, maxpoolshp, ignore_border in product(
['max', 'sum', 'average_inc_pad', 'average_exc_pad'], maxpoolshps,
[True, False]):
for stride in stridesizes:
outputshp = outputshps[indx % len(outputshps)]
indx += 1
# Pool op
numpy_output_val = \
self.numpy_max_pool_2d_stride(imval, maxpoolshp,
ignore_border, stride,
mode)
assert numpy_output_val.shape == outputshp, (
"outshape is %s, calculated shape is %s" %
(outputshp, numpy_output_val.shape))
maxpool_op = \
Pool(ignore_border=ignore_border, mode=mode)(
images, maxpoolshp, stride)
f = function([images], maxpool_op)
output_val = f(imval)
utt.assert_allclose(output_val, numpy_output_val)
def test_DownsampleFactorMaxPaddingStride(self):
ignore_border = True # padding does not support ignore_border=False
rng = numpy.random.RandomState(utt.fetch_seed())
maxpoolsizes = [(3, 3), (4, 4), (3, 4), (4, 3), (2, 2)]
stridesizes = [(2, 2), (2, 2), (1, 1), (1, 2), (2, 2)]
paddingsizes = [(2, 2), (1, 2), (2, 1), (0, 0), (1, 1)]
imgsizes = [(5, 5), (5, 5), (5, 6), (6, 5), (5, 5)]
m = 4 # minibatch
c = 2 # channel size
images = tensor.dtensor4()
for indx, mode in product(numpy.arange(len(maxpoolsizes)),
['max', 'sum', 'average_inc_pad',
'average_exc_pad']):
imgsize = imgsizes[indx]
imval = rng.rand(m, c, imgsize[0], imgsize[1]) - 0.5
stridesize = stridesizes[indx]
maxpoolsize = maxpoolsizes[indx]
paddingsize = paddingsizes[indx]
numpy_output_val = self.numpy_max_pool_2d_stride_padding(
imval, maxpoolsize, ignore_border,
stridesize, paddingsize, mode)
maxpool_op = Pool(
maxpoolsize,
ignore_border=ignore_border,
st=stridesize, padding=paddingsize, mode=mode)(images)
f = function([images], maxpool_op)
output_val = f(imval)
utt.assert_allclose(output_val, numpy_output_val)
def test_DownsampleFactorMaxPaddingStride(self):
ignore_border = True # padding does not support ignore_border=False
rng = numpy.random.RandomState(utt.fetch_seed())
# maxpool, stride, padding, input sizes
examples = (
((3, ), (2, ), (2, ), (5, )),
((3, ), (2, ), (2, ), (4, 5)),
((3, ), (2, ), (2, ), (4, 2, 5)),
((3, ), (2, ), (2, ), (4, 2, 5, 5)),
((3, 3), (2, 2), (2, 2), (4, 2, 5, 5)),
((4, 4), (2, 2), (1, 2), (4, 2, 5, 5)),
((3, 4), (1, 1), (2, 1), (4, 2, 5, 6)),
((4, 3), (1, 2), (0, 0), (4, 2, 6, 5)),
((2, 2), (2, 2), (1, 1), (4, 2, 5, 5)),
((4, 3, 2), (1, 2, 2), (0, 2, 1), (4, 6, 6, 5)),
((4, 3, 2), (1, 2, 2), (0, 2, 1), (4, 2, 6, 5, 5)),
)
for example, mode in product(
examples,
['max', 'sum', 'average_inc_pad', 'average_exc_pad']):
(maxpoolshp, stridesize, paddingsize, inputsize) = example
imval = rng.rand(*inputsize) - 0.5
images = theano.shared(imval)
numpy_output_val = self.numpy_max_pool_nd_stride_padding(
imval, maxpoolshp, ignore_border, stridesize, paddingsize,
mode)
maxpool_op = Pool(ndim=len(maxpoolshp),
ignore_border=ignore_border,
mode=mode)(images, maxpoolshp, stridesize,
paddingsize)
f = function([], maxpool_op)
output_val = f()
utt.assert_allclose(output_val, numpy_output_val)
def mp(input):
return Pool(
maxpoolsize, ignore_border=True,
st=stridesize,
padding=paddingsize,
mode=mode,
)(input)
def mp(input1, input2):
op1 = Pool(ndim=len(maxpoolshp), ignore_border=True)
pooled_out = op1(input1, maxpoolshp, stridesize, paddingsize)
op2 = DownsampleFactorMaxGradGrad(ndim=len(maxpoolshp),
ignore_border=True)
out = op2(input1, pooled_out, input2, maxpoolshp, stridesize,
paddingsize)
return out
def mp(input, grad):
out = Pool(
maxpoolshp, ignore_border=ignore_border,
st=stride)(input)
grad_op = MaxPoolGrad(
maxpoolshp, ignore_border=ignore_border,
st=stride)
return grad_op(input, out, grad)
def mp(input, grad):
out = Pool(
ndim=len(maxpoolshp),
ignore_border=True,
)(input, maxpoolshp, stridesize, paddingsize)
grad_op = MaxPoolGrad(ndim=len(maxpoolshp), ignore_border=True)
return grad_op(input, out, grad, maxpoolshp, stridesize,
paddingsize)
def mp(input, grad):
out = Pool(ndim=len(maxpoolshp),
ignore_border=ignore_border)(input, maxpoolshp,
stride)
grad_op = MaxPoolGrad(ndim=len(maxpoolshp),
ignore_border=ignore_border)
return grad_op(input, out, grad, maxpoolshp, stride)
utt.verify_grad(mp, [imval, grad_val], rng=rng)
def mp(input, grad):
out = Pool(
maxpoolsize, ignore_border=True,
st=stridesize,
padding=paddingsize,
)(input)
grad_op = MaxPoolGrad(maxpoolsize, ignore_border=True,
st=stridesize, padding=paddingsize)
return grad_op(input, out, grad)
def test_downsample(self):
rng = np.random.RandomState(utt.fetch_seed())
# ws, shp
examples = (
((2, ), (16, )),
(
(2, ),
(
4,
16,
),
),
(
(2, ),
(
4,
2,
16,
),
),
((1, 1), (4, 2, 16, 16)),
((2, 2), (4, 2, 16, 16)),
((3, 3), (4, 2, 16, 16)),
((3, 2), (4, 2, 16, 16)),
((3, 2, 2), (3, 2, 16, 16, 16)),
((2, 3, 2), (3, 2, 16, 16, 16)),
((2, 2, 3), (3, 2, 16, 16, 16)),
((2, 2, 3, 2), (3, 2, 6, 6, 6, 5)),
)
for example, ignore_border in itertools.product(
examples, [True, False]):
(ws, shp) = example
vx = rng.rand(*shp)
vex = rng.rand(*shp)
x = theano.shared(vx)
ex = theano.shared(vex)
maxpool_op = Pool(ignore_border, ndim=len(ws))
a_pooled = maxpool_op(x, ws).flatten()
yv = tensor.Rop(a_pooled, x, ex)
mode = None
if theano.config.mode == "FAST_COMPILE":
mode = "FAST_RUN"
rop_f = function([], yv, on_unused_input="ignore", mode=mode)
sy, _ = theano.scan(
lambda i, y, x, v: (tensor.grad(y[i], x) * v).sum(),
sequences=tensor.arange(a_pooled.shape[0]),
non_sequences=[a_pooled, x, ex],
mode=mode,
)
scan_f = function([], sy, on_unused_input="ignore", mode=mode)
v1 = rop_f()
v2 = scan_f()
assert np.allclose(v1, v2), f"Rop mismatch: {v1} {v2}"
def test_max_pool3d_grad_grad():
shps = [(1, 1, 12),
(1, 1, 1, 1, 1),
(1, 1, 1, 1, 1025),
(1, 1, 2, 2, 2),
(1, 1, 7, 7, 7),
(1, 1, 9, 10, 11),
(1, 6, 18, 18, 18),
(1, 1, 6, 24, 24),
(1, 10, 1, 24, 24),
(1, 10, 6, 24, 24),
(1, 30, 6, 12, 12),
(1, 30, 2, 24, 24),
(1, 30, 6, 24, 24),
(1, 10, 10, 10, 11),
(1, 1, 10, 10, 1025),
(1, 1, 10, 10, 1023),
(1, 1, 10, 1025, 10),
(1, 1, 10, 1023, 10), ]
numpy.random.RandomState(utt.fetch_seed()).shuffle(shps)
test_ds = (2, 2, 2), (3, 2, 3), (1, 1, 1)
test_st = (2, 2, 2), (2, 3, 2), (1, 1, 1)
for shp in shps:
for ds, st in itertools.product(test_ds, test_st):
if ds[0] > shp[-3] or ds[1] > shp[-2] or ds[2] > shp[-1]:
continue
for ignore_border, pad in zip((True, False), [(1, 1, 1), (0, 0, 0)]):
if pad[0] >= ds[0] or pad[1] >= ds[1] or pad[2] >= ds[2]:
continue
# print('test_downsample', shp, ds, st, pad, ignore_border)
ds_op = Pool(ndim=len(ds), ignore_border=ignore_border)
a = theano.shared(rand(*shp), 'a')
ggf = gradient.Lop(tensor.grad((ds_op(
tensor.as_tensor_variable(a), ds, st, pad)**2).sum(), a), a, a)
ref_mode = copy.copy(mode_without_gpu)
ref_mode.check_py_code = False
gpu_mode = copy.copy(mode_with_gpu)
gpu_mode.check_py_code = False
gg = theano.function([], ggf, mode=gpu_mode)
gg2 = theano.function([], ggf, mode=ref_mode)
assert any([
isinstance(node.op, GpuDownsampleFactorMaxGradGrad)
for node in gg.maker.fgraph.toposort()
])
assert any([
isinstance(node.op, DownsampleFactorMaxGradGrad)
for node in gg2.maker.fgraph.toposort()
])
assert numpy.allclose(gg(), gg2()), (shp, ds, st,
ignore_border)
def test_DownsampleFactorMaxStrideExtra(self):
rng = np.random.RandomState(utt.fetch_seed())
maxpoolshps = ((5, 3), (5, 3), (5, 3), (5, 5), (3, 2), (7, 7), (9, 9))
stridesizes = ((3, 2), (7, 5), (10, 6), (1, 1), (2, 3), (10, 10), (1,
1))
imvsizs = ((16, 16), (16, 16), (16, 16), (8, 5), (8, 5), (8, 5), (8,
5))
outputshps = (
(4, 10, 4, 7),
(4, 10, 5, 8),
(4, 10, 2, 3),
(4, 10, 3, 4),
(4, 10, 2, 3),
(4, 10, 2, 3),
(4, 10, 4, 1),
(4, 10, 4, 1),
(4, 10, 3, 2),
(4, 10, 4, 2),
(4, 10, 1, 0),
(4, 10, 1, 1),
(4, 10, 0, 0),
(4, 10, 1, 1),
)
images = tensor.dtensor4()
for indx in np.arange(len(maxpoolshps)):
imvsize = imvsizs[indx]
imval = rng.rand(4, 10, imvsize[0], imvsize[1])
stride = stridesizes[indx]
maxpoolshp = maxpoolshps[indx]
for ignore_border, mode in product(
[True, False],
["max", "sum", "average_inc_pad", "average_exc_pad"]):
indx_out = indx * 2
if not ignore_border:
indx_out += 1
outputshp = outputshps[indx_out]
# Pool op
numpy_output_val = self.numpy_max_pool_2d_stride(
imval, maxpoolshp, ignore_border, stride, mode)
assert (numpy_output_val.shape == outputshp
), "outshape is {}, calculated shape is {}".format(
outputshp,
numpy_output_val.shape,
)
maxpool_op = Pool(ignore_border=ignore_border,
ndim=len(maxpoolshp),
mode=mode)(images, maxpoolshp, stride)
f = function([images], maxpool_op)
output_val = f(imval)
utt.assert_allclose(output_val, numpy_output_val)
def mp(input1, input2):
op1 = Pool(ignore_border=True)
pooled_out = op1(input1,
maxpoolsize,
stride=stridesize,
pad=paddingsize)
op2 = DownsampleFactorMaxGradGrad(ignore_border=True)
out = op2(input1,
pooled_out,
input2,
ws=maxpoolsize,
stride=stridesize,
pad=paddingsize)
return out
def test_DownsampleFactorMax(self):
rng = numpy.random.RandomState(utt.fetch_seed())
# generate random images
maxpoolshps = ((1, 1), (2, 2), (3, 3), (2, 3))
imval = rng.rand(4, 2, 16, 16)
images = tensor.dtensor4()
for maxpoolshp, ignore_border, mode in product(
maxpoolshps, [True, False],
['max', 'sum', 'average_inc_pad', 'average_exc_pad']):
# print 'maxpoolshp =', maxpoolshp
# print 'ignore_border =', ignore_border
# Pure Numpy computation
numpy_output_val = self.numpy_max_pool_2d(imval,
maxpoolshp,
ignore_border,
mode=mode)
output = pool_2d(images, maxpoolshp, ignore_border, mode=mode)
f = function([
images,
], [
output,
])
output_val = f(imval)
utt.assert_allclose(output_val, numpy_output_val)
# Pool op
maxpool_op = Pool(maxpoolshp,
ignore_border=ignore_border,
mode=mode)(images)
output_shape = Pool.out_shape(imval.shape,
maxpoolshp,
ignore_border=ignore_border)
utt.assert_allclose(numpy.asarray(output_shape),
numpy_output_val.shape)
f = function([images], maxpool_op)
output_val = f(imval)
utt.assert_allclose(output_val, numpy_output_val)
def test_downsample():
shps = [(1, 12),
(1, 1, 12),
(1, 1, 1, 12),
(1, 1, 2, 2),
(1, 1, 1, 1),
(1, 1, 4, 4),
(1, 1, 10, 11),
(1, 2, 2, 2),
(3, 5, 4, 4),
(25, 1, 7, 7),
(1, 1, 12, 12),
(1, 1, 2, 14),
(1, 1, 12, 14),
(1, 1, 14, 14),
(1, 1, 16, 16),
(1, 1, 18, 18),
(1, 1, 24, 24),
(1, 6, 24, 24),
(10, 1, 24, 24),
(10, 6, 24, 24),
(30, 6, 12, 12),
(30, 2, 24, 24),
(30, 6, 24, 24),
(10, 10, 10, 11),
(1, 1, 10, 1025),
(1, 1, 10, 1023),
(1, 1, 1025, 10),
(1, 1, 1023, 10),
(65536, 1, 10, 10),
(1, 65536, 10, 10), ]
numpy.random.RandomState(unittest_tools.fetch_seed()).shuffle(shps)
for shp in shps:
for ds in (2, 2), (3, 2), (1, 1):
if ds[0] > shp[-2]:
continue
if ds[1] > shp[-1]:
continue
# GpuDownsampleFactorMax doesn't like having more than 512 columns
# in the output tensor.
if float(shp[-1]) / ds[1] > 512:
continue
for ignore_border in (True, False):
# print 'test_downsample', shp, ds, ignore_border
ds_op = Pool(ndim=len(ds), ignore_border=ignore_border)
a = tcn.shared_constructor(my_rand(*shp), 'a')
f = pfunc([], ds_op(tensor.as_tensor_variable(a), ds),
mode=mode_with_gpu.excluding('cudnn'))
f2 = pfunc([], ds_op(tensor.as_tensor_variable(a), ds),
mode=mode_without_gpu)
assert any([isinstance(node.op,
tcn.blas.GpuDownsampleFactorMax)
for node in f.maker.fgraph.toposort()])
assert any([isinstance(node.op, Pool)
for node in f2.maker.fgraph.toposort()])
assert numpy.allclose(f(), f2())
# The grad is too slow on GT220 GPU
# This cause the computer to freeze...
# Remove this when it gets optimized enough
# This only bypass the last 2 checks
# Those tests where passing in all Mode on a GTX470
if shp[0] > 30000 or shp[1] > 30000:
continue
g = pfunc(
[],
tensor.grad(ds_op(tensor.as_tensor_variable(a), ds).sum(),
a),
mode=mode_with_gpu.excluding('cudnn'))
g2 = pfunc(
[],
tensor.grad(ds_op(tensor.as_tensor_variable(a), ds).sum(),
a),
mode=mode_without_gpu)
assert any([isinstance(node.op,
tcn.blas.GpuDownsampleFactorMaxGrad)
for node in g.maker.fgraph.toposort()])
assert any([isinstance(node.op, PoolGrad)
for node in g2.maker.fgraph.toposort()])
assert numpy.allclose(g(), g2()), shp
ggf = gradient.Lop(tensor.grad((ds_op(
tensor.as_tensor_variable(a), ds)**2).sum(), a), a, a)
ref_mode = copy.copy(mode_without_gpu)
ref_mode.check_py_code = False
gpu_mode = copy.copy(mode_with_gpu)
gpu_mode.check_py_code = False
gg = pfunc([], ggf, mode=gpu_mode)
gg2 = pfunc([], ggf, mode=ref_mode)
assert any([isinstance(
node.op, tcn.blas.GpuDownsampleFactorMaxGradGrad)
for node in gg.maker.fgraph.toposort()])
assert any([isinstance(
node.op, DownsampleFactorMaxGradGrad)
for node in gg2.maker.fgraph.toposort()])
assert numpy.allclose(gg(), gg2()), shp
def mp(input, grad):
out = Pool(ndim=len(maxpoolshp),
ignore_border=ignore_border)(input, maxpoolshp)
grad_op = MaxPoolGrad(ndim=len(maxpoolshp),
ignore_border=ignore_border)
return grad_op(input, out, grad, maxpoolshp)
def mp(input):
return Pool(ndim=len(maxpoolshp),
ignore_border=ignore_border,
mode=mode)(input, maxpoolshp, stridesize)
def mp(input):
return Pool(
ndim=len(maxpoolshp),
ignore_border=True,
mode=mode,
)(input, maxpoolshp, stridesize, paddingsize)
def max_pool_3d(input, ds, ignore_border=False):
"""
Takes as input a N-D tensor, where N >= 3. It downscales the input video by
the specified factor, by keeping only the maximum value of non-overlapping
patches of size (ds[0],ds[1],ds[2]) (time, height, width)
:type input: N-D theano tensor of input images.
:param input: input images. Max pooling will be done over the 3 last dimensions.
:type ds: tuple of length 3
:param ds: factor by which to downscale. (2,2,2) will halve the video in each dimension.
:param ignore_border: boolean value. When True, (5,5,5) input with ds=(2,2,2) will generate a
(2,2,2) output. (3,3,3) otherwise.
"""
if input.ndim < 3:
raise NotImplementedError('max_pool_3d requires a dimension >= 3')
# extract nr dimensions
vid_dim = input.ndim
# max pool in two different steps, so we can use the 2d implementation of
# downsamplefactormax. First maxpool frames as usual.
# Then maxpool the time dimension. Shift the time dimension to the third
# position, so rows and cols are in the back
# extract dimensions
frame_shape = input.shape[-2:]
# count the number of "leading" dimensions, store as dmatrix
batch_size = tensor.prod(input.shape[:-2])
batch_size = tensor.shape_padright(batch_size, 1)
# store as 4D tensor with shape: (batch_size,1,height,width)
new_shape = tensor.cast(
tensor.join(0, batch_size, tensor.as_tensor([
1,
]), frame_shape), 'int32')
input_4D = tensor.reshape(input, new_shape, ndim=4)
# downsample mini-batch of videos in rows and cols
op = Pool(ignore_border)
output = op(input_4D, (ds[1], ds[2]))
# restore to original shape
outshape = tensor.join(0, input.shape[:-2], output.shape[-2:])
out = tensor.reshape(output, outshape, ndim=input.ndim)
# now maxpool time
# output (time, rows, cols), reshape so that time is in the back
shufl = (list(range(vid_dim - 3)) + [vid_dim - 2] + [vid_dim - 1] +
[vid_dim - 3])
input_time = out.dimshuffle(shufl)
# reset dimensions
vid_shape = input_time.shape[-2:]
# count the number of "leading" dimensions, store as dmatrix
batch_size = tensor.prod(input_time.shape[:-2])
batch_size = tensor.shape_padright(batch_size, 1)
# store as 4D tensor with shape: (batch_size,1,width,time)
new_shape = tensor.cast(
tensor.join(0, batch_size, tensor.as_tensor([
1,
]), vid_shape), 'int32')
input_4D_time = tensor.reshape(input_time, new_shape, ndim=4)
# downsample mini-batch of videos in time
op = Pool(ignore_border)
outtime = op(input_4D_time, (1, ds[0]))
# output
# restore to original shape (xxx, rows, cols, time)
outshape = tensor.join(0, input_time.shape[:-2], outtime.shape[-2:])
shufl = (list(range(vid_dim - 3)) + [vid_dim - 1] + [vid_dim - 3] +
[vid_dim - 2])
return tensor.reshape(outtime, outshape, ndim=input.ndim).dimshuffle(shufl)
def test_DownsampleFactorMaxStride(self):
rng = numpy.random.RandomState(utt.fetch_seed())
# maxpool, stride, ignore_border, input, output sizes
examples = (
((1, 1), (1, 1), True, (4, 10, 16, 16), (4, 10, 16, 16)),
((1, 1), (3, 3), True, (4, 10, 16, 16), (4, 10, 6, 6)),
((1, 1), (5, 7), True, (4, 10, 16, 16), (4, 10, 4, 3)),
((1, 1), (1, 1), False, (4, 10, 16, 16), (4, 10, 16, 16)),
((1, 1), (3, 3), False, (4, 10, 16, 16), (4, 10, 6, 6)),
((1, 1), (5, 7), False, (4, 10, 16, 16), (4, 10, 4, 3)),
((3, 3), (1, 1), True, (4, 10, 16, 16), (4, 10, 14, 14)),
((3, 3), (3, 3), True, (4, 10, 16, 16), (4, 10, 5, 5)),
((3, 3), (5, 7), True, (4, 10, 16, 16), (4, 10, 3, 2)),
((3, 3), (1, 1), False, (4, 10, 16, 16), (4, 10, 14, 14)),
((3, 3), (3, 3), False, (4, 10, 16, 16), (4, 10, 6, 6)),
((3, 3), (5, 7), False, (4, 10, 16, 16), (4, 10, 4, 3)),
((5, 3), (1, 1), True, (4, 10, 16, 16), (4, 10, 12, 14)),
((5, 3), (3, 3), True, (4, 10, 16, 16), (4, 10, 4, 5)),
((5, 3), (5, 7), True, (4, 10, 16, 16), (4, 10, 3, 2)),
((5, 3), (1, 1), False, (4, 10, 16, 16), (4, 10, 12, 14)),
((5, 3), (3, 3), False, (4, 10, 16, 16), (4, 10, 5, 6)),
((5, 3), (5, 7), False, (4, 10, 16, 16), (4, 10, 4, 3)),
((16, 16), (1, 1), True, (4, 10, 16, 16), (4, 10, 1, 1)),
((16, 16), (3, 3), True, (4, 10, 16, 16), (4, 10, 1, 1)),
((16, 16), (5, 7), True, (4, 10, 16, 16), (4, 10, 1, 1)),
((16, 16), (1, 1), False, (4, 10, 16, 16), (4, 10, 1, 1)),
((16, 16), (3, 3), False, (4, 10, 16, 16), (4, 10, 1, 1)),
((16, 16), (5, 7), False, (4, 10, 16, 16), (4, 10, 1, 1)),
((3, ), (5, ), True, (16, ), (3, )),
((3, ), (5, ), True, (
2,
16,
), (
2,
3,
)),
((5, ), (3, ), True, (
2,
3,
16,
), (
2,
3,
4,
)),
((5, 1, 3), (3, 3, 3), True, (2, 16, 16, 16), (2, 4, 6, 5)),
((5, 1, 3), (3, 3, 3), True, (4, 2, 16, 16, 16), (4, 2, 4, 6, 5)),
)
for example, mode in product(
examples,
['max', 'sum', 'average_inc_pad', 'average_exc_pad']):
(maxpoolshp, stride, ignore_border, inputshp, outputshp) = example
# generate random images
imval = rng.rand(*inputshp)
images = theano.shared(imval)
# Pool op
numpy_output_val = \
self.numpy_max_pool_nd_stride(imval, maxpoolshp,
ignore_border, stride,
mode)
assert numpy_output_val.shape == outputshp, (
"outshape is %s, calculated shape is %s" %
(outputshp, numpy_output_val.shape))
maxpool_op = \
Pool(ndim=len(maxpoolshp),
ignore_border=ignore_border,
mode=mode)(images, maxpoolshp, stride)
f = function([], maxpool_op)
output_val = f()
utt.assert_allclose(output_val, numpy_output_val)
def mp(input):
return Pool(ignore_border=True,
mode=mode)(input, maxpoolsize, stridesize,
paddingsize)
def mp(input, grad):
out = Pool(ignore_border=True)(input, maxpoolsize, stridesize,
paddingsize)
grad_op = MaxPoolGrad(ignore_border=True)
return grad_op(input, out, grad, maxpoolsize, stridesize,
paddingsize)
def mp(input):
return Pool(maxpoolshp,
ignore_border=ignore_border,
st=stride,
mode=mode)(input)
def mp(input):
return Pool(ignore_border=ignore_border,
mode=mode)(input, maxpoolshp, stride)
def test_DownsampleFactorMax(self):
rng = numpy.random.RandomState(utt.fetch_seed())
# maxpool, input size
examples = (
((2, ), (16, )),
((2, ), (
4,
16,
)),
((2, ), (
4,
2,
16,
)),
((1, 1), (4, 2, 16, 16)),
((2, 2), (4, 2, 16, 16)),
((3, 3), (4, 2, 16, 16)),
((3, 2), (4, 2, 16, 16)),
((3, 2, 2), (3, 2, 16, 16, 16)),
((2, 3, 2), (3, 2, 16, 16, 16)),
((2, 2, 3), (3, 2, 16, 16, 16)),
((2, 2, 3, 2), (3, 2, 6, 6, 6, 5)),
)
for example, ignore_border, mode in product(
examples, [True, False],
['max', 'sum', 'average_inc_pad', 'average_exc_pad']):
(maxpoolshp, inputsize) = example
imval = rng.rand(*inputsize)
images = theano.shared(imval)
# Pure Numpy computation
numpy_output_val = self.numpy_max_pool_nd(imval,
maxpoolshp,
ignore_border,
mode=mode)
# The pool_2d or pool_3d helper methods
if len(maxpoolshp) == 2:
output = pool_2d(images, maxpoolshp, ignore_border, mode=mode)
f = function([], [
output,
])
output_val = f()
utt.assert_allclose(output_val, numpy_output_val)
elif len(maxpoolshp) == 3:
output = pool_3d(images, maxpoolshp, ignore_border, mode=mode)
f = function([], [
output,
])
output_val = f()
utt.assert_allclose(output_val, numpy_output_val)
# Pool op
maxpool_op = Pool(ndim=len(maxpoolshp),
ignore_border=ignore_border,
mode=mode)(images, maxpoolshp)
output_shape = Pool.out_shape(imval.shape,
maxpoolshp,
ndim=len(maxpoolshp),
ignore_border=ignore_border)
utt.assert_allclose(numpy.asarray(output_shape),
numpy_output_val.shape)
f = function([], maxpool_op)
output_val = f()
utt.assert_allclose(output_val, numpy_output_val)
def mp(input, grad):
out = Pool(ignore_border=ignore_border)(input, maxpoolshp,
stride)
grad_op = MaxPoolGrad(ignore_border=ignore_border)
return grad_op(input, out, grad, maxpoolshp, stride)
def test_pool2d():
shps = [
(1, 12),
(1, 1, 12),
(1, 1, 1, 12),
(1, 1, 2, 2),
(1, 1, 1, 1),
(1, 1, 4, 4),
(1, 1, 10, 11),
(1, 2, 2, 2),
(3, 5, 4, 4),
(25, 1, 7, 7),
(1, 1, 12, 12),
(1, 1, 2, 14),
(1, 1, 12, 14),
(1, 1, 14, 14),
(1, 1, 16, 16),
(1, 1, 18, 18),
(1, 1, 24, 24),
(1, 6, 24, 24),
(10, 1, 24, 24),
(10, 6, 24, 24),
(30, 6, 12, 12),
(30, 2, 24, 24),
(30, 6, 24, 24),
(10, 10, 10, 11),
(1, 1, 10, 1025),
(1, 1, 10, 1023),
(1, 1, 1025, 10),
(1, 1, 1023, 10),
(3, 2, 16, 16, 16),
(3, 2, 6, 6, 6, 5),
(3, 2, 6, 6, 6, 5, 7),
]
numpy.random.RandomState(utt.fetch_seed()).shuffle(shps)
test_ws = (2, 2), (3, 2), (1, 1)
test_st = (2, 2), (3, 2), (1, 1)
test_mode = ['max', 'sum', 'average_inc_pad', 'average_exc_pad']
ref_mode = copy.copy(mode_without_gpu)
ref_mode.check_py_code = False
gpu_mode = copy.copy(mode_with_gpu).excluding("cudnn")
gpu_mode.check_py_code = False
for shp in shps:
for mode, ws, st in itertools.product(test_mode, test_ws, test_st):
if ws[0] > shp[-2] or ws[1] > shp[-1]:
continue
for ignore_border, pad in zip((True, False), [(1, 1), (0, 0)]):
if pad[0] >= ws[0] or pad[1] >= ws[1]:
continue
if mode == 'average_exc_pad' and (pad[0] > 0 or pad[1] > 0):
continue
# print('test_pool2d', shp, ws, st, pad, mode, ignore_border)
ds_op = Pool(ndim=len(ws),
mode=mode,
ignore_border=ignore_border)
a = theano.shared(rand(*shp), 'a')
a_pooled = ds_op(tensor.as_tensor_variable(a), ws, st, pad)
f = theano.function([], a_pooled, mode=gpu_mode)
f2 = theano.function([], a_pooled, mode=ref_mode)
assert any([
isinstance(node.op, GpuPool)
for node in f.maker.fgraph.toposort()
])
assert any([
isinstance(node.op, Pool)
for node in f2.maker.fgraph.toposort()
])
assert numpy.allclose(f(), f2()), (shp, ws, st, pad, mode,
ignore_border)
a_pooled_grad = tensor.grad(a_pooled.sum(), a)
g = theano.function([], a_pooled_grad, mode=gpu_mode)
g2 = theano.function([], a_pooled_grad, mode=ref_mode)
if mode == 'max':
gop = GpuMaxPoolGrad
gop2 = MaxPoolGrad
else:
gop = GpuAveragePoolGrad
gop2 = AveragePoolGrad
assert any([
isinstance(node.op, gop)
for node in g.maker.fgraph.toposort()
])
assert any([
isinstance(node.op, gop2)
for node in g2.maker.fgraph.toposort()
])
assert numpy.allclose(g(), g2()), (shp, ws, st, pad, mode,
ignore_border)
# test grad grad for max pooling
# for average pooling grad grad is just average pooling grad
if mode != 'max':
continue
ggf = gradient.Lop(tensor.grad((a_pooled**2).sum(), a), a, a)
gg = theano.function([], ggf, mode=gpu_mode)
gg2 = theano.function([], ggf, mode=ref_mode)
assert any([
isinstance(node.op, GpuDownsampleFactorMaxGradGrad)
for node in gg.maker.fgraph.toposort()
])
assert any([
isinstance(node.op, DownsampleFactorMaxGradGrad)
for node in gg2.maker.fgraph.toposort()
])
assert numpy.allclose(gg(), gg2()), (shp, ws, st, pad, mode,
ignore_border)
