def exec_multilayer_conv_nnet_old(
conv_mode,
ss,
bsize,
imshp,
kshps,
nkerns,
unroll_batch=0,
unroll_kern=0,
img=None,
validate=True,
conv_op_py=False,
do_print=True,
repeat=1,
unroll_patch=False,
unroll_patch_size=False,
verbose=0,
):
if img is None:
img = tt.dmatrix()
# build actual input images
imgval = global_rng.rand(bsize, imshp[0], imshp[1], imshp[2])
a = tt.dmatrix()
kerns = [a for i in nkerns]
inputs4 = dmatrix4()
kerns4 = dmatrix4()
# for each layer
ntot = 0
tctot = 0
tpytot = 0
for kshp, kern, nkern, n_layer in zip(kshps, kerns, nkerns,
range(len(nkerns))):
if do_print:
print("************* layer %i ***************" % n_layer)
print(conv_mode, ss, n_layer, kshp, nkern)
# actual values
w = global_rng.random_sample(N.r_[nkern, imshp[0], kshp])
w_flip = flip(w, kshp).reshape(w.shape)
# manual implementation
# check first stage
padimg = imgval
if conv_mode == "full":
padimg_shp = N.array(
imshp[1:]) + 2 * (N.array(kshp) - N.array([1, 1]))
padimg = N.zeros(N.r_[bsize, imshp[0], padimg_shp])
padimg[:, :, kshp[0] - 1:-kshp[0] + 1,
kshp[1] - 1:-kshp[1] + 1] = imgval
outshp = N.hstack(
(nkern, ConvOp.getOutputShape(imshp[1:], kshp, ss, conv_mode)))
time1 = time.time()
outval = N.zeros(N.r_[bsize, outshp])
if validate:
# causes an atexit problem
from scipy.signal.signaltools import _bvalfromboundary, _valfrommode
from scipy.signal.sigtools import _convolve2d
val = _valfrommode(conv_mode)
bval = _bvalfromboundary("fill")
for b in range(bsize): # loop over batches
for n in range(nkern): # loop over filters
for i in range(imshp[0]): # loop over input feature maps
outval[b, n,
...] += _convolve2d(imgval[b, i, ...],
w_flip[n, i, ...], 1, val,
bval, 0)[0::ss[0], 0::ss[1]]
ntot += time.time() - time1
# ConvOp
if unroll_patch and not unroll_patch_size:
conv_op = ConvOp(
dx=ss[0],
dy=ss[1],
output_mode=conv_mode,
unroll_patch=unroll_patch,
verbose=verbose,
)(inputs4, kerns4)
else:
conv_op = ConvOp(
imshp,
kshp,
nkern,
bsize,
ss[0],
ss[1],
conv_mode,
unroll_batch=unroll_batch,
unroll_kern=unroll_kern,
unroll_patch=unroll_patch,
verbose=verbose,
)(inputs4, kerns4)
# l1shp = N.hstack((nkern,
# ConvOp.getOutputShape(imshp[1:], kshp, ss, conv_mode)))
propup2 = function([inputs4, kerns4], conv_op)
propup3 = function([inputs4, kerns4], conv_op, mode=Mode(linker="py"))
time1 = time.time()
for i in range(repeat):
hidval2_ = propup2(imgval, w_flip)
hidval2 = hidval2_ # [:,:,0::ss[0],0::ss[1]]
tctot += time.time() - time1
if conv_op_py:
time1 = time.time()
for i in range(repeat):
hidval3_ = propup3(imgval, w_flip)
hidval3 = hidval3_ # [:,:,0::ss[0],0::ss[1]]
tpytot += time.time() - time1
assert (N.abs(hidval2 - hidval3) < 1e-5).all()
else:
tpytot += 0
if validate:
temp = N.abs(outval - hidval2)
assert (temp < 1e-5).all()
if validate and conv_op_py:
temp = N.abs(outval - hidval3)
assert (temp < 1e-5).all()
imshp = tuple(outshp)
imgval = outval.reshape(bsize, outshp[0], outshp[1], outshp[2])
return tctot, tpytot, ntot
def exec_multilayer_conv_nnet(
conv_mode,
ss,
bsize,
imshp,
kshps,
nkerns,
unroll_batch=0,
unroll_kern=0,
img=None,
do_print=True,
repeat=1,
unroll_patch=False,
unroll_patch_size=False,
verbose=0,
):
if img is None:
img = tt.dmatrix()
# build actual input images
imgval = global_rng.rand(bsize, imshp[0], imshp[1], imshp[2])
a = tt.dmatrix()
kerns = [a for i in nkerns]
inputs4 = dmatrix4()
kerns4 = dmatrix4()
# for each layer
ntot = 0
tctot = 0
tpytot = 0
for kshp, kern, nkern, n_layer in zip(kshps, kerns, nkerns,
range(len(nkerns))):
if do_print:
print("************* layer %i ***************" % n_layer)
print(conv_mode, ss, n_layer, kshp, nkern)
# actual values
w = global_rng.random_sample(N.r_[nkern, imshp[0], kshp])
w_flip = flip(w, kshp).reshape(w.shape)
outshp = N.hstack(
(nkern, ConvOp.getOutputShape(imshp[1:], kshp, ss, conv_mode)))
time1 = time.time()
# outval = N.zeros(N.r_[bsize, outshp])
# ConvOp
if unroll_patch and not unroll_patch_size:
conv_op = ConvOp(
dx=ss[0],
dy=ss[1],
output_mode=conv_mode,
unroll_patch=unroll_patch,
verbose=verbose,
)(inputs4, kerns4)
else:
conv_op = ConvOp(
imshp,
kshp,
nkern,
bsize,
ss[0],
ss[1],
conv_mode,
unroll_batch=unroll_batch,
unroll_kern=unroll_kern,
unroll_patch=unroll_patch,
verbose=verbose,
)(inputs4, kerns4)
# l1shp = N.hstack((nkern,
# ConvOp.getOutputShape(imshp[1:], kshp, ss, conv_mode)))
propup2 = function([inputs4, kerns4], conv_op)
time1 = time.time()
for i in range(repeat):
propup2(imgval, w_flip)
tctot += time.time() - time1
imshp = tuple(outshp)
# imgval = outval.reshape(bsize, outshp[0], outshp[1], outshp[2])
return tctot, tpytot, ntot