def decoder(self, z, name='decoder', is_reuse=False): with tf.variable_scope(name) as scope: if is_reuse is True: scope.reuse_variables() tf_utils.print_activations(z) # 1st hidden layer h0_linear = tf_utils.linear(z, self.n_hidden, name='h0_linear') h0_tanh = tf_utils.tanh(h0_linear, name='h0_tanh') h0_drop = tf.nn.dropout(h0_tanh, keep_prob=self.keep_prob_tfph, name='h0_drop') tf_utils.print_activations(h0_drop) # 2nd hidden layer h1_linear = tf_utils.linear(h0_drop, self.n_hidden, name='h1_linear') h1_elu = tf_utils.elu(h1_linear, name='h1_elu') h1_drop = tf.nn.dropout(h1_elu, keep_prob=self.keep_prob_tfph, name='h1_drop') tf_utils.print_activations(h1_drop) # 3rd hidden layer h2_linear = tf_utils.linear(h1_drop, self.output_dim, name='h2_linear') h2_sigmoid = tf_utils.sigmoid(h2_linear, name='h2_sigmoid') tf_utils.print_activations(h2_sigmoid) output = tf.reshape(h2_sigmoid, [-1, *self.image_size]) tf_utils.print_activations(output) return output
def basicGenerator(self, data, name='g_'): with tf.variable_scope(name): data_flatten = flatten(data) tf_utils.print_activations(data_flatten) # from (N, 128) to (N, 4, 4, 256) h0_linear = tf_utils.linear(data_flatten, self.gen_c[0], name='h0_linear') if self.flags.dataset == 'cifar10': h0_linear = tf.reshape(h0_linear, [ tf.shape(h0_linear)[0], 4, 4, int(self.gen_c[0] / (4 * 4)) ]) h0_linear = tf_utils.norm(h0_linear, _type='batch', _ops=self.gen_train_ops, name='h0_norm') h0_relu = tf.nn.relu(h0_linear, name='h0_relu') h0_reshape = tf.reshape( h0_relu, [tf.shape(h0_relu)[0], 4, 4, int(self.gen_c[0] / (4 * 4))]) # from (N, 4, 4, 256) to (N, 8, 8, 128) h1_deconv = tf_utils.deconv2d(h0_reshape, self.gen_c[1], k_h=5, k_w=5, name='h1_deconv2d') if self.flags.dataset == 'cifar10': h1_deconv = tf_utils.norm(h1_deconv, _type='batch', _ops=self.gen_train_ops, name='h1_norm') h1_relu = tf.nn.relu(h1_deconv, name='h1_relu') # from (N, 8, 8, 128) to (N, 16, 16, 64) h2_deconv = tf_utils.deconv2d(h1_relu, self.gen_c[2], k_h=5, k_w=5, name='h2_deconv2d') if self.flags.dataset == 'cifar10': h2_deconv = tf_utils.norm(h2_deconv, _type='batch', _ops=self.gen_train_ops, name='h2_norm') h2_relu = tf.nn.relu(h2_deconv, name='h2_relu') # from (N, 16, 16, 64) to (N, 32, 32, 1) output = tf_utils.deconv2d(h2_relu, self.image_size[2], k_h=5, k_w=5, name='h3_deconv2d') return tf_utils.tanh(output)
def __call__(self, x): with tf.variable_scope(self.name, reuse=self.reuse): tf_utils.print_activations(x) # (N, H, W, C) -> (N, H, W, 64) conv1 = tf_utils.padding2d(x, p_h=3, p_w=3, pad_type='REFLECT', name='conv1_padding') conv1 = tf_utils.conv2d(conv1, self.ngf, k_h=7, k_w=7, d_h=1, d_w=1, padding='VALID', name='conv1_conv') conv1 = tf_utils.norm(conv1, _type='instance', _ops=self._ops, name='conv1_norm') conv1 = tf_utils.relu(conv1, name='conv1_relu', is_print=True) # (N, H, W, 64) -> (N, H/2, W/2, 128) conv2 = tf_utils.conv2d(conv1, 2*self.ngf, k_h=3, k_w=3, d_h=2, d_w=2, padding='SAME', name='conv2_conv') conv2 = tf_utils.norm(conv2, _type='instance', _ops=self._ops, name='conv2_norm',) conv2 = tf_utils.relu(conv2, name='conv2_relu', is_print=True) # (N, H/2, W/2, 128) -> (N, H/4, W/4, 256) conv3 = tf_utils.conv2d(conv2, 4*self.ngf, k_h=3, k_w=3, d_h=2, d_w=2, padding='SAME', name='conv3_conv') conv3 = tf_utils.norm(conv3, _type='instance', _ops=self._ops, name='conv3_norm',) conv3 = tf_utils.relu(conv3, name='conv3_relu', is_print=True) # (N, H/4, W/4, 256) -> (N, H/4, W/4, 256) if (self.image_size[0] <= 128) and (self.image_size[1] <= 128): # use 6 residual blocks for 128x128 images res_out = tf_utils.n_res_blocks(conv3, num_blocks=6, is_print=True) else: # use 9 blocks for higher resolution res_out = tf_utils.n_res_blocks(conv3, num_blocks=9, is_print=True) # (N, H/4, W/4, 256) -> (N, H/2, W/2, 128) conv4 = tf_utils.deconv2d(res_out, 2*self.ngf, name='conv4_deconv2d') conv4 = tf_utils.norm(conv4, _type='instance', _ops=self._ops, name='conv4_norm') conv4 = tf_utils.relu(conv4, name='conv4_relu', is_print=True) # (N, H/2, W/2, 128) -> (N, H, W, 64) conv5 = tf_utils.deconv2d(conv4, self.ngf, name='conv5_deconv2d') conv5 = tf_utils.norm(conv5, _type='instance', _ops=self._ops, name='conv5_norm') conv5 = tf_utils.relu(conv5, name='conv5_relu', is_print=True) # (N, H, W, 64) -> (N, H, W, 3) conv6 = tf_utils.padding2d(conv5, p_h=3, p_w=3, pad_type='REFLECT', name='output_padding') conv6 = tf_utils.conv2d(conv6, self.image_size[2], k_h=7, k_w=7, d_h=1, d_w=1, padding='VALID', name='output_conv') output = tf_utils.tanh(conv6, name='output_tanh', is_print=True) # set reuse=True for next call self.reuse = True self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=self.name) return output
def encoder(self, data, name='encoder'): with tf.variable_scope(name): data_flatten = flatten(data) tf_utils.print_activations(data_flatten) # 1st hidden layer h0_linear = tf_utils.linear(data_flatten, self.n_hidden, name='h0_linear') h0_elu = tf_utils.elu(h0_linear, name='h0_elu') h0_drop = tf.nn.dropout(h0_elu, keep_prob=self.keep_prob_tfph, name='h0_drop') tf_utils.print_activations(h0_drop) # 2nd hidden layer h1_linear = tf_utils.linear(h0_drop, self.n_hidden, name='h1_linear') h1_tanh = tf_utils.tanh(h1_linear, name='h1_tanh') h1_drop = tf.nn.dropout(h1_tanh, keep_prob=self.keep_prob_tfph, name='h1_drop') tf_utils.print_activations(h1_drop) # 3rd hidden layer h2_linear = tf_utils.linear(h1_drop, 2 * self.flags.z_dim, name='h2_linear') tf_utils.print_activations(h2_linear) # The mean parameter is unconstrained mean = h2_linear[:, :self.flags.z_dim] # The standard deviation must be positive. # Parameterize with a softplus and add a small epsilon for numerical stability stddev = 1e-6 + tf.nn.softplus(h2_linear[:, self.flags.z_dim:]) tf_utils.print_activations(mean) tf_utils.print_activations(stddev) return mean, stddev
def __call__(self, i_to_s, state, name='DiagonalBiLSTMCell'): c_prev = tf.slice(state, begin=[0, 0], size=[-1, self._num_units]) # [batch, height * hidden_dims] h_prev = tf.slice(state, begin=[0, self._num_units], size=[-1, self._num_units]) # i_to_s: [batch, 4 * height * hidden_dims] input_size = i_to_s.get_shape().with_rank(2)[1] if input_size.value is None: raise ValueError( "Could not infer input size from inputs.get_shape()[-1]") with tf.variable_scope(name): # input-to-state (K_ss * h_{i-1}) : 2x1 convolution. generate 4h x n x n ternsor. # [batch, height, 1, hidden_dims] conv1d_inputs = tf.reshape( h_prev, [-1, self._height, 1, self._hidden_dims], name='conv1d_inputs') # [batch, height, 1, hidden_dims * 4] conv_s_to_s = tf_utils.conv1d(conv1d_inputs, 4 * self._hidden_dims, kernel_size=2, name='s_to_s') # [batch, height * hidden_dims * 4] s_to_s = tf.reshape(conv_s_to_s, [-1, self._height * self._hidden_dims * 4]) lstm_matrix = tf_utils.sigmoid(s_to_s + i_to_s) # i=input_gate, g=new_input, f=forget_gate, o=output_gate o, f, i, g = tf.split(lstm_matrix, 4, axis=1) c = f * c_prev + i * g h = o * tf_utils.tanh(c) new_state = tf.concat([c, h], axis=1) return h, new_state
def __call__(self, x): with tf.variable_scope(self.name, reuse=self.reuse): tf_utils.print_activations(x) # conv: (N, H, W, C) -> (N, H/2, W/2, 64) output = tf_utils.conv2d(x, self.conv_dims[0], k_h=4, k_w=4, d_h=2, d_w=2, padding='SAME', name='conv0_conv2d') output = tf_utils.lrelu(output, name='conv0_lrelu', is_print=True) for idx, conv_dim in enumerate(self.conv_dims[1:]): # conv: (N, H/2, W/2, C) -> (N, H/4, W/4, 2C) output = tf_utils.conv2d(output, conv_dim, k_h=4, k_w=4, d_h=2, d_w=2, padding='SAME', name='conv{}_conv2d'.format(idx + 1)) output = tf_utils.norm(output, _type=self.norm, _ops=self._ops, name='conv{}_norm'.format(idx + 1)) output = tf_utils.lrelu(output, name='conv{}_lrelu'.format(idx + 1), is_print=True) for idx, deconv_dim in enumerate(self.deconv_dims): # deconv: (N, H/16, W/16, C) -> (N, W/8, H/8, C/2) output = tf_utils.deconv2d(output, deconv_dim, k_h=4, k_w=4, name='deconv{}_conv2d'.format(idx)) output = tf_utils.norm(output, _type=self.norm, _ops=self._ops, name='deconv{}_norm'.format(idx)) output = tf_utils.relu(output, name='deconv{}_relu'.format(idx), is_print=True) # conv: (N, H/2, W/2, 64) -> (N, W, H, 3) output = tf_utils.deconv2d(output, self.output_channel, k_h=4, k_w=4, name='conv3_deconv2d') output = tf_utils.tanh(output, name='conv4_tanh', is_print=True) # set reuse=True for next call self.reuse = True self.variables = tf.get_collection( tf.GraphKeys.TRAINABLE_VARIABLES, scope=self.name) return output
def generator(self, data, name='g_'): with tf.variable_scope(name): data_flatten = flatten(data) tf_utils.print_activations(data_flatten) # from (N, 128) to (N, 2, 4, 512) h0_linear = tf_utils.linear(data_flatten, self.gen_c[0], name='h0_linear') h0_reshape = tf.reshape( h0_linear, [tf.shape(h0_linear)[0], 2, 4, int(self.gen_c[0] / (2 * 4))]) # (N, 4, 8, 512) resblock_1 = tf_utils.res_block_v2(h0_reshape, self.gen_c[1], filter_size=3, _ops=self.gen_train_ops, norm_='batch', resample='up', name='res_block_1') # (N, 8, 16, 256) resblock_2 = tf_utils.res_block_v2(resblock_1, self.gen_c[2], filter_size=3, _ops=self.gen_train_ops, norm_='batch', resample='up', name='res_block_2') # (N, 16, 32, 128) resblock_3 = tf_utils.res_block_v2(resblock_2, self.gen_c[3], filter_size=3, _ops=self.gen_train_ops, norm_='batch', resample='up', name='res_block_3') # (N, 32, 64, 64) resblock_4 = tf_utils.res_block_v2(resblock_3, self.gen_c[4], filter_size=3, _ops=self.gen_train_ops, norm_='batch', resample='up', name='res_block_4') # (N, 64, 128, 32) resblock_5 = tf_utils.res_block_v2(resblock_4, self.gen_c[5], filter_size=3, _ops=self.gen_train_ops, norm_='batch', resample='up', name='res_block_5') # (N, 128, 256, 32) resblock_6 = tf_utils.res_block_v2(resblock_5, self.gen_c[6], filter_size=3, _ops=self.gen_train_ops, norm_='batch', resample='up', name='res_block_6') norm_7 = tf_utils.norm(resblock_6, _type='batch', _ops=self.gen_train_ops, name='norm_7') relu_7 = tf_utils.relu(norm_7, name='relu_7') # (N, 128, 256, 3) output = tf_utils.conv2d(relu_7, output_dim=self.image_size[2], k_w=3, k_h=3, d_h=1, d_w=1, name='output') return tf_utils.tanh(output)
def __call__(self, x, keep_rate=0.5): with tf.compat.v1.variable_scope(self.name, reuse=self.reuse): tf_utils.print_activations(x, logger=self.logger) # E0: (320, 200) -> (160, 100) e0_conv2d = tf_utils.conv2d(x, output_dim=self.gen_c[0], initializer='He', logger=self.logger, name='e0_conv2d') e0_lrelu = tf_utils.lrelu(e0_conv2d, logger=self.logger, name='e0_lrelu') # E1: (160, 100) -> (80, 50) e1_conv2d = tf_utils.conv2d(e0_lrelu, output_dim=self.gen_c[1], initializer='He', logger=self.logger, name='e1_conv2d') e1_batchnorm = tf_utils.norm(e1_conv2d, _type=self.norm, _ops=self._ops, logger=self.logger, name='e1_norm') e1_lrelu = tf_utils.lrelu(e1_batchnorm, logger=self.logger, name='e1_lrelu') # E2: (80, 50) -> (40, 25) e2_conv2d = tf_utils.conv2d(e1_lrelu, output_dim=self.gen_c[2], initializer='He', logger=self.logger, name='e2_conv2d') e2_batchnorm = tf_utils.norm(e2_conv2d, _type=self.norm, _ops=self._ops, logger=self.logger, name='e2_norm') e2_lrelu = tf_utils.lrelu(e2_batchnorm, logger=self.logger, name='e2_lrelu') # E3: (40, 25) -> (20, 13) e3_conv2d = tf_utils.conv2d(e2_lrelu, output_dim=self.gen_c[3], initializer='He', logger=self.logger, name='e3_conv2d') e3_batchnorm = tf_utils.norm(e3_conv2d, _type=self.norm, _ops=self._ops, logger=self.logger, name='e3_norm') e3_lrelu = tf_utils.lrelu(e3_batchnorm, logger=self.logger, name='e3_lrelu') # E4: (20, 13) -> (10, 7) e4_conv2d = tf_utils.conv2d(e3_lrelu, output_dim=self.gen_c[4], initializer='He', logger=self.logger, name='e4_conv2d') e4_batchnorm = tf_utils.norm(e4_conv2d, _type=self.norm, _ops=self._ops, logger=self.logger, name='e4_norm') e4_lrelu = tf_utils.lrelu(e4_batchnorm, logger=self.logger, name='e4_lrelu') # E5: (10, 7) -> (5, 4) e5_conv2d = tf_utils.conv2d(e4_lrelu, output_dim=self.gen_c[5], initializer='He', logger=self.logger, name='e5_conv2d') e5_batchnorm = tf_utils.norm(e5_conv2d, _type=self.norm, _ops=self._ops, logger=self.logger, name='e5_norm') e5_lrelu = tf_utils.lrelu(e5_batchnorm, logger=self.logger, name='e5_lrelu') # E6: (5, 4) -> (3, 2) e6_conv2d = tf_utils.conv2d(e5_lrelu, output_dim=self.gen_c[6], initializer='He', logger=self.logger, name='e6_conv2d') e6_batchnorm = tf_utils.norm(e6_conv2d, _type=self.norm, _ops=self._ops, logger=self.logger, name='e6_norm') e6_lrelu = tf_utils.lrelu(e6_batchnorm, logger=self.logger, name='e6_lrelu') # E7: (3, 2) -> (2, 1) e7_conv2d = tf_utils.conv2d(e6_lrelu, output_dim=self.gen_c[7], initializer='He', logger=self.logger, name='e7_conv2d') e7_batchnorm = tf_utils.norm(e7_conv2d, _type=self.norm, _ops=self._ops, logger=self.logger, name='e7_norm') e7_relu = tf_utils.lrelu(e7_batchnorm, logger=self.logger, name='e7_relu') # D0: (2, 1) -> (3, 2) # Stage1: (2, 1) -> (4, 2) d0_deconv = tf_utils.deconv2d(e7_relu, output_dim=self.gen_c[8], initializer='He', logger=self.logger, name='d0_deconv2d') # Stage2: (4, 2) -> (3, 2) shapeA = e6_conv2d.get_shape().as_list()[1] shapeB = d0_deconv.get_shape().as_list()[1] - e6_conv2d.get_shape( ).as_list()[1] d0_split, _ = tf.split(d0_deconv, [shapeA, shapeB], axis=1, name='d0_split') tf_utils.print_activations(d0_split, logger=self.logger) # Stage3: Batch norm, concatenation, and relu d0_batchnorm = tf_utils.norm(d0_split, _type=self.norm, _ops=self._ops, logger=self.logger, name='d0_norm') d0_drop = tf_utils.dropout(d0_batchnorm, keep_prob=keep_rate, logger=self.logger, name='d0_dropout') d0_concat = tf.concat([d0_drop, e6_batchnorm], axis=3, name='d0_concat') d0_relu = tf_utils.relu(d0_concat, logger=self.logger, name='d0_relu') # D1: (3, 2) -> (5, 4) # Stage1: (3, 2) -> (6, 4) d1_deconv = tf_utils.deconv2d(d0_relu, output_dim=self.gen_c[9], initializer='He', logger=self.logger, name='d1_deconv2d') # Stage2: (6, 4) -> (5, 4) shapeA = e5_batchnorm.get_shape().as_list()[1] shapeB = d1_deconv.get_shape().as_list( )[1] - e5_batchnorm.get_shape().as_list()[1] d1_split, _ = tf.split(d1_deconv, [shapeA, shapeB], axis=1, name='d1_split') tf_utils.print_activations(d1_split, logger=self.logger) # Stage3: Batch norm, concatenation, and relu d1_batchnorm = tf_utils.norm(d1_split, _type=self.norm, _ops=self._ops, logger=self.logger, name='d1_norm') d1_drop = tf_utils.dropout(d1_batchnorm, keep_prob=keep_rate, logger=self.logger, name='d1_dropout') d1_concat = tf.concat([d1_drop, e5_batchnorm], axis=3, name='d1_concat') d1_relu = tf_utils.relu(d1_concat, logger=self.logger, name='d1_relu') # D2: (5, 4) -> (10, 7) # Stage1: (5, 4) -> (10, 8) d2_deconv = tf_utils.deconv2d(d1_relu, output_dim=self.gen_c[10], initializer='He', logger=self.logger, name='d2_deconv2d') # Stage2: (10, 8) -> (10, 7) shapeA = e4_batchnorm.get_shape().as_list()[2] shapeB = d2_deconv.get_shape().as_list( )[2] - e4_batchnorm.get_shape().as_list()[2] d2_split, _ = tf.split(d2_deconv, [shapeA, shapeB], axis=2, name='d2_split') tf_utils.print_activations(d2_split, logger=self.logger) # Stage3: Batch norm, concatenation, and relu d2_batchnorm = tf_utils.norm(d2_split, _type=self.norm, _ops=self._ops, logger=self.logger, name='d2_norm') d2_drop = tf_utils.dropout(d2_batchnorm, keep_prob=keep_rate, logger=self.logger, name='d2_dropout') d2_concat = tf.concat([d2_drop, e4_batchnorm], axis=3, name='d2_concat') d2_relu = tf_utils.relu(d2_concat, logger=self.logger, name='d2_relu') # D3: (10, 7) -> (20, 13) # Stage1: (10, 7) -> (20, 14) d3_deconv = tf_utils.deconv2d(d2_relu, output_dim=self.gen_c[11], initializer='He', logger=self.logger, name='d3_deconv2d') # Stage2: (20, 14) -> (20, 13) shapeA = e3_batchnorm.get_shape().as_list()[2] shapeB = d3_deconv.get_shape().as_list( )[2] - e3_batchnorm.get_shape().as_list()[2] d3_split, _ = tf.split(d3_deconv, [shapeA, shapeB], axis=2, name='d3_split_2') tf_utils.print_activations(d3_split, logger=self.logger) # Stage3: Batch norm, concatenation, and relu d3_batchnorm = tf_utils.norm(d3_split, _type=self.norm, _ops=self._ops, logger=self.logger, name='d3_norm') d3_concat = tf.concat([d3_batchnorm, e3_batchnorm], axis=3, name='d3_concat') d3_relu = tf_utils.relu(d3_concat, logger=self.logger, name='d3_relu') # D4: (20, 13) -> (40, 25) # Stage1: (20, 13) -> (40, 26) d4_deconv = tf_utils.deconv2d(d3_relu, output_dim=self.gen_c[12], initializer='He', logger=self.logger, name='d4_deconv2d') # Stage2: (40, 26) -> (40, 25) shapeA = e2_batchnorm.get_shape().as_list()[2] shapeB = d4_deconv.get_shape().as_list( )[2] - e2_batchnorm.get_shape().as_list()[2] d4_split, _ = tf.split(d4_deconv, [shapeA, shapeB], axis=2, name='d4_split') tf_utils.print_activations(d4_split, logger=self.logger) # Stage3: Batch norm, concatenation, and relu d4_batchnorm = tf_utils.norm(d4_split, _type=self.norm, _ops=self._ops, logger=self.logger, name='d4_norm') d4_concat = tf.concat([d4_batchnorm, e2_batchnorm], axis=3, name='d4_concat') d4_relu = tf_utils.relu(d4_concat, logger=self.logger, name='d4_relu') # D5: (40, 25, 256) -> (80, 50, 128) d5_deconv = tf_utils.deconv2d(d4_relu, output_dim=self.gen_c[13], initializer='He', logger=self.logger, name='d5_deconv2d') d5_batchnorm = tf_utils.norm(d5_deconv, _type=self.norm, _ops=self._ops, logger=self.logger, name='d5_norm') d5_concat = tf.concat([d5_batchnorm, e1_batchnorm], axis=3, name='d5_concat') d5_relu = tf_utils.relu(d5_concat, logger=self.logger, name='d5_relu') # D6: (80, 50, 128) -> (160, 100, 64) d6_deconv = tf_utils.deconv2d(d5_relu, output_dim=self.gen_c[14], initializer='He', logger=self.logger, name='d6_deconv2d') d6_batchnorm = tf_utils.norm(d6_deconv, _type=self.norm, _ops=self._ops, logger=self.logger, name='d6_norm') d6_concat = tf.concat([d6_batchnorm, e0_conv2d], axis=3, name='d6_concat') d6_relu = tf_utils.relu(d6_concat, logger=self.logger, name='d6_relu') # D7: (160, 100, 64) -> (320, 200, 1) d7_deconv = tf_utils.deconv2d(d6_relu, output_dim=self.gen_c[15], initializer='He', logger=self.logger, name='d7_deconv2d') output = tf_utils.tanh(d7_deconv, logger=self.logger, name='output_tanh') # Set reuse=True for next call self.reuse = True self.variables = tf.compat.v1.get_collection( tf.compat.v1.GraphKeys.TRAINABLE_VARIABLES, scope=self.name) return output
def __call__(self, x): with tf.variable_scope(self.name, reuse=self.reuse): tf_utils.print_activations(x) # conv: (N, H, W, C) -> (N, H/2, W/2, 64) output = tf_utils.conv2d(x, self.conv_dims[0], k_h=4, k_w=4, d_h=2, d_w=2, padding='SAME', name='conv0_conv2d') output = tf_utils.lrelu(output, name='conv0_lrelu', is_print=True) for idx, conv_dim in enumerate(self.conv_dims[1:]): # conv: (N, H/2, W/2, C) -> (N, H/4, W/4, 2C) output = tf_utils.conv2d(output, conv_dim, k_h=4, k_w=4, d_h=2, d_w=2, padding='SAME', name='conv{}_conv2d'.format(idx + 1)) output = tf_utils.norm(output, _type=self.norm, _ops=self._ops, name='conv{}_norm'.format(idx + 1)) output = tf_utils.lrelu(output, name='conv{}_lrelu'.format(idx + 1), is_print=True) for idx, deconv_dim in enumerate(self.deconv_dims): # deconv: (N, H/16, W/16, C) -> (N, W/8, H/8, C/2) output = tf_utils.deconv2d(output, deconv_dim, k_h=4, k_w=4, name='deconv{}_conv2d'.format(idx)) output = tf_utils.norm(output, _type=self.norm, _ops=self._ops, name='deconv{}_norm'.format(idx)) output = tf_utils.relu(output, name='deconv{}_relu'.format(idx), is_print=True) # split (N, 152, 104, 64) to (N, 150, 104, 64) shapeA = int(self.img_size[0] / 2) shapeB = output.get_shape().as_list()[1] - shapeA output, _ = tf.split(output, [shapeA, shapeB], axis=1, name='split_0') tf_utils.print_activations(output) # split (N, 150, 104, 64) to (N, 150, 100, 64) shapeA = int(self.img_size[1] / 2) shapeB = output.get_shape().as_list()[2] - shapeA output, _ = tf.split(output, [shapeA, shapeB], axis=2, name='split_1') tf_utils.print_activations(output) # conv: (N, H/2, W/2, 64) -> (N, W, H, 3) output = tf_utils.deconv2d(output, self.img_size[2], k_h=4, k_w=4, name='conv3_deconv2d') output = tf_utils.tanh(output, name='conv4_tanh', is_print=True) # set reuse=True for next call self.reuse = True self.variables = tf.get_collection( tf.GraphKeys.TRAINABLE_VARIABLES, scope=self.name) return output
def __call__(self, x, is_train=True): with tf.variable_scope(self.name, reuse=self.reuse): tf_utils.print_activations(x) # (N, 100) -> (N, 4, 5, 1024) h0_linear = tf_utils.linear( x, 4 * 5 * self.dims[0], name='h0_linear', initializer='He', logger=self.logger if is_train is True else None) h0_reshape = tf.reshape( h0_linear, [tf.shape(h0_linear)[0], 4, 5, self.dims[0]]) h0_norm = tf_utils.norm( h0_reshape, name='h0_batch', _type='batch', _ops=self._ops, is_train=is_train, logger=self.logger if is_train is True else None) h0_relu = tf_utils.relu( h0_norm, name='h0_relu', logger=self.logger if is_train is True else None) # (N, 4, 5, 1024) -> (N, 8, 10, 512) h1_deconv = tf_utils.deconv2d( h0_relu, output_dim=self.dims[1], name='h1_deconv2d', initializer='He', logger=self.logger if is_train is True else None) h1_norm = tf_utils.norm( h1_deconv, name='h1_batch', _type='batch', _ops=self._ops, is_train=is_train, logger=self.logger if is_train is True else None) h1_relu = tf_utils.relu( h1_norm, name='h1_relu', logger=self.logger if is_train is True else None) # (N, 8, 10, 512) -> (N, 16, 20, 256) h2_deconv = tf_utils.deconv2d( h1_relu, output_dim=self.dims[2], name='h2_deconv2d', initializer='He', logger=self.logger if is_train is True else None) h2_norm = tf_utils.norm( h2_deconv, name='h2_batch', _type='batch', _ops=self._ops, is_train=is_train, logger=self.logger if is_train is True else None) h2_relu = tf_utils.relu( h2_norm, name='h2_relu', logger=self.logger if is_train is True else None) # (N, 16, 20, 256) -> (N, 15, 20, 256) h2_split, _ = tf.split(h2_relu, [15, 1], axis=1, name='h2_split') tf_utils.print_activations( h2_split, logger=self.logger if is_train is True else None) # (N, 15, 20, 256) -> (N, 30, 40, 128) h3_deconv = tf_utils.deconv2d( h2_split, output_dim=self.dims[3], name='h3_deconv2d', initializer='He', logger=self.logger if is_train is True else None) h3_norm = tf_utils.norm( h3_deconv, name='h3_batch', _type='batch', _ops=self._ops, is_train=is_train, logger=self.logger if is_train is True else None) h3_relu = tf_utils.relu( h3_norm, name='h3_relu', logger=self.logger if is_train is True else None) # (N, 30, 40, 128) -> (N, 60, 80, 64) h4_deconv = tf_utils.deconv2d( h3_relu, output_dim=self.dims[4], name='h4_deconv2d', initializer='He', logger=self.logger if is_train is True else None) h4_norm = tf_utils.norm( h4_deconv, name='h4_batch', _type='batch', _ops=self._ops, is_train=is_train, logger=self.logger if is_train is True else None) h4_relu = tf_utils.relu( h4_norm, name='h4_relu', logger=self.logger if is_train is True else None) # (N, 60, 80, 64) -> (N, 120, 160, 1) h5_deconv = tf_utils.deconv2d( h4_relu, output_dim=self.dims[5], name='h5_deconv', initializer='He', logger=self.logger if is_train is True else None) output = tf_utils.tanh( h5_deconv, name='output', logger=self.logger if is_train is True else None) # Set reuse=True for next call self.reuse = True self.variables = tf.get_collection( tf.GraphKeys.TRAINABLE_VARIABLES, scope=self.name) return output
def __call__(self, x, is_train=True): with tf.variable_scope(self.name, reuse=self.reuse): tf_utils.print_activations(x) # (N, 100) -> (N, 4, 5, 512) h0_linear = tf_utils.linear( x, 4 * 5 * self.dims[0], name='h0_linear', initializer='He', logger=self.logger if is_train is True else None) h0_reshape = tf.reshape( h0_linear, [tf.shape(h0_linear)[0], 4, 5, self.dims[0]]) # (N, 4, 5, 512) -> (N, 8, 10, 512) resblock_1 = tf_utils.res_block_v2( x=h0_reshape, k=self.dims[1], filter_size=3, _ops=self._ops, norm_='batch', resample='up', name='res_block_1', logger=self.logger if is_train is True else None) # (N, 8, 10, 512) -> (N, 16, 20, 256) resblock_2 = tf_utils.res_block_v2( x=resblock_1, k=self.dims[2], filter_size=3, _ops=self._ops, norm_='batch', resample='up', name='res_block_2', logger=self.logger if is_train is True else None) # (N, 16, 20, 256) -> (N, 15, 20, 256) resblock_2_split, _ = tf.split(resblock_2, [15, 1], axis=1, name='resblock_2_split') tf_utils.print_activations( resblock_2_split, logger=self.logger if is_train is True else None) # (N, 15, 20, 256) -> (N, 30, 40, 128) resblock_3 = tf_utils.res_block_v2( x=resblock_2_split, k=self.dims[3], filter_size=3, _ops=self._ops, norm_='batch', resample='up', name='res_block_3', logger=self.logger if is_train is True else None) # (N, 30, 40, 128) -> (N, 60, 80, 64) resblock_4 = tf_utils.res_block_v2( x=resblock_3, k=self.dims[4], filter_size=3, _ops=self._ops, norm_='batch', resample='up', name='res_block_4', logger=self.logger if is_train is True else None) # (N, 60, 80, 64) -> (N, 120, 160, 64) resblock_5 = tf_utils.res_block_v2( x=resblock_4, k=self.dims[5], filter_size=3, _ops=self._ops, norm_='batch', resample='up', name='res_block_5', logger=self.logger if is_train is True else None) norm_5 = tf_utils.norm( resblock_5, name='norm_5', _type='batch', _ops=self._ops, is_train=is_train, logger=self.logger if is_train is True else None) relu_5 = tf_utils.relu( norm_5, name='relu_5', logger=self.logger if is_train is True else None) # (N, 120, 160, 64) -> (N, 120, 160, 3) conv_6 = tf_utils.conv2d( relu_5, output_dim=self.dims[6], k_h=3, k_w=3, d_h=1, d_w=1, name='conv_6', logger=self.logger if is_train is True else None) output = tf_utils.tanh( conv_6, name='output', logger=self.logger if is_train is True else None) # Set reuse=True for next call self.reuse = True self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=self.name) return output
def __call__(self, x): with tf.variable_scope(self.name, reuse=self.reuse): tf_utils.print_activations(x) # (300, 200) -> (150, 100) e0_conv2d = tf_utils.conv2d(x, self.gen_c[0], name='e0_conv2d') e0_lrelu = tf_utils.lrelu(e0_conv2d, name='e0_lrelu') # (150, 100) -> (75, 50) e1_conv2d = tf_utils.conv2d(e0_lrelu, self.gen_c[1], name='e1_conv2d') e1_batchnorm = tf_utils.batch_norm(e1_conv2d, name='e1_batchnorm', _ops=self._ops) e1_lrelu = tf_utils.lrelu(e1_batchnorm, name='e1_lrelu') # (75, 50) -> (38, 25) e2_conv2d = tf_utils.conv2d(e1_lrelu, self.gen_c[2], name='e2_conv2d') e2_batchnorm = tf_utils.batch_norm(e2_conv2d, name='e2_batchnorm', _ops=self._ops) e2_lrelu = tf_utils.lrelu(e2_batchnorm, name='e2_lrelu') # (38, 25) -> (19, 13) e3_conv2d = tf_utils.conv2d(e2_lrelu, self.gen_c[3], name='e3_conv2d') e3_batchnorm = tf_utils.batch_norm(e3_conv2d, name='e3_batchnorm', _ops=self._ops) e3_lrelu = tf_utils.lrelu(e3_batchnorm, name='e3_lrelu') # (19, 13) -> (10, 7) e4_conv2d = tf_utils.conv2d(e3_lrelu, self.gen_c[4], name='e4_conv2d') e4_batchnorm = tf_utils.batch_norm(e4_conv2d, name='e4_batchnorm', _ops=self._ops) e4_lrelu = tf_utils.lrelu(e4_batchnorm, name='e4_lrelu') # (10, 7) -> (5, 4) e5_conv2d = tf_utils.conv2d(e4_lrelu, self.gen_c[5], name='e5_conv2d') e5_batchnorm = tf_utils.batch_norm(e5_conv2d, name='e5_batchnorm', _ops=self._ops) e5_lrelu = tf_utils.lrelu(e5_batchnorm, name='e5_lrelu') # (5, 4) -> (3, 2) e6_conv2d = tf_utils.conv2d(e5_lrelu, self.gen_c[6], name='e6_conv2d') e6_batchnorm = tf_utils.batch_norm(e6_conv2d, name='e6_batchnorm', _ops=self._ops) e6_lrelu = tf_utils.lrelu(e6_batchnorm, name='e6_lrelu') # (3, 2) -> (2, 1) e7_conv2d = tf_utils.conv2d(e6_lrelu, self.gen_c[7], name='e7_conv2d') e7_batchnorm = tf_utils.batch_norm(e7_conv2d, name='e7_batchnorm', _ops=self._ops) e7_relu = tf_utils.relu(e7_batchnorm, name='e7_relu') # (2, 1) -> (4, 2) d0_deconv = tf_utils.deconv2d(e7_relu, self.gen_c[8], name='d0_deconv2d') shapeA = e6_conv2d.get_shape().as_list()[1] shapeB = d0_deconv.get_shape().as_list()[1] - e6_conv2d.get_shape( ).as_list()[1] # (4, 2) -> (3, 2) d0_split, _ = tf.split(d0_deconv, [shapeA, shapeB], axis=1, name='d0_split') tf_utils.print_activations(d0_split) d0_batchnorm = tf_utils.batch_norm(d0_split, name='d0_batchnorm', _ops=self._ops) d0_drop = tf.nn.dropout(d0_batchnorm, keep_prob=0.5, name='d0_dropout') d0_concat = tf.concat([d0_drop, e6_batchnorm], axis=3, name='d0_concat') d0_relu = tf_utils.relu(d0_concat, name='d0_relu') # (3, 2) -> (6, 4) d1_deconv = tf_utils.deconv2d(d0_relu, self.gen_c[9], name='d1_deconv2d') # (6, 4) -> (5, 4) shapeA = e5_batchnorm.get_shape().as_list()[1] shapeB = d1_deconv.get_shape().as_list( )[1] - e5_batchnorm.get_shape().as_list()[1] d1_split, _ = tf.split(d1_deconv, [shapeA, shapeB], axis=1, name='d1_split') tf_utils.print_activations(d1_split) d1_batchnorm = tf_utils.batch_norm(d1_split, name='d1_batchnorm', _ops=self._ops) d1_drop = tf.nn.dropout(d1_batchnorm, keep_prob=0.5, name='d1_dropout') d1_concat = tf.concat([d1_drop, e5_batchnorm], axis=3, name='d1_concat') d1_relu = tf_utils.relu(d1_concat, name='d1_relu') # (5, 4) -> (10, 8) d2_deconv = tf_utils.deconv2d(d1_relu, self.gen_c[10], name='d2_deconv2d') # (10, 8) -> (10, 7) shapeA = e4_batchnorm.get_shape().as_list()[2] shapeB = d2_deconv.get_shape().as_list( )[2] - e4_batchnorm.get_shape().as_list()[2] d2_split, _ = tf.split(d2_deconv, [shapeA, shapeB], axis=2, name='d2_split') tf_utils.print_activations(d2_split) d2_batchnorm = tf_utils.batch_norm(d2_split, name='d2_batchnorm', _ops=self._ops) d2_drop = tf.nn.dropout(d2_batchnorm, keep_prob=0.5, name='d2_dropout') d2_concat = tf.concat([d2_drop, e4_batchnorm], axis=3, name='d2_concat') d2_relu = tf_utils.relu(d2_concat, name='d2_relu') # (10, 7) -> (20, 14) d3_deconv = tf_utils.deconv2d(d2_relu, self.gen_c[11], name='d3_deconv2d') # (20, 14) -> (19, 14) shapeA = e3_batchnorm.get_shape().as_list()[1] shapeB = d3_deconv.get_shape().as_list( )[1] - e3_batchnorm.get_shape().as_list()[1] d3_split_1, _ = tf.split(d3_deconv, [shapeA, shapeB], axis=1, name='d3_split_1') tf_utils.print_activations(d3_split_1) # (19, 14) -> (19, 13) shapeA = e3_batchnorm.get_shape().as_list()[2] shapeB = d3_split_1.get_shape().as_list( )[2] - e3_batchnorm.get_shape().as_list()[2] d3_split_2, _ = tf.split(d3_split_1, [shapeA, shapeB], axis=2, name='d3_split_2') tf_utils.print_activations(d3_split_2) d3_batchnorm = tf_utils.batch_norm(d3_split_2, name='d3_batchnorm', _ops=self._ops) d3_concat = tf.concat([d3_batchnorm, e3_batchnorm], axis=3, name='d3_concat') d3_relu = tf_utils.relu(d3_concat, name='d3_relu') # (19, 13) -> (38, 26) d4_deconv = tf_utils.deconv2d(d3_relu, self.gen_c[12], name='d4_deconv2d') # (38, 26) -> (38, 25) shapeA = e2_batchnorm.get_shape().as_list()[2] shapeB = d4_deconv.get_shape().as_list( )[2] - e2_batchnorm.get_shape().as_list()[2] d4_split, _ = tf.split(d4_deconv, [shapeA, shapeB], axis=2, name='d4_split') tf_utils.print_activations(d4_split) d4_batchnorm = tf_utils.batch_norm(d4_split, name='d4_batchnorm', _ops=self._ops) d4_concat = tf.concat([d4_batchnorm, e2_batchnorm], axis=3, name='d4_concat') d4_relu = tf_utils.relu(d4_concat, name='d4_relu') # (38, 25) -> (76, 50) d5_deconv = tf_utils.deconv2d(d4_relu, self.gen_c[13], name='d5_deconv2d') # (76, 50) -> (75, 50) shapeA = e1_batchnorm.get_shape().as_list()[1] shapeB = d5_deconv.get_shape().as_list( )[1] - e1_batchnorm.get_shape().as_list()[1] d5_split, _ = tf.split(d5_deconv, [shapeA, shapeB], axis=1, name='d5_split') tf_utils.print_activations(d5_split) d5_batchnorm = tf_utils.batch_norm(d5_split, name='d5_batchnorm', _ops=self._ops) d5_concat = tf.concat([d5_batchnorm, e1_batchnorm], axis=3, name='d5_concat') d5_relu = tf_utils.relu(d5_concat, name='d5_relu') # (75, 50) -> (150, 100) d6_deconv = tf_utils.deconv2d(d5_relu, self.gen_c[14], name='d6_deconv2d') d6_batchnorm = tf_utils.batch_norm(d6_deconv, name='d6_batchnorm', _ops=self._ops) d6_concat = tf.concat([d6_batchnorm, e0_conv2d], axis=3, name='d6_concat') d6_relu = tf_utils.relu(d6_concat, name='d6_relu') # (150, 100) -> (300, 200) d7_deconv = tf_utils.deconv2d(d6_relu, self.gen_c[15], name='d7_deconv2d') output = tf_utils.tanh(d7_deconv, name='output_tanh') # set reuse=True for next call self.reuse = True self.variables = tf.get_collection( tf.GraphKeys.TRAINABLE_VARIABLES, scope=self.name) return output