def generator(self, z): s_h, s_w = self.image_h, self.image_w s_h2, s_w2 = utils.compute_size(s_h, 2), utils.compute_size(s_w, 2) s_h4, s_w4 = utils.compute_size(s_h2, 2), utils.compute_size(s_w2, 2) s_h8, s_w8 = utils.compute_size(s_h4, 2), utils.compute_size(s_w4, 2) s_h16, s_w16 = utils.compute_size(s_h8, 2), utils.compute_size(s_w8, 2) fmap_dim = self.fmap_dim_g batch_size = self.batch_size with tf.variable_scope("generator") as scope: z_ = utils.fc(z, s_h16 * s_w16 * 8 * fmap_dim, name='g_l0_fc') gl0 = utils.lrelu( self.g_bn_l0( tf.reshape(z_, [batch_size, s_h16, s_w16, fmap_dim * 8]))) gl1 = utils.lrelu( self.g_bn_l1( utils.deconv2d(gl0, [batch_size, s_h8, s_w8, fmap_dim * 4], name='g_l1_deconv'))) gl2 = utils.lrelu( self.g_bn_l2( utils.deconv2d(gl1, [batch_size, s_h4, s_w4, fmap_dim * 2], name='g_l2_deconv'))) gl3 = utils.lrelu( self.g_bn_l3( utils.deconv2d(gl2, [batch_size, s_h2, s_w2, fmap_dim * 1], name='g_l3_deconv'))) gl4 = utils.deconv2d(gl3, [batch_size, s_h, s_w, 3], name='g_l4_deconv') return tf.nn.tanh(gl4)
def discriminate(self, inputs, is_training, reuse=False): with tf.variable_scope(self.var_scope) as scope: if reuse: scope.reuse_variables() conv1 = self.conv(inputs, 64, 'conv1') batch_norm_1 = self.batch_norm(conv1, 'batch_norm1') activation1 = lrelu(batch_norm_1, n='activation1') conv2 = self.conv(activation1, 128, 'conv2') batch_norm_2 = self.batch_norm(conv2, 'batch_norm2') activation2 = lrelu(batch_norm_2, n='activation2') conv3 = self.conv(activation2, 256, 'conv3') batch_norm_3 = self.batch_norm(conv3, 'batch_norm3') activation3 = lrelu(batch_norm_3, n='activation3') conv4 = self.conv(activation3, 512, 'conv4') batch_norm_4 = self.batch_norm(conv4, 'batch_norm4') activation4 = lrelu(batch_norm_4, n='activation4') feature_dimension = np.prod(activation4.get_shape()[1:]) fully_connected_1 = tf.reshape(activation4, shape=[-1, feature_dimension], name='fully_connected_1') weights2 = tf.get_variable('weights2', shape=[fully_connected_1.shape[-1], 1], dtype=tf.float32, initializer=tf.truncated_normal_initializer(stddev=0.02)) bias2 = tf.get_variable('bias2', shape=[1], dtype=tf.float32, initializer=tf.constant_initializer(0.0)) logits = tf.add(tf.matmul(fully_connected_1, weights2), bias2, name='logits') return logits
def __call__(self, x, y=None, sn=False, is_training=True, reuse=False): with tf.variable_scope(self.name, reuse=reuse): batch_size = x.get_shape().as_list()[0] if y is not None: ydim = y.get_shape().as_list()[-1] y = tf.reshape(y, [batch_size, 1, 1, ydim]) x = conv_cond_concat(x, y) # [bz, 28, 28, 11] x = tf.reshape(x, (batch_size, -1)) net = lrelu(dense(x, 512, sn=sn, name='d_fc1'), name='d_l1') net = lrelu(bn(dense(net, 256, sn=sn, name='d_fc2'), is_training, name='d_bn2'), name='d_l2') net = lrelu(bn(dense(net, 128, sn=sn, name='d_fc3'), is_training, name='d_bn3'), name='d_l3') yd = dense(net, 1, sn=sn, name="D_dense") if self.class_num: yc = dense(net, self.class_num, sn=sn, name='C_dense') return yd, net, yc else: return yd, net
def add_prediction_op(self): fs = [5, 5] # filter sizes cs = [4, 40, 80] # cs[i] is output number of channels from layer i [where layer 0 is input layer] # First conv layer W_conv1 = utils.weight_variable([fs[0], cs[0], cs[1]]) b_conv1 = utils.bias_variable([cs[1]]) h_conv1 = utils.lrelu(utils.conv1d(self.x, W_conv1) + b_conv1) # Second conv layer W_conv2 = utils.weight_variable([fs[1], cs[1], cs[2]]) b_conv2 = utils.bias_variable([cs[2]]) h_conv2 = utils.lrelu(utils.conv1d(h_conv1, W_conv2) + b_conv2) # First fully connected layer. Reshape the convolution output to 1D vector W_fc1 = utils.weight_variable([self.config.strlen * cs[2], 1024]) b_fc1 = utils.bias_variable([1024]) h_conv2_flat = tf.reshape(h_conv2, [-1, self.config.strlen * cs[2]]) h_fc1 = utils.lrelu(tf.matmul(h_conv2_flat, W_fc1) + b_fc1) # Dropout (should be added to earlier layers too...) h_fc1_drop = tf.nn.dropout(h_fc1, self.keep_prob) # Final fully-connected layer W_fc2 = utils.weight_variable([1024, 1]) b_fc2 = utils.bias_variable([1]) y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2 y_out = tf.sigmoid(y_conv) is_zero = tf.clip_by_value(tf.reduce_sum(self.x), 0, 1) # basically will be 1 iff at least one entry of x is nonzero y_out = tf.multiply(y_out, is_zero) return y_out
def create_discriminator(discrim_inputs, discrim_targets): n_layers = 3 layers = [] # 2x [batch, in_channels, height, width] => [batch, in_channels * 2, height, width] input = fluid.layers.concat(input=[discrim_inputs, discrim_targets], axis=1) # layer_1: [batch, in_channels * 2, 256, 256] => [batch, ndf, 128, 128] convolved = discrim_conv(input, a.ndf, stride=2) rectified = utils.lrelu(convolved, 0.2) layers.append(rectified) # layer_2: [batch, 128, 128, ndf] => [batch, 64, 64, ndf * 2] # layer_3: [batch, 64, 64, ndf * 2] => [batch, 32, 32, ndf * 4] # layer_4: [batch, 32, 32, ndf * 4] => [batch, 31, 31, ndf * 8] for i in range(n_layers): out_channels = a.ndf * min(2 ** (i + 1), 8) stride = 1 if i == n_layers - 1 else 2 # last layer here has stride 1 convolved = discrim_conv(layers[-1], out_channels, stride=stride) normalized = utils.batchnorm(convolved) rectified = utils.lrelu(normalized, 0.2) layers.append(rectified) # layer_5: [batch, 31, 31, ndf * 8] => [batch, 30, 30, 1] convolved = discrim_conv(rectified, out_channels=1, stride=1) output = fluid.layers.sigmoid(convolved) layers.append(output) return layers[-1]
def generator(x, y, isTrain=True, reuse=False): with tf.variable_scope('generator', reuse=reuse): # print x.shape # 1st hidden layer y1 = tf.expand_dims(tf.expand_dims(y, axis=1), axis=1) x = tf.concat((x, y1), axis=3) conv1 = tf.layers.conv2d_transpose(x, 1024, [4, 4], strides=(1, 1), padding='valid') lrelu1 = utils.lrelu(tf.layers.batch_normalization(conv1, training=isTrain), 0.2) conv2 = tf.layers.conv2d_transpose(lrelu1, 512, [3, 3], strides=(1, 1), padding='valid') lrelu2 = utils.lrelu(tf.layers.batch_normalization(conv2, training=isTrain), 0.2) conv3 = tf.layers.conv2d_transpose(lrelu2, 256, [2, 2], strides=(1, 1), padding='valid') lrelu3 = utils.lrelu(tf.layers.batch_normalization(conv3, training=isTrain), 0.2) # 4th hidden layer conv4 = tf.layers.conv2d_transpose(lrelu3, 128, [4, 4], strides=(2, 2), padding='same') lrelu4 = utils.lrelu(tf.layers.batch_normalization(conv4, training=isTrain), 0.2) # # output layer conv5 = tf.layers.conv2d_transpose(lrelu4, 1, [4, 4], strides=(2, 2), padding='same') # lrelu5 = lrelu(tf.layers.batch_normalization(conv5, training=isTrain), 0.2) # # # output layer # conv6 = tf.layers.conv2d_transpose(lrelu5, 1, [4, 4], strides=(2, 2), padding='same') # print conv6.shape o = tf.nn.tanh(conv5) return o
def discriminator(input, y, isTrain=True, reuse=False): epsilon = 1e-9 # if isTrain: with tf.variable_scope('discriminator', reuse=reuse) as scope: # reshape so it's batchx1x1xy_size y_dim = int(y.get_shape().as_list()[-1]) y = tf.reshape(y, shape=[batch_size, 1, 1, y_dim]) input_ = utils.conv_cond_concat(input, y) conv1 = tcl.conv2d(input_, 64, 5, 2, activation_fn=tf.identity, weights_initializer=tf.random_normal_initializer(stddev=0.02), scope='d_conv1') conv1 = utils.lrelu(conv1) conv2 = tcl.conv2d(conv1, 128, 5, 2, activation_fn=tf.identity, weights_initializer=tf.random_normal_initializer(stddev=0.02), scope='d_conv2') conv2 = utils.lrelu(conv2) conv3 = tcl.conv2d(conv2, 256, 5, 2, activation_fn=tf.identity, weights_initializer=tf.random_normal_initializer(stddev=0.02), scope='d_conv3') conv3 = utils.lrelu(conv3) conv4 = tcl.conv2d(conv3, 512, 5, 2, activation_fn=tf.identity, weights_initializer=tf.random_normal_initializer(stddev=0.02), scope='d_conv4') conv4 = utils.lrelu(conv4) conv5 = tcl.conv2d(conv4, 1, 4, 1, activation_fn=tf.identity, weights_initializer=tf.random_normal_initializer(stddev=0.02), scope='d_conv5') return conv5
def fusion_model(self, img): with tf.compat.v1.variable_scope('fusion_model'): with tf.compat.v1.variable_scope('layer1'): weights = tf.compat.v1.get_variable("w1", [5, 5, 2, 256], initializer=tf.truncated_normal_initializer(stddev=1e-3)) weights = weights_spectral_norm(weights) bias = tf.compat.v1.get_variable("b1", [256], initializer=tf.constant_initializer(0.0)) conv1_ir = tf.contrib.layers.batch_norm(tf.nn.conv2d(img, weights, strides=[1, 1, 1, 1], padding='VALID') + bias, decay=0.9, updates_collections=None, epsilon=1e-5, scale=True) conv1_ir = lrelu(conv1_ir) with tf.compat.v1.variable_scope('layer2'): weights = tf.compat.v1.get_variable("w2", [5, 5, 256, 128], initializer=tf.truncated_normal_initializer(stddev=1e-3)) weights = weights_spectral_norm(weights) bias = tf.compat.v1.get_variable("b2", [128], initializer=tf.constant_initializer(0.0)) conv2_ir = tf.contrib.layers.batch_norm(tf.nn.conv2d(conv1_ir, weights, strides=[1, 1, 1, 1], padding='VALID') + bias, decay=0.9, updates_collections=None, epsilon=1e-5, scale=True) conv2_ir = lrelu(conv2_ir) with tf.compat.v1.variable_scope('layer3'): weights = tf.compat.v1.get_variable("w3", [3, 3, 128, 64], initializer=tf.truncated_normal_initializer(stddev=1e-3)) weights = weights_spectral_norm(weights) bias = tf.compat.v1.get_variable("b3", [64], initializer=tf.constant_initializer(0.0)) conv3_ir = tf.contrib.layers.batch_norm(tf.nn.conv2d(conv2_ir, weights, strides=[1, 1, 1, 1], padding='VALID') + bias, decay=0.9, updates_collections=None, epsilon=1e-5, scale=True) conv3_ir = lrelu(conv3_ir) with tf.compat.v1.variable_scope('layer4'): weights = tf.compat.v1.get_variable("w4", [3, 3, 64, 32], initializer=tf.truncated_normal_initializer(stddev=1e-3)) weights = weights_spectral_norm(weights) bias = tf.compat.v1.get_variable("b4", [32], initializer=tf.constant_initializer(0.0)) conv4_ir = tf.contrib.layers.batch_norm(tf.nn.conv2d(conv3_ir, weights, strides=[1, 1, 1, 1], padding='VALID') + bias, decay=0.9, updates_collections=None, epsilon=1e-5, scale=True) conv4_ir = lrelu(conv4_ir) with tf.compat.v1.variable_scope('layer5'): weights = tf.compat.v1.get_variable("w5", [1, 1, 32, 1], initializer=tf.truncated_normal_initializer(stddev=1e-3)) weights = weights_spectral_norm(weights) bias = tf.compat.v1.get_variable("b5", [1], initializer=tf.constant_initializer(0.0)) conv5_ir = tf.nn.conv2d(conv4_ir, weights, strides=[1, 1, 1, 1], padding='VALID') + bias conv5_ir = tf.nn.tanh(conv5_ir) return conv5_ir
def add_prediction_op(self): fs = [5, 5] # filter sizes cs = [ 4, 40, 80 ] # cs[i] is output number of channels from layer i [where layer 0 is input layer] # First conv layer W_conv1 = utils.weight_variable([fs[0], cs[0], cs[1]]) b_conv1 = utils.bias_variable([cs[1]]) h_conv1 = utils.lrelu(utils.conv1d(self.x, W_conv1) + b_conv1) # Second conv layer W_conv2 = utils.weight_variable([fs[1], cs[1], cs[2]]) b_conv2 = utils.bias_variable([cs[2]]) h_conv2 = utils.lrelu(utils.conv1d(h_conv1, W_conv2) + b_conv2) # First fully connected layer. Reshape the convolution output to 1D vector W_fc1 = utils.weight_variable([self.config.strlen * cs[2], 1024]) b_fc1 = utils.bias_variable([1024]) h_conv2_flat = tf.reshape(h_conv2, [-1, self.config.strlen * cs[2]]) h_fc1 = utils.lrelu(tf.matmul(h_conv2_flat, W_fc1) + b_fc1) # Dropout (should be added to earlier layers too...) h_fc1_drop = tf.nn.dropout(h_fc1, self.keep_prob) # Final fully-connected layer W_fc2 = utils.weight_variable([1024, 3]) b_fc2 = utils.bias_variable([1]) y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2 return y_conv
def generator(x, isTrain=True, reuse=False): with tf.variable_scope('generator', reuse=reuse): conv1 = tf.layers.conv2d_transpose(x, 1024, [4, 4], strides=(1, 1), padding='valid') lrelu1 = utils.lrelu( tf.layers.batch_normalization(conv1, training=isTrain), 0.2) conv2 = tf.layers.conv2d_transpose(lrelu1, 512, [3, 3], strides=(1, 1), padding='valid') lrelu2 = utils.lrelu( tf.layers.batch_normalization(conv2, training=isTrain), 0.2) conv3 = tf.layers.conv2d_transpose(lrelu2, 256, [2, 2], strides=(1, 1), padding='valid') lrelu3 = utils.lrelu( tf.layers.batch_normalization(conv3, training=isTrain), 0.2) conv4 = tf.layers.conv2d_transpose(lrelu3, 128, [4, 4], strides=(2, 2), padding='same') lrelu4 = utils.lrelu( tf.layers.batch_normalization(conv4, training=isTrain), 0.2) conv5 = tf.layers.conv2d_transpose(lrelu4, 1, [4, 4], strides=(2, 2), padding='same') o = tf.nn.tanh(conv5) return o
def discriminative(self, images, reuse=False): with tf.variable_scope('discriminative') as scope: if reuse: scope.reuse_variables() if self.run_flags.run == 'train': is_training = True else: is_training = False conv1 = lrelu(batch_norm(conv2d(images, output_dim=64, kernel=7, stride=1, name='d_conv1'), \ is_training=is_training, name='g_conv1_bn')) # 128 x 128 x 64 conv2 = lrelu(batch_norm(conv2d(conv1, output_dim=64, kernel=7, stride=2, name='d_conv2'), \ is_training=is_training, name='g_conv2_bn')) # 64 x 64 x 64 conv3 = lrelu(batch_norm(conv2d(conv2, output_dim=32, kernel=3, stride=2, name='d_conv3'), \ is_training=is_training, name='g_conv3_bn')) # 32 x 32 x 32 conv4 = lrelu(batch_norm(conv2d(conv3, output_dim=1, kernel=3, stride=2, name='d_conv4'), \ is_training=is_training, name='g_conv4_bn')) # 16 x 16 x 1 # conv1 = lrelu(conv2d(images, output_dim=64, kernel=7, stride=1, name='d_conv1')) # 128 x 128 x 64 # # conv2 = lrelu(conv2d(conv1, output_dim=64, kernel=7, stride=2, name='d_conv2')) # 64 x 64 x 64 # # conv3 = lrelu(conv2d(conv2, output_dim=32, kernel=3, stride=2, name='d_conv3')) # 32 x 32 x 32 # # conv4 = lrelu(conv2d(conv3, output_dim=1, kernel=3, stride=2, name='d_conv4')) # 16 x 16 x 1 fc = tf.reshape(conv4, [-1, 16 * 16 * 1]) fc = ful_connect(fc, output_size=1, name='d_fc') return fc
def discriminator(self,img,reuse,update_collection=None): with tf.variable_scope('discriminator',reuse=reuse): print(img.shape) with tf.variable_scope('layer_1'): weights=tf.get_variable("w_1",[3,3,1,32],initializer=tf.truncated_normal_initializer(stddev=1e-3)) weights=weights_spectral_norm(weights,update_collection=update_collection) bias=tf.get_variable("b_1",[32],initializer=tf.constant_initializer(0.0)) conv1_vi=tf.nn.conv2d(img, weights, strides=[1,2,2,1], padding='VALID') + bias conv1_vi = lrelu(conv1_vi) with tf.variable_scope('layer_2'): weights=tf.get_variable("w_2",[3,3,32,64],initializer=tf.truncated_normal_initializer(stddev=1e-3)) weights=weights_spectral_norm(weights,update_collection=update_collection) bias=tf.get_variable("b_2",[64],initializer=tf.constant_initializer(0.0)) conv2_vi= tf.contrib.layers.batch_norm(tf.nn.conv2d(conv1_vi, weights, strides=[1,2,2,1], padding='VALID') + bias, decay=0.9, updates_collections=None, epsilon=1e-5, scale=True) conv2_vi = lrelu(conv2_vi) with tf.variable_scope('layer_3'): weights=tf.get_variable("w_3",[3,3,64,128],initializer=tf.truncated_normal_initializer(stddev=1e-3)) weights=weights_spectral_norm(weights,update_collection=update_collection) bias=tf.get_variable("b_3",[128],initializer=tf.constant_initializer(0.0)) conv3_vi= tf.contrib.layers.batch_norm(tf.nn.conv2d(conv2_vi, weights, strides=[1,2,2,1], padding='VALID') + bias, decay=0.9, updates_collections=None, epsilon=1e-5, scale=True) conv3_vi=lrelu(conv3_vi) with tf.variable_scope('layer_4'): weights=tf.get_variable("w_4",[3,3,128,256],initializer=tf.truncated_normal_initializer(stddev=1e-3)) weights=weights_spectral_norm(weights,update_collection=update_collection) bias=tf.get_variable("b_4",[256],initializer=tf.constant_initializer(0.0)) conv4_vi= tf.contrib.layers.batch_norm(tf.nn.conv2d(conv3_vi, weights, strides=[1,2,2,1], padding='VALID') + bias, decay=0.9, updates_collections=None, epsilon=1e-5, scale=True) conv4_vi=lrelu(conv4_vi) conv4_vi = tf.reshape(conv4_vi,[self.batch_size,6*6*256]) with tf.variable_scope('line_5'): weights=tf.get_variable("w_5",[6*6*256,2],initializer=tf.truncated_normal_initializer(stddev=1e-3)) weights=weights_spectral_norm(weights,update_collection=update_collection) bias=tf.get_variable("b_5",[2],initializer=tf.constant_initializer(0.0)) line_5=tf.matmul(conv4_vi, weights) + bias return line_5
def discriminative_gan(self, images, reuse=False): '''Discriminate 128 x 128 x 3 images fake or real within the range [fake, real] = [0, 1].''' with tf.variable_scope('discriminator') as scope: if reuse: scope.reuse_variables() if self.run_flags.run == 'train': is_training = True else: is_training = False conv1 = conv2d(images, output_dim=64, kernel=7, stride=1, name='d_conv1') conv1 = batch_norm(conv1, is_training=is_training, name='d_conv1_bn') conv1 = lrelu(conv1, 0.01) # 128 x 128 x 64 conv2 = conv2d(conv1, output_dim=64, kernel=7, stride=2, name='d_conv2') conv2 = batch_norm(conv2, is_training=is_training, name='d_conv2_bn') conv2 = lrelu(conv2, 0.01) # 64 x 64 x 64 conv3 = conv2d(conv2, output_dim=32, kernel=3, stride=2, name='d_conv3') conv3 = batch_norm(conv3, is_training=is_training, name='d_conv3_bn') conv3 = lrelu(conv3, 0.01) # 32 x 32 x 32 conv4 = conv2d(conv3, output_dim=1, kernel=3, stride=2, name='d_conv4') conv4 = batch_norm(conv4, is_training=is_training, name='d_conv4_bn') conv4 = lrelu(conv4, 0.01) # 16 x 16 x 1 fc = tf.reshape(conv4, [-1, 16 * 16 * 1]) fc = ful_connect(fc, output_size=1, name='d_fc') return fc
def predictor(xyl): batch_size = xyl.get_shape().as_list()[0] with tf.variable_scope("pred"): l0 = lrelu(linear(tf.reshape(xyl, [batch_size, -1]), 16, "l0")) l1 = lrelu(linear(l0, 16, "l1")) l2 = linear(l1, 3, "l2") tf.summary.histogram('l2', l2) return tf.nn.tanh(l2)
def add_prediction_op(self): fs = [5, 5] # filter sizes cs = [4, 40, 80] # cs[i] is output number of channels from layer i [where layer 0 is input layer] # First conv layer W_conv1 = utils.weight_variable([fs[0], cs[0], cs[1]]) b_conv1 = utils.bias_variable([cs[1]]) h_conv1 = utils.lrelu(utils.conv1d(self.x, W_conv1) + b_conv1) # Second conv layer W_conv2 = utils.weight_variable([fs[1], cs[1], cs[2]]) b_conv2 = utils.bias_variable([cs[2]]) h_conv2 = utils.lrelu(utils.conv1d(h_conv1, W_conv2) + b_conv2) # Conv layer on top of the coverage W_conv_coverage = utils.weight_variable([fs[0], 1, cs[2]]) b_conv_coverage = utils.bias_variable([cs[2]]) conv_c = tf.expand_dims(self.e, -1) #print(conv_c.shape, W_conv_coverage.shape, b_conv_coverage.shape) h_conv_coverage = utils.lrelu(utils.conv1d(conv_c, W_conv_coverage) + b_conv_coverage) h_concatenated = tf.concat([h_conv2, h_conv_coverage], axis = -1) # First fully connected layer. Reshape the convolution output to 1D vector orig_shape = h_concatenated.get_shape().as_list() flat_shape = np.prod(orig_shape[1:]) new_shape = [-1,] + [flat_shape] h_concatenated_flat = tf.reshape(h_concatenated, new_shape) h_concat_drop = tf.nn.dropout(h_concatenated_flat, self.keep_prob) fc1_in = h_concatenated_flat.get_shape().as_list()[-1] W_fc1 = utils.weight_variable([fc1_in, 1024]) b_fc1 = utils.bias_variable([1024]) h_fc1 = utils.lrelu(tf.matmul(h_concat_drop, W_fc1) + b_fc1) # Fully-connected layer on top of the coverage #W_fc_coverage = utils.weight_variable([self.config.strlen, cs[2]]) #b_fc_coverage = utils.bias_variable([cs[2]]) #h_fc_coverage = tf.nn.relu(tf.matmul(self.e, W_fc_coverage) + b_fc_coverage) #h_concatenated = tf.concat([h_fc1, h_fc_coverage], axis = -1) # Dropout (should be added to earlier layers too...) #h_concatenated_drop = tf.nn.dropout(h_concatenated, self.keep_prob) h_fc1_drop = tf.nn.dropout(h_fc1, self.keep_prob) # Final fully-connected layer W_fc2 = utils.weight_variable([1024, 1]) b_fc2 = utils.bias_variable([1]) y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2 y_out = tf.sigmoid(y_conv) return y_out
def discriminator(self, img, cond, reuse): dim = len(img.get_shape()) with tf.variable_scope("disc", reuse=reuse): image = tf.concat([img, cond], dim - 1) feature = conf.conv_channel_base h0 = lrelu(conv2d(image, feature, name="h0")) h1 = lrelu(batch_norm(conv2d(h0, feature * 2, name="h1"), "h1")) h2 = lrelu(batch_norm(conv2d(h1, feature * 4, name="h2"), "h2")) h3 = lrelu(batch_norm(conv2d(h2, feature * 8, name="h3"), "h3")) h4 = linear(tf.reshape(h3, [1, -1]), 1, "linear") return h4
def discriminator(self, image, reuse=False): with tf.variable_scope('discriminator') as scope: if reuse: scope.reuse_variables() h0 = lrelu(conv2d(image, self.df_dim, name='d_h0_conv')) h1 = lrelu(self.d_bns[0](conv2d(h0, self.df_dim * 2, name='d_h1_conv'), self.is_training)) h2 = lrelu(self.d_bns[1](conv2d(h1, self.df_dim * 4, name='d_h2_conv'), self.is_training)) h3 = lrelu(self.d_bns[2](conv2d(h2, self.df_dim * 8, name='d_h3_conv'), self.is_training)) h4 = linear(tf.reshape(h3, [-1, 8192]), 1, 'd_h4_lin') return tf.nn.sigmoid(h4), h4
def build_disc1(h1, testing=False, reuse=False): # 16 x 16 --> 8x8 disc1_conv1 = utils.batch_normalization(utils.lrelu( utils.conv2d(h1, (3, 3, 3, 32), stride=[1, 2, 2, 1], name='disc1_conv1')), name='disc1_bn1', reuse=reuse) disc1_conv2 = utils.batch_normalization(utils.lrelu( utils.conv2d(disc1_conv1, (3, 3, 32, 64), name='disc1_conv2')), name='disc1_bn2', reuse=reuse) # 8x8 --> 8x8 disc1_conv3 = utils.batch_normalization(utils.lrelu( utils.conv2d(disc1_conv2, (3, 3, 64, 64), name='disc1_conv3')), name='disc1_bn3', reuse=reuse) disc1_conv3 = tf.nn.dropout(disc1_conv3, 0.1 if testing else 1) # 8x8 --> 6x6 disc1_conv4 = tf.layers.batch_normalization(utils.lrelu( utils.conv2d(disc1_conv3, (3, 3, 64, 64), padding='VALID', name='disc1_conv4')), name='bn4', reuse=reuse) disc1_l5 = tf.reshape(disc1_conv4, [100, 6, 6, 64]) disc1_shared = utils.lrelu( utils.network_in_network(disc1_l5, 64, num_units=64, name='disc1_shared')) disc1_shared_flat = tf.reshape(disc1_shared, [-1, 64 * 6 * 6]) disc1_z_recon = utils.dense(disc1_shared_flat, num_inputs=64 * 6 * 6, num_units=50, name='disc1_z_recon') disc1_shared_pool = tf.reduce_mean(disc1_shared, [1, 2]) disc1_adv = utils.dense(disc1_shared_pool, num_inputs=64, num_units=1, name='disc1_z_adv') # disc1_adv is the pre-sigmoid output of the discriminator return disc1_adv, disc1_z_recon
def add_prediction_op(self): left_half, right_half = tf.split( self.x, [self.config.window, self.config.window + 1], axis=1) # First conv layer W_convleft1 = utils.weight_variable([5, 4, 40]) b_convleft1 = utils.bias_variable([40]) W_convright1 = utils.weight_variable([5, 4, 40]) b_convright1 = utils.bias_variable([40]) h_convleft1 = utils.lrelu( utils.conv1d(left_half, W_convleft1) + b_convleft1) h_convright1 = utils.lrelu( utils.conv1d(right_half, W_convright1) + b_convright1) # Second conv layer W_convleft2 = utils.weight_variable([5, 40, 80]) b_convleft2 = utils.bias_variable([80]) W_convright2 = utils.weight_variable([5, 40, 80]) b_convright2 = utils.bias_variable([80]) h_convleft2 = utils.lrelu( utils.conv1d(h_convleft1, W_convleft2) + b_convleft2) h_convright2 = utils.lrelu( utils.conv1d(h_convright1, W_convright2) + b_convright2) h_convout = tf.concat([h_convleft2, h_convright2], 1) # First fully connected layer. Reshape the convolution output to 1D vector fc_dim_1 = int(self.config.strlen * 80 / 7.89) W_fc1 = utils.weight_variable([self.config.strlen * 80, fc_dim_1]) b_fc1 = utils.bias_variable([fc_dim_1]) h_conv_flat = tf.reshape(h_convout, [-1, self.config.strlen * 80]) #h_conv_flat = tf.nn.dropout(h_conv_flat, self.keep_prob) h_fc1 = utils.lrelu(tf.matmul(h_conv_flat, W_fc1) + b_fc1) h_fc1 = tf.nn.dropout(h_fc1, self.keep_prob) # Final fully-connected layer W_fc2 = utils.weight_variable([fc_dim_1, 1]) b_fc2 = utils.bias_variable([1]) y_conv = tf.matmul(h_fc1, W_fc2) + b_fc2 y_out = tf.sigmoid(y_conv) #TODO: Add separate filter with unshared weights that looks at center? return y_out
def discriminator(x, is_training=True, reuse=False): # Network Architecture is exactly same as in infoGAN (https://arxiv.org/abs/1606.03657) batch_size = x.get_shape().as_list()[0] with tf.variable_scope("discriminator", reuse=reuse): net = conv2d(x, output_dim=64, kernel=(4, 4), stride=(2, 2), activation='lrelu', name='conv1') net = conv2d(net, output_dim=128, kernel=(4, 4), stride=(2, 2), activation='lrelu', use_bn=True, is_training=is_training, name='conv2') net = tf.reshape(net, [batch_size, -1]) net = lrelu( bn(linear(net, 1024, scope='d_fc3'), is_training=is_training, scope='linear1')) out_logit = linear(net, 1, scope='linear2') out = tf.nn.sigmoid(out_logit) return out, out_logit, net
def generator(self, noise, caption): s = self.image_size s2, s4, s8, s16 = int(s / 2), int(s / 4), int(s / 8), int(s / 16) reduced_caption = utils.lrelu( utils.linear(caption, self.reduced_text_dim, 'g_embedding')) noise_concat = tf.concat([noise, reduced_caption], 1) new_noise = utils.linear(noise_concat, self.channel_dim * 8 * s16 * s16, 'g_h0_lin') h0 = tf.reshape(new_noise, [-1, s16, s16, self.channel_dim * 8]) h0 = tf.nn.relu(self.g_bn0(h0)) h1 = utils.deconv2d(h0, [self.batch_size, s8, s8, self.channel_dim * 4], name='g_h1') h1 = tf.nn.relu(self.g_bn1(h1)) h2 = utils.deconv2d(h1, [self.batch_size, s4, s4, self.channel_dim * 2], name='g_h2') h2 = tf.nn.relu(self.g_bn2(h2)) h3 = utils.deconv2d(h2, [self.batch_size, s2, s2, self.channel_dim], name='g_h3') h3 = tf.nn.relu(self.g_bn3(h3)) h4 = utils.deconv2d(h3, [self.batch_size, s, s, 3], name='g_h4') return (tf.tanh(h4) / 2. + 0.5)
def generative(self, x, reuse=False): with tf.variable_scope('generator') as scope: if reuse: scope.reuse_variables() if self.run_flags.run == 'train': is_training = True else: is_training = False conv1 = lrelu(batch_norm(conv2d(x, output_dim=32, stride=1, name='g_conv1'), \ is_training=is_training, name='g_conv1_bn')) # 64 x 64 x 32 conv2 = lrelu(batch_norm(conv2d(conv1, output_dim=128, stride=1, name='g_conv2'), \ is_training=is_training, name='g_conv2_bn')) # 64 x 64 x 128 conv3 = lrelu(batch_norm(conv2d(conv2, output_dim=128, stride=1, name='g_conv3'), \ is_training=is_training, name='g_conv3_bn')) # 64 x 64 x 128 conv3_up = tf.image.resize_images(conv3, size=[128, 128]) conv4 = lrelu(batch_norm(conv2d(conv3_up, output_dim=128, stride=1, name='g_conv4'), \ is_training=is_training, name='g_conv4_bn')) # 128 x 128 x 128 conv5 = lrelu(batch_norm(conv2d(conv4, output_dim=64, stride=1, name='g_conv5'), \ is_training=is_training, name='g_conv5_bn')) # 128 x 128 x 64 conv6 = tf.nn.sigmoid( conv2d(conv5, output_dim=3, stride=1, name='g_conv6')) #128 x 128 x 3 # conv1 = lrelu(conv2d(x, output_dim=32, stride=1, name='g_conv1')) # 64 x 64 x 32 # # conv2 = lrelu(conv2d(conv1, output_dim=128, stride=1, name='g_conv2')) # 64 x 64 x 128 # # conv3 = lrelu(conv2d(conv2, output_dim=128, stride=1, name='g_conv3')) # 64 x 64 x 128 # # conv3_up = tf.image.resize_images(conv3, size=[128, 128]) # # conv4 = lrelu(conv2d(conv3_up, output_dim=128, stride=1, name='g_conv4')) # 128 x 128 x 128 # # conv5 = lrelu(conv2d(conv4, output_dim=64, stride=1, name='g_conv5')) # 128 x 128 x 64 # # conv6 = tf.nn.sigmoid(conv2d(conv5, output_dim=3, stride=1, name='g_conv6')) #128 x 128 x 3 return conv6
def generator(self, cond): with tf.variable_scope("gen"): feature = conf.conv_channel_base e1 = conv2d(cond, feature, name="e1") e2 = batch_norm(conv2d(lrelu(e1), feature*2, name="e2"), "e2") e3 = batch_norm(conv2d(lrelu(e2), feature*4, name="e3"), "e3") e4 = batch_norm(conv2d(lrelu(e3), feature*8, name="e4"), "e4") e5 = batch_norm(conv2d(lrelu(e4), feature*8, name="e5"), "e5") e6 = batch_norm(conv2d(lrelu(e5), feature*8, name="e6"), "e6") e7 = batch_norm(conv2d(lrelu(e6), feature*8, name="e7"), "e7") e8 = batch_norm(conv2d(lrelu(e7), feature*8, name="e8"), "e8") size = conf.img_size num = [0] * 9 for i in range(1,9): num[9-i]=size size =(size+1)/2 d1 = deconv2d(tf.nn.relu(e8), [1,num[1],num[1],feature*8], name="d1") d1 = tf.concat(3, [tf.nn.dropout(batch_norm(d1, "d1"), 0.5), e7]) d2 = deconv2d(tf.nn.relu(d1), [1,num[2],num[2],feature*8], name="d2") d2 = tf.concat(3, [tf.nn.dropout(batch_norm(d2, "d2"), 0.5), e6]) d3 = deconv2d(tf.nn.relu(d2), [1,num[3],num[3],feature*8], name="d3") d3 = tf.concat(3, [tf.nn.dropout(batch_norm(d3, "d3"), 0.5), e5]) d4 = deconv2d(tf.nn.relu(d3), [1,num[4],num[4],feature*8], name="d4") d4 = tf.concat(3, [batch_norm(d4, "d4"), e4]) d5 = deconv2d(tf.nn.relu(d4), [1,num[5],num[5],feature*4], name="d5") d5 = tf.concat(3, [batch_norm(d5, "d5"), e3]) d6 = deconv2d(tf.nn.relu(d5), [1,num[6],num[6],feature*2], name="d6") d6 = tf.concat(3, [batch_norm(d6, "d6"), e2]) d7 = deconv2d(tf.nn.relu(d6), [1,num[7],num[7],feature], name="d7") d7 = tf.concat(3, [batch_norm(d7, "d7"), e1]) d8 = deconv2d(tf.nn.relu(d7), [1,num[8],num[8],conf.img_channel], name="d8") return tf.nn.tanh(d8)
def generator(self, cond): with tf.variable_scope("gen"): feature = conf.conv_channel_base e1 = conv2d(cond, feature, name="e1") e2 = batch_norm(conv2d(lrelu(e1), feature*2, name="e2"), "e2") e3 = batch_norm(conv2d(lrelu(e2), feature*4, name="e3"), "e3") e4 = batch_norm(conv2d(lrelu(e3), feature*8, name="e4"), "e4") e5 = batch_norm(conv2d(lrelu(e4), feature*8, name="e5"), "e5") e6 = batch_norm(conv2d(lrelu(e5), feature*8, name="e6"), "e6") e7 = batch_norm(conv2d(lrelu(e6), feature*8, name="e7"), "e7") e8 = batch_norm(conv2d(lrelu(e7), feature*8, name="e8"), "e8") d1 = deconv2d(tf.nn.relu(e8), [1,2,2,feature*8], name="d1") d1 = tf.concat(3, [tf.nn.dropout(batch_norm(d1, "d1"), 0.5), e7]) d2 = deconv2d(tf.nn.relu(d1), [1,4,4,feature*8], name="d2") d2 = tf.concat(3, [tf.nn.dropout(batch_norm(d2, "d2"), 0.5), e6]) d3 = deconv2d(tf.nn.relu(d2), [1,8,8,feature*8], name="d3") d3 = tf.concat(3, [tf.nn.dropout(batch_norm(d3, "d3"), 0.5), e5]) d4 = deconv2d(tf.nn.relu(d3), [1,16,16,feature*8], name="d4") d4 = tf.concat(3, [batch_norm(d4, "d4"), e4]) d5 = deconv2d(tf.nn.relu(d4), [1,32,32,feature*4], name="d5") d5 = tf.concat(3, [batch_norm(d5, "d5"), e3]) d6 = deconv2d(tf.nn.relu(d5), [1,64,64,feature*2], name="d6") d6 = tf.concat(3, [batch_norm(d6, "d6"), e2]) d7 = deconv2d(tf.nn.relu(d6), [1,128,128,feature], name="d7") d7 = tf.concat(3, [batch_norm(d7, "d7"), e1]) d8 = deconv2d(tf.nn.relu(d7), [1,256,256,conf.img_channel], name="d8") return tf.nn.tanh(d8)
def discriminator(self, im, reuse): fmap_dim = self.fmap_dim_d with tf.variable_scope("discriminator", reuse=reuse) as scope: dl0 = utils.lrelu(utils.conv2d(im, fmap_dim, name='d_l0_conv')) dl1 = utils.lrelu( self.d_bn_l0(utils.conv2d(dl0, fmap_dim * 2, name='d_l1_conv'))) dl2 = utils.lrelu( self.d_bn_l1(utils.conv2d(dl1, fmap_dim * 4, name='d_l2_conv'))) dl3 = utils.lrelu( self.d_bn_l2(utils.conv2d(dl2, fmap_dim * 8, name='d_l3_conv'))) dim = 1 for d in dl3.get_shape()[1:].as_list(): dim *= d dl4 = utils.fc(tf.reshape(dl3, [-1, dim]), 1, name='d_l4_fc') return tf.nn.sigmoid(dl4), dl4
def __call__(self, x, y=None, sn=False, is_training=True, reuse=False): with tf.variable_scope(self.name, reuse=reuse): batch_size = x.get_shape().as_list()[0] if y is not None: ydim = y.get_shape().as_list()[-1] y = tf.reshape(y, [batch_size, 1, 1, ydim]) x = conv_cond_concat(x, y) # [bz, 28, 28, 11] # [bz, 14, 14, 64] net = lrelu(conv2d(x, 64, 4, 4, 2, 2, sn=sn, padding="SAME", name='d_conv1'), name='d_l1') # [bz, 7, 7, 128] net = lrelu(bn(conv2d(net, 128, 4, 4, 2, 2, sn=sn, padding="SAME", name='d_conv2'), is_training, name='d_bn2'), name='d_l2') net = tf.reshape(net, [batch_size, 7 * 7 * 128]) # [bz, 1024] net = lrelu(bn(dense(net, 1024, sn=sn, name='d_fc3'), is_training, name='d_bn3'), name='d_l3') # [bz, 1] yd = dense(net, 1, sn=sn, name='D_dense') if self.class_num: yc = dense(net, self.class_num, sn=sn, name='C_dense') return yd, net, yc else: return yd, net
def dis(self,x,training): x = tf.reshape(x,shape=[-1,self.shape,self.shape,3]) scope = 'dis_' layer = lrelu(conv2d(x,self.weights[scope+'w_conv1'])+self.biases[scope+'b_conv1']) for i in range(1,4): conv = prelu(conv2d(layer,self.weights[scope+'w_conv'+str(i+1)])+self.biases[scope+'b_conv'+str(i+1)],scope+'w_conv'+str(i+1)) conv = maxpool2d(conv) conv = tf.nn.dropout(conv,self.keep_rate) layer = conv fc = tf.reshape(layer,[-1, int(self.shape/8)*int(self.shape/8)*256]) fc = lrelu(tf.matmul(fc,self.weights[scope+'w_fc'])+self.biases[scope+'b_fc']) fc = tf.nn.dropout(fc,self.keep_rate) output = tf.matmul(fc,self.weights[scope+'out'])+self.biases[scope+'out'] output = (tanh(output)+1.0)*0.5 return output
def __call__(self, x, is_training=True, reuse=False): with tf.variable_scope(self.name, reuse): net = lrelu(bn(dense(x, 64, name='c_fc1'), is_training, name='c_bn1'), name='c_l1') out_logit = dense(net, self.class_num, name='c_l2') out = tf.nn.softmax(out_logit) return out_logit, out
def discriminator(self, x, prior): inputs = tf.concat([x, prior], axis=1) self.D_h1 = lrelu(tf.matmul(inputs, self.D_W1) + self.D_b1) self.D_h2 = tf.nn.sigmoid(tf.matmul(self.D_h1, self.D_W2) + self.D_b2) ''' self.D_h3 = lrelu(tf.matmul(self.D_h2, self.D_W3) + self.D_b3) self.D_h4 = lrelu(tf.matmul(self.D_h3, self.D_W4) + self.D_b4) self.D_h5 = lrelu(tf.matmul(self.D_h4, self.D_W5) + self.D_b5) self.D_h6 = tf.nn.sigmoid(tf.matmul(self.D_h5, self.D_W6) + self.D_b6) ''' return self.D_h2
def code_discriminator(inputs): ''' inputs: codeçš„tensor[-1, 128] ''' x = inputs units = 512 initializer = tf.random_normal_initializer(mean=0.0, stddev=0.02) # ----- x = tf.layers.dense(x, units=units, kernel_initializer=initializer) x = lrelu(x) # ----- x = tf.layers.dense(x, units=units, kernel_initializer=initializer) x = lrelu(x) # ----- x = tf.layers.dense(x, units=1, kernel_initializer=initializer) return x