def build_resnet_block_Att(inputres, dim, name="resnet", padding="REFLECT"): out_res = PadLayer([[0, 0], [1, 1], [1, 1], [0, 0]], mode=padding)(inputres) out_res = Conv2d( n_filter=dim, filter_size=(3, 3), strides=(1, 1), padding="VALID", act=None, W_init=tf.initializers.TruncatedNormal(stddev=0.02), b_init=tf.constant_initializer(0.0) )(out_res) out_res = InstanceNorm2d(act=tf.nn.relu)(out_res) out_res = PadLayer([[0, 0], [1, 1], [1, 1], [0, 0]], mode=padding)(out_res) out_res = Conv2d( n_filter=dim, filter_size=(3, 3), strides=(1, 1), padding="VALID", act=None, W_init=tf.initializers.TruncatedNormal(stddev=0.02), b_init=tf.constant_initializer(0.0) )(out_res) out_res = InstanceNorm2d(act=None)(out_res) return tf.nn.relu(out_res + inputres)
def get_base(shape): w_init = tf.random_normal_initializer(stddev=0.02) gamma_init = tf.random_normal_initializer(1., 0.02) lrelu = lambda x: tf.nn.leaky_relu(x, flags.leaky_rate) ni = Input(shape) nn = Conv2d(n_filter=64, filter_size=(4, 4), strides=(2, 2), act=lrelu, W_init=w_init)(ni) nn = Conv2d(n_filter=128, filter_size=(4, 4), strides=(2, 2), W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(nn) nn = Conv2d(n_filter=256, filter_size=(4, 4), strides=(2, 2), W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(nn) nn = Flatten()(nn) return tl.models.Model(inputs=ni, outputs=nn, name='base')
def get_generator(shape, gf_dim=64): # Dimension of gen filters in first conv layer. [64] image_size = flags.output_size s16 = image_size // 8 # w_init = tf.glorot_normal_initializer() w_init = tf.random_normal_initializer(stddev=0.02) gamma_init = tf.random_normal_initializer(1., 0.02) lrelu = lambda x : tf.nn.leaky_relu(x, 0.2) ni = Input(shape) nn = Dense(n_units=(gf_dim * 8 * s16 * s16), W_init=w_init, b_init=None)(ni) nn = Reshape(shape=[-1, s16, s16, gf_dim*16])(nn) nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init, name=None)(nn) #nn = DeConv2d(gf_dim * 4, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn) nn = UpSampling2d(scale=(2, 2),antialias=True)(nn) nn = Conv2d(gf_dim * 8, (5, 5), padding='SAME', b_init=None, W_init=w_init)(nn) nn = BatchNorm2d( decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn) # nn = DeConv2d(gf_dim * 2, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn) nn = UpSampling2d(scale=(2, 2),antialias=True)(nn) nn = Conv2d(gf_dim * 4, (5, 5), padding='SAME', b_init=None, W_init=w_init)(nn) nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn) #nn = DeConv2d(gf_dim, (5, 5), (2, 2), W_init=w_init, b_init=None)(nn) nn = UpSampling2d(scale=(2, 2),antialias=True)(nn) nn = Conv2d(gf_dim *2, (5, 5), padding='SAME', b_init=None, W_init=w_init)(nn) nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn) nn = UpSampling2d(scale=(2, 2),antialias=True)(nn) nn = Conv2d(gf_dim , (5, 5), padding='SAME', b_init=None, W_init=w_init)(nn) nn = BatchNorm2d(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init)(nn) nn = DeConv2d(3, (5, 5), (2, 2), act=tf.nn.tanh, W_init=w_init)(nn) return tl.models.Model(inputs=ni, outputs=nn, name='generator')
def model(x, is_train, reuse): with tf.variable_scope("STN", reuse=reuse): nin = InputLayer(x, name='in') ## 1. Localisation network # use MLP as the localisation net nt = FlattenLayer(nin, name='flatten') nt = DenseLayer(nt, n_units=20, act=tf.nn.tanh, name='dense1') nt = DropoutLayer(nt, 0.8, True, is_train, name='drop1') # you can also use CNN instead for MLP as the localisation net # nt = Conv2d(nin, 16, (3, 3), (2, 2), act=tf.nn.relu, padding='SAME', name='tc1') # nt = Conv2d(nt, 8, (3, 3), (2, 2), act=tf.nn.relu, padding='SAME', name='tc2') ## 2. Spatial transformer module (sampler) n = SpatialTransformer2dAffineLayer(nin, nt, out_size=[40, 40], name='spatial') s = n ## 3. Classifier n = Conv2d(n, 16, (3, 3), (2, 2), act=tf.nn.relu, padding='SAME', name='conv1') n = Conv2d(n, 16, (3, 3), (2, 2), act=tf.nn.relu, padding='SAME', name='conv2') n = FlattenLayer(n, name='flatten2') n = DenseLayer(n, n_units=1024, act=tf.nn.relu, name='out1') n = DenseLayer(n, n_units=10, act=tf.identity, name='out2') return n, s
def get_Ek(shape): w_init = tf.random_normal_initializer(stddev=0.02) gamma_init = tf.random_normal_initializer(1., 0.02) ngf = 64 isize = 64 n_extra_layers = flags.n_extra_layers w_init = tf.random_normal_initializer(stddev=0.02) gamma_init = tf.random_normal_initializer(1., 0.02) ngf = 64 isize = 64 n_extra_layers = flags.n_extra_layers ni = Input(shape) nn = Conv2d(ngf, (4, 4), (2, 2), W_init=w_init, act=tf.nn.relu)(ni) nn = Conv2d(ngf * 2, (4, 4), (2, 2), W_init=w_init, b_init=None)(nn) nn = BatchNorm(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init, name=None)(nn) nn = Conv2d(ngf * 2, (4, 4), (2, 2), W_init=w_init, b_init=None)(nn) nn = BatchNorm(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init, name=None)(nn) nn = DeConv2d(ngf // 2, (4, 4), (2, 2), W_init=w_init, b_init=None)(nn) nn = BatchNorm(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init, name=None)(nn) nn = DeConv2d(ngf // 8, (1, 1), (1, 1), W_init=w_init, b_init=None)(nn) # nn = BatchNorm(decay=0.9, act=tf.nn.relu, gamma_init=gamma_init, name=None)(nn) # # nn = DeConv2d(ngf // 8, (4, 4), (2, 2), W_init=w_init, act=tf.nn.relu)(nn) return tl.models.Model(inputs=ni, outputs=nn)
def model_batch_norm(x_crop, y_, is_train, reuse): W_init = tf.truncated_normal_initializer(stddev=5e-2) W_init2 = tf.truncated_normal_initializer(stddev=0.04) b_init2 = tf.constant_initializer(value=0.1) with tf.variable_scope("model", reuse=reuse): net = InputLayer(x_crop, name='input') net = Conv2d(net, 64, (5, 5), (1, 1), padding='SAME', W_init=W_init, b_init=None, name='cnn1') net = BatchNormLayer(net, decay=0.99, is_train=is_train, act=tf.nn.relu, name='batch1') net = MaxPool2d(net, (3, 3), (2, 2), padding='SAME', name='pool1') net = Conv2d(net, 64, (5, 5), (1, 1), padding='SAME', W_init=W_init, b_init=None, name='cnn2') net = BatchNormLayer(net, decay=0.99, is_train=is_train, act=tf.nn.relu, name='batch2') net = MaxPool2d(net, (3, 3), (2, 2), padding='SAME', name='pool2') net = FlattenLayer(net, name='flatten') net = DenseLayer(net, 384, act=tf.nn.relu, W_init=W_init2, b_init=b_init2, name='d1relu') net = DenseLayer(net, 192, act=tf.nn.relu, W_init=W_init2, b_init=b_init2, name='d2relu') net = DenseLayer(net, n_units=10, act=None, W_init=W_init2, name='output') y = net.outputs ce = tl.cost.cross_entropy(y, y_, name='cost') # L2 for the MLP, without this, the accuracy will be reduced by 15%. L2 = 0 for p in tl.layers.get_variables_with_name('relu/W', True, True): L2 += tf.contrib.layers.l2_regularizer(0.004)(p) cost = ce + L2 correct_prediction = tf.equal(tf.cast(tf.argmax(y, 1), tf.int32), y_) acc = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) return net, cost, acc
def __init__(self, n_filter=128, in_channels=512, data_format="channels_first"): super().__init__() self.data_format = data_format self.init_layer = Conv2d(n_filter=n_filter, in_channels=in_channels, filter_size=(1, 1), act=tf.nn.relu, data_format=self.data_format) self.main_block = layers.LayerList([ conv_block(n_filter=n_filter, in_channels=n_filter, data_format=self.data_format), conv_block(n_filter=n_filter, in_channels=n_filter, data_format=self.data_format), conv_block(n_filter=n_filter, in_channels=n_filter, data_format=self.data_format), ]) self.end_layer = Conv2d(n_filter=n_filter, in_channels=n_filter, filter_size=(3, 3), act=tf.nn.relu, data_format=self.data_format)
def __init__(self, n_filter=128, in_channels=185, n_confmaps=19, n_pafmaps=38, data_format="channels_first"): super().__init__() self.data_format = data_format self.block_1 = self.Refinement_block(n_filter=n_filter, in_channels=in_channels, data_format=self.data_format) self.block_2 = self.Refinement_block(n_filter=n_filter, in_channels=n_filter, data_format=self.data_format) self.block_3 = self.Refinement_block(n_filter=n_filter, in_channels=n_filter, data_format=self.data_format) self.block_4 = self.Refinement_block(n_filter=n_filter, in_channels=n_filter, data_format=self.data_format) self.block_5 = self.Refinement_block(n_filter=n_filter, in_channels=n_filter, data_format=self.data_format) self.conf_block=layers.LayerList([ Conv2d(n_filter=512,in_channels=n_filter,filter_size=(1,1),strides=(1,1),act=tf.nn.relu,W_init=initializer,b_init=initializer,\ data_format=self.data_format), Conv2d(n_filter=n_confmaps,in_channels=512,filter_size=(1,1),strides=(1,1),W_init=initializer,b_init=initializer,\ data_format=self.data_format) ]) self.paf_block=layers.LayerList([ Conv2d(n_filter=512,in_channels=n_filter,filter_size=(1,1),strides=(1,1),act=tf.nn.relu,W_init=initializer,b_init=initializer,\ data_format=self.data_format), Conv2d(n_filter=n_pafmaps,in_channels=512,filter_size=(1,1),strides=(1,1),W_init=initializer,b_init=initializer,\ data_format=self.data_format) ])
def __init__(self, n_filter=128, in_channels=128, strides=(1, 1), exp_ratio=6, data_format="channels_first"): super().__init__() self.n_filter = n_filter self.in_channels = in_channels self.strides = strides self.exp_ratio = exp_ratio self.data_format = data_format self.hidden_dim = self.exp_ratio * self.in_channels self.identity = False if (self.strides == (1, 1) and self.in_channels == self.n_filter): self.identity = True if (self.exp_ratio == 1): self.main_block=LayerList([ DepthwiseConv2d(in_channels=self.hidden_dim,filter_size=(3,3),strides=self.strides,\ b_init=None,data_format=self.data_format), BatchNorm2d(num_features=self.hidden_dim,is_train=True,act=tf.nn.relu6,data_format=self.data_format), Conv2d(n_filter=self.n_filter,in_channels=self.hidden_dim,filter_size=(1,1),strides=(1,1),b_init=None,data_format=self.data_format), BatchNorm2d(num_features=self.n_filter,is_train=True,act=None,data_format=self.data_format) ]) else: self.main_block=LayerList([ Conv2d(n_filter=self.hidden_dim,in_channels=self.in_channels,filter_size=(1,1),strides=(1,1),b_init=None,data_format=self.data_format), BatchNorm2d(num_features=self.hidden_dim,is_train=True,act=tf.nn.relu6,data_format=self.data_format), DepthwiseConv2d(in_channels=self.hidden_dim,filter_size=(3,3),strides=self.strides,\ b_init=None,data_format=self.data_format), BatchNorm2d(num_features=self.hidden_dim,is_train=True,act=tf.nn.relu6,data_format=self.data_format), Conv2d(n_filter=self.n_filter,in_channels=self.hidden_dim,filter_size=(1,1),strides=(1,1),b_init=None,data_format=self.data_format) ])
def get_encoder(shape=[None, flags.output_size, flags.output_size, flags.c_dim] \ , df_dim=64, name=None): w_init = tf.random_normal_initializer(stddev=0.02) gamma_init = tf.random_normal_initializer(1., 0.02) lrelu = lambda x: tf.nn.leaky_relu(x, 0.2) ni = Input(shape) nn = Conv2d(df_dim, (5, 5), (2, 2), act=lrelu, W_init=w_init)(ni) nn = Conv2d(df_dim * 2, (5, 5), (2, 2), act=None, W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(nn) nn = Conv2d(df_dim * 4, (5, 5), (2, 2), act=None, W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(nn) nn = Conv2d(df_dim * 8, (5, 5), (2, 2), act=None, W_init=w_init, b_init=None)(nn) nn = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(nn) nn = Flatten()(nn) #print(nn.shape) nn = Dense(flags.z_dim, act=tf.identity, W_init=w_init)(nn) return tl.models.Model(inputs=ni, outputs=nn, name=name)
def build_resnet_block_Att(inputres, dim, name="resnet", padding="REFLECT"): with tf.compat.v1.variable_scope(name): out_res = PadLayer([[0, 0], [1, 1], [1, 1], [0, 0]], padding)(inputres) out_res = Conv2d(n_filter=dim, filter_size=(3, 3), strides=(1, 1), padding="VALID", act=None, W_init=tf.initializers.TruncatedNormal(stddev=0.02), b_init=tf.constant_initializer(0.0))(out_res) out_res = InstanceNorm2d(act=tf.nn.relu)(out_res) out_res = PadLayer([[0, 0], [1, 1], [1, 1], [0, 0]], padding)(out_res) out_res = Conv2d(n_filter=dim, filter_size=(3, 3), strides=(1, 1), padding="VALID", act=None, W_init=tf.initializers.TruncatedNormal(stddev=0.02), b_init=tf.constant_initializer(0.0))(out_res) out_res = InstanceNorm2d(act=None)(out_res) tmp = Elementwise(combine_fn=tf.add)([out_res, inputres]) return Lambda(tf.nn.relu)(tmp)
def discriminator(inputs, is_train=True, reuse=False): df_dim = 64 # Dimension of discrim filters in first conv layer. [64] w_init = tf.glorot_normal_initializer() gamma_init = tf.random_normal_initializer(1., 0.02) with tf.variable_scope("discriminator", reuse=reuse): net_in = InputLayer(inputs, name='d/in') net_h0 = Conv2d(net_in, df_dim, (5, 5), (2, 2), act=tf.nn.leaky_relu, padding='SAME', W_init=w_init, name='d/h0/conv2d') net_h1 = Conv2d(net_h0, df_dim * 2, (5, 5), (2, 2), act=None, padding='SAME', W_init=w_init, name='d/h1/conv2d') net_h1 = BatchNormLayer(net_h1, act=tf.nn.leaky_relu, is_train=is_train, gamma_init=gamma_init, name='d/h1/batch_norm') net_h2 = Conv2d(net_h1, df_dim * 4, (5, 5), (2, 2), act=None, padding='SAME', W_init=w_init, name='d/h2/conv2d') net_h2 = BatchNormLayer(net_h2, act=tf.nn.leaky_relu, is_train=is_train, gamma_init=gamma_init, name='d/h2/batch_norm') net_h3 = Conv2d(net_h2, df_dim * 8, (5, 5), (2, 2), act=None, padding='SAME', W_init=w_init, name='d/h3/conv2d') net_h3 = BatchNormLayer(net_h3, act=tf.nn.leaky_relu, is_train=is_train, gamma_init=gamma_init, name='d/h3/batch_norm') net_h4 = FlattenLayer(net_h3, name='d/h4/flatten') net_h4 = DenseLayer(net_h4, n_units=1, act=tf.identity, W_init=w_init, name='d/h4/lin_sigmoid') logits = net_h4.outputs net_h4.outputs = tf.nn.sigmoid(net_h4.outputs) return net_h4, logits
def get_Ec(x_shape=(None, flags.img_size_h, flags.img_size_w, flags.c_dim), name=None): # ref: Multimodal Unsupervised Image-to-Image Translation lrelu = lambda x: tl.act.lrelu(x, 0.01) w_init = tf.random_normal_initializer(stddev=0.02) channel = 64 ni = Input(x_shape) n = Conv2d(channel, (7, 7), (1, 1), act=lrelu, W_init=w_init)(ni) for i in range(2): n = Conv2d(channel * 2, (3, 3), (2, 2), W_init=w_init)(n) n = InstanceNorm2d(act=tf.nn.relu, gamma_init=g_init)(n) channel = channel * 2 for i in range(1, 5): # res block nn = Conv2d(channel, (3, 3), (1, 1), act=None, W_init=w_init, b_init=None)(n) nn = InstanceNorm2d(act=tf.nn.relu, gamma_init=g_init)(nn) nn = Conv2d(channel, (3, 3), (1, 1), act=None, W_init=w_init, b_init=None)(nn) nn = InstanceNorm2d(act=None, gamma_init=g_init)(nn) n = Elementwise(tf.add)([n, nn]) n = GaussianNoise(is_always=False)(n) M = Model(inputs=ni, outputs=n, name=name) return M
def get_img_D(shape): df_dim = 8 w_init = tf.random_normal_initializer(stddev=0.02) gamma_init = tf.random_normal_initializer(1., 0.02) lrelu = lambda x: tf.nn.leaky_relu(x, 0.2) ni = Input(shape) n = Conv2d(df_dim, (5, 5), (2, 2), act=None, W_init=w_init, b_init=None)(ni) n = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(n) n = Conv2d(df_dim * 2, (5, 5), (1, 1), act=None, W_init=w_init, b_init=None)(n) n = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(n) n = Conv2d(df_dim * 4, (5, 5), (2, 2), act=None, W_init=w_init, b_init=None)(n) n = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(n) n = Conv2d(df_dim * 8, (5, 5), (1, 1), act=None, W_init=w_init, b_init=None)(n) n = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(n) n = Conv2d(df_dim * 8, (5, 5), (2, 2), act=None, W_init=w_init, b_init=None)(n) n = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(n) nf = Flatten(name='flatten')(n) n = Dense(n_units=1, act=None, W_init=w_init)(nf) return tl.models.Model(inputs=ni, outputs=n, name='img_Discriminator')
def model(x, is_train): with tf.variable_scope("model", reuse=tf.AUTO_REUSE): net = InputLayer(x, name='input') net = Conv2d(net, 64, (5, 5), (1, 1), padding='SAME', b_init=None, name='cnn1') net = BatchNormLayer(net, decay=0.99, is_train=is_train, act=tf.nn.relu, name='batch1') net = MaxPool2d(net, (3, 3), (2, 2), padding='SAME', name='pool1') net = Conv2d(net, 64, (5, 5), (1, 1), padding='SAME', b_init=None, name='cnn2') net = BatchNormLayer(net, decay=0.99, is_train=is_train, act=tf.nn.relu, name='batch2') net = MaxPool2d(net, (3, 3), (2, 2), padding='SAME', name='pool2') net = FlattenLayer(net, name='flatten') net = DenseLayer(net, 384, act=tf.nn.relu, name='d1relu') net = DenseLayer(net, 192, act=tf.nn.relu, name='d2relu') net = DenseLayer(net, 10, act=None, name='output') return net
def get_img_D(shape): w_init = tf.random_normal_initializer(stddev=0.02) lrelu = lambda x: tf.nn.leaky_relu(x, 0.2) ndf = 64 isize = 64 n_extra_layers = flags.n_extra_layers ni = Input(shape) n = Conv2d(ndf, (4, 4), (2, 2), act=None, W_init=w_init, b_init=None)(ni) csize, cndf = isize / 2, ndf for t in range(n_extra_layers): n = SpectralNormConv2d(cndf, (3, 3), (1, 1), act=lrelu, W_init=w_init, b_init=None)(n) while csize > 4: cndf = cndf * 2 n = SpectralNormConv2d(cndf, (4, 4), (2, 2), act=lrelu, W_init=w_init, b_init=None)(n) csize = csize / 2 n = Conv2d(1, (4, 4), (1, 1), act=None, W_init=w_init, b_init=None, padding='VALID')(n) return tl.models.Model(inputs=ni, outputs=n)
def tam_net(self): inputs = Input(self.in_shape, name='inputs') e_in = inputs for i in range(0, 5): e_out = Conv2d(self.f_size * (2**i), (3, 3), (2, 2), act=tf.nn.relu, name=f'e{i+1}_con')(e_in) e_in = self.residual_block(i, e=True)(e_out) self.__setattr__(f'e{i+1}', e_in) d_in = e_in for i in range(4, 0, -1): d_out = DeConv2d(self.f_size * (2**(i - 1)), (3, 3), (2, 2), name=f'd{i}_con')(d_in) encoder = self.__getattribute__(f'e{i}') d_out = Concat(concat_dim=3, name=f'concat{i}')([encoder, d_out]) d_out = Conv2d(self.f_size * (2**(i - 1)), (1, 1), (1, 1), name=f'fusion{i}')(d_out) d_in = self.residual_block(i - 1, e=False)(d_out) self.__setattr__(f'd{i + 1}', d_in) outs = DeConv2d(3, (3, 3), (2, 2), name='d_con_out')(d_in) outs = Conv2d(3, (1, 1), (1, 1), act=tf.nn.sigmoid, name='outs')(outs) return Model(inputs=inputs, outputs=outs, name="TAM_Net")
def get_discriminator(latent_shape, image_shape, df_dim=64): w_init = tf.random_normal_initializer(stddev=0.02) gamma_init = tf.random_normal_initializer(1., 0.02) lrelu = lambda x: tf.nn.leaky_relu(x, 0.2) n1i = Input(image_shape) n1 = Conv2d(df_dim, (5, 5), (2, 2), act=lrelu, W_init=w_init)(n1i) n1 = Conv2d(df_dim * 2, (5, 5), (2, 2), W_init=w_init, b_init=None)(n1) n1 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(n1) n1 = Dropout(keep=0.8)(n1) n1 = Conv2d(df_dim * 4, (5, 5), (2, 2), W_init=w_init, b_init=None)(n1) n1 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(n1) n1 = Dropout(keep=0.8)(n1) n1 = Conv2d(df_dim * 8, (5, 5), (2, 2), W_init=w_init, b_init=None)(n1) n1 = BatchNorm2d(decay=0.9, act=lrelu, gamma_init=gamma_init)(n1) n1 = Dropout(keep=0.8)(n1) n1 = Flatten()(n1) # [-1,4*4*df_dim*8] n2i = Input(latent_shape) n2 = Dense(n_units=4 * 4 * df_dim * 8, W_init=w_init, b_init=None)(n2i) n2 = Dropout(keep=0.8)(n2) nn = Concat()([n1, n2]) nn = Dense(n_units=1, W_init=w_init, b_init=None)(nn) return tl.models.Model(inputs=[n1i, n2i], outputs=nn, name='discriminator')
def __init__(self,n_pos=19,n_limbs=19,num_channels=128,hin=368,win=368,hout=46,wout=46,backbone=None,pretrained_backbone=True,data_format="channels_first"): super().__init__() self.num_channels=num_channels self.n_pos=n_pos self.n_limbs=n_limbs self.n_confmaps=n_pos self.n_pafmaps=2*n_limbs self.hin=hin self.win=win self.hout=hout self.wout=wout self.data_format=data_format self.pretrained_backbone=pretrained_backbone self.concat_dim=1 if self.data_format=="channels_first" else -1 #back bone configure if(backbone==None): self.backbone=self.vgg19(in_channels=3,pretrained=self.pretrained_backbone,data_format=self.data_format) else: self.backbone=backbone(scale_size=8,data_format=self.data_format) self.cpm_stage=LayerList([ Conv2d(n_filter=256,in_channels=self.backbone.out_channels,filter_size=(3,3),strides=(1,1),padding="SAME",act=tf.nn.relu,data_format=self.data_format), Conv2d(n_filter=128,in_channels=256,filter_size=(3,3),strides=(1,1),padding="SAME",act=tf.nn.relu,data_format=self.data_format) ]) #init stage self.init_stage=self.Init_stage(n_confmaps=self.n_confmaps, n_pafmaps=self.n_pafmaps,in_channels=128,data_format=self.data_format) #one refinemnet stage self.refinement_stage_1=self.Refinement_stage(n_confmaps=self.n_confmaps, n_pafmaps=self.n_pafmaps, in_channels=self.n_confmaps+self.n_pafmaps+128,data_format=self.data_format) self.refinement_stage_2=self.Refinement_stage(n_confmaps=self.n_confmaps, n_pafmaps=self.n_pafmaps, in_channels=self.n_confmaps+self.n_pafmaps+128,data_format=self.data_format) self.refinement_stage_3=self.Refinement_stage(n_confmaps=self.n_confmaps, n_pafmaps=self.n_pafmaps, in_channels=self.n_confmaps+self.n_pafmaps+128,data_format=self.data_format) self.refinement_stage_4=self.Refinement_stage(n_confmaps=self.n_confmaps, n_pafmaps=self.n_pafmaps, in_channels=self.n_confmaps+self.n_pafmaps+128,data_format=self.data_format) self.refinement_stage_5=self.Refinement_stage(n_confmaps=self.n_confmaps, n_pafmaps=self.n_pafmaps, in_channels=self.n_confmaps+self.n_pafmaps+128,data_format=self.data_format)
def fire_block(n, n_filter, max_pool=False, name='fire_block'): n = Conv2d(n_filter, (1, 1), (1, 1), tf.nn.relu, 'SAME', name=name + '.squeeze1x1')(n) n1 = Conv2d(n_filter * 4, (1, 1), (1, 1), tf.nn.relu, 'SAME', name=name + '.expand1x1')(n) n2 = Conv2d(n_filter * 4, (3, 3), (1, 1), tf.nn.relu, 'SAME', name=name + '.expand3x3')(n) n = Concat(-1, name=name + '.concat')([n1, n2]) if max_pool: n = MaxPool2d((3, 3), (2, 2), 'VALID', name=name + '.max')(n) return n
def discriminator(inputs, is_train=True): with tf.variable_scope("discriminator", reuse=tf.AUTO_REUSE): net_in = InputLayer(inputs, name='din') #Conv2d is tf.nn.conv2d + tf.nn.relu dnet_c0 = Conv2d(net_in, 64, (8, 8), (2, 2), act=tf.nn.relu, padding='SAME', name='dnet_c0') #Conv2d is tf.nn.conv2d #BatchNormLayer is tf.nn.batch_normalization + tf.nn.relu dnet_c1 = Conv2d(dnet_c0, 128, (8, 8), (2, 2), act=None, padding='SAME', name='dnet_c1') dnet_b1 = BatchNormLayer(dnet_c1, decay=0.9, act=tf.nn.relu, is_train=is_train, name='dnet_b1') # dnet_p1 = MaxPool2d(dnet_b1, (2, 2), name='pool2') #Don't use pool layer, it is not good. But you can try. dnet_c2 = Conv2d(dnet_b1, 256, (8, 8), (2, 2), act=None, padding='SAME', name='dnet_c2') dnet_b2 = BatchNormLayer(dnet_c2, decay=0.9, act=tf.nn.relu, is_train=is_train, name='dnet_b2') dnet_c3 = Conv2d(dnet_b2, 512, (8, 8), (2, 2), act=None, padding='SAME', name='dnet_c3') dnet_b3 = BatchNormLayer(dnet_c3, decay=0.9, act=tf.nn.relu, is_train=is_train, name='dnet_b3') #FlattenLayer is tf.reshape dnet_f1 = FlattenLayer(dnet_b3, name='dnet_f1') #DenseLayer is tf.layers.dense, the full-connected dnet_d1 = DenseLayer(dnet_f1, n_units=1, act=tf.identity, name='dnet_h4') logits = dnet_d1.outputs dnet_d1.outputs = tf.nn.sigmoid(dnet_d1.outputs) return dnet_d1, logits
def __init__(self,K_size=18,L_size=17,win=384,hin=384,wout=12,hout=12,wnei=9,hnei=9\ ,lmd_rsp=0.25,lmd_iou=1,lmd_coor=5,lmd_size=5,lmd_limb=0.5,backbone=None,data_format="channels_first"): super().__init__() #construct params self.K = K_size self.L = L_size self.win = win self.hin = hin self.wout = wout self.hout = hout self.hnei = hnei self.wnei = wnei self.n_pos = K_size self.lmd_rsp = lmd_rsp self.lmd_iou = lmd_iou self.lmd_coor = lmd_coor self.lmd_size = lmd_size self.lmd_limb = lmd_limb self.data_format = data_format self.output_dim = 6 * self.K + self.hnei * self.wnei * self.L #construct networks if (backbone == None): self.backbone = self.Resnet_18(n_filter=512, in_channels=3, data_format=data_format) else: self.backbone = backbone(scale_size=32, data_format=self.data_format) self.add_layer_1 = LayerList([ Conv2d(n_filter=512, in_channels=self.backbone.out_channels, filter_size=(3, 3), strides=(1, 1), data_format=self.data_format), BatchNorm2d(decay=0.9, act=lambda x: tl.act.leaky_relu(x, alpha=0.1), is_train=True, num_features=512, data_format=self.data_format) ]) self.add_layer_2 = LayerList([ Conv2d(n_filter=512, in_channels=512, filter_size=(3, 3), strides=(1, 1), data_format=self.data_format), BatchNorm2d(decay=0.9, act=lambda x: tl.act.leaky_relu(x, alpha=0.1), is_train=True, num_features=512, data_format=self.data_format) ]) self.add_layer_3 = Conv2d(n_filter=self.output_dim, in_channels=512, filter_size=(1, 1), strides=(1, 1), data_format=self.data_format)
def discriminator(inputs, is_train=True, reuse=False): dfs = 64 gamma_init = tf.random_normal_initializer(1., 0.02) W_init = tf.random_normal_initializer(stddev=0.02) with tf.variable_scope('discriminator', reuse=reuse): tl.layers.set_name_reuse(reuse) d = InputLayer(inputs, name='d/inputs') d = Conv2d(d, dfs, (5, 5), (2, 2), W_init=W_init, act=lambda x: tl.act.lrelu(x, 0.2), name='d/conv1') d = Conv2d(d, dfs * 2, (5, 5), (2, 2), W_init=W_init, act=None, name='d/conv2') d = BatchNormLayer(d, act=lambda x: tl.act.lrelu(x, 0.2), is_train=is_train, gamma_init=gamma_init, name='d/bn3') d = Conv2d(d, dfs * 4, (5, 5), (2, 2), W_init=W_init, act=None, name='d/conv4') d = BatchNormLayer(d, act=lambda x: tl.act.lrelu(x, 0.2), is_train=is_train, gamma_init=gamma_init, name='d/bn5') d = Conv2d(d, dfs * 8, (5, 5), (2, 2), W_init=W_init, act=None, name='d/conv6') d = BatchNormLayer(d, act=lambda x: tl.act.lrelu(x, 0.2), is_train=is_train, gamma_init=gamma_init, name='d/bn7') d = FlattenLayer(d, name='d/flt8') d = DenseLayer(d, 1, act=tl.act.identity, W_init=W_init, name='d/output') logits = d.outputs d.outputs = tf.nn.sigmoid(d.outputs) return d, logits
def model(x, y_, reuse, is_train=False): W_init = tf.truncated_normal_initializer(stddev=5e-2) W_init2 = tf.truncated_normal_initializer(stddev=0.04) b_init2 = tf.constant_initializer(value=0.1) with tf.variable_scope("model", reuse=reuse): tl.layers.set_name_reuse(reuse) net = InputLayer(x, name='input') net = Conv2d(net, 32, (3, 3), (1, 1), act=tf.nn.relu, padding='SAME', W_init=W_init, name='cnn1') net = Conv2d(net, 32, (3, 3), (1, 1), act=tf.nn.relu, W_init=W_init, name='cnn2', padding="VALID") net = MaxPool2d(net, name='pool1', padding="VALID") net = DropoutLayer(net, keep=0.75, is_train=is_train, name='drop1') net = Conv2d(net, 64, (3, 3), (1, 1), act=tf.nn.relu, padding='SAME', W_init=W_init, name='cnn3') net = Conv2d(net, 64, (3, 3), (1, 1), act=tf.nn.relu, W_init=W_init, name='cnn4', padding="VALID") net = MaxPool2d(net, name='pool2', padding="VALID") net = DropoutLayer(net, keep=0.75, is_train=is_train, name='drop2') net = FlattenLayer(net, name='flatten') net = DenseLayer(net, n_units=512, act=tf.nn.relu, W_init=W_init2, b_init=b_init2, name='d1relu') net = DenseLayer(net, n_units=10, act=tf.identity, W_init=tf.truncated_normal_initializer(stddev=1 / 192.0), name='output') # output: (batch_size, 10) y = net.outputs loss = tl.cost.cross_entropy(y, y_, name='cost') correct_prediction = tf.equal(tf.argmax(y, 1), y_) acc = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) return net, loss, acc
def __init__(self): super(ResBlock,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=64, padding='SAME', W_init=w_init,b_init=None) self.bn1 = BatchNorm2d(num_features = 64,gamma_init=g_init, act=tf.nn.relu) 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.bn2 = BatchNorm2d(num_features = 64,gamma_init=g_init) self.add = Elementwise(tf.add)
def get_G_res_block(n, w_init, g_init): nn = Conv2d(64, (3, 3), (1, 1), padding='SAME', W_init=w_init, b_init=None)(n) nn = BatchNorm2d(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 = BatchNorm2d(gamma_init=g_init)(nn) nn = Elementwise(tf.add)([n, nn]) return nn
def residual_block(self, n_k=1, e=True): k_size = self.f_size * (2**n_k) ni = Input([None, None, None, k_size]) nn = Conv2d(k_size, (3, 3), (1, 1))(ni) nn = BatchNorm(act=tf.nn.relu)(nn) nn = Conv2d(k_size, (3, 3), (1, 1))(nn) nn = BatchNorm()(nn) nn = Elementwise(tf.add)([ni, nn]) return Model(inputs=ni, outputs=nn, name=f'{"e" if e else "d"}{n_k+1}_res').as_layer()
def conv_block(input, kernel_size, n_filters, stage, block, strides=(2, 2)): """The conv block where there is a conv layer at shortcut. Parameters ---------- input : tf tensor Input tensor from above layer. kernel_size : int The kernel size of middle conv layer at main path. n_filters : list of integers The numbers of filters for 3 conv layer at main path. stage : int Current stage label. block : str Current block label. strides : tuple Strides for the first conv layer in the block. Returns ------- Output tensor of this block. """ filters1, filters2, filters3 = n_filters conv_name_base = 'res' + str(stage) + block + '_branch' bn_name_base = 'bn' + str(stage) + block + '_branch' x = Conv2d(filters1, (1, 1), strides=strides, W_init=tf.initializers.he_normal(), name=conv_name_base + '2a')(input) x = BatchNorm(name=bn_name_base + '2a', act='relu')(x) ks = (kernel_size, kernel_size) x = Conv2d(filters2, ks, padding='SAME', W_init=tf.initializers.he_normal(), name=conv_name_base + '2b')(x) x = BatchNorm(name=bn_name_base + '2b', act='relu')(x) x = Conv2d(filters3, (1, 1), W_init=tf.initializers.he_normal(), name=conv_name_base + '2c')(x) x = BatchNorm(name=bn_name_base + '2c')(x) shortcut = Conv2d(filters3, (1, 1), strides=strides, W_init=tf.initializers.he_normal(), name=conv_name_base + '1')(input) shortcut = BatchNorm(name=bn_name_base + '1')(shortcut) x = Elementwise(tf.add, act='relu')([x, shortcut]) return x
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)