def get_G(input_shape):
w_init = tf.random_normal_initializer(stddev=0.02)
g_init = tf.random_normal_initializer(1., 0.02)
nin = Input(input_shape)
n = Conv2d(64, (3, 3), (1, 1), act=tf.nn.relu, padding='SAME', W_init=w_init)(nin)
temp = n
# B residual blocks
for i in range(16):
nn = Conv2d(64, (3, 3), (1, 1), padding='SAME', W_init=w_init, b_init=None)(n)
nn = BatchNorm(act=tf.nn.relu, gamma_init=g_init)(nn)
nn = Conv2d(64, (3, 3), (1, 1), padding='SAME', W_init=w_init, b_init=None)(nn)
nn = BatchNorm(gamma_init=g_init)(nn)
nn = Elementwise(tf.add)([n, nn])
n = nn
n = Conv2d(64, (3, 3), (1, 1), padding='SAME', W_init=w_init, b_init=None)(n)
n = BatchNorm(gamma_init=g_init)(n)
n = Elementwise(tf.add)([n, temp])
# B residual blacks end
n = Conv2d(256, (3, 3), (1, 1), padding='SAME', W_init=w_init)(n)
n = SubpixelConv2d(scale=2, n_out_channels=None, act=tf.nn.relu)(n)
n = Conv2d(256, (3, 3), (1, 1), act=None, padding='SAME', W_init=w_init)(n)
n = SubpixelConv2d(scale=2, n_out_channels=None, act=tf.nn.relu)(n)
nn = Conv2d(3, (1, 1), (1, 1), act=tf.nn.tanh, padding='SAME', W_init=w_init)(n)
G = Model(inputs=nin, outputs=nn, name="generator")
return G
def LapSRNSingleLevel(net_image, net_feature, reuse=False):
with tf.variable_scope("Model_level", reuse=reuse):
tl.layers.set_name_reuse(reuse)
net_tmp = net_feature
# recursive block
for d in range(config.model.resblock_depth):
net_tmp = PReluLayer(net_tmp, name='prelu_D%s' % (d))
net_tmp = Conv2dLayer(
net_tmp,
shape=[3, 3, 64, 64],
strides=[1, 1, 1, 1],
name='conv_D%s' % (d),
W_init=tf.contrib.layers.xavier_initializer())
# for r in range(1,config.model.recursive_depth):
# for d in range(config.model.resblock_depth):
# net_tmp = PReluLayer(net_tmp, name='prelu_R%s_D%s'%(r,d))
# net_tmp = Conv2dLayer(net_tmp,shape=[3,3,64,64],strides=[1,1,1,1],
# name='conv_R%s_D%s'%(r,d), W_init=tf.contrib.layers.xavier_initializer())
net_feature = ElementwiseLayer(layer=[net_feature, net_tmp],
combine_fn=tf.add,
name='add_feature')
net_feature = PReluLayer(net_feature, name='prelu_feature')
net_feature = Conv2dLayer(
net_feature,
shape=[3, 3, 64, 256],
strides=[1, 1, 1, 1],
name='upconv_feature',
W_init=tf.contrib.layers.xavier_initializer())
net_feature = SubpixelConv2d(net_feature,
scale=2,
n_out_channel=64,
name='subpixel_feature')
# add image back
gradient_level = Conv2dLayer(
net_feature,
shape=[3, 3, 64, 3],
strides=[1, 1, 1, 1],
act=lrelu,
name='grad',
W_init=tf.contrib.layers.xavier_initializer())
net_image = Conv2dLayer(net_image,
shape=[3, 3, 3, 12],
strides=[1, 1, 1, 1],
name='upconv_image',
W_init=tf.contrib.layers.xavier_initializer())
net_image = SubpixelConv2d(net_image,
scale=2,
n_out_channel=3,
name='subpixel_image')
net_image = ElementwiseLayer(layer=[gradient_level, net_image],
combine_fn=tf.add,
name='add_image')
return net_image, net_feature, gradient_level
def upscale(layer,
out_channels,
out_size=None,
scale=None,
mode='upconv',
name='upsale'):
# if (out_size is None) and (scale is None):
# raise ValueError("At least one of out_size and scale must be non-None")
if mode == 'upconv':
if out_size is None:
batch, height, width, _ = layer.outputs.get_shape()
out_size = [int(height * scale), int(width * scale)]
return upconv(layer, out_channels, out_size, filter_size=3, name=name)
elif mode == 'deconv':
return deconv2d(layer,
out_channels=out_channels,
out_size=out_size,
name='%sdeconv' % name)
elif mode == 'subpixel':
if (scale is None):
raise ValueError('scale cannot be None when mode==subpixel')
n = SubpixelConv2d(layer, scale=scale, name='%s/subpixel' % name)
return conv2d(n,
n_filter=out_channels,
filter_size=3,
name='%s/conv' % name)
else:
raise ValueError('unknown mode: %s' % mode)
def Generator(input_shape):
w_init = tf.random_normal_initializer(stddev=0.02)
g_init = tf.random_normal_initializer(1., 0.02)
layer_in = Input(input_shape)
l = Conv2d(64, (3, 3), (1, 1),
padding='SAME',
act=tf.nn.relu,
w_init=w_init)(layer_in)
temp = l
#Residual Blocks
for i in range(16):
nn = Conv2d(64, (3, 3), (1, 1),
act=tf.nn.relu,
padding='SAME',
W_init=w_init,
b_init=None)(l)
nn = BatchNorm2d(act=tf.nn.relu, gamma_init=g_init)(nn)
#nn = PRelu(a_init = w_init)(nn)
nn = Conv2d(64, (3, 3), (1, 1),
act=tf.nn.relu,
padding='SAME',
W_init=w_init,
b_init=None)(nn)
nn = BatchNorm2d(act=tf.nn.relu, gamma_init=g_init)(nn)
nn = Elementwise(tf.add)[l, nn]
l = nn
l = Conv2d(64, (3, 3), (1, 1), padding='SAME', W_init=w_init,
b_init=None)(l)
l = BatchNorm2d(gamma_init=g_init)(l)
l = Elementwise(tf.add)[l, temp]
l = Conv2d(256, (3, 3), (1, 1), padding='SAME', W_init=w_init)(l)
l = SubpixelConv2d(scale=2, n_out_channels=None, act=tf.nn.relu)(l)
l = Conv2d(256, (3, 3), (1, 1), padding='SAME', W_init=w_init)(l)
l = SubpixelConv2d(scale=2, n_out_chanels=None, act=tf.nn.relu)(l)
layer_out = Conv2d(3, (1, 1), (1, 1),
act=tf.nn.tanh,
padding='SAME',
W_init=w_init)(l)
Generator = Model(inputs=layer_in, outputs=layer_out, name='generator')
return Generator
def get_G(input_shape):
w_init = tf.random_normal_initializer(stddev=0.02)
nin = Input(input_shape)
n = Conv2d(64, (3, 3), (1, 1),
act=tf.nn.relu,
padding='SAME',
W_init=w_init)(nin)
'''上采样后直接加到网络末尾'''
up_bicubic = tl.layers.UpSampling2d((4, 4), method='bicubic')(nin)
temp = n
# B residual blocks
for i in range(16):
nn = Conv2d(64, (3, 3), (1, 1),
act=tf.nn.relu,
padding='SAME',
W_init=w_init,
b_init=None)(n)
nn = Conv2d(64, (3, 3), (1, 1),
padding='SAME',
W_init=w_init,
b_init=None)(nn)
nn = Elementwise(tf.add)([n, nn])
n = nn
n = Conv2d(64, (3, 3), (1, 1), padding='SAME', W_init=w_init,
b_init=None)(n)
n = Elementwise(tf.add)([n, temp])
# B residual blacks end
n = Conv2d(256, (3, 3), (1, 1), padding='SAME', W_init=w_init)(n)
n = SubpixelConv2d(scale=2, n_out_channels=None, act=tf.nn.relu)(n)
n = Conv2d(256, (3, 3), (1, 1), act=None, padding='SAME', W_init=w_init)(n)
n = SubpixelConv2d(scale=2, n_out_channels=None, act=tf.nn.relu)(n)
nn = Conv2d(3, (1, 1), (1, 1),
act=tf.nn.tanh,
padding='SAME',
W_init=w_init)(n)
nn = Elementwise(tf.add)([nn, up_bicubic])
G = Model(inputs=nin, outputs=nn)
return G
def __init__(self):
super(SRresnet,self).__init__()
w_init = tf.random_normal_initializer(stddev=0.02)
g_init = tf.random_normal_initializer(1., 0.02)
self.conv1 = Conv2d(n_filter=64,filter_size=(3, 3),strides=(1, 1),in_channels=3, act=tf.nn.relu, padding='SAME', W_init=w_init,b_init=None)
self.conv2 = Conv2d(n_filter=64,filter_size=(3, 3),strides=(1, 1),in_channels=64, padding='SAME', W_init=w_init,b_init=None)
self.conv3 = Conv2d(n_filter=256,filter_size=(3, 3),strides=(1, 1),in_channels=64, padding='SAME', W_init=w_init,b_init=None)
self.conv4 = Conv2d(n_filter=3,filter_size=(3, 3),strides=(1, 1),in_channels=64, act=tf.nn.tanh, padding='SAME', W_init=w_init,b_init=None)
self.bn2 = BatchNorm2d(num_features = 64,gamma_init=g_init)
self.bn1 = BatchNorm2d(num_features = 64,gamma_init=g_init, act=tf.nn.relu)
self.subconv1 = SubpixelConv2d(scale=2, n_out_channels=256,in_channels=256, act=tf.nn.relu)
self.add1 = Elementwise(tf.add)
def model_G2(): ##Phase2 Generator
gamma_init = tf1.random_normal_initializer(1., 0.02)
w_init = tf1.random_normal_initializer(stddev=0.02)
fn = tf1.nn.relu
## Input layers
lr_image = Input(
(None, 128, 128, 3)) ## (batch_size, height, width, channel)
hr_image = Input((None, 512, 512, 3))
## Feature extracting layers from LR image
lr_feature_layer_1 = Conv2d(64, (3, 3), (1, 1),
act=fn,
padding='SAME',
W_init=w_init)(lr_image) # Shape(1,256,256,64)
lr_feature_layer_1 = BatchNorm2d(gamma_init=gamma_init)(lr_feature_layer_1)
lr_feature_layer_2 = SubpixelConv2d(scale=4, act=fn)(
lr_feature_layer_1) # Shape(1,256,256,16)
## Feature extracting layers from HR image
hr_feature_layer_1 = Conv2d(64, (3, 3), (1, 1),
act=fn,
padding='SAME',
W_init=w_init)(hr_image) # Shape(1,256,256,64)
hr_feature_layer_1 = BatchNorm2d(gamma_init=gamma_init)(hr_feature_layer_1)
## Features Merging layers
merge_layer = Concat(concat_dim=-1)(
[lr_feature_layer_2, hr_feature_layer_1]) # Shape(1,256,256,128)
non_linearity_layer_1 = Conv2d(64, (5, 5), (1, 1),
act=fn,
padding='SAME',
W_init=w_init)(
merge_layer) # Shape(1,256,256,256)
non_linearity_layer_1 = BatchNorm2d(
gamma_init=gamma_init)(non_linearity_layer_1)
## Reconstruction layers
Recon_layer_1 = Conv2d(3, (5, 5), (1, 1),
act=fn,
padding='SAME',
W_init=w_init)(
non_linearity_layer_1) # Shape(1,256,256,1)
Recon_layer_2 = Elementwise(combine_fn=tf1.add)([Recon_layer_1, hr_image
]) # Shape(1,256,256,1)
return Model(inputs=[lr_image, hr_image], outputs=Recon_layer_2)
def get_espcn(input_shape):
w_init = tf.random_normal_initializer(stddev=0.02)
g_init = tf.random_normal_initializer(1., 0.02)
nin = Input(input_shape)
n = Conv2d(64, (5, 5), (1, 1),
act=tf.nn.relu,
padding='SAME',
W_init=w_init)(nin)
n = Conv2d(32, (3, 3), (1, 1),
act=tf.nn.relu,
padding='SAME',
W_init=w_init)(n)
n = SubpixelConv2d(scale=2, n_out_channels=None, act=tf.nn.relu)(n)
n = Conv2d(48, (3, 3), (1, 1), act=None, padding='SAME', W_init=w_init)(n)
n = SubpixelConv2d(scale=2, n_out_channels=None, act=tf.nn.relu)(n)
nn = Conv2d(3, (1, 1), (1, 1),
act=tf.nn.tanh,
padding='SAME',
W_init=w_init)(n)
G = Model(inputs=nin, outputs=nn, name="generator_espcn")
return G
raise Exception("shape dont match")
if len(n.all_layers) != 2:
raise Exception("layers dont match")
if len(n.all_params) != 2:
raise Exception("params dont match")
if n.count_params() != 416:
raise Exception("params dont match")
## 2D
x = tf.placeholder('float32', [10, 100, 100, 3], name='x')
n = InputLayer(x, name='in')
n = Conv2d(n, 32, (3, 2), (1, 1), padding='SAME', name='conv2d')
n = SubpixelConv2d(n, scale=2, name='subpixel2d')
print(n.outputs.shape)
n.print_layers()
n.print_params(False)
shape = n.outputs.get_shape().as_list()
if shape != [10, 200, 200, 8]:
raise Exception("shape dont match")
if len(n.all_layers) != 2:
raise Exception("layers dont match")
if len(n.all_params) != 2:
raise Exception("params dont match")
def SRGAN_g(t_image, is_train=False, reuse=False):
'''
Build the generator
'''
w_init = tf.random_normal_initializer(stddev=0.02)
b_init = tf.constant_initializer(value=0.0)
g_init = tf.random_normal_initializer(1., 0.02)
with tf.variable_scope("SRGAN_g", reuse=reuse) as vs:
n = InputLayer(t_image, name='in')
n = Conv2d(n,
64, (3, 3), (1, 1),
act=tf.nn.relu,
padding='SAME',
W_init=w_init,
name='n64s1/c')
temp = n
# 16 residual blocks
for i in range(16):
nn = Conv2d(n,
64, (3, 3), (1, 1),
act=None,
padding='SAME',
W_init=w_init,
b_init=b_init,
name='n64s1/c1/%s' % i)
nn = BatchNormLayer(nn,
act=tf.nn.relu,
is_train=is_train,
gamma_init=g_init,
name='n64s1/b1/%s' % i)
nn = Conv2d(nn,
64, (3, 3), (1, 1),
act=None,
padding='SAME',
W_init=w_init,
b_init=b_init,
name='n64s1/c2/%s' % i)
nn = BatchNormLayer(nn,
is_train=is_train,
gamma_init=g_init,
name='n64s1/b2/%s' % i)
nn = ElementwiseLayer([n, nn],
tf.add,
name='b_residual_add/%s' % i)
n = nn
n = Conv2d(n,
64, (3, 3), (1, 1),
act=None,
padding='SAME',
W_init=w_init,
b_init=b_init,
name='n64s1/c/m')
n = BatchNormLayer(n,
is_train=is_train,
gamma_init=g_init,
name='n64s1/b/m')
n = ElementwiseLayer([n, temp], tf.add, name='add3')
# 16 residual blacks end
n = Conv2d(n,
256, (3, 3), (1, 1),
act=None,
padding='SAME',
W_init=w_init,
b_init=b_init,
name='n256s1/1')
n = SubpixelConv2d(n,
scale=2,
n_out_channel=None,
act=tf.nn.relu,
name='pixelshufflerx2/1')
# n = Conv2d(n, 256, (3, 3), (1, 1), act=None, padding='SAME', W_init=w_init, name='n256s1/2')
# n = SubpixelConv2d(n, scale=2, n_out_channel=None, act=tf.nn.relu, name='pixelshufflerx2/2')
n = Conv2d(n,
3, (1, 1), (1, 1),
act=tf.nn.tanh,
padding='SAME',
W_init=w_init,
b_init=b_init,
name='out')
return n
def get_conv_block(n, w_init):
n = Conv2d(256, (3, 3), (1, 1), padding='SAME', W_init=w_init)(n)
n = SubpixelConv2d(scale=2, n_out_channels=None, act=tf.nn.relu)(n)
return n
def _phase_shift(x):
n = InputLayer(x, name='input_subpixel')
n = SubpixelConv2d(n, scale=scale, n_out_channel=None, act=tf.nn.relu)
return n.outputs
def UNet_A(lf_extra,
n_slices,
output_size,
is_train=True,
reuse=False,
name='unet'):
'''U-net based VCD-Net for light field reconstruction.
Params:
lf_extra: tf.tensor
In shape of [batch, height, width, n_num^2], the extracted views from the light field image
n_slices: int
The slices number of the 3-D reconstruction.
output_size: list of int
Lateral size of the 3-D reconstruction, i.e., [height, width].
is_train: boolean
Sees tl.layers.BatchNormLayer.
reuse: boolean
Whether to reuse the variables or not. See tf.variable_scope() for details.
name: string
The name of the variable scope.
Return:
The 3-D reconstruction in shape of [batch, height, width, depth=n_slices]
'''
n_interp = 4
# _, w, h, _ = lf_extra.shape
#channels_interp = in_channels.value
channels_interp = 128
act = tf.nn.relu
with tf.variable_scope(name, reuse=reuse):
n = InputLayer(lf_extra, 'lf_extra')
n = conv2d(n, n_filter=channels_interp, filter_size=7, name='conv1')
## Up-scale input
with tf.variable_scope('interp'):
for i in range(n_interp):
channels_interp = channels_interp / 2
n = SubpixelConv2d(n, scale=2, name='interp/subpixel%d' % i)
n = conv2d(n,
n_filter=channels_interp,
filter_size=3,
name='conv%d' % i)
n = conv2d(n,
n_filter=channels_interp,
filter_size=3,
name='conv_final') # 176*176
n = batch_norm(n, is_train=is_train, name='bn_final')
n = ReluLayer(n, name='reul_final')
pyramid_channels = [
128, 256, 512, 512, 512
] # output channels number of each conv layer in the encoder
encoder_layers = []
with tf.variable_scope('encoder'):
n = conv2d(n, n_filter=64, filter_size=3, stride=1, name='conv0')
n = batch_norm(n, is_train=is_train, name='bn_0')
n = ReluLayer(n, name='reul0')
for idx, nc in enumerate(pyramid_channels):
encoder_layers.append(
n
) # append n0, n1, n2, n3, n4 (but without n5)to the layers list
print('encoder %d : %s' % (idx, str(n.outputs.get_shape())))
n = conv2d(n,
n_filter=nc,
filter_size=3,
stride=1,
name='conv%d' % (idx + 1))
n = batch_norm(n, is_train=is_train, name='bn%d' % (idx + 1))
n = ReluLayer(n, name='reul%d' % (idx + 1))
n1 = PadDepth(encoder_layers[-1], desired_channels=nc)
n = merge([n, n1], name='add%d' % (idx + 1))
n = tl.layers.MaxPool2d(n,
filter_size=(3, 3),
strides=(2, 2),
name='maxplool%d' % (idx + 1))
nl = len(encoder_layers)
with tf.variable_scope('decoder'):
_, h, w, _ = encoder_layers[-1].outputs.shape.as_list()
n = UpSampling2dLayer(n,
size=(h, w),
is_scale=False,
name='upsamplimg')
for idx in range(nl - 1, -1, -1): # idx = 4,3,2,1,0
if idx > 0:
_, h, w, _ = encoder_layers[idx -
1].outputs.shape.as_list()
out_size = (h, w)
out_channels = pyramid_channels[idx - 1]
else:
#out_size = None
out_channels = n_slices
print('decoder %d : %s' % (idx, str(n.outputs.get_shape())))
n = ConcatLayer([encoder_layers[idx], n],
concat_dim=-1,
name='concat%d' % (nl - idx))
n = conv2d(n,
out_channels,
filter_size=3,
stride=1,
name='conv%d' % (nl - idx + 1))
n = ReluLayer(n, name='relu%d' % (nl - idx + 1))
n = batch_norm(n,
is_train=is_train,
name='bn%d' % (nl - idx + 1))
#n = UpConv(n, 512, filter_size=4, factor=2, name='upconv2')
n = UpSampling2dLayer(n,
size=out_size,
is_scale=False,
name='upsamplimg%d' % (nl - idx + 1))
#n = DropoutLayer(n, keep=0.5, is_fix=True, is_train=is_train, name='dropout1')
if n.outputs.shape[1] != output_size[0]:
n = UpSampling2dLayer(n,
size=output_size,
is_scale=False,
name='resize_final')
#n = conv2d(n, n_slices, filter_size=3, stride=1,name='conv_final' )
n.outputs = tf.tanh(n.outputs)
#n.outputs = tf.nn.relu(n.outputs)
#n = conv2d(n, n_filter=n_slices, filter_size=3, act=tf.tanh, name='out')
return n
