我们从Python开源项目中，提取了以下23个代码示例，用于说明如何使用ops.lrelu()。
def discriminate(self, x_var, y, weights, biases, reuse=False): y1 = tf.reshape(y, shape=[self.batch_size, 1, 1, self.y_dim]) x_var = conv_cond_concat(x_var, y1) conv1= lrelu(conv2d(x_var, weights['wc1'], biases['bc1'])) conv1 = conv_cond_concat(conv1, y1) conv2= lrelu(batch_normal(conv2d(conv1, weights['wc2'], biases['bc2']), scope='dis_bn1', reuse=reuse)) conv2 = tf.reshape(conv2, [self.batch_size, -1]) conv2 = tf.concat([conv2, y], 1) fc1 = lrelu(batch_normal(fully_connect(conv2, weights['wc3'], biases['bc3']), scope='dis_bn2', reuse=reuse)) fc1 = tf.concat([fc1, y], 1) #for D output= fully_connect(fc1, weights['wd'], biases['bd']) return tf.nn.sigmoid(output)
def discriminator_labeler(image, output_dim, config, reuse=None): batch_size=tf.shape(image)[0] with tf.variable_scope("disc_labeler",reuse=reuse) as vs: dl_bn1 = batch_norm(name='dl_bn1') dl_bn2 = batch_norm(name='dl_bn2') dl_bn3 = batch_norm(name='dl_bn3') h0 = lrelu(conv2d(image, config.df_dim, name='dl_h0_conv'))#16,32,32,64 h1 = lrelu(dl_bn1(conv2d(h0, config.df_dim*2, name='dl_h1_conv')))#16,16,16,128 h2 = lrelu(dl_bn2(conv2d(h1, config.df_dim*4, name='dl_h2_conv')))#16,16,16,248 h3 = lrelu(dl_bn3(conv2d(h2, config.df_dim*8, name='dl_h3_conv'))) dim3=np.prod(h3.get_shape().as_list()[1:]) h3_flat=tf.reshape(h3, [-1,dim3]) D_labels_logits = linear(h3_flat, output_dim, 'dl_h3_Label') D_labels = tf.nn.sigmoid(D_labels_logits) variables = tf.contrib.framework.get_variables(vs) return D_labels, D_labels_logits, variables
def discriminator_gen_labeler(image, output_dim, config, reuse=None): batch_size=tf.shape(image)[0] with tf.variable_scope("disc_gen_labeler",reuse=reuse) as vs: dl_bn1 = batch_norm(name='dl_bn1') dl_bn2 = batch_norm(name='dl_bn2') dl_bn3 = batch_norm(name='dl_bn3') h0 = lrelu(conv2d(image, config.df_dim, name='dgl_h0_conv'))#16,32,32,64 h1 = lrelu(dl_bn1(conv2d(h0, config.df_dim*2, name='dgl_h1_conv')))#16,16,16,128 h2 = lrelu(dl_bn2(conv2d(h1, config.df_dim*4, name='dgl_h2_conv')))#16,16,16,248 h3 = lrelu(dl_bn3(conv2d(h2, config.df_dim*8, name='dgl_h3_conv'))) dim3=np.prod(h3.get_shape().as_list()[1:]) h3_flat=tf.reshape(h3, [-1,dim3]) D_labels_logits = linear(h3_flat, output_dim, 'dgl_h3_Label') D_labels = tf.nn.sigmoid(D_labels_logits) variables = tf.contrib.framework.get_variables(vs) return D_labels, D_labels_logits,variables
def discriminator_on_z(image, config, reuse=None): batch_size=tf.shape(image)[0] with tf.variable_scope("disc_z_labeler",reuse=reuse) as vs: dl_bn1 = batch_norm(name='dl_bn1') dl_bn2 = batch_norm(name='dl_bn2') dl_bn3 = batch_norm(name='dl_bn3') h0 = lrelu(conv2d(image, config.df_dim, name='dzl_h0_conv'))#16,32,32,64 h1 = lrelu(dl_bn1(conv2d(h0, config.df_dim*2, name='dzl_h1_conv')))#16,16,16,128 h2 = lrelu(dl_bn2(conv2d(h1, config.df_dim*4, name='dzl_h2_conv')))#16,16,16,248 h3 = lrelu(dl_bn3(conv2d(h2, config.df_dim*8, name='dzl_h3_conv'))) dim3=np.prod(h3.get_shape().as_list()[1:]) h3_flat=tf.reshape(h3, [-1,dim3]) D_labels_logits = linear(h3_flat, config.z_dim, 'dzl_h3_Label') D_labels = tf.nn.tanh(D_labels_logits) variables = tf.contrib.framework.get_variables(vs) return D_labels,variables
def create_discriminator(hr_images_fake, hr_images, cfg): n_layers = 3 layers = [] input = tf.concat([hr_images_fake, hr_images ], axis = 3) conv = slim.conv2d(input, cfg.ndf, [3,3], stride = 2, activation_fn = lrelu, scope = 'layers%d'%(0)) layers.append(conv) for i in range(n_layers): out_channels = cfg.ndf*min(2**(i+1), 8) stride = 1 if i == n_layers -1 else 2 conv = slim.conv2d(layers[-1], out_channels, [3,3], stride = stride, activation_fn = lrelu, scope = 'layers_%d'%(i+2)) layers.append(conv) conv = slim.conv2d(layers[-1], 1, [3,3], stride = 1) output = tf.sigmoid(conv) return output
def discriminator(self, opts, input_, is_training, prefix='DISCRIMINATOR', reuse=False): """Discriminator function, suitable for simple toy experiments. """ num_filters = opts['d_num_filters'] with tf.variable_scope(prefix, reuse=reuse): h0 = ops.conv2d(opts, input_, num_filters, scope='h0_conv') h0 = ops.batch_norm(opts, h0, is_training, reuse, scope='bn_layer1') h0 = ops.lrelu(h0) h1 = ops.conv2d(opts, h0, num_filters * 2, scope='h1_conv') h1 = ops.batch_norm(opts, h1, is_training, reuse, scope='bn_layer2') h1 = ops.lrelu(h1) h2 = ops.conv2d(opts, h1, num_filters * 4, scope='h2_conv') h2 = ops.batch_norm(opts, h2, is_training, reuse, scope='bn_layer3') h2 = ops.lrelu(h2) h3 = ops.linear(opts, h2, 1, scope='h3_lin') return h3
def discriminator(self, image, y=None, reuse=False): if reuse: tf.get_variable_scope().reuse_variables() s = self.output_size if np.mod(s, 16) == 0: h0 = lrelu(conv2d(image, self.df_dim, name='d_h0_conv')) h1 = lrelu(self.d_bn1(conv2d(h0, self.df_dim*2, name='d_h1_conv'))) h2 = lrelu(self.d_bn2(conv2d(h1, self.df_dim*4, name='d_h2_conv'))) h3 = lrelu(self.d_bn3(conv2d(h2, self.df_dim*8, name='d_h3_conv'))) h4 = linear(tf.reshape(h3, [self.batch_size, -1]), 1, 'd_h3_lin') return tf.nn.sigmoid(h4), h4 else: h0 = lrelu(conv2d(image, self.df_dim, name='d_h0_conv')) h1 = lrelu(self.d_bn1(conv2d(h0, self.df_dim*2, name='d_h1_conv'))) h2 = linear(tf.reshape(h1, [self.batch_size, -1]), 1, 'd_h2_lin') if not self.config.use_kernel: return tf.nn.sigmoid(h2), h2 else: return tf.nn.sigmoid(h2), h2, h1, h0
def feature_extract_net(self, lr_image): end_points = {} with slim.arg_scope([slim.conv2d, slim.conv2d_transpose], activation_fn = lrelu, ): conv = slim.conv2d(lr_image, self.nfc, [3,3], scope = 'conv1') for l in range(self.level): for d in range(self.depth): conv = slim.conv2d(conv, self.nfc, [3,3], scope = 'conv_%d_level_%d'%(l,d)) conv = slim.conv2d_transpose(conv, self.nfc, [4,4], stride = 2, scope = 'residual_level_%d'%(l)) conv = slim.conv2d(conv, 3, [3,3], activation_fn = None, scope = 'conv_level_%d'%(l)) end_points['residual_level_%d'%(l)] = conv return end_points
def discriminator(input, is_train, reuse=False): c2, c4, c8 = 16, 32, 64 # channel num,32, 64, 128 with tf.variable_scope('dis') as scope: if reuse: scope.reuse_variables() # 16*16*32 conv1 = tf.layers.conv2d(input, c2, kernel_size=[4, 4], strides=[2, 2], padding="SAME", kernel_initializer=tf.truncated_normal_initializer(stddev=0.02), name='conv1') act1 = lrelu(conv1, n='act1') # 8*8*64 conv2 = tf.layers.conv2d(act1, c4, kernel_size=[4, 4], strides=[2, 2], padding="SAME", kernel_initializer=tf.truncated_normal_initializer(stddev=0.02), name='conv2') bn2 = tf.layers.batch_normalization(conv2, training=is_train, name='bn2') act2 = lrelu(bn2, n='act2') # 4*4*128 conv3 = tf.layers.conv2d(act2, c8, kernel_size=[4, 4], strides=[2, 2], padding="SAME", kernel_initializer=tf.truncated_normal_initializer(stddev=0.02), name='conv3') bn3 = tf.layers.batch_normalization(conv3, training=is_train, name='bn3') act3 = lrelu(bn3, n='act3') shape = act3.get_shape().as_list() dim = shape[1] * shape[2] * shape[3] fc1 = tf.reshape(act3, shape=[-1, dim], name='fc1') w1 = tf.get_variable('w1', shape=[fc1.shape[1], 1], dtype=tf.float32, initializer=tf.truncated_normal_initializer(stddev=0.02)) b1 = tf.get_variable('b1', shape=[1], dtype=tf.float32, initializer=tf.constant_initializer(0.0)) # wgan just get rid of the sigmoid output = tf.add(tf.matmul(fc1, w1), b1, name='output') return output
def discriminator(input, is_train, reuse=False): c2, c4, c8 = 16, 32, 64 with tf.variable_scope('dis') as scope: if reuse: scope.reuse_variables() # 16*16*16 conv1 = tf.layers.conv2d(input, c2, kernel_size=[4, 4], strides=[2, 2], padding="SAME", kernel_initializer=tf.truncated_normal_initializer(stddev=0.02), name='conv1') act1 = lrelu(conv1, n='act1') # 8*8*32 conv2 = tf.layers.conv2d(act1, c4, kernel_size=[4, 4], strides=[2, 2], padding="SAME", kernel_initializer=tf.truncated_normal_initializer(stddev=0.02), name='conv2') bn2 = tf.layers.batch_normalization(conv2, training=is_train, name='bn2') act2 = lrelu(bn2, n='act2') # 4*4*64 conv3 = tf.layers.conv2d(act2, c8, kernel_size=[4, 4], strides=[2, 2], padding="SAME", kernel_initializer=tf.truncated_normal_initializer(stddev=0.02), name='conv3') bn3 = tf.layers.batch_normalization(conv3, training=is_train, name='bn3') act3 = lrelu(bn3, n='act3') # 1024 shape = act3.get_shape().as_list() dim = shape[1] * shape[2] * shape[3] fc1 = tf.reshape(act3, shape=[-1, dim], name='fc1') w1 = tf.get_variable('w1', shape=[fc1.shape[1], 1], dtype=tf.float32, initializer=tf.truncated_normal_initializer(stddev=0.02)) b1 = tf.get_variable('b1', shape=[1], dtype=tf.float32, initializer=tf.constant_initializer(0.0)) output = tf.nn.sigmoid(tf.add(tf.matmul(fc1, w1), b1, name='output')) return output
def __init__(self, config, debug_information=False, is_train=True): self.debug = debug_information self.config = config self.batch_size = self.config.batch_size self.input_height = self.config.data_info[0] self.input_width = self.config.data_info[1] self.num_class = self.config.data_info[2] self.c_dim = self.config.data_info[3] self.visualize_shape = self.config.visualize_shape self.conv_info = self.config.conv_info self.activation_fn = { 'selu': selu, 'relu': tf.nn.relu, 'lrelu': lrelu, }[self.config.activation] # create placeholders for the input self.image = tf.placeholder( name='image', dtype=tf.float32, shape=[self.batch_size, self.input_height, self.input_width, self.c_dim], ) self.label = tf.placeholder( name='label', dtype=tf.float32, shape=[self.batch_size, self.num_class], ) self.is_training = tf.placeholder_with_default(bool(is_train), [], name='is_training') self.build(is_train=is_train)
def dis_net(self, images, y, reuse=False): with tf.variable_scope("discriminator") as scope: if reuse == True: scope.reuse_variables() # mnist data's shape is (28 , 28 , 1) yb = tf.reshape(y, shape=[self.batch_size, 1, 1, self.y_dim]) # concat concat_data = conv_cond_concat(images, yb) conv1, w1 = conv2d(concat_data, output_dim=10, name='dis_conv1') tf.add_to_collection('weight_1', w1) conv1 = lrelu(conv1) conv1 = conv_cond_concat(conv1, yb) tf.add_to_collection('ac_1', conv1) conv2, w2 = conv2d(conv1, output_dim=64, name='dis_conv2') tf.add_to_collection('weight_2', w2) conv2 = lrelu(batch_normal(conv2, scope='dis_bn1')) tf.add_to_collection('ac_2', conv2) conv2 = tf.reshape(conv2, [self.batch_size, -1]) conv2 = tf.concat([conv2, y], 1) f1 = lrelu(batch_normal(fully_connect(conv2, output_size=1024, scope='dis_fully1'), scope='dis_bn2', reuse=reuse)) f1 = tf.concat([f1, y], 1) out = fully_connect(f1, output_size=1, scope='dis_fully2') return tf.nn.sigmoid(out), out
def discriminator(hparams, x, scope_name, train, reuse): with tf.variable_scope(scope_name) as scope: if reuse: scope.reuse_variables() d_bn1 = ops.batch_norm(name='d_bn1') d_bn2 = ops.batch_norm(name='d_bn2') d_bn3 = ops.batch_norm(name='d_bn3') h0 = ops.lrelu(ops.conv2d(x, hparams.df_dim, name='d_h0_conv')) h1 = ops.conv2d(h0, hparams.df_dim*2, name='d_h1_conv') h1 = ops.lrelu(d_bn1(h1, train=train)) h2 = ops.conv2d(h1, hparams.df_dim*4, name='d_h2_conv') h2 = ops.lrelu(d_bn2(h2, train=train)) h3 = ops.conv2d(h2, hparams.df_dim*8, name='d_h3_conv') h3 = ops.lrelu(d_bn3(h3, train=train)) h4 = ops.linear(tf.reshape(h3, [hparams.batch_size, -1]), 1, 'd_h3_lin') d_logit = h4 d = tf.nn.sigmoid(d_logit) return d, d_logit
def discriminator(hparams, x, train, reuse): if reuse: tf.get_variable_scope().reuse_variables() d_bn1 = ops.batch_norm(name='d_bn1') d_bn2 = ops.batch_norm(name='d_bn2') d_bn3 = ops.batch_norm(name='d_bn3') h0 = ops.lrelu(ops.conv2d(x, hparams.df_dim, name='d_h0_conv')) h1 = ops.conv2d(h0, hparams.df_dim*2, name='d_h1_conv') h1 = ops.lrelu(d_bn1(h1, train=train)) h2 = ops.conv2d(h1, hparams.df_dim*4, name='d_h2_conv') h2 = ops.lrelu(d_bn2(h2, train=train)) h3 = ops.conv2d(h2, hparams.df_dim*8, name='d_h3_conv') h3 = ops.lrelu(d_bn3(h3, train=train)) h4 = ops.linear(tf.reshape(h3, [hparams.batch_size, -1]), 1, 'd_h3_lin') d_logit = h4 d = tf.nn.sigmoid(d_logit) return d, d_logit
def DiscriminatorCNN(image, config, reuse=None): ''' Discriminator for GAN model. image : batch_size x 64x64x3 image config : see causal_dcgan/config.py reuse : pass True if not calling for first time returns: probabilities(real) : logits(real) : first layer activation used to estimate z from : variables list ''' with tf.variable_scope("discriminator",reuse=reuse) as vs: d_bn1 = batch_norm(name='d_bn1') d_bn2 = batch_norm(name='d_bn2') d_bn3 = batch_norm(name='d_bn3') if not config.stab_proj: h0 = lrelu(conv2d(image, config.df_dim, name='d_h0_conv'))#16,32,32,64 else:#method to restrict disc from winning #I think this is equivalent to just not letting disc optimize first layer #and also removing nonlinearity #k_h=5, k_w=5, d_h=2, d_w=2, stddev=0.02, #paper used 8x8 kernel, but I'm using 5x5 because it is more similar to my achitecture #n_projs=config.df_dim#64 instead of 32 in paper n_projs=config.n_stab_proj#64 instead of 32 in paper print("WARNING:STAB_PROJ active, using ",n_projs," projections") w_proj = tf.get_variable('w_proj', [5, 5, image.get_shape()[-1],n_projs], initializer=tf.truncated_normal_initializer(stddev=0.02),trainable=False) conv = tf.nn.conv2d(image, w_proj, strides=[1, 2, 2, 1], padding='SAME') b_proj = tf.get_variable('b_proj', [n_projs],#does nothing initializer=tf.constant_initializer(0.0),trainable=False) h0=tf.nn.bias_add(conv,b_proj) h1_ = lrelu(d_bn1(conv2d(h0, config.df_dim*2, name='d_h1_conv')))#16,16,16,128 h1 = add_minibatch_features(h1_, config.df_dim) h2 = lrelu(d_bn2(conv2d(h1, config.df_dim*4, name='d_h2_conv')))#16,16,16,248 h3 = lrelu(d_bn3(conv2d(h2, config.df_dim*8, name='d_h3_conv'))) #print('h3shape: ',h3.get_shape().as_list()) #print('8df_dim:',config.df_dim*8) #dim3=tf.reduce_prod(tf.shape(h3)[1:]) dim3=np.prod(h3.get_shape().as_list()[1:]) h3_flat=tf.reshape(h3, [-1,dim3]) h4 = linear(h3_flat, 1, 'd_h3_lin') prob=tf.nn.sigmoid(h4) variables = tf.contrib.framework.get_variables(vs,collection=tf.GraphKeys.TRAINABLE_VARIABLES) return prob, h4, h1_, variables
def create_generator(hr_image_bilinear, num_channels, cfg): layers = [] print(hr_image_bilinear.get_shape()) conv = slim.conv2d(hr_image_bilinear, cfg.ngf, [3,3], stride = 2, scope = 'encoder0') layers.append(conv) layers_specs = [ cfg.ngf*2, cfg.ngf*4, cfg.ngf*8, cfg.ngf*8, cfg.ngf*8, cfg.ngf*8, ] for idx, out_channels in enumerate(layers_specs): with slim.arg_scope([slim.conv2d], activation_fn = lrelu, stride = 2, padding = 'VALID'): conv = conv2d(layers[-1], out_channels, scope = 'encoder%d'%(idx+1)) print(conv.get_shape()) layers.append(conv) ### decoder part layers_specs = [ (cfg.ngf*8, 0.5), (cfg.ngf*8, 0.5), (cfg.ngf*8, 0.0), (cfg.ngf*4, 0.0), (cfg.ngf*2, 0.0), (cfg.ngf, 0.0) ] num_encoder_layers = len(layers) for decoder_layer_idx, (out_channels, dropout) in enumerate(layers_specs): skip_layer = num_encoder_layers - decoder_layer_idx - 1 with slim.arg_scope([slim.conv2d], activation_fn = lrelu): if decoder_layer_idx == 0: input = layers[-1] else: input = tf.concat([layers[-1], layers[skip_layer]], axis = 3) output = upsample_layer(input, out_channels, mode = 'deconv') print(output.get_shape()) if dropout > 0.0: output = tf.nn.dropout(output, keep_prob = 1 - dropout) layers.append(output) input = tf.concat([layers[-1],layers[0]], axis = 3) output = slim.conv2d_transpose(input, num_channels, [4,4], stride = 2, activation_fn = tf.tanh) return output
def generator(self, opts, noise, is_training, reuse=False): """Generator function, suitable for simple picture experiments. Args: noise: [num_points, dim] array, where dim is dimensionality of the latent noise space. is_training: bool, defines whether to use batch_norm in the train or test mode. Returns: [num_points, dim1, dim2, dim3] array, where the first coordinate indexes the points, which all are of the shape (dim1, dim2, dim3). """ output_shape = self._data.data_shape # (dim1, dim2, dim3) # Computing the number of noise vectors on-the-go dim1 = tf.shape(noise)[0] num_filters = opts['g_num_filters'] with tf.variable_scope("GENERATOR", reuse=reuse): height = output_shape[0] / 4 width = output_shape[1] / 4 h0 = ops.linear(opts, noise, num_filters * height * width, scope='h0_lin') h0 = tf.reshape(h0, [-1, height, width, num_filters]) h0 = ops.batch_norm(opts, h0, is_training, reuse, scope='bn_layer1') # h0 = tf.nn.relu(h0) h0 = ops.lrelu(h0) _out_shape = [dim1, height * 2, width * 2, num_filters / 2] # for 28 x 28 does 7 x 7 --> 14 x 14 h1 = ops.deconv2d(opts, h0, _out_shape, scope='h1_deconv') h1 = ops.batch_norm(opts, h1, is_training, reuse, scope='bn_layer2') # h1 = tf.nn.relu(h1) h1 = ops.lrelu(h1) _out_shape = [dim1, height * 4, width * 4, num_filters / 4] # for 28 x 28 does 14 x 14 --> 28 x 28 h2 = ops.deconv2d(opts, h1, _out_shape, scope='h2_deconv') h2 = ops.batch_norm(opts, h2, is_training, reuse, scope='bn_layer3') # h2 = tf.nn.relu(h2) h2 = ops.lrelu(h2) _out_shape = [dim1] + list(output_shape) # data_shape[0] x data_shape[1] x ? -> data_shape h3 = ops.deconv2d(opts, h2, _out_shape, d_h=1, d_w=1, scope='h3_deconv') h3 = ops.batch_norm(opts, h3, is_training, reuse, scope='bn_layer4') if opts['input_normalize_sym']: return tf.nn.tanh(h3) else: return tf.nn.sigmoid(h3)
def ali_deconv(self, opts, noise, is_training, reuse, keep_prob): output_shape = self._data.data_shape batch_size = tf.shape(noise)[0] noise_size = int(noise.get_shape()[1]) data_height = output_shape[0] data_width = output_shape[1] data_channels = output_shape[2] noise = tf.reshape(noise, [-1, 1, 1, noise_size]) num_units = opts['g_num_filters'] layer_params = [] layer_params.append([4, 1, num_units]) layer_params.append([4, 2, num_units / 2]) layer_params.append([4, 1, num_units / 4]) layer_params.append([4, 2, num_units / 8]) layer_params.append([5, 1, num_units / 8]) # For convolution: (n - k) / stride + 1 = s # For transposed: (s - 1) * stride + k = n layer_x = noise height = 1 width = 1 for i, (kernel, stride, channels) in enumerate(layer_params): height = (height - 1) * stride + kernel width = height layer_x = ops.deconv2d( opts, layer_x, [batch_size, height, width, channels], d_h=stride, d_w=stride, scope='h%d_deconv' % i, conv_filters_dim=kernel, padding='VALID') if opts['batch_norm']: layer_x = ops.batch_norm(opts, layer_x, is_training, reuse, scope='bn%d' % i) layer_x = ops.lrelu(layer_x, 0.1) assert height == data_height assert width == data_width # Then two 1x1 convolutions. layer_x = ops.conv2d(opts, layer_x, num_units / 8, d_h=1, d_w=1, scope='conv2d_1x1', conv_filters_dim=1) if opts['batch_norm']: layer_x = ops.batch_norm(opts, layer_x, is_training, reuse, scope='bnlast') layer_x = ops.lrelu(layer_x, 0.1) layer_x = ops.conv2d(opts, layer_x, data_channels, d_h=1, d_w=1, scope='conv2d_1x1_2', conv_filters_dim=1) if opts['input_normalize_sym']: return tf.nn.tanh(layer_x) else: return tf.nn.sigmoid(layer_x)
def ali_encoder(self, opts, input_, is_training=False, reuse=False, keep_prob=1.): num_units = opts['e_num_filters'] layer_params = [] layer_params.append([5, 1, num_units / 8]) layer_params.append([4, 2, num_units / 4]) layer_params.append([4, 1, num_units / 2]) layer_params.append([4, 2, num_units]) layer_params.append([4, 1, num_units * 2]) # For convolution: (n - k) / stride + 1 = s # For transposed: (s - 1) * stride + k = n layer_x = input_ height = int(layer_x.get_shape()[1]) width = int(layer_x.get_shape()[2]) assert height == width for i, (kernel, stride, channels) in enumerate(layer_params): height = (height - kernel) / stride + 1 width = height # print((height, width)) layer_x = ops.conv2d( opts, layer_x, channels, d_h=stride, d_w=stride, scope='h%d_conv' % i, conv_filters_dim=kernel, padding='VALID') if opts['batch_norm']: layer_x = ops.batch_norm(opts, layer_x, is_training, reuse, scope='bn%d' % i) layer_x = ops.lrelu(layer_x, 0.1) assert height == 1 assert width == 1 # Then two 1x1 convolutions. layer_x = ops.conv2d(opts, layer_x, num_units * 2, d_h=1, d_w=1, scope='conv2d_1x1', conv_filters_dim=1) if opts['batch_norm']: layer_x = ops.batch_norm(opts, layer_x, is_training, reuse, scope='bnlast') layer_x = ops.lrelu(layer_x, 0.1) layer_x = ops.conv2d(opts, layer_x, num_units / 2, d_h=1, d_w=1, scope='conv2d_1x1_2', conv_filters_dim=1) if opts['e_is_random']: latent_mean = ops.linear( opts, layer_x, opts['latent_space_dim'], scope='hlast_lin') log_latent_sigmas = ops.linear( opts, layer_x, opts['latent_space_dim'], scope='hlast_lin_sigma') return latent_mean, log_latent_sigmas else: return ops.linear(opts, layer_x, opts['latent_space_dim'], scope='hlast_lin')
def _recon_loss_using_disc_conv_eb(self, opts, reconstructed_training, real_points, is_training, keep_prob): """Build an additional loss using a discriminator in X space, using Energy Based approach.""" def copy3D(height, width, channels): m = np.zeros([height, width, channels, height, width, channels]) for i in xrange(height): for j in xrange(width): for c in xrange(channels): m[i, j, c, i, j, c] = 1.0 return tf.constant(np.reshape(m, [height, width, channels, -1]), dtype=tf.float32) def _architecture(inputs, reuse=None): dim = opts['adv_c_patches_size'] height = int(inputs.get_shape()[1]) width = int(inputs.get_shape()[2]) channels = int(inputs.get_shape()[3]) with tf.variable_scope('DISC_X_LOSS', reuse=reuse): num_units = opts['adv_c_num_units'] num_layers = 1 layer_x = inputs for i in xrange(num_layers): # scale = 2**(num_layers-i-1) layer_x = ops.conv2d(opts, layer_x, num_units, d_h=1, d_w=1, scope='h%d_conv' % i, conv_filters_dim=dim, padding='SAME') # if opts['batch_norm']: # layer_x = ops.batch_norm(opts, layer_x, is_training, reuse, scope='bn%d' % i) layer_x = ops.lrelu(layer_x, 0.1) #tf.nn.relu(layer_x) copy_w = copy3D(dim, dim, channels) duplicated = tf.nn.conv2d(inputs, copy_w, strides=[1, 1, 1, 1], padding='SAME') decoded = ops.conv2d( opts, layer_x, channels * dim * dim, d_h=1, d_w=1, scope="decoder", conv_filters_dim=1, padding='SAME') reconstruction = tf.reduce_mean(tf.square(tf.stop_gradient(duplicated) - decoded), [1, 2, 3]) assert len(reconstruction.get_shape()) == 1 return flatten(layer_x), reconstruction reconstructed_embed_sg, adv_fake_layer = _architecture(tf.stop_gradient(reconstructed_training), reuse=None) reconstructed_embed, _ = _architecture(reconstructed_training, reuse=True) # Below line enforces the forward to be reconstructed_embed and backwards to NOT change the discriminator.... crazy_hack = reconstructed_embed-reconstructed_embed_sg+tf.stop_gradient(reconstructed_embed_sg) real_p_embed_sg, adv_true_layer = _architecture(tf.stop_gradient(real_points), reuse=True) real_p_embed, _ = _architecture(real_points, reuse=True) adv_fake = tf.reduce_mean(adv_fake_layer) adv_true = tf.reduce_mean(adv_true_layer) adv_c_loss = tf.log(adv_true) - tf.log(adv_fake) emb_c = tf.reduce_sum(tf.square(crazy_hack - tf.stop_gradient(real_p_embed)), 1) emb_c_loss = tf.reduce_mean(emb_c) return adv_c_loss, emb_c_loss
