def resnet_without_bottleneck(self, input, is_training,layer_from_2=[2,2,2,2],first_kernel=7,first_stride=2,first_pool=True,stride=2): input_shape = input.get_shape().as_list()[1:] conv=ops.conv2d(input,'initial_conv',[first_kernel,first_kernel,input_shape[2],64],[1,first_stride,first_stride,1]) if first_pool: conv=ops.max_pool(conv, [1, 3, 3, 1], [1, 2, 2, 1]) for i in range(layer_from_2[0]): conv=ops.residual_block(conv,'Block_1_'+str(i),is_training,64,kernel=3,first_block=True,stride=stride) for i in range(layer_from_2[1]): conv=ops.residual_block(conv,'Block_2_'+str(i),is_training,128,kernel=3,first_block=True,stride=stride) for i in range(layer_from_2[2]): conv=ops.residual_block(conv,'Block_3_'+str(i),is_training,256,kernel=3,first_block=True,stride=stride) for i in range(layer_from_2[3]): conv=ops.residual_block(conv,'Block_4_'+str(i),is_training,512,kernel=3,first_block=True,stride=stride) with tf.variable_scope('unit'): conv = ops.batch_normalization(conv,is_training) conv = tf.nn.relu(conv) conv = ops.global_avg_pool(conv) conv =ops.flatten(conv) with tf.variable_scope('logit'): conv = ops.get_hidden_layer(conv,'output_layer',self.no_of_classes,'none') return conv
def ResNet(image, is_train, num_classes=10, reuse=False, name='ResNet-cifar'): channel_list = [16, 32, 64] with tf.variable_scope(name): if reuse: tf.get_variable_scope().reuse_variables() else: assert tf.get_variable_scope().reuse is False Res_Block_0 = tf.nn.relu(batch_norm_layer(conv(image, 16, 3, 'Block_0/res_conv_0', s=1, use_bias=False), is_train)) Res_Block_1 = residual_block(Res_Block_0, channel_list[0], False, is_train, 'Block_1') Res_Block_2 = residual_block(Res_Block_1, channel_list[1], True, is_train, 'Block_2') Res_Block_3 = residual_block(Res_Block_2, channel_list[2], True, is_train, 'Block_3') ave_vec = tf.reshape(tf.nn.avg_pool(Res_Block_3, [1, 8, 8, 1], [1, 1, 1, 1], 'VALID'), [-1, channel_list[2]]) logits = tf.layers.dense(ave_vec, num_classes, kernel_initializer=tf.truncated_normal_initializer(stddev=0.01), kernel_regularizer=tf.contrib.layers.l2_regularizer(0.0001), name='logits') embed = logits return logits, embed
def _create_mover(self, x, reuse=False, train=True, name="mover"): with tf.variable_scope(name) as scope: if reuse: scope.reuse_variables() normalizer = partial(batch_norm, is_training=train) # residual blocks resamples = ["down"] * (self.num_mov_layers // 2) + ["up"] * (self.num_mov_layers // 2) h = x for i in range(len(resamples)): h = residual_block(h, k=3, s=2, stddev=0.02, atv_input=i > 0, bn_input=i > 0, resample=resamples[i], output_dim=self.num_gen_feature_maps, bn=normalizer, activation_fn=tf.nn.relu, name="m_block{}".format(i)) h = normalizer(h, scope="m_preout.bn") h = tf.nn.relu(h, name="m_preout.relu") h = tf.layers.conv2d(h, filters=3, kernel_size=3, strides=1, name="m_out.lin", padding="SAME") m_out = tf.nn.tanh(h, name="m_out.tanh") return m_out
def _create_critic(self, x, reuse=False, train=True, name="critic"): with tf.variable_scope(name) as scope: if reuse: scope.reuse_variables() normalizer = partial(batch_norm, is_training=train) # residual blocks resamples = ["down", "down", None, None] h = x for i in range(4): h = residual_block(h, k=3, s=2, stddev=0.02, atv_input=i > 0, bn_input=i > 0, resample=resamples[i], output_dim=self.num_cri_feature_maps, bn=normalizer, activation_fn=tf.nn.relu, name="c_block{}".format(i)) # mean pool layer h = normalizer(h, scope="c_mean_pool.bn") h = tf.nn.relu(h, name="c_mean_pool.relu") h = tf.reduce_mean(h, axis=[1, 2], name="c_mean_pool") # output layer c_out = linear(h, 1, scope='c_out.lin') c_out = self.critic_atv(c_out, name="c_out.atv") return c_out
def residual(inputs, reuse=None, scope=None, num_channels=1): net = inputs with tf.variable_scope(scope or "model", reuse=reuse) as scp: end_pts_collection = scp.name+"end_pts" with slim.arg_scope([slim.conv2d], outputs_collections=end_pts_collection): net = slim.conv2d(net, 64, [3, 3], normalizer_fn=None, normalizer_params=None, scope="preconv1") for i in range(10): net = ops.residual_block(net, 64, scope="unit{}".format(i+1)) net = slim.batch_norm(net, activation_fn=tf.nn.relu, scope="postact") net = slim.conv2d(net, 64, [3, 3], scope="postconv1") net = slim.conv2d(net, 64, [3, 3], scope="postconv2") net = slim.conv2d(net, 64, [3, 3], scope="postconv3") net = slim.conv2d(net, num_channels, [3, 3], activation_fn=tf.nn.tanh, normalizer_fn=None, normalizer_params=None, scope="logit") end_pts = slim.utils.convert_collection_to_dict(end_pts_collection) dn = inputs - net return dn, net, end_pts
def wavenet_prior(net, is_training): from ops import causal_conv, gated_cnn, residual_block import json with open('wavenet.json') as file: wavenet_parameters = json.load(file) net = causal_conv(net, **wavenet_parameters['preprocess']) skip_outputs = [] num_layers = len(wavenet_parameters['dilation_rates']) print('num_layers:', num_layers) print('net_0:', net.shape) for i in range(num_layers): layer_id = 'layer_%d' % (i + 1) conv_args = wavenet_parameters['residual_stack'] conv_args['dilation_rate'] = wavenet_parameters['dilation_rates'][i] net = tf.keras.layers.BatchNormalization()(net) skip, net = residual_block(net, **conv_args) print('net_%d:' % (i + 1), net.shape, ' dr: %d' % conv_args['dilation_rate']) skip_outputs.append(skip) net = tf.keras.layers.Dropout(0.5)(net, training=is_training) net = sum(skip_outputs) net = tf.keras.activations.relu(net) net = causal_conv(net, **wavenet_parameters['postprocess1']) print('net:', net.shape) net = causal_conv(net, **wavenet_parameters['postprocess2']) print('net:', net.shape) shape = net.shape net = tf.reshape(net, [-1, shape[1] * shape[2]]) return net
def generator_128(input, scope_name, reuse=False, skip=False): """ Funtion to build the generator of a GAN. Parameters: """ with tf.variable_scope(scope_name, reuse=reuse): c7s1_32 = ops.conv_instn_relu(input, [7, 7, 3, 32], 'c7s1-32', 1, padding="REFLECT") d64 = ops.conv_instn_relu(c7s1_32, [3, 3, 32, 64], 'd64', 2, padding="SAME") d128 = ops.conv_instn_relu(d64, [3, 3, 64, 128], 'd128', 2, padding="SAME") r128_1 = ops.residual_block(d128, [3, 3, 128, 128], 'r128_1', padding="REFLECT") r128_2 = ops.residual_block(r128_1, [3, 3, 128, 128], 'r128_2', padding="REFLECT") r128_3 = ops.residual_block(r128_2, [3, 3, 128, 128], 'r128_3', padding="REFLECT") r128_4 = ops.residual_block(r128_3, [3, 3, 128, 128], 'r128_4', padding="REFLECT") r128_5 = ops.residual_block(r128_4, [3, 3, 128, 128], 'r128_5', padding="REFLECT") r128_6 = ops.residual_block(r128_5, [3, 3, 128, 128], 'r128_6', padding="REFLECT") u64 = ops.convt_instn_relu(r128_6, [3, 3, 64, 128], tf.shape(d64), 'u64', 2, padding="SAME") u64.set_shape(d64.get_shape().as_list()) u32 = ops.convt_instn_relu(u64, [3, 3, 32, 64], tf.shape(c7s1_32), 'u32', 2, padding="SAME") u32.set_shape(c7s1_32.get_shape().as_list()) c7s1_3 = ops.conv2d(u32, [7, 7, 32, 3], 'c7s1-3', 1, padding="REFLECT") if skip: return tf.nn.tanh(c7s1_3 + input, "output") else: return tf.nn.tanh(c7s1_3, "output")
def generator(img, attr, size): concat = Concatenate()([img, Lambda(tileAttr)(attr)]) DownSample = functools.partial(Conv2D, padding="same", kernel_initializer=init_weight, kernel_regularizer=orthogonal) UpSample = functools.partial(Conv2DTranspose, padding="same", kernel_initializer=init_weight, kernel_regularizer=orthogonal) conv_in = DownSample(64, 7, name="conv_in_conv")(concat) conv_in = SwitchNormalization(axis=-1, name="conv_in_norm")(conv_in) conv_in = Activation('relu', name="conv_in_relu")(conv_in) down1 = DownSample(128, 4, strides=2, name="down1_conv")(conv_in) down1 = SwitchNormalization(axis=-1, name="down1_norm")(down1) down1 = Activation('relu', name="down1_relu")(down1) down2 = DownSample(256, 4, strides=2, name="down2_conv")(down1) down2 = SwitchNormalization(axis=-1, name="down2_norm")(down2) down2 = Activation('relu', name="down2_relu")(down2) resb = residual_block(down2, 256, 3, res_init_weight, 'block1') resb = residual_block(resb, 256, 3, res_init_weight, 'block2') resb = residual_block(resb, 256, 3, res_init_weight, 'block3') encode_out = resb resb = residual_block(resb, 256, 3, res_init_weight, 'block4') resb = residual_block(resb, 256, 3, res_init_weight, 'block5') resb = residual_block(resb, 256, 3, res_init_weight, 'block6') up2 = UpSample(128, 4, strides=2, name="up2_deconv2")(resb) up2 = SwitchNormalization(axis=-1, name="up2_norm")(up2) up2 = Activation('relu', name="up2_relu")(up2) brid2 = up2 up1 = UpSample(64, 4, strides=2, name="up1_deconv2")(brid2) up1 = SwitchNormalization(axis=-1, name="up1_norm")(up1) up1 = Activation('relu', name="up1_relu")(up1) brid3 = up1 conv_out = DownSample(3, 7, name="conv_out_conv")(brid3) conv_out = Activation('tanh', name="conv_out_tanh")(conv_out) return conv_out, encode_out
def __call__(self, input_op): # 改回了魔术方法的实现,更加简洁 with tf.variable_scope(self.name): conv1 = ops.conv_block(input_op, 32, 'conv1', 7, 1, self.is_train, self.reuse, self.norm, self.activation, pad='REFLECT') conv2 = ops.conv_block(conv1, 64, 'conv2', 3, 2, self.is_train, self.reuse, self.norm, self.activation) res = ops.conv_block(conv2, 128, 'conv3', 3, 2, self.is_train, self.reuse, self.norm, self.activation) for i in range(self.block_size): res = ops.residual_block(res, 128, 'res' + str(i), self.is_train, self.reuse, self.norm) deconv1 = ops.deconv_block(res, 64, 'deconv1', 3, 2, self.is_train, self.reuse, self.norm, self.activation) deconv2 = ops.deconv_block(deconv1, 32, 'deconv2', 3, 2, self.is_train, self.reuse, self.norm, self.activation) self.gen = ops.conv_block(deconv2, 3, 'conv_end', 7, 1, self.is_train, self.reuse, norm=None, activation=tf.nn.tanh, pad='REFLECT') self.reuse = True self.var_list = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, self.name)
def _create_generator(self, z, train=True, reuse=False, name="generator"): with tf.variable_scope(name) as scope: if reuse: scope.reuse_variables() normalizer = partial(batch_norm, is_training=train) # project to the first layer h = linear(z, 4 * 4 * self.num_gen_feature_maps, scope="g_h0.linear") h = tf.reshape(h, [self.batch_size, 4, 4, self.num_gen_feature_maps]) if self.img_size[0] == 32: num_res_blocks = 3 elif self.img_size[0] == 64: num_res_blocks = 4 for i in range(num_res_blocks): h = residual_block(h, k=3, s=2, stddev=0.02, resample="up", output_dim=self.num_gen_feature_maps, bn=normalizer, activation_fn=tf.nn.relu, name="g_block{}".format(i)) h = normalizer(h, scope="g_preout.bn") h = tf.nn.relu(h, name="g_preout.relu") h = tf.layers.conv2d(h, filters=3, kernel_size=3, strides=1, name="g_out.lin", padding="SAME") g_out = tf.nn.tanh(h, name="g_out.tanh") return g_out
def __init__(self, data_loader, layers=(16, 32, 64), residual_layers=(5, 5, 5), data_augmentation=True, non_core_layers=(1, 1, 1), learning_rate=0.01, batch_size=128, zero_init=False): """ :param layers: tuple that has the depth dimension vector """ assert (len(layers) == len(residual_layers)) m_data, labels, self.valid_data, self.valid_labels = data_loader.get_data() self.q = DataQueue(m_data, labels, batch_size, capacity=200, threads=32, data_aug=data_augmentation) self.q.start() n, y_dim, x_dim, channel = m_data.shape y_dim = x_dim = 32 self.batch_size = batch_size self.batch_len_in_epoch = int(math.ceil(n / self.batch_size)) - 1 self.layers = layers self.residual_layers_between = residual_layers self.x = tf.placeholder(tf.float32, shape=(batch_size, y_dim, x_dim, channel)) self.y = tf.placeholder(tf.int32, shape=(batch_size,)) self.phase = tf.placeholder(tf.bool, name='phase') self.global_step = tf.Variable(0, trainable=False, name='global_step') self.learning_rate = tf.Variable(learning_rate, trainable=False, dtype=tf.float32, name='learning_rate') self.decrease_learning_rate = tf.assign(self.learning_rate, tf.multiply(self.learning_rate, 0.1)) # Layers conv_layer = None for i, depth in enumerate(layers): if conv_layer is None: conv_layer = residual_block(self.x, depth, block_num=str(depth), first_block=True, core=True, is_training=self.phase) else: conv_layer = residual_block(conv_layer, depth, block_num=str(depth), first_block=False, core=True, is_training=self.phase) assert (conv_layer.get_shape()[-1] == depth) for k in range(residual_layers[i]): if k > residual_layers[i] - non_core_layers[i]: # non-core layer conv_layer = residual_block(conv_layer, depth, block_num=str(depth) + '_' + str(k), zero_init=zero_init, is_training=self.phase) else: conv_layer = residual_block(conv_layer, depth, block_num=str(depth) + '_' + str(k), core=True, zero_init=False, is_training=self.phase) assert (conv_layer.get_shape()[-1] == depth) self.update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) pool_layer = tf.reduce_mean(conv_layer, [1, 2]) self.logits = tf.layers.dense(tf.reshape(pool_layer, [batch_size, -1]), 10) self.prediction = tf.argmax(self.logits, 1) trainable_vars = tf.trainable_variables() core_var_list = [v for v in trainable_vars if 'core' in v.name] loss_l2 = tf.add_n([tf.nn.l2_loss(v) for v in trainable_vars if 'bn' not in v.name]) / 2 * 0.0001 self.loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits( logits=self.logits, labels=self.y)) + loss_l2 prediction = tf.equal(tf.argmax(self.logits, 1), tf.cast(self.y, tf.int64)) self.accuracy = tf.reduce_mean(tf.cast(prediction, tf.float32)) with tf.control_dependencies(self.update_ops): with tf.name_scope('train'): self.optimizer = tf.train.AdagradOptimizer(learning_rate=self.learning_rate) self.train_op = self.optimizer.minimize(loss=self.loss, global_step=self.global_step) # train core only self.train_core_op = self.optimizer.minimize(loss=self.loss, var_list=core_var_list, global_step=self.global_step) self.saver = tf.train.Saver(max_to_keep=10)
def convResnet(x, is_training, aux=None, reuse=None, scope='dn_net', ngf=32, n_blocks=2, n_down=2, learn_residual=True): with tf.variable_scope(scope, reuse=reuse) as scp: end_pts_collection = scp.name + 'end_pts' weight_collection = scp.name + 'weight' with slim.arg_scope([slim.conv2d, slim.conv2d_transpose], activation_fn=tf.nn.leaky_relu, normalizer_fn=None, weights_regularizer=slim.l2_regularizer(0.05), variables_collections=[weight_collection], outputs_collections=end_pts_collection): scale_skips = [] cat_axis = 3 # NHWC if aux is None: cnv = slim.conv2d(x, ngf, [3, 3], scope='cnv0') else: cnv0_d = slim.conv2d(x, ngf // 2, [3, 3], stride=2, scope='cnv0_d') cnv0_c = slim.conv2d(resize_like(aux, cnv0_d), ngf // 2, [1, 1], stride=1, scope='cnv0_c') cnv = tf.concat([cnv1_d, cnv0_c], axis=3) scale_skips.append(cnv) mult = 1 for i in range(n_down): mult *= 2 cnv = slim.conv2d(cnv, ngf * mult, [3, 3], stride=2, scope='cnv_down{}'.format(i)) scale_skips.append(cnv) for i in range(n_blocks): cnv = ops.residual_block(cnv, ngf * mult, norm_fn=None, scope='res{}'.format(i)) for i in range(n_down): mult /= 2 cnv = tf.concat([scale_skips[-1], cnv], cat_axis, name='cat{}'.format(i + 1)) scale_skips.pop() cnv = slim.conv2d_transpose(cnv, ngf * mult, [3, 3], stride=2, scope='cnv_up{}'.format(i)) cnv = tf.concat([scale_skips[0], cnv], cat_axis, name='cat_final') assert len(scale_skips) == 1 del scale_skips cnv = slim.conv2d(cnv, 1, [3, 3], activation_fn=tf.nn.tanh, normalizer_fn=None, scope='cnv_final') if learn_residual: out = x + cnv out = tf.clip_by_value(out, -1, 1) else: out = cnv # if cnv_final act is tanh # out = tf.clip_by_value(cnv, -1, 1) # if cnv_final act is None end_pts = slim.utils.convert_collection_to_dict(end_pts_collection) weight_vars = tf.get_collection(weight_collection) return out, end_pts, weight_vars
def C(img, scope='Classifier', reuse=False): with tf.variable_scope(scope) as scope: log.warn(scope.name) _ = img # MNIST, Fashion MNIST, SVHN, CIFAR if not self.config.dataset == 'ImageNet': # conv layers num_channels = [64, 128, 256, 512] for i in range(len(num_channels)): _ = conv2d(_, num_channels[i], is_train, norm_type=self.norm_type, info=not reuse, name='conv_{}'.format(i)) _ = slim.dropout(_, keep_prob=0.5, is_training=is_train) # fc layers _ = tf.reshape(_, [self.batch_size, -1]) num_fc_channels = [512, 128, 32, n] for i in range(len(num_fc_channels)): _ = fc(_, num_fc_channels[i], is_train, norm_type='none', info=not reuse, name='fc_{}'.format(i)) # ImageNet else: # conv layers num_channels = [64, 128, 256, 512, 1024] num_residual_block = [0, 2, 3, 5, 2] for i in range(len(num_channels)): _ = conv2d(_, num_channels[i], is_train, norm_type=self.norm_type, info=not reuse, name='conv_{}'.format(i)) for j in range(num_residual_block[i]): _ = residual_block(_, num_channels[i], is_train, norm_type=self.norm_type, info=not reuse, name='residual_{}_{}'.format( i, j)) _ = tf.layers.average_pooling2d(_, [7, 7], [7, 7]) log.info('{} {}'.format(_.name, _.get_shape().as_list())) # fc layers _ = tf.reshape(_, [self.batch_size, -1]) num_fc_channels = [n] for i in range(len(num_fc_channels)): _ = fc(_, num_fc_channels[i], is_train, norm_type='none', info=not reuse, name='fc_{}'.format(i)) return _
def Joint_Decoder(pixel_input, flow_input, input_image, scope='Joint_Decoder', reuse=False): with tf.variable_scope(scope, reuse=reuse) as scope: if not reuse: log.warn(scope.name) assert pixel_input[-1].get_shape() == flow_input[-1].get_shape( ) _p = pixel_input[-1] _f = flow_input[-1] with tf.variable_scope('Pixel'): # Res blocks ch = int(_p.get_shape()[-1]) for i in range(int(num_res_block_pixel)): _p = residual_block(_p, ch, is_train, info=not reuse, norm=self.norm_type, name='pixel_R{}_{}'.format(ch, i)) with tf.variable_scope('Flow'): # Res blocks ch = int(_f.get_shape()[-1]) for i in range(int(num_res_block_flow)): _f = residual_block(_f, ch, is_train, info=not reuse, norm=self.norm_type, name='flow_R{}_{}'.format(ch, i)) # Deconv pixel_output = None flow_output = None pixel_output_list = [] flow_output_list = [] x_list = [] y_list = [] pixel_mask_list = [] flow_mask_list = [] num_deconv_layer = int( np.log2(self.input_height / int(pixel_input[-1].get_shape()[1]))) num_channel = [256, 128, 64, 32, 16, 8] for i in range(num_deconv_layer): with tf.variable_scope('Flow'): _f = deconv2d(_f, [num_channel[i], 3, 2], is_train, info=not reuse, norm=self.norm_type, name='flow_deconv{}'.format(i + 1)) with tf.variable_scope('Pixel'): # skip connection if not (num_res_block_pixel == 0 and i == 0): _p = tf.concat([_p, pixel_input.pop(-1)], axis=-1) else: pixel_input.pop(-1) if not reuse: log.info( 'pixel_deconv{}_in_layer_concat {}'.format( i + 1, _p.get_shape().as_list())) _p = deconv2d(_p, [num_channel[i], 3, 2], is_train, info=not reuse, norm=self.norm_type, name='pixel_deconv{}'.format(i + 1)) if num_deconv_layer - i <= num_scale: with tf.variable_scope('Flow'): flow_output = deconv2d( _f, [int(num_channel[i] / 2), 3, 1], is_train, info=not reuse, norm=self.norm_type, name='flow_deconv{}_out_layer_1'.format(i + 1)) flow_output = deconv2d( flow_output, [3, 3, 1], is_train, info=not reuse, norm='None', activation_fn=None, name='flow_deconv{}_out_layer_2'.format(i + 1)) # bilinear sample: flow -> img x, y = flow_output[:, :, :, 0], flow_output[:, :, :, 1] flow_mask = flow_output[:, :, :, -1] h = int(flow_output.get_shape()[1]) w = int(flow_output.get_shape()[2]) x_g = tf.convert_to_tensor(np.expand_dims( 2 * np.array(range(w)) / w - 1, axis=0), dtype=tf.float32) y_g = tf.convert_to_tensor(np.expand_dims( 2 * np.array(range(h)) / h - 1, axis=1), dtype=tf.float32) flow_output_img = bilinear_sampler( tf.image.resize_nearest_neighbor( (input_image + 1) / 2, [h, w]), x + x_g, y + y_g) * 2 - 1 flow_output_list.append(flow_output_img) x_list.append(x) y_list.append(y) flow_mask_list.append(flow_mask) with tf.variable_scope('Pixel'): if i == num_deconv_layer - 1: log.error('pixel output') pixel_output = deconv2d( _p, [int(num_channel[i] / 2), 3, 1], is_train, info=not reuse, norm=self.norm_type, name='pixel_deconv{}_out_layer_1'.format( i + 1)) pixel_output = deconv2d( pixel_output, [c + 1, 3, 1], is_train, info=not reuse, norm='None', activation_fn=None, name='pixel_deconv{}_out_layer_2'.format( i + 1)) pixel_mask = pixel_output[:, :, :, -1] pixel_output = tf.tanh( pixel_output[:, :, :, :c]) else: log.error('pixel dummy output') pixel_output = tf.zeros_like(flow_output) pixel_mask = tf.zeros_like(flow_mask) pixel_mask_list.append(pixel_mask) pixel_output_list.append(pixel_output) if not reuse: log.infov( 'flow_output_img: {}, pixel output: {}, ' 'flow_feature_map: {}, pixel_feature_map: {}'. format(flow_output_img.get_shape().as_list(), pixel_output.get_shape().as_list(), _f.get_shape().as_list(), _p.get_shape().as_list())) _f = tf.concat([_f, flow_output], axis=-1) _p = tf.concat([_p, pixel_output], axis=-1) if not reuse: log.info( 'flow_deconv{}_out_layer_concat {}'.format( i + 1, _f.get_shape().as_list())) if not reuse: log.info( 'pixel_deconv{}_out_layer_concat {}'.format( i + 1, _p.get_shape().as_list())) return pixel_output_list, pixel_mask_list, flow_output_list, \ flow_mask_list, x_list, y_list