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)