def test_deconvolution2d_with_conv2d_gpu_contiguous():
input_shape = (64, 1, 8, 8)
model = Sequential()
model.add(Activation('linear', batch_input_shape=input_shape))
model.add(Deconvolution2D(8, 3, 3, subsample=(1, 1), border_mode=(1, 1)))
model.add(BatchNormalization(axis=1))
model.add(Activation('relu'))
model.add(Convolution2D(10, 3, 3, border_mode='same'))
model.add(BatchNormalization(axis=1))
model.add(Activation('relu'))
model.add(Deconvolution2D(1, 3, 3, subsample=(2, 2), border_mode=(1, 1)))
model.compile('sgd', 'mse')
img = np.random.sample((64, 1, 16, 16)).astype(np.float32)
model.predict(img)
def deconv(nb_filter, h, w):
return Deconvolution2D(nb_filter,
h,
w,
subsample=(2, 2),
border_mode=(2, 2),
init=init)
def test_deconvolution2d():
x = Input(shape=(1, 16, 16))
out = Deconvolution2D(10, 3, 3, subsample=(2, 2))(x)
fn = theano.function([x], out)
img = np.random.sample((64, 1, 16, 16)).astype(np.float32)
deconv_out = fn(img)
assert deconv_out.shape == (64, 10, 32, 32)
def dcgan_generator_conv(n=32,
input_dim=50,
nb_output_channels=1,
init=normal(0.02)):
def conv(nb_filter, h, w):
model.add(Convolution2D(nb_filter, h, w, border_mode='same',
init=init))
model.add(batch_norm())
model.add(Activation('relu'))
def deconv(nb_filter, h, w):
deconv_layer = Deconvolution2D(nb_filter,
h,
w,
border_mode=(1, 1),
init=init)
model.add(deconv_layer)
w = np.random.normal(0, 0.02, deconv_layer.W_shape).astype(np.float32)
w *= np.random.uniform(0, 1, (1, w.shape[1], 1, 1))
deconv_layer.W.set_value(w)
model.add(batch_norm())
model.add(Activation('relu'))
def up():
model.add(UpSampling2D())
z = Layer(input_shape=(input_dim, ))
model = Sequential()
model.add(z)
model.add(Dense(8 * n * 4 * 4, init=init))
model.add(batch_norm())
model.add(Reshape((
8 * n,
4,
4,
)))
model.add(Activation('relu'))
up() # 8
conv(4 * n, 3, 3)
up() # 16
conv(2 * n, 3, 3)
conv(2 * n, 3, 3)
up() # 32
conv(n, 3, 3)
conv(n, 3, 3)
up() # 64
conv(n, 3, 3)
model.add(
Deconvolution2D(nb_output_channels,
3,
3,
border_mode=(1, 1),
init=init))
model.add(InBounds(-1, 1))
return model
def get_mask_postprocess(inputs, nb_units):
n = nb_units
return sequential([
conv(n, 3, 3),
conv(n, 3, 3),
Deconvolution2D(1, 5, 5, border_mode=(2, 2)),
LinearInBounds(-1, 1, clip=True),
],
ns='mask_post')(concat(inputs))
def test_deconvolution2d():
model = Sequential()
model.add(
Deconvolution2D(10, 3, 3, subsample=(2, 2), input_shape=(1, 16, 16)))
out = model.get_output()
fn = theano.function([model.input], out)
img = np.random.sample((64, 1, 16, 16)).astype(np.float32)
deconv_out = fn(img)
assert deconv_out.shape == (64, 10, 32, 32)
def deconv(nb_filter, h, w):
deconv_layer = Deconvolution2D(nb_filter,
h,
w,
border_mode=(1, 1),
init=init)
model.add(deconv_layer)
w = np.random.normal(0, 0.02, deconv_layer.W_shape).astype(np.float32)
w *= np.random.uniform(0, 1, (1, w.shape[1], 1, 1))
deconv_layer.W.set_value(w)
model.add(batch_norm())
model.add(Activation('relu'))
def deconv(model, nb_filter, h, w, activation='relu'):
def deconv_init(shape, name=None):
w = np.random.normal(0, 0.02, shape).astype(np.float32)
nb_filter = shape[1]
mask = np.random.binomial(1, 10 / nb_filter, (1, nb_filter, 1, 1))
w *= mask
return K.variable(w, name=name)
model.add(
Deconvolution2D(nb_filter, h, w, border_mode=(1, 1), init=deconv_init))
model.add(batch_norm())
if issubclass(type(activation), Layer):
model.add(activation)
else:
model.add(Activation(activation))
def dcgan_generator(n=32,
input_dim=50,
nb_output_channels=1,
use_dct=False,
init=normal(0.02)):
def deconv(nb_filter, h, w):
return Deconvolution2D(nb_filter,
h,
w,
subsample=(2, 2),
border_mode=(2, 2),
init=init)
model = Sequential()
model.add(Dense(8 * n * 4 * 4, input_dim=input_dim, init=init))
model.add(batch_norm())
model.add(Reshape((
8 * n,
4,
4,
)))
if use_dct:
model.add(iDCT())
model.add(Activation('relu'))
model.add(deconv(4 * n, 5, 5))
model.add(batch_norm())
model.add(Activation('relu'))
model.add(deconv(2 * n, 5, 5))
model.add(batch_norm())
model.add(Activation('relu'))
model.add(deconv(n, 5, 5))
model.add(batch_norm())
model.add(Activation('relu'))
model.add(
Deconvolution2D(nb_output_channels,
5,
5,
subsample=(2, 2),
border_mode=(2, 2),
init=init))
model.add(InBounds(-1, 1))
return model
def deconv(self, name, batch_norm=True, activation='relu'):
deconv = name + "_deconv"
batch = name + "_batch_norm"
act = name + "_" + activation
self.g.add_node(Deconvolution2D(self.deconv_filter,
5,
5,
subsample=(2, 2),
border_mode=(2, 2)),
deconv,
input=self.get_input())
if batch_norm:
self.g.add_node(BatchNormalization(), batch, input=deconv)
act_in = batch
else:
act_in = deconv
self.g.add_node(Activation(activation), act, input=act_in)
return self.add_output(act)
def dcgan_seperated_generator(input_dim=40,
model_generator=None,
variation_generator=None):
if model_generator is None:
model_generator = dcgan_generator(input_dim)
if variation_generator is None:
variation_generator = dcgan_generator(input_dim,
include_last_layer=False)
g = Graph()
g.add_input('input', input_shape=(input_dim, ))
g.add_node(model_generator, 'model', input='input')
g.add_node(variation_generator, 'variation', input='input')
g.add_node(Deconvolution2D(1, 5, 5, subsample=(2, 2), border_mode=(2, 2)),
'variation_deconv',
input='variation')
g.add_node(Activation('sigmoid'),
'variation_out',
input='variation_deconv')
g.add_output('output', inputs=['model', 'variation_out'], concat_axis=1)
return g
def deconv_bn(model,
nb_filter,
h=3,
w=3,
init=normal(0.02),
activation='relu',
upsample=True,
**kwargs):
if upsample:
subsample = (2, 2)
else:
subsample = (1, 1)
model.add(
Deconvolution2D(nb_filter,
h,
w,
subsample=subsample,
border_mode=(h // 2, w // 2),
init=init,
**kwargs))
model.add(batch_norm())
if activation is not None:
model.add(Activation(activation))
def dcgan_small_generator(nb_units=64,
input_dim=20,
init=normal(0.02),
dense_factor=2,
nb_dense_layers=2,
nb_output_channels=1,
filter_size=3,
deconv_layers=False,
output_size=32):
n = nb_units
f = filter_size
def deconv_up(nb_filter, h, w):
return Deconvolution2D(nb_filter,
h,
w,
subsample=(2, 2),
border_mode=(h // 2, w // 2),
init=init)
def deconv(nb_filter, h, w):
return Deconvolution2D(nb_filter,
h,
w,
subsample=(1, 1),
border_mode=(h // 2, w // 2),
init=init)
model = Sequential()
model.add(Layer(input_shape=(input_dim, )))
for _ in range(nb_dense_layers):
model.add(
Dense(dense_factor * nb_units,
input_dim=input_dim,
activation='relu'))
model.add(Dense(8 * n * 4 * 4, input_dim=input_dim))
model.add(Activation('relu'))
model.add(Reshape((
8 * n,
4,
4,
)))
if deconv_layers:
model.add(deconv(8 * n, f, f))
model.add(Activation('relu'))
model.add(deconv_up(4 * n, f, f))
model.add(Activation('relu'))
if deconv_layers:
model.add(deconv(4 * n, f, f))
model.add(Activation('relu'))
if output_size >= 16:
model.add(deconv_up(2 * n, f, f))
model.add(Activation('relu'))
if deconv_layers:
model.add(deconv(2 * n, f, f))
model.add(Activation('relu'))
if output_size == 32:
model.add(deconv_up(n, f, f))
model.add(Activation('relu'))
if deconv_layers:
model.add(deconv(n, f, f))
model.add(Activation('relu'))
model.add(
Deconvolution2D(nb_output_channels,
f,
f,
border_mode=(1, 1),
init=init))
model.add(Activation('linear'))
return model
def mask_generator_with_conv(nb_units=64,
input_dim=20,
init=normal(0.02),
nb_output_channels=1,
filter_size=3):
n = nb_units
f = filter_size
def deconv(nb_filter, h, w):
return Deconvolution2D(nb_filter,
h,
w,
subsample=(2, 2),
border_mode=(h // 2, w // 2),
init=init)
model = Sequential()
model.add(Dense(5 * input_dim, input_dim=input_dim, init=init))
model.add(batch_norm())
model.add(Activation('relu'))
model.add(Dense(8 * n * 4 * 4, input_dim=input_dim, init=init))
model.add(batch_norm())
model.add(Activation('relu'))
model.add(Reshape((
8 * n,
4,
4,
)))
model.add(deconv(4 * n, f, f))
model.add(batch_norm())
model.add(Activation('relu'))
model.add(Convolution2D(4 * n, f, f, border_mode='same'))
model.add(batch_norm())
model.add(Activation('relu'))
model.add(deconv(2 * n, f, f))
model.add(batch_norm())
model.add(Activation('relu'))
model.add(Convolution2D(2 * n, f, f, border_mode='same'))
model.add(batch_norm())
model.add(Activation('relu'))
model.add(deconv(n, f, f))
model.add(batch_norm())
model.add(Activation('relu'))
model.add(Convolution2D(n, f, f, border_mode='same'))
model.add(batch_norm())
model.add(Activation('relu'))
model.add(
Deconvolution2D(nb_output_channels,
f,
f,
border_mode=(1, 1),
init=init))
model.add(Activation('linear'))
return model
