def test_multilayer_conv(self):
# fixed parameters
bsize = 10 # batch size
imshp = (5, 5)
kshp = ((3, 3), (2, 2))
nkerns = (3, 6) # per output pixel
ssizes = (((1, 1), (2, 2)),)
convmodes = ("full",) # 'valid',)
# symbolic stuff
kerns = [dmatrix(), dmatrix()]
input = dmatrix()
# rng = np.random.RandomState(3423489)
# build actual input images
img2d = np.arange(bsize * np.prod(imshp)).reshape((bsize,) + imshp)
img1d = img2d.reshape(bsize, -1)
for mode in ("FAST_COMPILE", "FAST_RUN"):
for conv_mode in convmodes:
for ss in ssizes:
l1hid, l1shp = sp.convolve(
kerns[0],
kshp[0],
nkerns[0],
input,
imshp,
ss[0],
mode=conv_mode,
)
l1propup = function([kerns[0], input], l1hid, mode=mode)
# l1kernvals = np.random.rand(nkerns[0],np.prod(kshp[0]))
l1kernvals = np.arange(nkerns[0] * np.prod(kshp[0])).reshape(
nkerns[0], np.prod(kshp[0])
)
l1hidval = l1propup(l1kernvals, img1d)
# actual values
l2hid, l2shp = sp.convolve(
kerns[1],
kshp[1],
nkerns[1],
l1hid,
l1shp,
ss[1],
mode=conv_mode,
)
l2propup = function([kerns[1], l1hid], l2hid, mode=mode)
# l2kernvals = np.random.rand(nkerns[1],np.prod(kshp[1])*nkerns[0])
l2kernvals = np.arange(
nkerns[1] * np.prod(kshp[1]) * nkerns[0]
).reshape(nkerns[1], np.prod(kshp[1]) * nkerns[0])
# for debugging, we bring things back to integers
l1hidval = np.arange(np.size(l1hidval)).reshape(l1hidval.shape)
l2propup(l2kernvals, l1hidval)
def test_convolution(self):
# print '\n\n*************************************************'
# print ' TEST CONVOLUTION'
# print '*************************************************'
# fixed parameters
bsize = 10 # batch size
imshp = (28, 28)
kshp = (5, 5)
nkern = 5
ssizes = ((1, 1), (2, 2), (3, 3), (4, 4))
convmodes = ("full", "valid")
# symbolic stuff
bias = tensor.dvector()
kerns = tensor.dmatrix()
input = tensor.dmatrix()
rng = np.random.RandomState(3423489)
filters = rng.randn(nkern, np.prod(kshp))
biasvals = rng.randn(nkern)
for mode in ("FAST_COMPILE", "FAST_RUN"):
ttot, ntot = 0, 0
for conv_mode in convmodes:
for ss in ssizes:
output, outshp = sp.convolve(kerns,
kshp,
nkern,
input,
imshp,
ss,
bias=bias,
mode=conv_mode)
f = function([kerns, bias, input], output, mode=mode)
# now test with real values
img2d = np.arange(
bsize * np.prod(imshp)).reshape((bsize, ) + imshp)
img1d = img2d.reshape(bsize, -1)
# create filters (need to be flipped to use convolve2d)
filtersflipped = np.zeros((nkern, ) + kshp)
for k in range(nkern):
it = reversed(filters[k, :])
for i in range(kshp[0]):
for j in range(kshp[1]):
filtersflipped[k, i, j] = next(it)
# compute output with convolve2d
if conv_mode == "valid":
fulloutshp = np.array(imshp) - np.array(kshp) + 1
else:
fulloutshp = np.array(imshp) + np.array(kshp) - 1
ntime1 = time.time()
refout = np.zeros((bsize, ) + tuple(fulloutshp) +
(nkern, ))
for b in range(bsize):
for n in range(nkern):
refout[b, ...,
n] = convolve2d(img2d[b, :, :],
filtersflipped[n, ...],
conv_mode)
ntot += time.time() - ntime1
# need to flatten images
bench1 = refout[:, 0::ss[0],
0::ss[1], :].reshape(bsize, -1, nkern)
bench1 += biasvals.reshape(1, 1, nkern)
# swap the last two dimensions (output needs to be nkern x outshp)
bench1 = np.swapaxes(bench1, 1, 2)
ttime1 = time.time()
out1 = f(filters, biasvals, img1d)
ttot += time.time() - ttime1
temp = bench1.flatten() - out1.flatten()
assert (temp < 1e-5).all()
