def generator(hparams, z, train, reuse): with tf.variable_scope("generator") as scope: if reuse: tf.get_variable_scope().reuse_variables() s_h, s_w = hparams.output_height, hparams.output_width s_h2, s_h4, s_h8, s_h16 = int(s_h/2), int(s_h/4), int(s_h/8), int(s_h/16) s_w2, s_w4, s_w8, s_w16 = int(s_w/2), int(s_w/4), int(s_w/8), int(s_w/16) g_bn0 = ops.batch_norm(name='g_bn0') g_bn1 = ops.batch_norm(name='g_bn1') g_bn2 = ops.batch_norm(name='g_bn2') g_bn3 = ops.batch_norm(name='g_bn3') # project `z` and reshape h0 = tf.reshape(ops.linear(z, hparams.gf_dim*8*s_h16*s_w16, 'g_h0_lin'), [-1, s_h16, s_w16, hparams.gf_dim * 8]) h0 = tf.nn.relu(g_bn0(h0, train=train)) h1 = ops.deconv2d(h0, [hparams.batch_size, s_h8, s_w8, hparams.gf_dim*4], name='g_h1') h1 = tf.nn.relu(g_bn1(h1, train=train)) h2 = ops.deconv2d(h1, [hparams.batch_size, s_h4, s_w4, hparams.gf_dim*2], name='g_h2') h2 = tf.nn.relu(g_bn2(h2, train=train)) h3 = ops.deconv2d(h2, [hparams.batch_size, s_h2, s_w2, hparams.gf_dim*1], name='g_h3') h3 = tf.nn.relu(g_bn3(h3, train=train)) h4 = ops.deconv2d(h3, [hparams.batch_size, s_h, s_w, hparams.c_dim], name='g_h4') x_gen = tf.nn.tanh(h4) return x_gen
def generator(z, is_training): # Firstly let's reshape input vector into 3-d tensor. z_ = ops.linear(z, GENERATOR_DENSE_SIZE*4*4, 'g_h0_lin') h_in = tf.reshape(z_, [-1, 4, 4, GENERATOR_DENSE_SIZE]) g_batch_norm_in=ops.batch_norm(name='g_batch_norm_in') h_in_bn = g_batch_norm_in(h_in,is_training) h_in_z=ops.lrelu(x=h_in_bn,name='g_lr_1') h_1=ops.deconv2d(h_in_z,output_shape=[BATCH_SIZE,8,8,512],k_h=5,k_w=5,d_h=2, d_w=2,name="g_deconv_1") g_batch_norm_1=ops.batch_norm(name='g_batch_norm_1') h_1_bn = g_batch_norm_1(h_1,is_training) h_1_z=ops.lrelu(x=h_1_bn,name='g_lr_2') h_1_z_dr=tf.nn.dropout(h_1_z,0.3) h_2=ops.deconv2d(h_1_z_dr,output_shape=[BATCH_SIZE,16,16,256],k_h=5,k_w=5,d_h=2, d_w=2,name="g_deconv_2") g_batch_norm_2=ops.batch_norm(name='g_batch_norm_2') h_2_bn = g_batch_norm_2(h_2,is_training) h_2_z=ops.lrelu(x=h_2_bn,name='g_lr_3') h_2_z_dr=tf.nn.dropout(h_2_z,0.3) h_3=ops.deconv2d(h_2_z_dr,output_shape=[BATCH_SIZE,32,32,128],k_h=5,k_w=5,d_h=2, d_w=2,name="g_deconv_3") g_batch_norm_3=ops.batch_norm(name='g_batch_norm_3') h_3_bn = g_batch_norm_3(h_3,is_training) h_3_z=ops.lrelu(x=h_3_bn,name='g_lr_4') h_out = ops.deconv2d(h_3_z, [BATCH_SIZE, IMAGE_SIZE, IMAGE_SIZE, N_CHANNELS], name='g_out') return tf.nn.tanh(h_out)
def generator(self, z): # project `z` and reshape self.h0, self.h0_w, self.h0_b = ops.deconv2d( z, [self.batch_size, 32, 32, self.gf_dim], k_h=1, k_w=1, d_h=1, d_w=1, name='g_h0', with_w=True) h0 = ops.lrelu(self.h0) self.h1, self.h1_w, self.h1_b = ops.deconv2d( h0, [self.batch_size, 32, 32, self.gf_dim], name='g_h1', d_h=1, d_w=1, with_w=True) h1 = ops.lrelu(self.h1) h2, self.h2_w, self.h2_b = ops.deconv2d( h1, [self.batch_size, 32, 32, 3 * 16], d_h=1, d_w=1, name='g_h2', with_w=True) h2 = PS(h2, r=4, color=True) return tf.tanh(h2) # [-1 1]
def generator(self, t_z, t_text_embedding): s = self.options['image_size'] s2, s4, s8, s16 = int(s / 2), int(s / 4), int(s / 8), int(s / 16) reduced_text_embedding = ops.lrelu( ops.linear(t_text_embedding, self.options['t_dim'], 'g_embedding')) z_concat = tf.concat(1, [t_z, reduced_text_embedding]) z_ = ops.linear(z_concat, self.options['gf_dim'] * 8 * s16 * s16, 'g_h0_lin') h0 = tf.reshape(z_, [-1, s16, s16, self.options['gf_dim'] * 8]) h0 = tf.nn.relu(self.g_bn0(h0)) h1 = ops.deconv2d( h0, [self.options['batch_size'], s8, s8, self.options['gf_dim'] * 4], name='g_h1') h1 = tf.nn.relu(self.g_bn1(h1)) h2 = ops.deconv2d( h1, [self.options['batch_size'], s4, s4, self.options['gf_dim'] * 2], name='g_h2') h2 = tf.nn.relu(self.g_bn2(h2)) h3 = ops.deconv2d( h2, [self.options['batch_size'], s2, s2, self.options['gf_dim'] * 1], name='g_h3') h3 = tf.nn.relu(self.g_bn3(h3)) h4 = ops.deconv2d(h3, [self.options['batch_size'], s, s, 3], name='g_h4') return (tf.tanh(h4) / 2. + 0.5)
def generator_pix2pix(self, image, reuse=False): output_size = self.patch_size s = math.ceil(output_size/16.0)*16 s2, s4, s8, s16 = int(s/2), int(s/4), int(s/8), int(s/16) # gf_dim = 16 # Dimension of gen filters in first conv layer. with tf.variable_scope("generator") as scope: # image is 128 x 128 x (input_c_dim + output_c_dim) if reuse: tf.get_variable_scope().reuse_variables() else: assert tf.get_variable_scope().reuse == False # do we need here??? #image = image / 255.0 # liuas 2018.5.9 # trick: using lrelu instead of relu ngf = 16 # number of generator filters in first conv layer # encoder_1: [batch, 16, 16, 3] => [batch, 8, 8, ngf] conv1 = conv2d(image, ngf, k_h=4, k_w=4, name='adv_g_enc1') conv2 = layer_norm(conv2d(lrelu(conv1, 0.2), ngf*2, k_h=4, k_w=4, name='adv_g_enc2'), name='adv_g_enc2ln') conv3 = layer_norm(conv2d(lrelu(conv2, 0.2), ngf*4, k_h=4, k_w=4, name='adv_g_enc3'), name='adv_g_enc3ln') conv4 = layer_norm(conv2d(lrelu(conv3, 0.2), ngf*8, k_h=4, k_w=4, name='adv_g_enc4'), name='adv_g_enc4ln') deconv1, _, _ = deconv2d(tf.nn.relu(conv4), [self.batch_size, s8, s8, ngf*4], k_h=4, k_w=4, name='adv_g_dec1', with_w=True) deconv1 = layer_norm(deconv1, name="adv_g_dec1ln") input = tf.concat([deconv1, conv3], axis=3) deconv2, _, _ = deconv2d(tf.nn.relu(input), [self.batch_size, s4, s4, ngf*2], k_h=4, k_w=4, name='adv_g_dec2', with_w=True) deconv2 = layer_norm(deconv2, name="adv_g_dec2ln") input = tf.concat([deconv2, conv2], axis=3) deconv3, _, _ = deconv2d(tf.nn.relu(input), [self.batch_size, s2, s2, ngf], k_h=4, k_w=4, name='adv_g_dec3', with_w=True) deconv3 = layer_norm(deconv3, name="adv_g_dec3ln") input = tf.concat([deconv3, conv1], axis=3) deconv4, _, _ = deconv2d(tf.nn.relu(input), [self.batch_size, output_size, output_size, 3], k_h=4, k_w=4, name='adv_g_dec4', with_w=True) return tf.tanh(deconv4)
def generator(input_z, t_txt=None, is_train=True, reuse=False, batch_size=batch_size): g_bn0 = ops.batch_norm(name='g_bn0') g_bn1 = ops.batch_norm(name='g_bn1') g_bn2 = ops.batch_norm(name='g_bn2') g_bn3 = ops.batch_norm(name='g_bn3') s = image_size # output image size [64] s2, s4, s8, s16 = int(s / 2), int(s / 4), int(s / 8), int(s / 16) gf_dim = 128 with tf.variable_scope("generator", reuse=reuse): tl.layers.set_name_reuse(reuse) z_concat = tf.concat([input_z, t_txt], 1) z_ = ops.linear(z_concat, gf_dim * 8 * s16 * s16, 'g_h0_lin') h0 = tf.reshape(z_, [-1, s16, s16, gf_dim * 8]) h0 = tf.nn.relu(g_bn0(h0)) h1 = ops.deconv2d(h0, [batch_size, s8, s8, gf_dim * 4], name='g_h1') h1 = tf.nn.relu(g_bn1(h1)) h2 = ops.deconv2d(h1, [batch_size, s4, s4, gf_dim * 2], name='g_h2') h2 = tf.nn.relu(g_bn2(h2)) h3 = ops.deconv2d(h2, [batch_size, s2, s2, gf_dim * 1], name='g_h3') h3 = tf.nn.relu(g_bn3(h3)) h4 = ops.deconv2d(h3, [batch_size, s, s, 3], name='g_h4') return h4, tf.tanh(h4)
def __init__(self, z_size, channel, resnet=False, output_size=32): super(Generator, self).__init__() s = 4 self.output_size = output_size if self.output_size == 32: s = 4 if self.output_size == 48: s = 6 self.s = s self.z_size = z_size self.resnet = resnet self.fully_connect = nn.Linear(z_size, s * s * 256) self.relu = nn.ReLU() self.tanh = nn.Tanh() self.deconv1 = deconv2d(256, 256, padding=0) self.bn1 = nn.BatchNorm2d(256) self.deconv2 = deconv2d(256, 128, padding=0) self.bn2 = nn.BatchNorm2d(128) self.deconv3 = deconv2d(128, 64, padding=0) self.bn3 = nn.BatchNorm2d(64) self.conv4 = conv2d(64, channel, padding=1, kernel_size=3, stride=1) self.conv_res4 = conv2d(256, channel, padding=1, kernel_size=3, stride=1) self.re1 = Residual_G(256, 256, up_sampling=True) self.re2 = Residual_G(256, 256, up_sampling=True) self.re3 = Residual_G(256, 256, up_sampling=True) self.bn = nn.BatchNorm2d(256)
def dcgan_decoder(opts, noise, is_training=False, reuse=False): output_shape = datashapes[opts['dataset']] num_units = opts['g_num_filters'] batch_size = tf.shape(noise)[0] num_layers = opts['g_num_layers'] height = output_shape[0] // 2 ** (num_layers - 1) width = output_shape[1] // 2 ** (num_layers - 1) h0 = ops.linear( opts, noise, num_units * height * width, scope='h0_lin') h0 = tf.reshape(h0, [-1, height, width, num_units]) h0 = tf.nn.relu(h0) layer_x = h0 for i in range(num_layers - 1): scale = 2 ** (i + 1) _out_shape = [batch_size, height * scale, width * scale, num_units // scale] layer_x = ops.deconv2d(opts, layer_x, _out_shape, scope='h%d_deconv' % i) if opts['batch_norm']: layer_x = ops.batch_norm(opts, layer_x, is_training, reuse, scope='h%d_bn' % i) layer_x = tf.nn.relu(layer_x) _out_shape = [batch_size] + list(output_shape) last_h = ops.deconv2d( opts, layer_x, _out_shape, d_h=1, d_w=1, scope='hfinal_deconv') return tf.nn.sigmoid(last_h), last_h
def generator(self, z): with tf.variable_scope('generator') as scope: # 从输出大小推各步尺寸 o_h0, o_w0 = self.cfg.output_height, self.cfg.output_width o_h1, o_w1 = get_conved_size(o_h0, 2), get_conved_size(o_w0, 2) o_h2, o_w2 = get_conved_size(o_h1, 2), get_conved_size(o_w1, 2) o_h3, o_w3 = get_conved_size(o_h2, 2), get_conved_size(o_w2, 2) o_h4, o_w4 = get_conved_size(o_h3, 2), get_conved_size(o_w3, 2) # 把relu过程分开是因为deconv2d过程需要权重共享 z_ = linear(z, self.cfg.gf_dim * 8 * o_h4 * o_w4, scope='g_h0_lin') h0 = tf.reshape(z_, [-1, o_h4, o_w4, self.cfg.gf_dim * 8]) h0 = tf.nn.relu(self.bn_g0(h0, train=True)) h1 = deconv2d( h0, [self.cfg.batch_size, o_h3, o_w3, self.cfg.gf_dim * 4], scope='g_h1') h1 = tf.nn.relu(self.bn_g1(h1, train=True)) h2 = deconv2d( h1, [self.cfg.batch_size, o_h2, o_w2, self.cfg.gf_dim * 2], scope='g_h2') h2 = tf.nn.relu(self.bn_g2(h2, train=True)) h3 = deconv2d( h2, [self.cfg.batch_size, o_h1, o_w1, self.cfg.gf_dim * 1], scope='g_h3') h3 = tf.nn.relu(self.bn_g3(h3, train=True)) h4 = deconv2d(h3, [self.cfg.batch_size, o_h0, o_w0, self.c_dim], scope='g_h4') return tf.nn.tanh(h4)
def patch_generator(self, index, z, y=None): """ patch generator :param z: :param y: :param scope: :return: """ with tf.variable_scope("generator%d" % index) as scope: s_h, s_w = self.output_height/int(np.sqrt(self.num_patches)), \ int(self.output_width/np.sqrt(self.num_patches)) # 16, 16 s_h2, s_w2 = int(s_h / 2), int(s_w / 2) # 8, 8 s_h4, s_w4 = int(s_h2 / 2), int(s_w2 / 2) # 4, 4 yb = tf.reshape(y, [self.batch_size, 1, 1, self.y_dim + 2]) z = tf.concat([z, y], 1) h0 = tf.nn.relu(self.g_bns_all[index][0](linear( z, self.gfc_dim, "g_h0_lin"))) h0 = tf.concat([h0, y], 1) h1 = tf.nn.relu(self.g_bns_all[index][1](linear( h0, self.gf_dim * 4 * s_h4 * s_w4, "g_h1_lin"))) h1 = tf.reshape(h1, [self.batch_size, s_h4, s_w4, self.gf_dim * 4]) h1 = conv_cond_concat(h1, yb) h2 = deconv2d(h1, [self.batch_size, s_h2, s_w2, self.gf_dim * 2], name="g_h2") h2 = self.g_bns_all[index][2](h2) h2 = tf.nn.relu(h2) h2 = conv_cond_concat(h2, yb) return tf.nn.sigmoid( deconv2d(h2, [self.batch_size, s_h, s_w, self.c_dim], name="g_h3"))
def generator(self, z_set, y_set): """ Fully generator :param z_set: :param y_set: :return: """ z = tf.concat([v for v in z_set], axis=1) y = y_set[0] with tf.variable_scope("generator_f") as scope: s_h, s_w = self.output_height, self.output_width # 32, 32 s_h2, s_w2 = int(s_h / 2), int(s_w / 2) # 16, 16 s_h4, s_w4 = int(s_h2 / 2), int(s_w2 / 2) # 8, 8 yb = tf.reshape(y, [self.batch_size, 1, 1, self.y_dim + 2]) z = tf.concat([z, y], 1) h0 = tf.nn.relu(self.g_bn_f0(linear(z, self.gfc_dim, "g_h0_lin"))) h0 = tf.concat([h0, y], 1) h1 = tf.nn.relu( self.g_bn_f1( linear(h0, self.gf_dim * 4 * s_h4 * s_w4, "g_h1_lin"))) h1 = tf.reshape(h1, [self.batch_size, s_h4, s_w4, self.gf_dim * 4]) h1 = conv_cond_concat(h1, yb) h2 = deconv2d(h1, [self.batch_size, s_h2, s_w2, self.gf_dim * 2], name="g_h2") h2 = self.g_bn_f2(h2) h2 = tf.nn.relu(h2) h2 = conv_cond_concat(h2, yb) return tf.nn.sigmoid( deconv2d(h2, [self.batch_size, s_h, s_w, self.c_dim], name="g_h3"))
def generator(self, z, train=True): with tf.variable_scope("generator") as scope: # train is True when training, False when sampling batch_size = self.batch_size if not train: # When sampling scope.reuse_variables() batch_size = self.sample_num # Convolution parameter sizes s_h, s_w = self.image_shape s_h2, s_w2 = self.conv_out_size_same(s_h, 2), self.conv_out_size_same(s_w, 2) s_h4, s_w4 = self.conv_out_size_same(s_h2, 2), self.conv_out_size_same(s_w2, 2) s_h8, s_w8 = self.conv_out_size_same(s_h4, 2), self.conv_out_size_same(s_w4, 2) s_h16, s_w16 = self.conv_out_size_same(s_h8, 2), self.conv_out_size_same(s_w8, 2) # Project z, reshape and go through 4 convolution blocks (deconv, batch norm, relu) self.z_ = linear(z, self.gf_dim * 8 * s_h16 * s_w16, 'g_h0_lin') self.h0 = tf.reshape(self.z_, [-1, s_h16, s_w16, self.gf_dim * 8]) h0 = tf.nn.relu(self.g_bn0(self.h0, train=train)) h1 = tf.nn.relu(self.g_bn1(deconv2d(h0, [batch_size, s_h8, s_w8, self.gf_dim * 4], name='g_h1'), train=train)) h2 = tf.nn.relu(self.g_bn2(deconv2d(h1, [batch_size, s_h4, s_w4, self.gf_dim * 2], name='g_h2'), train=train)) h3 = tf.nn.relu(self.g_bn3(deconv2d(h2, [batch_size, s_h2, s_w2, self.gf_dim * 1], name='g_h3'), train=train)) h4 = tf.nn.tanh(deconv2d(h3, [batch_size, s_h, s_w, self.c_dim], name='g_h4')) return h4
def generator(images, options, reuse=False, name='gen'): # reuse or not with tf.variable_scope(name): if reuse: tf.get_variable_scope().reuse_variables() else: assert tf.get_variable_scope().reuse is False # down sampling x = relu(instance_norm(conv2d(images, options.nf, ks=7, s=1, name='gen_ds_conv1'), 'in1_1')) x = relu(instance_norm(conv2d(x, 2*options.nf, ks=4, s=2, name='gen_ds_conv2'), 'in1_2')) x = relu(instance_norm(conv2d(x, 4*options.nf, ks=4, s=2, name='gen_ds_conv3'), 'in1_3')) # bottleneck x = relu(instance_norm(conv2d(x, 4*options.nf, ks=3, s=1, name='gen_bn_conv1'), 'in2_1')) x = relu(instance_norm(conv2d(x, 4*options.nf, ks=3, s=1, name='gen_bn_conv2'), 'in2_2')) x = relu(instance_norm(conv2d(x, 4*options.nf, ks=3, s=1, name='gen_bn_conv3'), 'in2_3')) x = relu(instance_norm(conv2d(x, 4*options.nf, ks=3, s=1, name='gen_bn_conv4'), 'in2_4')) x = relu(instance_norm(conv2d(x, 4*options.nf, ks=3, s=1, name='gen_bn_conv5'), 'in2_5')) x = relu(instance_norm(conv2d(x, 4*options.nf, ks=3, s=1, name='gen_bn_conv6'), 'in2_6')) # up sampling x = relu(instance_norm(deconv2d(x, 2*options.nf, ks=4, s=2, name='gen_us_deconv1'), 'in3_1')) x = relu(instance_norm(deconv2d(x, options.nf, ks=4, s=2, name='gen_us_deconv2'), 'in3_2')) x = tanh(deconv2d(x, 3, ks=7, s=1, name='gen_us_dwconv3')) return x
def generator(hparams, z, scope_name, train, reuse): with tf.variable_scope(scope_name) as scope: if reuse: scope.reuse_variables() output_size = 64 s = output_size s2, s4, s8, s16 = int(s/2), int(s/4), int(s/8), int(s/16) g_bn0 = ops.batch_norm(name='g_bn0') g_bn1 = ops.batch_norm(name='g_bn1') g_bn2 = ops.batch_norm(name='g_bn2') g_bn3 = ops.batch_norm(name='g_bn3') # project `z` and reshape h0 = tf.reshape(ops.linear(z, hparams.gf_dim*8*s16*s16, 'g_h0_lin'), [-1, s16, s16, hparams.gf_dim * 8]) h0 = tf.nn.relu(g_bn0(h0, train=train)) h1 = ops.deconv2d(h0, [hparams.batch_size, s8, s8, hparams.gf_dim*4], name='g_h1') h1 = tf.nn.relu(g_bn1(h1, train=train)) h2 = ops.deconv2d(h1, [hparams.batch_size, s4, s4, hparams.gf_dim*2], name='g_h2') h2 = tf.nn.relu(g_bn2(h2, train=train)) h3 = ops.deconv2d(h2, [hparams.batch_size, s2, s2, hparams.gf_dim*1], name='g_h3') h3 = tf.nn.relu(g_bn3(h3, train=train)) h4 = ops.deconv2d(h3, [hparams.batch_size, s, s, hparams.c_dim], name='g_h4') x_gen = tf.nn.tanh(h4) return x_gen
def G(z, scope='Generator'): """[using prior distribution z to generator fake image] Arguments: z {np.array} -- [numpy array for describe prior distribution] Keyword Arguments: scope {str} -- [scope of generator] (default: {'Generator'}) Returns: [Tensor] -- [fake image] """ with tf.variable_scope(scope) as scope: log.warn(scope.name) z = tf.reshape(z, [self.batch_size, 1, 1, -1]) g_1 = deconv2d(z, deconv_info[0], is_train, name='g_1_deconv') log.info('{} {}'.format(scope.name, g_1)) g_2 = deconv2d(g_1, deconv_info[1], is_train, name='g_2_deconv') log.info('{} {}'.format(scope.name, g_2)) g_3 = deconv2d(g_2, deconv_info[2], is_train, name='g_3_deconv') log.info('{} {}'.format(scope.name, g_3)) g_4 = deconv2d(g_3, deconv_info[3], is_train, name='g_4_deconv', activation_fn=tf.tanh) log.info('{} {}'.format(scope.name, g_4)) output = g_4 assert output.get_shape().as_list() == self.image.get_shape().as_list(), output.get_shape().as_list() return output
def mdl_resize_net_64(net, mdl_feats): # Assume input feature map dimensions of 224x224 net.mdl_resize_net = {} with tf.variable_scope('MDLResize_Net'): # Output (bs, 112, 112) # conv1 = conv2d('conv1', mdl_feats, 3, 128, stride=2, padding="SAME", norm=net.norm, mode=net.mode) # net.mdl_resize_net['conv1'] = conv1 # Output (bs, 56, 56) pool1 = tf.layers.max_pooling2d(mdl_feats, 4, 4, padding='same', name='pool1') net.mdl_resize_net['pool1'] = pool1 # Output (bs, 60, 60) deconv1 = deconv2d('deconv1', pool1, 5, 64, stride=1, padding="VALID", norm=net.norm, mode=net.mode) net.mdl_resize_net['deconv1'] = deconv1 # Output (bs, 64, 64) deconv2 = deconv2d('deconv2', deconv1, 5, 32, stride=1, padding="VALID", norm=net.norm, mode=net.mode) net.mdl_resize_net['deconv2'] = deconv2 return deconv2
def _build_model(self): with tf.variable_scope('generator', reuse=self.reuse): s = self.hparas['IMAGE_SIZE'][0] s2, s4, s8, s16 = int(s / 2), int(s / 4), int(s / 8), int(s / 16) gf_dim = self.gf_dim reduced_text_embedding = ops.lrelu(ops.linear( self.text, self.hparas['TEXT_DIM'], 'g_embedding')) z_concat = tf.concat([self.z, reduced_text_embedding], 1) z_ = ops.linear(z_concat, gf_dim * 8 * s16 * s16, 'g_h0_lin') h0 = tf.reshape(z_, [-1, s16, s16, gf_dim * 8]) h0 = tf.nn.relu(ops.batch_norm(h0)) h1 = ops.deconv2d(h0, [self.hparas['BATCH_SIZE'], s8, s8, gf_dim * 4], name='g_h1') h1 = tf.nn.relu(ops.batch_norm(h1)) h2 = ops.deconv2d(h1, [self.hparas['BATCH_SIZE'], s4, s4, gf_dim * 2], name='g_h2') h2 = tf.nn.relu(ops.batch_norm(h2)) h3 = ops.deconv2d(h2, [self.hparas['BATCH_SIZE'], s2, s2, gf_dim * 1], name='g_h3') h3 = tf.nn.relu(ops.batch_norm(h3)) h4 = ops.deconv2d(h3, [self.hparas['BATCH_SIZE'], s, s, 3], name='g_h4') self.generator_net = tf.tanh(h4) / 2.0 + 0.5 self.outputs = tf.tanh(h4) / 2.0 + 0.5
def sampler(self, z): # 与Generator不同在于: 1)设置了变量重用 2)在batch_norm时设置train=False with tf.variable_scope('generator') as scope: scope.reuse_variables() o_h0, o_w0 = self.cfg.output_height, self.cfg.output_width o_h1, o_w1 = get_conved_size(o_h0, 2), get_conved_size(o_w0, 2) o_h2, o_w2 = get_conved_size(o_h1, 2), get_conved_size(o_w1, 2) o_h3, o_w3 = get_conved_size(o_h2, 2), get_conved_size(o_w2, 2) o_h4, o_w4 = get_conved_size(o_h3, 2), get_conved_size(o_w3, 2) z_ = linear(z, self.cfg.gf_dim * 8 * o_h4 * o_w4, scope='g_h0_lin') h0 = tf.reshape(z_, [-1, o_h4, o_w4, self.cfg.gf_dim * 8]) h0 = tf.nn.relu(self.bn_g0(h0, train=False)) h1 = deconv2d( h0, [self.cfg.batch_size, o_h3, o_w3, self.cfg.gf_dim * 4], scope='g_h1') h1 = tf.nn.relu(self.bn_g1(h1, train=False)) h2 = deconv2d( h1, [self.cfg.batch_size, o_h2, o_w2, self.cfg.gf_dim * 2], scope='g_h2') h2 = tf.nn.relu(self.bn_g2(h2, train=False)) h3 = deconv2d( h2, [self.cfg.batch_size, o_h1, o_w1, self.cfg.gf_dim * 1], scope='g_h3') h3 = tf.nn.relu(self.bn_g3(h3, train=False)) h4 = deconv2d(h3, [self.cfg.batch_size, o_h0, o_w0, self.c_dim], scope='g_h4') return tf.nn.tanh(h4)
def G(z, scope='Generator'): with tf.variable_scope(scope) as scope: log.warn(scope.name) z = tf.reshape(z, [self.batch_size, 1, 1, -1]) g_1 = deconv2d(z, deconv_info[0], is_train, name='g_1_deconv') log.info('{} {}'.format(scope.name, g_1)) g_2 = deconv2d(g_1, deconv_info[1], is_train, name='g_2_deconv') log.info('{} {}'.format(scope.name, g_2)) g_3 = deconv2d(g_2, deconv_info[2], is_train, name='g_3_deconv') log.info('{} {}'.format(scope.name, g_3)) g_4 = deconv2d(g_3, deconv_info[3], is_train, name='g_4_deconv', activation_fn=tf.tanh) log.info('{} {}'.format(scope.name, g_4)) output = g_4 #print(output.get_shape().as_list(), self.image.get_shape().as_list(), output.get_shape().as_list()) assert output.get_shape().as_list() == self.image.get_shape( ).as_list(), output.get_shape().as_list() return output
def discriminator_ae(x, reuse=False): #x_small = resize(x, (56, 56)) with tf.variable_scope('discriminator', reuse=reuse): net = conv2d(x, 3, 32, d=2, scope='conv_1', dropout=False) net = conv2d(net, 32, 64, d=2, scope='conv_2', dropout=False) net = tf.reshape(net, [-1, 56 * 56 * 64]) code = lrelu(fc(net, 1000, scope='fc_3')) net = lrelu(fc(code, 56 * 56 * 64, scope='fc_4')) net = tf.reshape(net, [-1, 56, 56, 64]) net = resize(net, (112, 112)) net = deconv2d(net, 64, 32, 112, scope='conv_5', dropout=False) net = resize(net, (224, 224)) #net = deconv2d(net, 32, 16, 224, scope='conv_6') dimension = 3 if dimension == 2: sc_1, x = tf.split(x, [1, 2], axis=3) net = deconv2d(net, 32, 2, 224, scope='deconv_7', bn=False) #loss = tf.sqrt(2 * tf.nn.l2_loss(x - net)) / (224*224) loss = tf.norm(x - net, ord=1) / (224 * 224) net = tf.concat([sc_1, net], axis=3) else: net = deconv2d(net, 32, 3, 224, scope='deconv_10', bn=False) loss = tf.sqrt(2 * tf.nn.l2_loss(x - net)) / (224 * 224) return net, loss
def __call__(self, input): if self._deconv_type == 'bilinear': from ops import bilinear_deconv2d as deconv2d elif self._deconv_type == 'nn': from ops import nn_deconv2d as deconv2d elif self._deconv_type == 'transpose': from ops import deconv2d else: raise NotImplementedError with tf.variable_scope(self.name, reuse=self._reuse): if not self._reuse: log.warn(self.name) _ = fc(input, self.start_dim_x * self.start_dim_y * self.start_dim_ch, self._is_train, info=not self._reuse, norm='none', name='fc') _ = tf.reshape(_, [ _.shape.as_list()[0], self.start_dim_y, self.start_dim_x, self.start_dim_ch ]) if not self._reuse: log.info('reshape {} '.format(_.shape.as_list())) num_deconv_layer = int( np.ceil( np.log2( max(float(self._h / self.start_dim_y), float(self._w / self.start_dim_x))))) for i in range(num_deconv_layer): _ = deconv2d(_, max(self._c, int(_.get_shape().as_list()[-1] / 2)), self._is_train, info=not self._reuse, norm=self._norm_type, name='deconv{}'.format(i + 1)) if num_deconv_layer - i <= self._num_res_block: _ = conv2d_res( _, self._is_train, info=not self._reuse, name='res_block{}'.format(self._num_res_block - num_deconv_layer + i + 1)) _ = deconv2d(_, self._c, self._is_train, k=1, s=1, info=not self._reuse, activation_fn=tf.tanh, norm='none', name='deconv{}'.format(i + 2)) _ = tf.image.resize_bilinear(_, [self._h, self._w]) self._reuse = True self.var_list = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, self.name) return _
def GeneratorCNN(z, config, reuse=None): ''' maps z to a 64x64 images with values in [-1,1] uses batch normalization internally ''' #trying to get around batch_size like this: batch_size = tf.shape(z)[0] #batch_size=tf.placeholder_with_default(64,[],'bs') with tf.variable_scope("generator", reuse=reuse) as vs: g_bn0 = batch_norm(name='g_bn0') g_bn1 = batch_norm(name='g_bn1') g_bn2 = batch_norm(name='g_bn2') g_bn3 = batch_norm(name='g_bn3') s_h, s_w = config.gf_dim, config.gf_dim #64,64 s_h2, s_w2 = conv_out_size_same(s_h, 2), conv_out_size_same(s_w, 2) s_h4, s_w4 = conv_out_size_same(s_h2, 2), conv_out_size_same(s_w2, 2) s_h8, s_w8 = conv_out_size_same(s_h4, 2), conv_out_size_same(s_w4, 2) s_h16, s_w16 = conv_out_size_same(s_h8, 2), conv_out_size_same(s_w8, 2) # project `z` and reshape z_, self_h0_w, self_h0_b = linear(z, config.gf_dim * 8 * s_h16 * s_w16, 'g_h0_lin', with_w=True) self_h0 = tf.reshape(z_, [-1, s_h16, s_w16, config.gf_dim * 8]) h0 = tf.nn.relu(g_bn0(self_h0)) h1, h1_w, h1_b = deconv2d(h0, [batch_size, s_h8, s_w8, config.gf_dim * 4], name='g_h1', with_w=True) h1 = tf.nn.relu(g_bn1(h1)) h2, h2_w, h2_b = deconv2d(h1, [batch_size, s_h4, s_w4, config.gf_dim * 2], name='g_h2', with_w=True) h2 = tf.nn.relu(g_bn2(h2)) h3, h3_w, h3_b = deconv2d(h2, [batch_size, s_h2, s_w2, config.gf_dim * 1], name='g_h3', with_w=True) h3 = tf.nn.relu(g_bn3(h3)) h4, h4_w, h4_b = deconv2d(h3, [batch_size, s_h, s_w, config.c_dim], name='g_h4', with_w=True) out = tf.nn.tanh(h4) variables = tf.contrib.framework.get_variables(vs) return out, variables
def generator(self, z, reuse=None): with tf.variable_scope('generator', reuse=reuse): # project `z` and reshape h0 = tf.reshape(linear(z, self.gf_dim * 8 * 4 * 4, 'g_h0_lin'), [-1, 4, 4, self.gf_dim * 8]) h0 = tf.nn.relu(self.g_bn0(h0)) h1 = deconv2d(h0, [self.batch_size, 8, 8, self.gf_dim * 4], name='g_h1') h1 = tf.nn.relu(self.g_bn1(h1)) h2 = deconv2d(h1, [self.batch_size, 16, 16, self.gf_dim * 2], name='g_h2') h2 = tf.nn.relu(self.g_bn2(h2)) h3 = deconv2d(h2, [self.batch_size, 32, 32, 3], name='g_h3') return tf.nn.tanh(h3)
def _create_generator(self, z, train=True, reuse=False, name="generator"): out_size = [(conv_out_size_same(self.img_size[0], 2), conv_out_size_same(self.img_size[1], 2), self.num_gen_feature_maps)] for i in range(self.g_num_conv_layers - 1): out_size = [(conv_out_size_same( out_size[0][0], 2), conv_out_size_same( out_size[0][1], 2), out_size[0][2] * 2)] + out_size print(out_size) with tf.variable_scope(name) as scope: if reuse: scope.reuse_variables() z_split = tf.split(z, self.num_gens, axis=0) h0 = [] for i, var in enumerate(z_split): h0.append( tf.nn.relu(linear(var, out_size[0][0] * out_size[0][1] * out_size[0][2], scope='g_h0_linear{}'.format(i), stddev=0.02), name="g_h0_relu{}".format(i))) g_out = [] for k, var in enumerate(h0): var = tf.reshape(var, [ self.g_batch_size, out_size[0][0], out_size[0][1], out_size[0][2] ]) for i in range(1, self.g_num_conv_layers): var = tf.nn.relu(deconv2d(var, [ self.g_batch_size, out_size[i][0], out_size[i][1], out_size[i][2] ], stddev=0.02, name="g{}_h{}_deconv".format( k, i)), name="g{}_h{}_relu".format(k, i)) g_out.append( tf.nn.tanh(deconv2d(var, [ self.g_batch_size, self.img_size[0], self.img_size[1], self.img_size[2] ], stddev=0.02, name="g{}_out_deconv".format(k, i)), name="g{}_out_tanh".format(k, i))) g_out = tf.concat(g_out, axis=0, name="g_out") return g_out
def im_unet(net, ims): net.im_net = {} bs, h, w, ch = ims.get_shape().as_list() with tf.variable_scope('ImNet_UNet'): conv1 = conv2d('conv1', ims, 5, 32, act=None, norm=net.norm, mode=net.mode) net.im_net['conv1'] = conv1 conv2 = conv2d('conv2', conv1, 3, 64, norm=net.norm, mode=net.mode) net.im_net['conv2'] = conv2 conv3 = conv2d('conv3', conv2, 3, 128, norm=net.norm, mode=net.mode) net.im_net['conv3'] = conv3 conv4 = conv2d('conv4', conv3, 3, 256, norm=net.norm, mode=net.mode) net.im_net['conv4'] = conv4 _, fh, fw, ch = conv4.get_shape().as_list() deconv1 = deconv2d('deconv1', conv4, 3, 128, norm=net.norm, mode=net.mode) net.im_net['deconv1'] = deconv1 deconv1 = tf.concat([deconv1, conv3], axis=3) deconv2 = deconv2d('deconv2', deconv1, 3, 64, norm=net.norm, mode=net.mode) net.im_net['deconv2'] = deconv2 deconv2 = tf.concat([deconv2, conv2], axis=3) deconv3 = deconv2d('deconv3', deconv2, 3, 32, norm=net.norm, mode=net.mode) net.im_net['deconv3'] = deconv3 deconv3 = tf.concat([deconv3, conv1], axis=3) im_feats = deconv2d('deconv4', deconv3, 5, 32, stride=1, norm=None, mode=net.mode) net.im_net['out'] = im_feats return im_feats
def deconv_gen(z, batch_size): """ Transpose-convolutional Generator. """ z_expand1 = dense(z, 7 * 7 * 64, "expand1") # TODO : add a relu here ? z_matrix = tf.nn.relu(tf.reshape(z_expand1, [batch_size, 7, 7, 64])) deconv1 = tf.nn.relu( deconv2d(z_matrix, 5, [batch_size, 14, 14, 32], "deconv1")) deconv2 = deconv2d(deconv1, 5, [batch_size, 28, 28, 1], "deconv2") gen_image = tf.nn.sigmoid(deconv2) return gen_image
def dcgan_decoder(opts, inputs, archi, num_layers, num_units, output_shape, batch_norm, reuse, is_training): batch_size = tf.shape(inputs)[0] if archi == 'dcgan': height = output_shape[0] / 2**num_layers width = output_shape[1] / 2**num_layers elif archi == 'dcgan_mod': height = output_shape[0] / 2**(num_layers - 1) width = output_shape[1] / 2**(num_layers - 1) h0 = ops.linear(opts, inputs, num_units * ceil(height) * ceil(width), scope='hid0/lin') h0 = tf.reshape(h0, [-1, ceil(height), ceil(width), num_units]) h0 = tf.nn.relu(h0) layer_x = h0 for i in range(num_layers - 1): scale = 2**(i + 1) _out_shape = [ batch_size, ceil(height * scale), ceil(width * scale), int(num_units / scale) ] layer_x = ops.deconv2d(opts, layer_x, _out_shape, scope='hid%d/deconv' % i) if batch_norm: layer_x = ops.batch_norm(opts, layer_x, is_training, reuse, scope='hid%d/bn' % i) layer_x = tf.nn.relu(layer_x) _out_shape = [batch_size] + list(output_shape) if archi == 'dcgan': last_h = ops.deconv2d(opts, layer_x, _out_shape, scope='hid_final/deconv') elif archi == 'dcgan_mod': last_h = ops.deconv2d(opts, layer_x, _out_shape, d_h=1, d_w=1, scope='hid_final/deconv') if opts['input_normalize_sym']: return tf.nn.tanh(last_h), last_h else: return tf.nn.sigmoid(last_h), last_h
def dcgan_decoder(opts, noise, is_training=False, reuse=False): output_shape = datashapes[opts['dataset']] num_units = opts['k_g_num_filters'] batch_size = tf.shape(noise)[0] num_layers = opts['k_g_num_layers'] if opts['k_g_arch'] == 'dcgan': height = output_shape[0] / 2**num_layers width = output_shape[1] / 2**num_layers elif opts['k_g_arch'] == 'dcgan_mod': height = output_shape[0] / 2**(num_layers - 1) width = output_shape[1] / 2**(num_layers - 1) h0 = ops.linear(opts, noise, num_units * ceil(height) * ceil(width), scope='h0_lin') h0 = tf.reshape(h0, [-1, ceil(height), ceil(width), num_units]) h0 = tf.nn.relu(h0) layer_x = h0 for i in range(num_layers - 1): scale = 2**(i + 1) _out_shape = [ batch_size, ceil(height * scale), ceil(width * scale), int(num_units / scale) ] layer_x = ops.deconv2d(opts, layer_x, _out_shape, scope='h%d_deconv' % i) if opts['batch_norm']: layer_x = ops.batch_norm(opts, layer_x, is_training, reuse, scope='h%d_bn' % i) layer_x = tf.nn.relu(layer_x) _out_shape = [batch_size] + list(output_shape) if opts['k_g_arch'] == 'dcgan': last_h = ops.deconv2d(opts, layer_x, _out_shape, scope='hfinal_deconv') elif opts['k_g_arch'] == 'dcgan_mod': last_h = ops.deconv2d(opts, layer_x, _out_shape, d_h=1, d_w=1, scope='hfinal_deconv') if opts['input_normalize_sym']: return tf.nn.tanh(last_h), last_h else: return tf.nn.sigmoid(last_h), last_h
def get_generator_net(self, name): batch_size = self.get_batch_size() with tf.variable_scope('generator') as scope: z = tf.concat([self.noise, self.labels], 1) net = ops.linear( z, output_size=1024, scope='gen_fully1', weights_initializer=self.get_weights_initializer()) net = ops.batch_norm(net, self.is_training, scope='gen_bn1') net = ops.lrelu(net) net = tf.concat([net, self.labels], 1) # Wonder what this will be doing if the size is not divisible by 4 h, w = self.data.shape[0] // 4, self.data.shape[1] // 4 net = ops.linear( net, output_size=h * w * 2 * batch_size, scope='gen_fully2', weights_initializer=self.get_weights_initializer()) net = ops.batch_norm(net, self.is_training, scope='gen_bn2') net = ops.lrelu(net) net = tf.reshape(net, [batch_size, h, w, 2 * batch_size]) yb = tf.reshape(self.labels, shape=[batch_size, 1, 1, -1]) net = ops.conv_cond_concat(net, yb) h, w = self.data.shape[0] // 2, self.data.shape[1] // 2 net = ops.deconv2d( net, [batch_size, h, w, 2 * batch_size], 4, 4, 2, 2, scope='gen_deconv1', weights_initializer=self.get_weights_initializer()) net = ops.batch_norm(net, self.is_training, scope='gen_bn3') net = ops.lrelu(net) net = ops.conv_cond_concat(net, yb) out = ops.deconv2d(net, self.images.shape, 4, 4, 2, 2, scope='gen_deconv2', weights_initializer=xavier_initializer()) return tf.nn.sigmoid(out, name=name), out
def __call__(self, input, reuse=False): with tf.variable_scope(self.name): if reuse: tf.get_variable_scope().reuse_variables() else: assert tf.get_variable_scope().reuse is False act = tf.nn.relu _, h, w, c = input.shape.as_list() # Justin Johnson's model from https://github.com/jcjohnson/fast-neural-style/ # The network with 9 blocks consists of: c7s1-32, d64, d128, R128, R128, R128, # R128, R128, R128, R128, R128, R128, u64, u32, c7s1-3 # input shape == (32 x 32 x 128) c1 = act( instance_norm(conv2d(input, c, 7, 1, name='g_e1_c'), 'g_e1_bn')) # c1 shape == (32 x 32 x 128) c2 = act( instance_norm(conv2d(c1, c * 2, 3, 2, name='g_e2_c'), 'g_e2_bn')) # c2 shape == (16 x 16 x 256) c3 = act( instance_norm(conv2d(c2, c * 4, 3, 2, name='g_e3_c'), 'g_e3_bn')) # c3 shape == (8 x 8 x 512) # define G network with 9 resnet blocks r1 = residule_block(c3, c * 4, name='g_r1') r2 = residule_block(r1, c * 4, name='g_r2') r3 = residule_block(r2, c * 4, name='g_r3') r4 = residule_block(r3, c * 4, name='g_r4') r5 = residule_block(r4, c * 4, name='g_r5') r6 = residule_block(r5, c * 4, name='g_r6') r7 = residule_block(r6, c * 4, name='g_r7') r8 = residule_block(r7, c * 4, name='g_r8') r9 = residule_block(r8, c * 4, name='g_r9') d1 = act( instance_norm(deconv2d(r9, c * 2, 3, 2, name='g_d1_dc'), 'g_d1_bn')) # d1 shape == (16 x 16 x 256) d2 = act( instance_norm(deconv2d(d1, c, 3, 2, name='g_d2_dc'), 'g_d2_bn')) # d1 shape == (32 x 32 x 128) output = tf.nn.tanh(deconv2d(d2, c, 7, 1, name='g_output_dc')) # output shape == (32, 32, 128) return tf.identity(output, name=self.name + '_output')
def __call__(self, is_ref): """ Builds the graph propagating from z to x. On the first pass, should make variables. All variables with names beginning with "g_" will be used for the generator network. """ dcgan = self.dcgan assert isinstance(dcgan, DCGAN) def make_z(shape, minval, maxval, name, dtype): assert dtype is tf.float32 if is_ref: with tf.variable_scope(name) as scope: z = tf.get_variable("z", shape, initializer=tf.random_uniform_initializer(minval, maxval), trainable=False) if z.device != "/device:GPU:0": print "z.device is " + str(z.device) assert False else: z = tf.random_uniform(shape, minval=minval, maxval=maxval, name=name, dtype=tf.float32) return z z = make_z([dcgan.batch_size, dcgan.z_dim], minval=-1., maxval=1., name='z', dtype=tf.float32) zs = [z] if hasattr(dcgan, 'generator_built'): tf.get_variable_scope().reuse_variables() make_vars = False else: make_vars = True def reuse_wrapper(packed, *args): """ A wrapper that processes the output of TensorFlow calls differently based on whether we are reusing Variables or not. Parameters ---------- packed: The output of the TensorFlow call args: List of names If make_vars is True, then `packed` will contain all the new Variables, and we need to assign them to dcgan.foo fields. If make_vars is False, then `packed` is just the output tensor, and we just return that. """ if make_vars: assert len(packed) == len(args) + 1, len(packed) out = packed[0] else: out = packed return out assert not dcgan.y_dim # project `z` and reshape z_ = reuse_wrapper(linear(z, dcgan.gf_dim*8*4*4, 'g_h0_lin', with_w=make_vars), 'h0_w', 'h0_b') h0 = tf.reshape(z_, [-1, 4, 4, dcgan.gf_dim * 8]) h0 = tf.nn.relu(dcgan.vbn(h0, "g_vbn_0")) h0z = make_z([dcgan.batch_size, 4, 4, dcgan.gf_dim], minval=-1., maxval=1., name='h0z', dtype=tf.float32) zs.append(h0z) h0 = tf.concat(3, [h0, h0z]) h1 = reuse_wrapper(deconv2d(h0, [dcgan.batch_size, 8, 8, dcgan.gf_dim*4], name='g_h1', with_w=make_vars), 'h1_w', 'h1_b') h1 = tf.nn.relu(dcgan.vbn(h1, "g_vbn_1")) h1z = make_z([dcgan.batch_size, 8, 8, dcgan.gf_dim], minval=-1., maxval=1., name='h1z', dtype=tf.float32) zs.append(h1z) h1 = tf.concat(3, [h1, h1z]) h2 = reuse_wrapper(deconv2d(h1, [dcgan.batch_size, 16, 16, dcgan.gf_dim*2], name='g_h2', with_w=make_vars), 'h2_w', 'h2_b') h2 = tf.nn.relu(dcgan.vbn(h2, "g_vbn_2")) half = dcgan.gf_dim // 2 if half == 0: half = 1 h2z = make_z([dcgan.batch_size, 16, 16, half], minval=-1., maxval=1., name='h2z', dtype=tf.float32) zs.append(h2z) h2 = tf.concat(3, [h2, h2z]) h3 = reuse_wrapper(deconv2d(h2, [dcgan.batch_size, 32, 32, dcgan.gf_dim*1], name='g_h3', with_w=make_vars), 'h3_w', 'h3_b') if make_vars: h3_name = "h3_relu_first" else: h3_name = "h3_relu_reuse" h3 = tf.nn.relu(dcgan.vbn(h3, "g_vbn_3"), name=h3_name) print "h3 shape: ", h3.get_shape() quarter = dcgan.gf_dim // 4 if quarter == 0: quarter = 1 h3z = make_z([dcgan.batch_size, 32, 32, quarter], minval=-1., maxval=1., name='h3z', dtype=tf.float32) zs.append(h3z) h3 = tf.concat(3, [h3, h3z]) assert dcgan.image_shape[0] == 128 h4 = reuse_wrapper(deconv2d(h3, [dcgan.batch_size, 64, 64, dcgan.gf_dim*1], name='g_h4', with_w=make_vars), 'h4_w', 'h4_b') h4 = tf.nn.relu(dcgan.vbn(h4, "g_vbn_4")) print "h4 shape: ", h4.get_shape() eighth = dcgan.gf_dim // 8 if eighth == 0: eighth = 1 h4z = make_z([dcgan.batch_size, 64, 64, eighth], minval=-1., maxval=1., name='h4z', dtype=tf.float32) zs.append(h4z) h4 = tf.concat(3, [h4, h4z]) h5 = reuse_wrapper(deconv2d(h4, [dcgan.batch_size, 128, 128, dcgan.gf_dim * 1], name='g_h5', with_w=make_vars), 'h5_w', 'h5_b') h5 = tf.nn.relu(dcgan.vbn(h5, "g_vbn_5")) print "h5 shape: ", h5.get_shape() sixteenth = dcgan.gf_dim // 16 if sixteenth == 0: sixteenth = 1 h5z = make_z([dcgan.batch_size, 128, 128, sixteenth], minval=-1., maxval=1., name='h5z', dtype=tf.float32) zs.append(h5z) h5 = tf.concat(3, [h5, h5z]) h6 = reuse_wrapper(deconv2d(h5, [dcgan.batch_size, 128, 128, 3], d_w = 1, d_h = 1, name='g_h6', with_w=make_vars, init_bias=dcgan.out_init_b, stddev=dcgan.out_stddev), 'h6_w', 'h6_b') print 'h6 shape: ', h6.get_shape() out = tf.nn.tanh(h6) dcgan.generator_built = True return out, zs