示例#1
0
 def test_transform_thin_plate_spline_shift(self):
     from lasagne.layers import InputLayer, TPSTransformerLayer
     from theano.tensor import constant
     batchsize = 5
     num_control_points = 16
     dest_offset = np.ones(shape=(batchsize, 2*num_control_points))
     l_in = InputLayer((batchsize, 3, 28, 28))
     l_loc = InputLayer((batchsize, 2*num_control_points))
     layer = TPSTransformerLayer(
             l_in, l_loc, control_points=num_control_points
     )
     image = np.zeros(shape=(28, 28))
     image[[0, -1], :] = 1
     image[:, [0, -1]] = 1
     inputs = np.tile(image, (batchsize, 3, 1, 1))
     shifted_input = np.ones(shape=(28, 28))
     shifted_input[:13, :13] = 0
     shifted_input[13, :13] = 0.50000271
     shifted_input[:13, 13] = 0.50000271
     shifted_input[13, 13] = 0.75000271
     shifted_input = np.tile(shifted_input, (batchsize, 3, 1, 1))
     outputs = layer.get_output_for([constant(inputs),
                                     constant(dest_offset)]).eval()
     np.testing.assert_allclose(shifted_input,
                                outputs, atol=1e-5)
示例#2
0
 def test_transform_thin_plate_spline_shift(self):
     from lasagne.layers import InputLayer, TPSTransformerLayer
     from theano.tensor import constant
     batchsize = 5
     num_control_points = 16
     dest_offset = np.ones(shape=(batchsize, 2*num_control_points))
     l_in = InputLayer((batchsize, 3, 28, 28))
     l_loc = InputLayer((batchsize, 2*num_control_points))
     layer = TPSTransformerLayer(
             l_in, l_loc, control_points=num_control_points
     )
     image = np.zeros(shape=(28, 28))
     image[[0, -1], :] = 1
     image[:, [0, -1]] = 1
     inputs = np.tile(image, (batchsize, 3, 1, 1))
     shifted_input = np.ones(shape=(28, 28))
     shifted_input[:13, :13] = 0
     shifted_input[13, :13] = 0.50000271
     shifted_input[:13, 13] = 0.50000271
     shifted_input[13, 13] = 0.75000271
     shifted_input = np.tile(shifted_input, (batchsize, 3, 1, 1))
     outputs = layer.get_output_for([constant(inputs),
                                     constant(dest_offset)]).eval()
     np.testing.assert_allclose(shifted_input,
                                outputs, atol=1e-5)
示例#3
0
def build_st_spline_network(input_shape):
    W = b = lasagne.init.Constant(0.0)
    num_points = 4
    num_filters = 64
    filter_size = (3, 3)
    pool_size = (2, 2)

    l_in = InputLayer(shape=(None, input_shape[1], input_shape[2],
                             input_shape[3]))

    l_conv1 = Conv2DLayer(l_in,
                          num_filters=num_filters,
                          filter_size=filter_size)

    l_pool1 = MaxPool2DLayer(l_conv1, pool_size=pool_size)

    l_conv2 = Conv2DLayer(l_pool1,
                          num_filters=num_filters,
                          filter_size=filter_size)

    l_pool2 = MaxPool2DLayer(l_conv2, pool_size=pool_size)

    l_dense1 = DenseLayer(l_pool2, num_units=128)

    l_dense2 = DenseLayer(l_dense1,
                          num_units=num_points * 2,
                          W=W,
                          b=b,
                          nonlinearity=None)

    l_st = TPSTransformerLayer(l_in, l_dense2, control_points=num_points)

    l_output = ReshapeLayer(l_st, shape=([0], -1))

    return l_output
示例#4
0
 def test_transform_thin_plate_spline_identity(self):
     from lasagne.layers import InputLayer, TPSTransformerLayer
     from lasagne.utils import floatX
     from theano.tensor import constant
     batchsize = 5
     num_control_points = 16
     dest_offset = np.zeros(shape=(batchsize, 2 * num_control_points))
     l_in = InputLayer((batchsize, 3, 28, 28))
     l_loc = InputLayer((batchsize, 2 * num_control_points))
     layer = TPSTransformerLayer(l_in,
                                 l_loc,
                                 control_points=num_control_points)
     inputs = floatX(np.arange(np.prod(l_in.shape)).reshape(l_in.shape))
     outputs = layer.get_output_for(
         [constant(inputs), constant(dest_offset)]).eval()
     np.testing.assert_allclose(inputs, outputs, atol=1e-5)
示例#5
0
 def test_transform_thin_plate_spline_identity(self):
     from lasagne.layers import InputLayer, TPSTransformerLayer
     from lasagne.utils import floatX
     from theano.tensor import constant
     batchsize = 5
     num_control_points = 16
     dest_offset = np.zeros(shape=(batchsize, 2*num_control_points))
     l_in = InputLayer((batchsize, 3, 28, 28))
     l_loc = InputLayer((batchsize, 2*num_control_points))
     layer = TPSTransformerLayer(
             l_in, l_loc, control_points=num_control_points
     )
     inputs = floatX(np.arange(np.prod(l_in.shape)).reshape(l_in.shape))
     outputs = layer.get_output_for([constant(inputs),
                                     constant(dest_offset)]).eval()
     np.testing.assert_allclose(inputs, outputs, atol=5e-4)