def test_conv2d_layer_kmax_pooling():
rng = np.random.RandomState(1)
print "Testing 2D Convolutional Layer with k-max Pooling..."
for k in xrange(5):
print "Layer %i..." % k
# random parameters
nb_filters = 1
stack_size = rng.randint(1, 10)
filter_height = rng.randint(1, 10)
filter_width = rng.randint(1, 10)
wide = rng.randint(2)
# hidden layer
conv_layer = convolution.Conv2DLayerKMaxPooling(
nb_filters,
stack_size,
filter_height,
filter_width,
wide,
"conv_layer_kmax_pooling"
)
filters = conv_layer.conv2d_layer.filters.get_value()[0]
# bias = conv_layer.conv2d_layer.bias.get_value()
for i in xrange(20):
print "%i" % i,
# tests for dimension 1, 2, 3 and 4
input = T.tensor4('input_test')
input_value = rng.rand(stack_size, rng.randint(20, 30), rng.randint(5, 20)).astype(floatX)
while not wide and (input_value.shape[1] < filters.shape[1] or input_value.shape[2] < filters.shape[2]):
input_value = rng.rand(stack_size, rng.randint(10, 20), rng.randint(5, 20)).astype(floatX)
input_value_4d = np.array([input_value])
# k_max = T.iscalar('k_max')
k_max_value = rng.randint(1, 10)
pooling.set_k_max(conv_layer, k_max_value, 1, 1, input.shape[2])
output = conv_layer.link(input)
expected_value = convolve2d(input_value[0], filters[0], mode="full" if wide else "valid")
for i in xrange(1, stack_size):
expected_value += convolve2d(input_value[i], filters[i], mode="full" if wide else "valid")
expected_value = kmax_pooling(np.array([[expected_value]]), k_max_value)
expected_value += conv_layer.conv2d_layer.bias.get_value()
expected_value = np.tanh(expected_value)
assert expected_value.shape[:2] == (1, 1)
assert expected_value.shape[2] in [k_max_value, input_value.shape[1] + (filters.shape[1] - 1) * (1 if wide else -1)]
assert expected_value.shape[3] == input_value.shape[2] + (filters.shape[2] - 1) * (1 if wide else -1)
np.testing.assert_array_almost_equal(
output.eval({input: input_value_4d}),
expected_value,
decimal=4
)
print "OK"
print "All tests ran successfully for 2D Convolution Layer with k-max Pooling."
def test_conv1d_layer_kmax_pooling():
print "Testing 1D convolutional layer with k-max pooling..."
for k in xrange(5):
print "Layer %i..." % k
# random parameters
nb_filters = 1 # np.random.randint(1, 10)
stack_size = np.random.randint(1, 10)
filter_height = np.random.randint(1, 10)
wide = np.random.randint(2)
emb_dim = np.random.randint(5, 20)
# hidden layer
conv_layer = convolution.Conv1DLayerKMaxPooling(
nb_filters,
stack_size,
filter_height,
wide,
emb_dim,
'conv1d_layer'
)
filters = conv_layer.conv1d_layer.filters.get_value()
bias = conv_layer.conv1d_layer.bias.get_value()
for i in xrange(20):
print "%i" % i,
# tests for dimension 1, 2, 3 and 4
input = T.tensor4('input_test')
input_value = np.random.rand(
1,
stack_size,
np.random.randint(20, 30),
emb_dim
).astype(floatX)
while (not wide) and input_value.shape[2] < filters.shape[3]:
input_value = np.random.rand(
1,
stack_size,
np.random.randint(20, 30),
emb_dim
).astype(floatX)
# k_max = T.iscalar('k_max')
k_max_value = np.random.randint(1, 10)
pooling.set_k_max(conv_layer, k_max_value, 1, 1, input.shape[2])
output = conv_layer.link(input)
expected_value_shape = (1, nb_filters, input_value.shape[2] + (filters.shape[3] - 1) * (1 if wide else -1), emb_dim)
expected_value = np.zeros(expected_value_shape)
# filter : (emb_dim, nb_filters, stack_size, filter_height, 1)
for i in xrange(nb_filters):
for j in xrange(stack_size):
for k in xrange(emb_dim):
# print ""
# print wide, input_value.shape, filters.shape
# print expected_value.shape
# print input_value[0][j][:,k].shape
# print filters[k][i][j].flatten().shape
# print np.convolve(input_value[0][j][:,k], filters[k][i][j].flatten(), mode = "full" if wide else "valid").shape
# print expected_value[0][i][:,k].shape
expected_value[0][i][:, k] += convolve(
input_value[0, j, :, k],
filters[k, i, j].flatten(),
mode="full" if wide else "valid"
)
# print expected_value[0][0]
# print output.eval({input:input_value})[0][0]
# return
expected_value = kmax_pooling(np.array(expected_value), k_max_value)
for i in xrange(nb_filters):
for j in xrange(emb_dim):
expected_value[:, i, :, j] += bias[i, j]
expected_value = np.tanh(expected_value)
assert expected_value.shape[:2] == (1, nb_filters)
assert expected_value.shape[2] in [k_max_value, input_value.shape[2] + (filters.shape[3] - 1) * (1 if wide else -1)]
assert expected_value.shape[3] == input_value.shape[3]
# print wide, k_max_value, input_value.shape, filters.shape, expected_value.shape
np.testing.assert_array_almost_equal(
output.eval({input: input_value}),
expected_value,
decimal=4
)
print "OK"
print "All tests ran successfully for 1D Convolution Layer with k-max pooling."
