def decoder(latent_var, is_training=True): activation_fn = leaky_relu # tf.nn.relu # activation_fn = tf.nn.elu weight_decay = 0.0 with tf.variable_scope('decoder', reuse=tf.AUTO_REUSE): with slim.arg_scope([slim.batch_norm], is_training=is_training): with slim.arg_scope([slim.convolution2d_transpose, slim.fully_connected], weights_initializer=tf.truncated_normal_initializer(stddev=0.05), weights_regularizer=slim.l2_regularizer(weight_decay), normalizer_fn=slim.batch_norm): # net = slim.fully_connected(latent_var, , activation_fn=None, normalizer_fn=None, scope='Fc_1') # net = tf.reshape(net, [-1,16,16,4], name='Reshape') # net = tf.image.resize_nearest_neighbor(net, size=(8,8), name='Upsample_1') # net = slim.convolution2d_transpose(latent_var, 512, [4, 4], 2, activation_fn=activation_fn, # scope='Conv2d_1') net = slim.convolution2d_transpose(latent_var, 512, [4, 4], 2, activation_fn=activation_fn, scope='Conv2d_1') # net = tf.image.resize_nearest_neighbor(net, size=(16,16), name='Upsample_2') net = slim.convolution2d_transpose(net, 256, [4, 4], 2, activation_fn=activation_fn, scope='Conv2d_2') net = slim.convolution2d_transpose(net, 128, [4, 4], 2, activation_fn=activation_fn, scope='Conv2d_3') net = slim.convolution2d_transpose(net, 64, [4, 4], 1, activation_fn=activation_fn, scope='Conv2d_4') net = slim.convolution2d_transpose(net, 6, [4, 4], 1, activation_fn=activation_fn, scope='Conv2d_5') return net
def generator(z): ''' The generator takes a vector of random numbers and transforms it into a 32x32 image. :param z: a vector of random numbers :return: a 32x32 image ''' with tf.variable_scope('G'): zP=slim.layers.fully_connected(z,4*4*256,activation_fn=tf.nn.leaky_relu,normalizer_fn=slim.batch_norm, scope='g_project', weights_initializer=initializer) # [n,4*4*256] zCon = tf.reshape(zP, [-1, 4, 4, 256]) # [n,4,4,256] gen1 = slim.convolution2d_transpose(zCon, num_outputs=64, kernel_size=[5, 5], stride=[2, 2],padding="SAME", normalizer_fn=slim.batch_norm,activation_fn=tf.nn.leaky_relu, scope='g_conv1', weights_initializer=initializer) # [n,8,8,64] 采样方式SAME h*stride gen2 = slim.convolution2d_transpose( \ gen1, num_outputs=32, kernel_size=[5, 5], stride=[2, 2], \ padding="SAME", normalizer_fn=slim.batch_norm, \ activation_fn=tf.nn.leaky_relu, scope='g_conv2', weights_initializer=initializer) # [n,16,16,32] 采样方式SAME h*stride gen3 = slim.convolution2d_transpose( \ gen2, num_outputs=16, kernel_size=[5, 5], stride=[2, 2], \ padding="SAME", normalizer_fn=slim.batch_norm, \ activation_fn=tf.nn.leaky_relu, scope='g_conv3', weights_initializer=initializer) # [n,32,32,16] 采样方式SAME h*stride g_out = slim.convolution2d_transpose( \ gen3, num_outputs=1, kernel_size=[32, 32], padding="SAME", \ biases_initializer=None, activation_fn=tf.nn.tanh, \ scope='g_out', weights_initializer=initializer) # [n,32,32,1] 这里stride默认为1 return g_out
def generator(z): ''' Generator is like a reverse convolutional Neural Network Taking in the input vector and projecting it into a large 'meaning' vector see https://arxiv.org/pdf/1511.06434.pdf ''' zP = slim.fully_connected(z,4*4*256,normalizer_fn=slim.batch_norm,\ activation_fn=tf.nn.relu,scope='g_project',weights_initializer=initializer) zCon = tf.reshape(zP, [-1, 4, 4, 256]) gen1 = slim.convolution2d_transpose(\ zCon,num_outputs=64,kernel_size=[5,5],stride=[2,2],\ padding="SAME",normalizer_fn=slim.batch_norm,\ activation_fn=tf.nn.relu,scope='g_conv1', weights_initializer=initializer) gen2 = slim.convolution2d_transpose(\ gen1,num_outputs=32,kernel_size=[5,5],stride=[2,2],\ padding="SAME",normalizer_fn=slim.batch_norm,\ activation_fn=tf.nn.relu,scope='g_conv2', weights_initializer=initializer) gen3 = slim.convolution2d_transpose(\ gen2,num_outputs=16,kernel_size=[5,5],stride=[2,2],\ padding="SAME",normalizer_fn=slim.batch_norm,\ activation_fn=tf.nn.relu,scope='g_conv3', weights_initializer=initializer) g_out = slim.convolution2d_transpose(\ gen3,num_outputs=1,kernel_size=[32,32],padding="SAME",\ biases_initializer=None,activation_fn=tf.nn.tanh,\ scope='g_out', weights_initializer=initializer) return g_out
def decode(X, reuse): with tf.variable_scope('G'): gen1 = slim.convolution2d_transpose( X, num_outputs=64, kernel_size=[5, 5], stride=[2, 2], padding="SAME", normalizer_fn=slim.batch_norm, activation_fn=tf.nn.leaky_relu, reuse=reuse, scope='g_conv1', weights_initializer=initializer ) # [n,8,8,64] 采样方式SAME h*stride gen2 = slim.convolution2d_transpose( \ gen1, num_outputs=32, kernel_size=[5, 5], stride=[2, 2], \ padding="SAME", normalizer_fn=slim.batch_norm, \ activation_fn=tf.nn.leaky_relu, scope='g_conv2',reuse=reuse, weights_initializer=initializer) # [n,16,16,32] 采样方式SAME h*stride gen3 = slim.convolution2d_transpose( \ gen2, num_outputs=16, kernel_size=[5, 5], stride=[2, 2], \ padding="SAME", normalizer_fn=slim.batch_norm, \ activation_fn=tf.nn.leaky_relu, scope='g_conv3',reuse=reuse, weights_initializer=initializer) # [n,32,32,16] 采样方式SAME h*stride g_out = slim.convolution2d_transpose( \ gen3, num_outputs=1, kernel_size=[32, 32], padding="SAME", \ biases_initializer=None, activation_fn=tf.nn.tanh, \ reuse=reuse,scope='g_out', weights_initializer=initializer) # [n,32,32,1] 这里stride默认为1 return g_out
def generator(z, reuse=False): with tf.variable_scope('generator', reuse=reuse): initializer = tf.truncated_normal_initializer(stddev=0.02) zP = slim.fully_connected(z, 4 * 4 * 256, normalizer_fn=slim.batch_norm, activation_fn=tf.nn.relu, scope='g_project', weights_initializer=initializer) zCon = tf.reshape(zP, [-1, 4, 4, 256]) gen1 = slim.convolution2d_transpose( zCon, num_outputs=32, kernel_size=[3, 3], stride=2, padding="SAME", normalizer_fn=slim.batch_norm, activation_fn=tf.nn.relu, scope='g_conv1', weights_initializer=initializer) gen2 = slim.convolution2d_transpose( gen1, num_outputs=16, kernel_size=[3, 3], stride=2, padding="SAME", normalizer_fn=slim.batch_norm, activation_fn=tf.nn.relu, scope='g_conv2', weights_initializer=initializer) gen3 = slim.convolution2d_transpose( gen2, num_outputs=8, kernel_size=[3, 3], stride=2, padding="SAME", normalizer_fn=slim.batch_norm, activation_fn=tf.nn.relu, scope='g_conv3', weights_initializer=initializer) ''' gen4 = slim.convolution2d_transpose( gen3, num_outputs=3, kernel_size=[3, 3], stride=2, padding="SAME", normalizer_fn=slim.batch_norm, activation_fn=tf.nn.relu, scope='g_conv4', weights_initializer=initializer) ''' g_out = slim.convolution2d_transpose( gen3, num_outputs=1, kernel_size=[32, 32], stride=1, padding="SAME", biases_initializer=None, activation_fn=tf.nn.tanh, scope='g_out', weights_initializer=initializer) g_out_concat = tf.concat(3, [g_out, g_out, g_out], name='concat') return g_out_concat
def decoder(x): print print 'x: ', x d_fc1 = slim.fully_connected(x, 32, normalizer_fn=slim.batch_norm, activation_fn=tf.identity, scope='d_fc1') d_fc1 = lrelu(d_fc1) print 'd_fc1: ', d_fc1 d_fc2 = slim.fully_connected(d_fc1, 64, normalizer_fn=slim.batch_norm, activation_fn=tf.identity, scope='d_fc2') d_fc2 = lrelu(d_fc2) print 'd_fc2: ', d_fc2 d_fc3 = slim.fully_connected(d_fc2, 256, normalizer_fn=slim.batch_norm, activation_fn=tf.identity, scope='d_fc3') d_fc3 = lrelu(d_fc3) print 'd_fc3: ', d_fc3 d_fc3 = tf.reshape(d_fc3, [batch_size, 4, 4, 16]) print 'd_fc3: ', d_fc3 e_transpose_conv1 = slim.convolution2d_transpose(d_fc3, 64, 2, stride=2, normalizer_fn=slim.batch_norm, activation_fn=tf.identity, scope='e_transpose_conv1') e_transpose_conv1 = lrelu(e_transpose_conv1) print 'e_transpose_conv1: ', e_transpose_conv1 e_transpose_conv2 = slim.convolution2d_transpose(e_transpose_conv1, 32, 2, stride=2, normalizer_fn=slim.batch_norm, activation_fn=tf.identity, scope='e_transpose_conv2') e_transpose_conv2 = lrelu(e_transpose_conv2) print 'e_transpose_conv2: ', e_transpose_conv2 e_transpose_conv3 = slim.convolution2d_transpose(e_transpose_conv2, 1, 2, stride=2, normalizer_fn=slim.batch_norm, activation_fn=tf.identity, scope='e_transpose_conv3') e_transpose_conv3 = lrelu(e_transpose_conv3) e_transpose_conv3 = e_transpose_conv3[:,:28,:28,:] print 'e_transpose_conv3: ', e_transpose_conv3 return e_transpose_conv3
def generator(z): zP = slim.fully_connected(z, 4 * 4 * 256, normalizer_fn=slim.batch_norm, \ activation_fn=tf.nn.relu, scope='g_project', weights_initializer=initializer) zCon = tf.reshape(zP, [-1, 4, 4, 256]) gen1 = slim.convolution2d_transpose( \ zCon, num_outputs=64, kernel_size=[5, 5], stride=[2, 2], \ padding="SAME", normalizer_fn=slim.batch_norm, \ activation_fn=tf.nn.relu, scope='g_conv1', weights_initializer=initializer) gen2 = slim.convolution2d_transpose( \ gen1, num_outputs=32, kernel_size=[5, 5], stride=[2, 2], \ padding="SAME", normalizer_fn=slim.batch_norm, \ activation_fn=tf.nn.relu, scope='g_conv2', weights_initializer=initializer) gen3 = slim.convolution2d_transpose( \ gen2, num_outputs=16, kernel_size=[5, 5], stride=[2, 2], \ padding="SAME", normalizer_fn=slim.batch_norm, \ activation_fn=tf.nn.relu, scope='g_conv3', weights_initializer=initializer) g_out = slim.convolution2d_transpose( \ gen3, num_outputs=1, kernel_size=[32, 32], padding="SAME", \ biases_initializer=None, activation_fn=tf.nn.tanh, \ scope='g_out', weights_initializer=initializer) return g_out
def generator(self, z): # This initializaer is used to initialize all the weights of the network. initializer = tf.truncated_normal_initializer(stddev=0.02) gen1 = slim.convolution2d_transpose(z, num_outputs=16, kernel_size=[10, 10], stride=[1, 1], padding="SAME", normalizer_fn=slim.batch_norm, activation_fn=lrelu, scope='g_conv1', weights_initializer=initializer) gen2 = slim.convolution2d_transpose(gen1, num_outputs=32, kernel_size=[5, 5], stride=[1, 1], padding="SAME", normalizer_fn=slim.batch_norm, activation_fn=lrelu, scope='g_conv2', weights_initializer=initializer) gen3 = slim.convolution2d_transpose(gen2, num_outputs=16, kernel_size=[3, 3], stride=[1, 1], padding="SAME", normalizer_fn=slim.batch_norm, activation_fn=lrelu, scope='g_conv3', weights_initializer=initializer) gen4 = slim.convolution2d_transpose(gen3, num_outputs=8, kernel_size=[2, 2], stride=[1, 1], padding="SAME", normalizer_fn=slim.batch_norm, activation_fn=lrelu, scope='g_conv4', weights_initializer=initializer) g_out = slim.convolution2d_transpose(gen4, num_outputs=3, kernel_size=[1, 1], stride=[1, 1], padding="SAME", biases_initializer=None, activation_fn=lrelu, scope='g_out', weights_initializer=initializer) return g_out
def generator(z): initializer = tf.truncated_normal_initializer(stddev=0.02) zP = slim.fully_connected(z, 4 * 4 * 256, normalizer_fn=slim.batch_norm, activation_fn=tf.nn.relu, scope='g_project', weights_initializer=initializer) zCon = tf.reshape(zP, [-1, 4, 4, 256]) gen1 = slim.convolution2d_transpose(zCon, num_outputs=64, kernel_size=(5, 5), stride=(2, 2), padding='SAME', normalizer_fn=slim.batch_norm, activation_fn=tf.nn.relu, scope='g_conv1', weights_initializer=initializer) gen2 = slim.convolution2d_transpose(gen1, num_outputs=32, kernel_size=(5, 5), stride=(2, 2), padding='SAME', normalizer_fn=slim.batch_norm, activation_fn=tf.nn.relu, scope='g_conv2', weights_initializer=initializer) gen3 = slim.convolution2d_transpose(gen2, num_outputs=16, kernel_size=(5, 5), stride=(2, 2), padding='SAME', normalizer_fn=slim.batch_norm, activation_fn=tf.nn.relu, scope='g_conv3', weights_initializer=initializer) g_out = slim.convolution2d_transpose(gen3, num_outputs=1, kernel_size=(100, 100), padding='SAME', biases_initializer=None, activation_fn=tf.nn.tanh, scope='g_out', weights_initializer=initializer) return g_out
def up_conv_block(input, output_dim, base_dim): block = slim.conv2d(input, base_dim, [1, 1]) block = slim.convolution2d_transpose(block, base_dim, [3, 3], stride=2) block = slim.conv2d(block, output_dim, [1, 1]) return block
def __call__(self, z, ys=None): if ys is None: z_concat = z else: z_concat = tf.concat([z, ys], axis=1) zP = slim.fully_connected( z_concat, 4*4*256, normalizer_fn=slim.batch_norm, activation_fn=tf.nn.relu,scope='g_project', weights_initializer=tf.truncated_normal_initializer(stddev=0.01)) zCon = tf.reshape(zP,[-1,4,4,256]) net = zCon with slim.arg_scope([slim.conv2d_transpose], weights_initializer=tf.truncated_normal_initializer(stddev=0.02), normalizer_fn=slim.batch_norm, activation_fn=self.g_activation_fn): for i, (g_unit, kernel_size, stride, padding) in enumerate(zip( self.g_conv_units, self.g_kernel_sizes, self.g_strides, self.g_paddings)): net = slim.conv2d_transpose(net, num_outputs=g_unit, kernel_size=kernel_size, stride=stride, padding=padding, scope='g_conv{0}'.format(i)) g_out = slim.convolution2d_transpose( net,num_outputs=self.x_ch, kernel_size=self.x_dims, padding="SAME", biases_initializer=None,activation_fn=tf.nn.tanh, scope='g_out', weights_initializer=tf.truncated_normal_initializer(stddev=0.02)) return g_out
def convolution2d_transpose(self, inputs, num_outputs, name, kernel_size=(3, 3), stride=2): output = slim.convolution2d_transpose(inputs, num_outputs, kernel_size=kernel_size, stride=stride, padding=DEFAULT_PADDING, scope=name) return output
def decoder(z): print('Decoder') input = slim.fully_connected(z, intermediate_dim, weights_initializer=intitializer, activation_fn=lrelu, scope='de_intermediate') print(input.shape) net = slim.fully_connected(input, 64 * 64 * 128, weights_initializer=intitializer, activation_fn=lrelu, scope='de_flat2') print(net.shape) net = tf.reshape(net, [1, 64, 64, 128]) print(net.shape) net = slim.convolution2d_transpose(net, 128, [3, 3], stride=[1, 1], weights_initializer=intitializer, activation_fn=lrelu, scope='de_deconv1') print(net.shape) net = slim.convolution2d_transpose(net, 64, [3, 3], stride=[2, 2], weights_initializer=intitializer, activation_fn=lrelu, scope='de_deconv2') print(net.shape) output = slim.convolution2d_transpose(net, 3, [3, 3], stride=[2, 2], weights_initializer=intitializer, activation_fn=tf.tanh, scope='de_output') print(output.shape) return output
def inference(image, dropout_keep_prob, num_classes=NUM_OF_CLASSES): print("setting up mobile initialized conv layers ...") mean = tf.constant(IMAGE_NET_MEAN) image -= mean net = mobile_net(image, num_classes=num_classes) with tf.variable_scope('inference',reuse=tf.AUTO_REUSE): net = slim.dropout(net, keep_prob=dropout_keep_prob, scope='Dropout') net = slim.conv2d(net, num_classes, [1, 1], activation_fn=None, normalizer_fn=None, scope='Conv2d_1x1') net = slim.convolution2d_transpose(net, num_classes, 64, 32) annotation_pred = tf.argmax(net, axis=3, name="prediction") return tf.expand_dims(annotation_pred, dim=3), net
def upsample(self, inp, poolhead, n_filters): print("inp=", inp.get_shape()) print("poolhead=", poolhead.get_shape()) conv = slim.convolution2d_transpose( inp, n_filters, 3, stride=2, activation_fn=self.activation, weights_initializer=self.initializer, weights_regularizer=self.regularizer, biases_initializer=self.initializer_b) print("transpose=", conv.get_shape()) conv = tf.concat([conv, poolhead], axis=-1) return conv
def generator(z, y, args): with tf.name_scope('generator'): with slim.arg_scope([slim.batch_norm], activation_fn=tf.nn.relu, is_training=(args.mode == 'train'), decay=0.9, epsilon=1e-5, scale=True): if args.dataset == 'stl10': with slim.arg_scope([slim.convolution2d_transpose], activation_fn=None, kernel_size=[5, 5], stride=2): G = slim.fully_connected(z, 8 * 4 * 4 *args.g_feature_dim, activation_fn=None, scope='generator_full1') G = tf.reshape(G, [-1, 4, 4, 8 * args.g_feature_dim]) G = slim.batch_norm(G, scope='generator_batchnorm1') G = slim.convolution2d_transpose(G, 4 * args.g_feature_dim, scope='generator_deconv1') G = slim.batch_norm(G, scope='generator_batchnorm2') G = slim.convolution2d_transpose(G, 2 * args.g_feature_dim, scope='generator_deconv2') G = slim.batch_norm(G, scope='generator_batchnorm3') G = slim.convolution2d_transpose(G, args.g_feature_dim, scope='generator_deconv3') G = slim.batch_norm(G, scope='generator_batchnorm4') G = slim.convolution2d_transpose(G, args.img_depth, activation_fn=tf.nn.tanh, scope='generator_deconv4') else: z = tf.concat(1, [z, y]) with slim.arg_scope([slim.convolution2d_transpose, slim.fully_connected], activation_fn=None): G = slim.fully_connected(z, 1024, scope='generator_full1') G = slim.batch_norm(G, scope='generator_batchnorm1') G = tf.concat(1, [G, y]) G = slim.fully_connected(G, (args.output_height / 4) * (args.output_width / 4) * 2 * args.g_feature_dim, scope='generator_full2') G = slim.batch_norm(G, scope='generator_batchnorm2') G = tf.reshape(G, [args.batch_size, args.output_height / 4, args.output_height / 4, 2 * args.g_feature_dim]) G = concatFeatureMap(G, tf.reshape(y, [args.batch_size, 1, 1, -1])) G = slim.convolution2d_transpose(G, 2 * args.g_feature_dim, kernel_size=[5, 5], stride=2, scope='generator_deconv1') G = slim.batch_norm(G, scope='generator_batchnorm3') G = concatFeatureMap(G, tf.reshape(y, [args.batch_size, 1, 1, -1])) G = slim.convolution2d_transpose(G, args.img_depth, activation_fn=tf.nn.tanh, kernel_size=[5, 5], stride=2, scope='generator_deconv2') return G
def model_fn(self, is_training=True, *args, **kwargs): batch_image = tf.placeholder(tf.float32, (ctx.params.batch_size, 512, 512, 3), name='image') batch_label = None if is_training: batch_label = tf.placeholder(tf.int32, (ctx.params.batch_size, 512, 512), name='label') # preprocess rgb_channels = tf.split(batch_image, 3, 3) rgb_channels[0] = rgb_channels[0] - 128.0 rgb_channels[1] = rgb_channels[1] - 128.0 rgb_channels[2] = rgb_channels[2] - 128.0 batch_image = tf.concat(rgb_channels, -1) # vgg 16 layers = ( 'conv1_1', 'relu1_1', 'conv1_2', 'relu1_2', 'pool1', 'conv2_1', 'relu2_1', 'conv2_2', 'relu2_2', 'pool2', 'conv3_1', 'relu3_1', 'conv3_2', 'relu3_2', 'conv3_3', 'relu3_3', 'pool3', 'conv4_1', 'relu4_1', 'conv4_2', 'relu4_2', 'conv4_3', 'relu4_3', 'pool4', 'conv5_1', 'relu5_1', 'conv5_2', 'relu5_2', 'conv5_3', 'relu5_3', 'pool5', ) net = batch_image net_collection = {} with slim.arg_scope( [slim.conv2d], weights_regularizer=slim.l2_regularizer(0.0001), normalizer_fn=None, activation_fn=None, weights_initializer=slim.variance_scaling_initializer()): for i, name in enumerate(layers): kind = name[:4] if kind == 'conv': block_i = int(name[4]) output_channels = block_i * 64 if block_i < 5 else 512 net = slim.conv2d(net, output_channels, [3, 3], stride=[1, 1], padding='SAME') net_collection[name] = net elif kind == 'relu': net = tf.nn.relu(net) net_collection[name] = net elif kind == 'pool': net = slim.avg_pool2d(net, 2, stride=2, padding='SAME') net_collection[name] = net pool5_output = net_collection['pool5'] # fully conv conv6 = slim.conv2d(pool5_output, 4096, [7, 7], stride=[1, 1], padding='SAME') relu6 = tf.nn.relu(conv6) relu6 = slim.dropout(relu6, 0.5) conv7 = slim.conv2d(relu6, 4096, [1, 1], stride=[1, 1], padding='SAME') relu7 = tf.nn.relu(conv7) relu7 = slim.dropout(relu7) # FCN32S score_32 = slim.conv2d(relu7, ctx.params.class_num, [1, 1], stride=[1, 1], padding='SAME') score_32_up = slim.convolution2d_transpose(score_32, ctx.params.class_num, [4, 4], [2, 2]) # FCN16S pool4_output = slim.conv2d(net_collection['pool4'], ctx.params.class_num, [1, 1], stride=[1, 1], padding='SAME') score_16 = score_32_up + pool4_output score_16_up = slim.convolution2d_transpose(score_16, ctx.params.class_num, [4, 4], [2, 2]) # FCN8S pool3_output = slim.conv2d(net_collection['pool3'], ctx.params.class_num, [1, 1], stride=[1, 1], padding='SAME') score_8 = score_16_up + pool3_output score_8_up = slim.convolution2d_transpose(score_8, ctx.params.class_num, [4, 4], [2, 2]) if is_training: one_hot_batch_label = tf.one_hot(batch_label, ctx.params.class_num) one_hot_batch_label = tf.image.resize_bilinear( one_hot_batch_label, [128, 128]) # cross entropy fcn8_loss = tf.losses.softmax_cross_entropy( one_hot_batch_label, score_8_up) return fcn8_loss else: logits = tf.nn.softmax(score_8_up) return logits
def osvos(inputs, scope='osvos'): """Defines the OSVOS network Args: inputs: Tensorflow placeholder that contains the input image scope: Scope name for the network Returns: net: Output Tensor of the network end_points: Dictionary with all Tensors of the network """ im_size = tf.shape(inputs) with tf.variable_scope(scope, 'osvos', [inputs]) as sc: end_points_collection = sc.name + '_end_points' # Collect outputs of all intermediate layers. with slim.arg_scope([slim.conv2d, slim.max_pool2d], padding='SAME', outputs_collections=end_points_collection): net = slim.repeat(inputs, 2, slim.conv2d, 64, [3, 3], scope='conv1') net = slim.max_pool2d(net, [2, 2], scope='pool1') net_2 = slim.repeat(net, 2, slim.conv2d, 128, [3, 3], scope='conv2') net = slim.max_pool2d(net_2, [2, 2], scope='pool2') net_3 = slim.repeat(net, 3, slim.conv2d, 256, [3, 3], scope='conv3') net = slim.max_pool2d(net_3, [2, 2], scope='pool3') net_4 = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv4') net = slim.max_pool2d(net_4, [2, 2], scope='pool4') net_5 = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv5') # Get side outputs of the network with slim.arg_scope([slim.conv2d], activation_fn=None): side_2 = slim.conv2d(net_2, 16, [3, 3], scope='conv2_2_16') side_3 = slim.conv2d(net_3, 16, [3, 3], scope='conv3_3_16') side_4 = slim.conv2d(net_4, 16, [3, 3], scope='conv4_3_16') side_5 = slim.conv2d(net_5, 16, [3, 3], scope='conv5_3_16') # Supervise side outputs side_2_s = slim.conv2d(side_2, 1, [1, 1], scope='score-dsn_2') side_3_s = slim.conv2d(side_3, 1, [1, 1], scope='score-dsn_3') side_4_s = slim.conv2d(side_4, 1, [1, 1], scope='score-dsn_4') side_5_s = slim.conv2d(side_5, 1, [1, 1], scope='score-dsn_5') with slim.arg_scope([slim.convolution2d_transpose], activation_fn=None, biases_initializer=None, padding='VALID', outputs_collections=end_points_collection, trainable=False): # Side outputs side_2_s = slim.convolution2d_transpose( side_2_s, 1, 4, 2, scope='score-dsn_2-up') side_2_s = crop_features(side_2_s, im_size) utils.collect_named_outputs(end_points_collection, 'osvos/score-dsn_2-cr', side_2_s) side_3_s = slim.convolution2d_transpose( side_3_s, 1, 8, 4, scope='score-dsn_3-up') side_3_s = crop_features(side_3_s, im_size) utils.collect_named_outputs(end_points_collection, 'osvos/score-dsn_3-cr', side_3_s) side_4_s = slim.convolution2d_transpose( side_4_s, 1, 16, 8, scope='score-dsn_4-up') side_4_s = crop_features(side_4_s, im_size) utils.collect_named_outputs(end_points_collection, 'osvos/score-dsn_4-cr', side_4_s) side_5_s = slim.convolution2d_transpose( side_5_s, 1, 32, 16, scope='score-dsn_5-up') side_5_s = crop_features(side_5_s, im_size) utils.collect_named_outputs(end_points_collection, 'osvos/score-dsn_5-cr', side_5_s) # Main output side_2_f = slim.convolution2d_transpose( side_2, 16, 4, 2, scope='score-multi2-up') side_2_f = crop_features(side_2_f, im_size) utils.collect_named_outputs(end_points_collection, 'osvos/side-multi2-cr', side_2_f) side_3_f = slim.convolution2d_transpose( side_3, 16, 8, 4, scope='score-multi3-up') side_3_f = crop_features(side_3_f, im_size) utils.collect_named_outputs(end_points_collection, 'osvos/side-multi3-cr', side_3_f) side_4_f = slim.convolution2d_transpose( side_4, 16, 16, 8, scope='score-multi4-up') side_4_f = crop_features(side_4_f, im_size) utils.collect_named_outputs(end_points_collection, 'osvos/side-multi4-cr', side_4_f) side_5_f = slim.convolution2d_transpose( side_5, 16, 32, 16, scope='score-multi5-up') side_5_f = crop_features(side_5_f, im_size) utils.collect_named_outputs(end_points_collection, 'osvos/side-multi5-cr', side_5_f) concat_side = tf.concat( [side_2_f, side_3_f, side_4_f, side_5_f], axis=3) net = slim.conv2d(concat_side, 1, [1, 1], scope='upscore-fuse') end_points = slim.utils.convert_collection_to_dict( end_points_collection) return net, end_points pass
def model_fn(self, is_training=True, *args, **kwargs): # write your own model code # for tensorflow # step 1: unwarp data batch_data = None batch_label = None origianl_img = None shape = None if len(args) > 0: # for method 2 and method 3 # on train or test stage, unwarp data from args (which comes from model_input()) if is_training: batch_data, batch_label = args[0].dequeue() else: batch_data, shape, origianl_img = args[0] else: # for method 1 # use placeholder batch_data = tf.placeholder(tf.float32, shape=[ ctx.params.batch_size, ctx.params.input_size, ctx.params.input_size, 3 ], name='data_node') if not is_training: batch_label = tf.placeholder(tf.int32, shape=[ ctx.params.batch_size, ctx.params.input_size, ctx.params.input_size ], name='label_node') # step 2: building model # 使用VGG16作为基础网络 with slim.arg_scope(vgg.vgg_arg_scope()): net, end_points = vgg.vgg_16(batch_data, None, is_training) # 抽取pool5, pool4, pool3 中间层 vgg_pool5 = end_points['vgg_16/pool5'] vgg_pool4 = end_points['vgg_16/pool4'] vgg_pool3 = end_points['vgg_16/pool3'] with tf.variable_scope(None, 'FCN', [vgg_pool5, vgg_pool4, vgg_pool3]): conv6 = slim.conv2d(vgg_pool5, 4096, [7, 7], padding='SAME', activation_fn=tf.nn.relu) conv7 = slim.conv2d(conv6, 4096, [1, 1], padding='SAME', activation_fn=tf.nn.relu) conv7_dropout = slim.dropout(conv7, is_training=is_training) # FCN32S # 使用最后一层(分辨率16x16)进行语义类别预测 score_32 = slim.conv2d(conv7_dropout, ctx.params.class_num, [1, 1], padding='SAME') score_32_up = slim.convolution2d_transpose( score_32, vgg_pool4.get_shape()[-1], [4, 4], [2, 2]) # FCN16S # 结合来自pool4的特征图(分辨率32x32)进行进一步语义类别预测 score_16 = score_32_up + vgg_pool4 score_16_up = slim.convolution2d_transpose( score_16, vgg_pool3.get_shape()[-1], [4, 4], [2, 2]) # FCN8S # 集合来自pool3的特征图(分辨率64x64)进行进一步语义类别预测 score_8 = score_16_up + vgg_pool3 score_8_up = slim.convolution2d_transpose(score_8, ctx.params.class_num, [16, 16], [8, 8], activation_fn=None) if is_training: one_hot_batch_label = tf.one_hot(batch_label, ctx.params.class_num) # cross entropy fcn8_loss = tf.losses.softmax_cross_entropy( one_hot_batch_label, score_8_up) return fcn8_loss else: logits = tf.nn.softmax(score_8_up) logits = tf.image.resize_images(logits, (shape[0], shape[1])) return logits, origianl_img
name="x") y = tf.placeholder(tf.float32, shape=(mb_size, n_classes), name="y") z = tf.placeholder(tf.float32, shape=(mb_size, n_inputs_G), name="z") with tf.variable_scope("G_net"): input_G = slim.fully_connected(z, 2 * 2 * 256, normalizer_fn=slim.batch_norm, activation_fn=tf.identity, scope='input_G') input_G = tf.reshape(input_G, [mb_size, 2, 2, 256]) conv1 = slim.convolution2d_transpose(input_G, 256, 3, stride=2, normalizer_fn=slim.batch_norm, activation_fn=tf.identity, scope='g_conv1') conv1 = tf.nn.relu(conv1) conv2 = slim.convolution2d_transpose(conv1, 256, 3, stride=1, normalizer_fn=slim.batch_norm, activation_fn=tf.identity, scope='g_conv2') conv2 = tf.nn.relu(conv2) conv3 = slim.convolution2d_transpose(conv2,
def generator(self, z): # project z z_filter_number = self.g_filter_number * 8 z_projection_size = self.image_size // 8 z_projected = slim.fully_connected( z, z_projection_size * z_projection_size * z_filter_number, activation_fn=tf.nn.relu, normalizer_fn=slim.batch_norm, weights_initializer=self._initialzier, scope='g_projection', ) z_reshaped = tf.reshape( z_projected, [-1, z_projection_size, z_projection_size, z_filter_number]) # transposed conv1 g_conv1_filter_number = z_filter_number // 2 g_conv1 = slim.convolution2d_transpose( z_reshaped, num_outputs=g_conv1_filter_number, kernel_size=[self.g_filter_size, self.g_filter_size], stride=[2, 2], padding='SAME', activation_fn=tf.nn.relu, normalizer_fn=slim.batch_norm, weights_initializer=self._initialzier, scope='g_conv1', ) # transposed conv2 g_conv2_filter_number = g_conv1_filter_number // 2 g_conv2 = slim.convolution2d_transpose( g_conv1, num_outputs=g_conv2_filter_number, kernel_size=[self.g_filter_size, self.g_filter_size], stride=[2, 2], padding='SAME', activation_fn=tf.nn.relu, normalizer_fn=slim.batch_norm, weights_initializer=self._initialzier, scope='g_conv2', ) # transposed conv3 g_conv3_filter_number = g_conv2_filter_number // 2 g_conv3 = slim.convolution2d_transpose( g_conv2, num_outputs=g_conv3_filter_number, kernel_size=[self.g_filter_size, self.g_filter_size], stride=[2, 2], padding='SAME', activation_fn=tf.nn.relu, normalizer_fn=slim.batch_norm, weights_initializer=self._initialzier, scope='g_conv3', ) # out g_out = slim.convolution2d_transpose( g_conv3, num_outputs=self.channel_size, kernel_size=[self.image_size, self.image_size], padding='SAME', biases_initializer=None, activation_fn=tf.nn.tanh, weights_initializer=self._initialzier, scope='g_out') return g_out
with tf.variable_scope("G_net"): # 1st Concatenate input_G = tf.concat([z, y], axis=1) # 1st hidden layer hidden1_G = slim.fully_connected(input_G, 8 * 8 * 128, normalizer_fn=slim.batch_norm, activation_fn=tf.nn.relu, scope='hidden1') hidden1_G_reshape = tf.reshape(hidden1_G, shape=[mb_size, 8, 8, 128]) # 2nd hidden layer hidden2_G = slim.convolution2d_transpose(hidden1_G_reshape, 128, 5, stride=2, normalizer_fn=slim.batch_norm, activation_fn=tf.nn.relu, scope='hidden2') # Output layer G = slim.convolution2d_transpose(hidden2_G, 3, 5, stride=2, activation_fn=tf.nn.tanh, scope='output') # Creating samples from Generator: ------------------------------------------------------- saver = tf.train.Saver()
def generator(z, is_train=True, reuse=True): initializer = tf.truncated_normal_initializer(stddev=0.02) with tf.variable_scope('generator') as scope: # z = slim.fully_connected(z, 4 * 4 * 512, normalizer_fn=slim.batch_norm, activation_fn=tf.nn.relu, reuse=reuse, # scope='g_project', weights_initializer=initializer) z = tf.reshape(z, [-1, 32, 32, 4]) z = slim.convolution2d(z, num_outputs=32, kernel_size=[3, 3], stride=[1, 1], padding='same', normalizer_fn=slim.batch_norm, trainable=is_train, reuse=reuse, activation_fn=tf.nn.relu, scope='g_conv1', weights_initializer=initializer) # z: [32, 32] z = slim.convolution2d(z, num_outputs=64, kernel_size=[3, 3], stride=[2, 2], padding='same', normalizer_fn=slim.batch_norm, trainable=is_train, reuse=reuse, activation_fn=tf.nn.relu, scope='g_conv2', weights_initializer=initializer) # z: [16, 16] z = slim.convolution2d(z, num_outputs=128, kernel_size=[3, 3], stride=[1, 1], padding='same', normalizer_fn=slim.batch_norm, trainable=is_train, reuse=reuse, activation_fn=tf.nn.relu, scope='g_conv3', weights_initializer=initializer) # z: [16, 16] z = slim.convolution2d(z, num_outputs=256, kernel_size=[3, 3], stride=[2, 2], padding='same', normalizer_fn=slim.batch_norm, trainable=is_train, reuse=reuse, activation_fn=tf.nn.relu, scope='g_conv4', weights_initializer=initializer) # z: [8, 8] z = slim.convolution2d(z, num_outputs=512, kernel_size=[3, 3], stride=[2, 2], padding='same', normalizer_fn=slim.batch_norm, trainable=is_train, reuse=reuse, activation_fn=tf.nn.relu, scope='g_conv5', weights_initializer=initializer) # z: [4, 4] z = slim.convolution2d_transpose(z, num_outputs=256, kernel_size=[3, 3], stride=[2, 2], padding="same", normalizer_fn=slim.batch_norm, trainable=is_train, reuse=reuse, activation_fn=tf.nn.relu, scope='g_trans_conv1', weights_initializer=initializer) # z: [8, 8] z = slim.convolution2d_transpose(z, num_outputs=128, kernel_size=[3, 3], stride=[2, 2], padding="same", normalizer_fn=slim.batch_norm, trainable=is_train, reuse=reuse, activation_fn=tf.nn.relu, scope='g_trans_conv2', weights_initializer=initializer) # z: [16, 16] z = slim.convolution2d_transpose(z, num_outputs=64, kernel_size=[3, 3], stride=[2, 2], padding="same", normalizer_fn=slim.batch_norm, trainable=is_train, reuse=reuse, activation_fn=tf.nn.relu, scope='g_trans_conv3', weights_initializer=initializer) # z: [32, 32] z = slim.convolution2d_transpose(z, num_outputs=3, kernel_size=[3, 3], stride=[2, 2], padding="same", reuse=reuse, biases_initializer=None, activation_fn=tf.nn.tanh, trainable=is_train, scope='g_out', weights_initializer=initializer) # z: [64, 64] return z