def test_graph(self):
# define common values first
groups = 3
bottom = np.random.rand(3, 6, 5, 5).astype(aesara.config.floatX)
kern = np.random.rand(9, 2, 3, 3).astype(aesara.config.floatX)
bottom_sym = tensor4("bottom")
kern_sym = tensor4("kern")
# grouped convolution graph
conv_group = self.conv(num_groups=groups)(bottom_sym, kern_sym)
gconv_func = aesara.function([bottom_sym, kern_sym],
conv_group,
mode=self.mode)
# Graph for the normal hard way
kern_offset = kern_sym.shape[0] // groups
bottom_offset = bottom_sym.shape[1] // groups
split_conv_output = [
self.conv()(
bottom_sym[:, i * bottom_offset:(i + 1) * bottom_offset, :, :],
kern_sym[i * kern_offset:(i + 1) * kern_offset, :, :, :],
) for i in range(groups)
]
concatenated_output = at.concatenate(split_conv_output, axis=1)
conv_func = aesara.function([bottom_sym, kern_sym],
concatenated_output,
mode=self.mode)
# calculate outputs for each graph
gconv_output = gconv_func(bottom, kern)
conv_output = conv_func(bottom, kern)
# compare values
utt.assert_allclose(gconv_output, conv_output)
def setup_method(self):
self.input = tensor4("input", dtype=self.dtype)
self.input.name = "default_V"
self.filters = tensor4("filters", dtype=self.dtype)
self.filters.name = "default_filters"
# This tests can run even when aesara.config.blas__ldflags is empty.
super().setup_method()
def burn():
sz = 128
img_shp = [sz, sz, sz, sz]
kern_shp = [sz // 2, sz, 3, 3]
out_shp = get_conv_output_shape(img_shp, kern_shp, "valid", (1, 1))
img = tensor4("img")
kern = tensor4("kern")
out = tensor4("out")
def rand(shp):
return np.random.rand(*shp).astype(config.floatX)
img = aesara.shared(rand(img_shp))
kern = aesara.shared(rand(kern_shp))
out = aesara.shared(rand(out_shp))
# beta 1 is needed to force the reuse of out, otherwise, it is
# replaced by a GpuAllocEmpty
o1 = dnn._dnn_conv(img, kern, conv_mode="conv", out=out, beta=1.0)
mode = aesara.compile.get_default_mode().including(
"local_remove_all_assert")
f = aesara.function([], [o1], mode=mode)
aesara.printing.debugprint(f)
print("Start computation")
for i in range(10000):
f.fn()
print("Computation stopped")
def test_dtype_upcast(self):
# Checks dtype upcast for CorrMM methods.
def rand(shape, dtype="float64"):
r = np.asarray(np.random.rand(*shape), dtype=dtype)
return r * 2 - 1
ops = [corr.CorrMM, corr.CorrMM_gradWeights, corr.CorrMM_gradInputs]
a_shapes = [[4, 5, 6, 3], [1, 5, 6, 3], [1, 5, 6, 3]]
b_shapes = [[7, 5, 3, 2], [1, 5, 3, 1], [7, 1, 3, 1]]
dtypes = ["float32", "float64"]
for op, a_shape, b_shape in zip(ops, a_shapes, b_shapes):
for a_dtype in dtypes:
for b_dtype in dtypes:
c_dtype = aesara.scalar.upcast(a_dtype, b_dtype)
a_tens = tensor4(dtype=a_dtype)
b_tens = tensor4(dtype=b_dtype)
a_tens_val = rand(a_shape, dtype=a_dtype)
b_tens_val = rand(b_shape, dtype=b_dtype)
c_tens = op()(a_tens, b_tens)
f = aesara.function([a_tens, b_tens],
c_tens,
mode=self.mode)
assert f(a_tens_val, b_tens_val).dtype == c_dtype
def test_perform(self, axis):
x = tensor4("x")
rng = np.random.default_rng(utt.fetch_seed())
xv = rng.standard_normal((2, 3, 4, 5)).astype(config.floatX)
f = aesara.function([x], softmax(x, axis=axis))
assert np.allclose(f(xv), sp.softmax(xv, axis=axis))
def test_can_not_infer_nb_dim(self):
# Was reported in gh-5613. Test that we do not crash
# or that we crash in a few other case found while
# investigating that case
img = tensor4("img")
patches = nnet.neighbours.images2neibs(img, [16, 16])
extractPatches = aesara.function([img], patches, mode=self.mode)
patsRecovery = matrix("patsRecovery")
original_size = ivector("original_size")
for mode in ["valid", "ignore_borders"]:
out = neibs2images(patsRecovery, (16, 16),
original_size,
mode=mode)
f = aesara.function([patsRecovery, original_size],
out,
mode=self.mode)
im_val = np.ones((1, 3, 320, 320), dtype=np.float32)
neibs = extractPatches(im_val)
f(neibs, im_val.shape)
# Wrong number of dimensions
with pytest.raises(ValueError):
f(neibs, (1, 1, 3, 320, 320))
# End up with a step of 0
# This can lead to division by zero in DebugMode
with pytest.raises((ValueError, ZeroDivisionError)):
f(neibs, (3, 320, 320, 1))
def setup_method(self):
super().setup_method()
self.A = tensor4("A", dtype=config.floatX)
self.B = tensor3("B", dtype=config.floatX)
self.a = np.random.rand(4, 6, 8, 3).astype(config.floatX)
self.b = np.random.rand(2, 15, 30).astype(config.floatX)
self.b1 = np.random.rand(30, 2, 15).astype(
config.floatX
) # for ind=1 since we need prod(b1.shape[:ind]) == prod(b1.shape[ind:])
def test_tensorsolve():
rng = np.random.RandomState(utt.fetch_seed())
A = tensor4("A", dtype=config.floatX)
B = matrix("B", dtype=config.floatX)
X = tensorsolve(A, B)
fn = function([A, B], [X])
# slightly modified example from np.linalg.tensorsolve docstring
a = np.eye(2 * 3 * 4).astype(config.floatX)
a.shape = (2 * 3, 4, 2, 3 * 4)
b = rng.rand(2 * 3, 4).astype(config.floatX)
n_x = np.linalg.tensorsolve(a, b)
t_x = fn(a, b)
assert _allclose(n_x, t_x)
# check the type upcast now
C = tensor4("C", dtype="float32")
D = matrix("D", dtype="float64")
Y = tensorsolve(C, D)
fn = function([C, D], [Y])
c = np.eye(2 * 3 * 4, dtype="float32")
c.shape = (2 * 3, 4, 2, 3 * 4)
d = rng.rand(2 * 3, 4).astype("float64")
n_y = np.linalg.tensorsolve(c, d)
t_y = fn(c, d)
assert _allclose(n_y, t_y)
assert n_y.dtype == Y.dtype
# check the type upcast now
E = tensor4("E", dtype="int32")
F = matrix("F", dtype="float64")
Z = tensorsolve(E, F)
fn = function([E, F], [Z])
e = np.eye(2 * 3 * 4, dtype="int32")
e.shape = (2 * 3, 4, 2, 3 * 4)
f = rng.rand(2 * 3, 4).astype("float64")
n_z = np.linalg.tensorsolve(e, f)
t_z = fn(e, f)
assert _allclose(n_z, t_z)
assert n_z.dtype == Z.dtype
def test_batch_normalization_train_without_running_averages():
# compile and run batch_normalization_train without running averages
utt.seed_rng()
x, scale, bias, dy = (
tensor4("x"),
tensor4("scale"),
tensor4("bias"),
tensor4("dy"),
)
data_shape = (5, 10, 30, 25)
param_shape = (1, 10, 30, 25)
# forward pass
out, x_mean, x_invstd = batchnorm.batch_normalization_train(
x, scale, bias, "per-activation"
)
# backward pass
grads = aet.grad(None, wrt=[x, scale, bias], known_grads={out: dy})
# compile
f = aesara.function([x, scale, bias, dy], [out, x_mean, x_invstd] + grads)
# check if the abstract Ops have been replaced
assert not any(
[
isinstance(
n.op,
(
batchnorm.AbstractBatchNormTrain,
batchnorm.AbstractBatchNormInference,
batchnorm.AbstractBatchNormTrainGrad,
),
)
for n in f.maker.fgraph.toposort()
]
)
# run
X = 4 + 3 * np.random.randn(*data_shape).astype(aesara.config.floatX)
Dy = -1 + 2 * np.random.randn(*data_shape).astype(aesara.config.floatX)
Scale = np.random.randn(*param_shape).astype(aesara.config.floatX)
Bias = np.random.randn(*param_shape).astype(aesara.config.floatX)
f(X, Scale, Bias, Dy)
def test_bn_feature_maps():
def bn_ref(x, G, B, M, V):
n = (x - M) / V
return n * G + B
rng = np.random.default_rng(1234)
X = 1 + rng.random([2, 3, 4, 4]).astype("float32")
B = 1 + rng.random([3]).astype("float32")
G = 1 + rng.random([3]).astype("float32")
M = 1 + rng.random([3]).astype("float32")
V = 1 + rng.random([3]).astype("float32")
x = tensor4("x")
b = vector("b")
g = vector("g")
m = vector("m")
v = vector("v")
bn_ref_op = bn_ref(
x,
g.dimshuffle("x", 0, "x", "x"),
b.dimshuffle("x", 0, "x", "x"),
m.dimshuffle("x", 0, "x", "x"),
v.dimshuffle("x", 0, "x", "x"),
)
f_ref = aesara.function([x, b, g, m, v], [bn_ref_op])
res_ref = f_ref(X, G, B, M, V)
for mode in ["low_mem", "high_mem"]:
bn_op = batchnorm.batch_normalization(
x,
g.dimshuffle("x", 0, "x", "x"),
b.dimshuffle("x", 0, "x", "x"),
m.dimshuffle("x", 0, "x", "x"),
v.dimshuffle("x", 0, "x", "x"),
mode=mode,
)
f = aesara.function([x, b, g, m, v], [bn_op])
res = f(X, G, B, M, V)
utt.assert_allclose(res_ref, res)
def conv_bn(inputs, gamma, beta, mean, std):
return batchnorm.batch_normalization(
inputs,
gamma.dimshuffle("x", 0, "x", "x"),
beta.dimshuffle("x", 0, "x", "x"),
mean.dimshuffle("x", 0, "x", "x"),
std.dimshuffle("x", 0, "x", "x"),
mode=mode,
)
utt.verify_grad(conv_bn, [X, G, B, M, V])
def test_binary_crossentropy_reshape():
# Reported as https://github.com/Theano/Theano/issues/4086
a = tensor4("a")
for c in (
binary_crossentropy(sigmoid(a.reshape((-1, 1))), 1).sum(),
binary_crossentropy(sigmoid(a).reshape((-1, 1)), 1).sum(),
):
ga = aesara.grad(c, a)
# This only works when "specialize" options are included
mode = aesara.compile.get_default_mode().including("fast_run")
fga = aesara.function([a], ga, mode=mode)
utt.assert_allclose(
fga(np.array([[[[30.0]]]], dtype=config.floatX)),
np.zeros((1, 1, 1, 1), dtype=config.floatX),
)
def test_broadcast_grad():
# rng = numpy.random.RandomState(utt.fetch_seed())
x1 = tensor4("x")
# x1_data = rng.randn(1, 1, 300, 300)
sigma = scalar("sigma")
# sigma_data = 20
window_radius = 3
filter_1d = aet.arange(-window_radius, window_radius + 1)
filter_1d = filter_1d.astype(aesara.config.floatX)
filter_1d = exp(-0.5 * filter_1d ** 2 / sigma ** 2)
filter_1d = filter_1d / filter_1d.sum()
filter_W = filter_1d.dimshuffle(["x", "x", 0, "x"])
y = conv2d(x1, filter_W, border_mode="full", filter_shape=[1, 1, None, None])
aesara.grad(y.sum(), sigma)
def test_max_pool_2d_2D_same_size(self):
rng = np.random.RandomState(utt.fetch_seed())
test_input_array = np.array([[[[1.0, 2.0, 3.0, 4.0],
[5.0, 6.0, 7.0,
8.0]]]]).astype(aesara.config.floatX)
test_answer_array = np.array([[[[0.0, 0.0, 0.0, 0.0],
[0.0, 6.0, 0.0,
8.0]]]]).astype(aesara.config.floatX)
input = tensor4(name="input")
patch_size = (2, 2)
op = max_pool_2d_same_size(input, patch_size)
op_output = function([input], op)(test_input_array)
utt.assert_allclose(op_output, test_answer_array)
def mp(input):
return max_pool_2d_same_size(input, patch_size)
utt.verify_grad(mp, [test_input_array], rng=rng)
def test_broadcast_grad():
x1 = tensor4("x")
sigma = scalar("sigma")
window_radius = 3
filter_1d = at.arange(-window_radius, window_radius + 1)
filter_1d = filter_1d.astype(aesara.config.floatX)
filter_1d = exp(-0.5 * filter_1d**2 / sigma**2)
filter_1d = filter_1d / filter_1d.sum()
filter_W = filter_1d.dimshuffle(["x", "x", 0, "x"])
y = conv2d(x1,
filter_W,
border_mode="full",
filter_shape=[1, 1, None, None])
# TODO FIXME: Make this a real test and `assert` something
aesara.grad(y.sum(), sigma)
def test_tensor_float16(self):
x = tensor4()
np_x = np.arange(30107).reshape(7, 11, 17, 23).astype("float16")
for offset, axis1, axis2 in [
(1, 0, 1),
(-1, 0, 1),
(0, 1, 0),
(-2, 1, 0),
(-3, 1, 0),
(-2, 2, 0),
(3, 3, 0),
(-1, 3, 2),
(2, 2, 3),
(-1, 2, 1),
(1, 3, 1),
(-1, 1, 3),
]:
assert np.allclose(
GpuExtractDiag(offset, axis1, axis2)(x).eval({x: np_x}),
np_x.diagonal(offset, axis1, axis2),
)
def test_perform(self, axis):
x = tensor4("x")
xv = np.random.randn(2, 3, 4, 5).astype(config.floatX)
f = aesara.function([x], softmax(x, axis=axis))
assert np.allclose(f(xv), sp.softmax(xv, axis=axis))
def setup_method(self):
self.input = tensor4("input", dtype=self.dtype)
self.input.name = "default_V"
self.filters = tensor4("filters", dtype=self.dtype)
self.filters.name = "default_filters"
super().setup_method()
