def SemanticFeatureGenerationBlock(inputs, D_features, D_prime_features, O_features, bottleneck_factor=2, cardinality=32): d_1 = ConvBlock(inputs, D_features, kernel_size=[3, 3]) pool_1 = slim.pool(d_1, [5, 5], stride=[1, 1], pooling_type='MAX') d_prime_1 = ConvBlock(pool_1, D_prime_features, kernel_size=[3, 3]) d_2 = ConvBlock(pool_1, D_features, kernel_size=[3, 3]) pool_2 = slim.pool(d_2, [5, 5], stride=[1, 1], pooling_type='MAX') d_prime_2 = ConvBlock(pool_2, D_prime_features, kernel_size=[3, 3]) d_3 = ConvBlock(pool_2, D_features, kernel_size=[3, 3]) pool_3 = slim.pool(d_3, [5, 5], stride=[1, 1], pooling_type='MAX') d_prime_3 = ConvBlock(pool_3, D_prime_features, kernel_size=[3, 3]) d_4 = ConvBlock(pool_3, D_features, kernel_size=[3, 3]) pool_4 = slim.pool(d_4, [5, 5], stride=[1, 1], pooling_type='MAX') d_prime_4 = ConvBlock(pool_4, D_prime_features, kernel_size=[3, 3]) net = tf.concat([d_prime_1, d_prime_2, d_prime_3, d_prime_4], axis=-1) net = ConvBlock(net, n_filters=D_features, kernel_size=[3, 3]) net = ResNeXtBlock(net, n_filters_out=D_features, bottleneck_factor=bottleneck_factor) net = ResNeXtBlock(net, n_filters_out=D_features, bottleneck_factor=bottleneck_factor) net = ResNeXtBlock(net, n_filters_out=D_features, bottleneck_factor=bottleneck_factor) net = ResNeXtBlock(net, n_filters_out=D_features, bottleneck_factor=bottleneck_factor) net = ConvBlock(net, O_features, kernel_size=[3, 3]) return net
def vggm1234(x, TRAIN_COVN=True): net = slim.convolution(x, 96, [7, 7], 2, padding='VALID', scope='conv1', activation_fn=tf.nn.relu, reuse=tf.AUTO_REUSE, trainable=TRAIN_COVN) net = tf.nn.lrn(net, depth_radius=5, bias=2, alpha=1e-4 * 1, beta=0.75) net = slim.pool(net, [3, 3], 'MAX', stride=2, padding='VALID', scope='pool1') net = slim.convolution(net, 256, [5, 5], 2, padding='VALID', scope='conv2', activation_fn=tf.nn.relu, reuse=tf.AUTO_REUSE, trainable=TRAIN_COVN) net = tf.nn.lrn(net, depth_radius=5, bias=2, alpha=1e-4 * 1, beta=0.75) net = slim.pool(net, [3, 3], 'MAX', stride=2, padding='VALID', scope='pool2') net = slim.convolution(net, 512, [3, 3], 1, padding='VALID', scope='conv3', activation_fn=tf.nn.relu, reuse=tf.AUTO_REUSE, trainable=TRAIN_COVN) net = slim.convolution(net, 512, [3, 3], 1, padding='VALID', scope='conv4', activation_fn=tf.nn.relu, reuse=tf.AUTO_REUSE, trainable=TRAIN_COVN) return U.flattenallbut0(net)
def create_model(self, model_input, vocab_size, num_frames, **unused_params): output = model_input output = slim.convolution(output, 1024, [3], stride = 1, padding = "SAME") output = slim.convolution(output, 1024, [3], stride = 1, padding = "SAME") # output = slim.convolution(output, 512, [3], stride = 1, padding = "SAME") output = tf.contrib.layers.batch_norm(output,center = True, scale = True, is_training = True, scope = None) output = slim.pool(output, [2], "MAX", stride = 2) # output = slim.convolution(output, 512, [3], stride = 1, padding = "SAME") output = slim.convolution(output, 1024, [3], stride = 1, padding = "SAME") output = slim.convolution(output, 1024, [3], stride = 1, padding = "SAME") output = tf.contrib.layers.batch_norm(output,center = True, scale = True, is_training = True, scope = None) output = slim.pool(output, [2], "MAX", stride = 2) output = slim.convolution(output, 1024, [3], stride = 1, padding = "SAME") output = slim.convolution(output, 1024, [3], stride = 1, padding = "SAME") output = slim.convolution(output, 1024, [3], stride = 1, padding = "SAME") output = tf.contrib.layers.batch_norm(output,center = True, scale = True, is_training = True, scope = None) output = slim.pool(output, [3], "MAX", stride = 2) output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = tf.contrib.layers.batch_norm(output,center = True, scale = True, is_training = True, scope = None) output = slim.pool(output, [3], "MAX", stride=2) output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = tf.contrib.layers.batch_norm(output,center = True, scale = True, is_training = True, scope = None) output = slim.pool(output, [2], "MAX", stride=2) output = slim.flatten(output) output = slim.fully_connected(output, 4096) output = tf.contrib.layers.batch_norm(output,center = True, scale = True, is_training = True, scope = None) output = slim.dropout(output) output = slim.fully_connected(output, 4096) output = tf.contrib.layers.batch_norm(output,center = True, scale = True, is_training = True, scope = None) output = slim.dropout(output) output = slim.fully_connected(output, vocab_size, activation_fn = tf.nn.sigmoid) return {"predictions": output}
def netD_discriminator_adloss_32(image_input, reuse=False): with tf.variable_scope('discriminator', reuse=reuse) as vs: kernel_size = [3, 3] filter_num = 64 imageshape = image_input.get_shape().as_list()[1] with slim.arg_scope([slim.conv2d], normalizer_fn=slim.batch_norm, activation_fn=tf.nn.elu, padding='SAME', weights_initializer=tf.truncated_normal_initializer(stddev=0.02)): # 224/96/32 net = slim.conv2d(image_input, filter_num, kernel_size, normalizer_fn=None, scope='conv1') net = slim.conv2d(net, filter_num * 2, kernel_size, scope='conv2') # 112/48/16 net = slim.conv2d(net, filter_num * 2, stride=2, kernel_size=kernel_size, scope='conv3') net = slim.conv2d(net, filter_num * 2, kernel_size, scope='conv4') # 56/24/8 net = slim.conv2d(net, filter_num * 4, stride=2, kernel_size=kernel_size, scope='conv6') net = slim.conv2d(net, filter_num * 4, kernel_size, scope='conv7') # 28/12/4 net = slim.conv2d(net, filter_num * 6, stride=2, kernel_size=kernel_size, scope='conv9') net = slim.conv2d(net, filter_num * 6, kernel_size, scope='conv10') # 14/6/2 net = slim.conv2d(net, filter_num * 8, stride=2, kernel_size=kernel_size, scope='conv12') net = slim.conv2d(net, filter_num * 8, kernel_size, scope='conv13') avgpool = slim.pool(net, [int(imageshape / 16), int(imageshape / 16)], stride=int(imageshape / 32), pooling_type="AVG", scope='avgpool') adlogits = slim.fully_connected(slim.flatten(avgpool), 1, activation_fn=None, normalizer_fn=None, weights_initializer=tf.truncated_normal_initializer(stddev=0.02), scope='ad_soft') return adlogits
def FullResolutionResidualUnit(pool_stream, res_stream, n_filters_3, n_filters_1, pool_scale): """ A full resolution residual unit Arguments: pool_stream: The inputs from the pooling stream res_stream: The inputs from the residual stream n_filters_3: Number of output feature maps for each 3x3 conv n_filters_1: Number of output feature maps for each 1x1 conv pool_scale: scale of the pooling layer i.e window size and stride Returns: Output of full resolution residual block """ G = tf.concat([pool_stream, slim.pool(res_stream, [pool_scale, pool_scale], stride=[pool_scale, pool_scale], pooling_type='MAX')], axis=-1) net = slim.conv2d(G, n_filters_3, kernel_size=3, activation_fn=None) net = slim.batch_norm(net) net = tf.nn.relu(net) net = slim.conv2d(net, n_filters_3, kernel_size=3, activation_fn=None) net = slim.batch_norm(net) pool_stream_out = tf.nn.relu(net) net = slim.conv2d(pool_stream_out, n_filters_1, kernel_size=1, activation_fn=None) net = Upsampling(net, scale=pool_scale) res_stream_out = tf.add(res_stream, net) return pool_stream_out, res_stream_out
def FullResolutionResidualUnit(pool_stream, res_stream, n_filters_3, n_filters_1, pool_scale): G = tf.concat([ pool_stream, slim.pool(res_stream, [pool_scale, pool_scale], stride=[pool_scale, pool_scale], pooling_type='MAX') ], axis=-1) net = slim.conv2d(G, n_filters_3, kernel_size=3, activation_fn=None) net = slim.batch_norm(net, fused=True) net = tf.nn.relu(net) net = slim.conv2d(net, n_filters_3, kernel_size=3, activation_fn=None) net = slim.batch_norm(net, fused=True) pool_stream_out = tf.nn.relu(net) net = slim.conv2d(pool_stream_out, n_filters_1, kernel_size=1, activation_fn=None) net = Upsampling(net, scale=pool_scale) res_stream_out = tf.add(res_stream, net) return pool_stream_out, res_stream_out
def CoRLModel(inputs, num_actions, scope, reuse=False): with tf.variable_scope(scope, reuse=reuse): activation = tf.nn.tanh convs1 = [ [8, [3, 3], 1], [16, [3, 3], 1], ] pool1 = [[[2, 2], 2]] convs2 = [ [16, [3, 3], 1], [8, [3, 3], 1], ] pool2 = [[[2, 2], 2]] hidden = 3528 net = inputs out_size, kernel, stride = convs1[0] net = slim.conv2d(net, out_size, kernel, stride, scope="conv1/conv3_1") out_size, kernel, stride = convs1[1] net = slim.conv2d(net, out_size, kernel, stride, scope="conv1/conv3_2") kernel, stride = pool1[0] net = slim.pool(net, kernel, "MAX", stride=stride, scope="pool1") #-------- out_size, kernel, stride = convs2[0] net = slim.conv2d(net, out_size, kernel, stride, scope="conv2/conv3_1") out_size, kernel, stride = convs2[1] net = slim.conv2d(net, out_size, kernel, stride, scope="conv2/conv3_2") kernel, stride = pool2[0] net = slim.pool(net, kernel, "MAX", stride=stride, scope="pool2") net = tf.squeeze(net) net = tf.reshape(net, [-1, 21, 21, 8]) #Flatten pool layer net = slim.flatten(net, scope="flatten3") #-------- net = slim.fully_connected( net, hidden, weights_initializer=xavier_initializer(uniform=False), activation_fn=activation, scope="fc4") net = slim.fully_connected( net, num_actions, weights_initializer=xavier_initializer(uniform=False), activation_fn=None, scope="y") return net
def TransitionDown(inputs, n_filters, dropout_p=0.2, scope=None): with tf.name_scope(scope) as sc: l = preact_conv(inputs, n_filters, filter_size=[1, 1], dropout_p=dropout_p) l = slim.pool(l, [2, 2], stride=[2, 2], pooling_type='MAX') return l
def TransitionDown(inputs, n_filters, dropout_p=0.2, scope=None): """ Transition Down (TD) for FC-DenseNet Apply 1x1 BN + ReLU + conv then 2x2 max pooling """ with tf.name_scope(scope) as sc: l = preact_conv(inputs, n_filters, kernel_size=[1, 1], dropout_p=dropout_p) l = slim.pool(l, [2, 2], stride=[2, 2], pooling_type='MAX') return l
def conv_block(self, inputs, no_convs=1, filters=1, kernel_size=[2, 2], dropout=0.0): # Define i conv layers followed by relu and dropout (if not set to 0.0) for i in range(0, no_convs): inputs = slim.conv2d(inputs, filters, kernel_size, activation_fn=None, normalizer_fn=None) inputs = tf.nn.relu(slim.batch_norm(inputs)) if dropout != 0.0: inputs = slim.dropout(inputs, keep_prob=dropout) # Define pooling after conv block inputs = slim.pool(inputs, [2, 2], stride=[2, 2], pooling_type='MAX') return inputs
def pool_layer(self, inputs, pool_size=2, n_filters=64, stride=2, _type='MAX', method='pool'): if method == 'pool': if _type == 'MAX': out = slim.pool(inputs, [pool_size, pool_size], stride=[stride, stride], pooling_type=_type) else: out = slim.avg_pool2d(inputs, [pool_size, pool_size], stride=[stride, stride]) else: out = slim.conv2d(inputs, n_filters, kernel_size=[1, 1], stride=[2, 2]) return out
def build_AUnet(inputs, n_classes): n_filters = 64 net_1 = ConvBlock(inputs, n_filters) net = slim.pool(net_1, [2, 2], stride=[2, 2], pooling_type='MAX') net_2 = ConvBlock(net, n_filters * 2) net = slim.pool(net_2, [2, 2], stride=[2, 2], pooling_type='MAX') net_3 = ConvBlock(net, n_filters * 4) net = slim.pool(net_3, [2, 2], stride=[2, 2], pooling_type='MAX') net_4 = ConvBlock(net, n_filters * 8, third=False) net = slim.pool(net_4, [2, 2], stride=[2, 2], pooling_type='MAX') net_5 = ConvBlock(net, n_filters * 16) #net = slim.pool(net, [2, 2], stride=[2, 2], pooling_type='MAX') #pooled = # Attention Mechanism net_5 = UpBlock(net, 8 * n_filters) net = attention(net_4, net_5, 8 * n_filters) net = concat(net_4, net_5) net = ConvBlock(net, 8 * n_filters) up_3 = UpBlock(net, 4 * n_filters) net = attention(net_3, up_3, 4 * n_filters) net = concat(up_3, net) net = ConvBlock(net, 4 * n_filters) up_2 = UpBlock(net, 2 * n_filters) net = attention(net_2, up_2, 2 * n_filters) net = concat(up_2, net) net = ConvBlock(net, 2 * n_filters) up_1 = UpBlock(net, n_filters) net = attention(net_1, up_1, n_filters) net = concat(up_1, net) net = ConvBlock(net, n_filters) net = conv2d(net, n_classes, kernel_size=[1, 1], activation_fn=None) return net
def __init__(self): self.X = tf.placeholder(tf.float32, [None, 28, 28, 3]) with tf.variable_scope('classifier', reuse=tf.AUTO_REUSE) as scope: y_ = slim.conv2d(inputs=self.X, num_outputs=32, kernel_size=3, stride=1, activation_fn=tf.nn.relu) y_ = slim.pool(y_, kernel_size=2, pooling_type='MAX') y_ = slim.conv2d(y_, num_outputs=64, kernel_size=3, stride=1, activation_fn=tf.nn.relu) y_ = slim.pool(y_, kernel_size=2, pooling_type='MAX') y_ = slim.flatten(y_) y_ = tf.layers.dense(y_, 512, activation=tf.nn.relu) y_ = tf.layers.dense(y_, 512, activation=tf.nn.relu) self.y_pred = tf.layers.dense(y_, 14)
def adapPooling(inputs, outputsize=1, _type='MAX'): shape = K.int_shape(inputs) h, w, ch = shape stride = np.floor(h/outputsize).astype(np.int32) kernel = h - (outputsize-1) * stride if _type == 'MAX': adapPooling = slim.pool(inputs, [kernel, kernel], stride=[stride, stride], pooling_type='MAX') else: adapPooling = slim.avg_pool2d(inputs, [kernel, kernel], stride=[stride, stride]) return adapPooling * inputs
def TransitionLayer(inputs, n_filters, dropout_p=0.2, compression=1.0, scope=None): """ Transition layer for DenseNet Apply 1x1 BN + conv then 2x2 max pooling """ with tf.name_scope(scope) as sc: if compression < 1.0: n_filters = tf.to_int32(tf.floor(n_filters*compression)) l = preact_conv(inputs, n_filters, filter_size=[1, 1], dropout_p=dropout_p) l = slim.pool(l, [2, 2], stride=[2, 2], pooling_type='AVG') return l
def interblock(inputs, level, feature_map, pooling_type): kernel_size = [feature_map[0] // level, feature_map[1] // level] stride_size = kernel_size pool = slim.pool(inputs, kernel_size, stride=stride_size, pooling_type=pooling_type) conv = ConvBlock(pool, 128, kernel_size=[1, 1]) #conv = desconv(conv, 128, stride=feature_map) conv = upsampling(conv, feature_map) conv = slim.conv2d(conv, 128, kernel_size=[3, 3]) return conv
def main(): import argparse parser = argparse.ArgumentParser() parser.add_argument('--test', type=bool, default=False) args = parser.parse_args() batch_size = 32 images, labels, images_test, labels_test = read_dataset() X = tf.placeholder(tf.float32, [None, 28, 28, 3]) y = tf.placeholder(tf.int64, [None, 14]) with tf.variable_scope('classifier', reuse=tf.AUTO_REUSE) as scope: y_ = slim.conv2d(inputs=X, num_outputs=32, kernel_size=3, stride=1, activation_fn=tf.nn.relu) y_ = slim.pool(y_, kernel_size=2, pooling_type='MAX') y_ = slim.conv2d(y_, num_outputs=64, kernel_size=3, stride=1, activation_fn=tf.nn.relu) y_ = slim.pool(y_, kernel_size=2, pooling_type='MAX') y_ = slim.flatten(y_) y_ = tf.layers.dense(y_, 512, activation=tf.nn.relu) y_ = tf.layers.dense(y_, 512, activation=tf.nn.relu) y_pred = tf.layers.dense(y_, 14) loss = tf.reduce_mean(tf.losses.softmax_cross_entropy(y, logits=y_pred)) train_step = tf.train.AdamOptimizer(5e-4).minimize(loss) config = tf.ConfigProto() config.gpu_options.allow_growth = True saver = tf.train.Saver() with tf.Session(config=config) as sess: ckpt = tf.train.get_checkpoint_state(os.path.dirname('checkpoints/mnist_plus')) if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) print('successfully restore') else: sess.run(tf.global_variables_initializer()) print('no pre-trained model') if args.test: run_model(sess, y_pred, loss, train_step, saver, images_test, labels_test, X, y, 1, batch_size, 100, args.test) else: run_model(sess, y_pred, loss, train_step, saver, images, labels, X, y, 10, batch_size, 100, args.test)
def build_adaptnet(inputs, num_classes): """ Builds the AdaptNet model. Arguments: inputs: The input tensor= preset_model: Which model you want to use. Select which ResNet model to use for feature extraction num_classes: Number of classes Returns: AdaptNet model """ net = ConvBlock(inputs, n_filters=64, kernel_size=[3, 3]) net = ConvBlock(net, n_filters=64, kernel_size=[7, 7], stride=2) net = slim.pool(net, [2, 2], stride=[2, 2], pooling_type='MAX') net = ResNetBlock_2(net, filters_1=64, filters_2=256, s=1) net = ResNetBlock_1(net, filters_1=64, filters_2=256) net = ResNetBlock_1(net, filters_1=64, filters_2=256) net = ResNetBlock_2(net, filters_1=128, filters_2=512, s=2) net = ResNetBlock_1(net, filters_1=128, filters_2=512) net = ResNetBlock_1(net, filters_1=128, filters_2=512) skip_connection = ConvBlock(net, n_filters=12, kernel_size=[1, 1]) net = MultiscaleBlock_1(net, filters_1=128, filters_2=512, filters_3=64, p=1, d=2) net = ResNetBlock_2(net, filters_1=256, filters_2=1024, s=2) net = ResNetBlock_1(net, filters_1=256, filters_2=1024) net = MultiscaleBlock_1(net, filters_1=256, filters_2=1024, filters_3=64, p=1, d=2) net = MultiscaleBlock_1(net, filters_1=256, filters_2=1024, filters_3=64, p=1, d=4) net = MultiscaleBlock_1(net, filters_1=256, filters_2=1024, filters_3=64, p=1, d=8) net = MultiscaleBlock_1(net, filters_1=256, filters_2=1024, filters_3=64, p=1, d=16) net = MultiscaleBlock_2(net, filters_1=512, filters_2=2048, filters_3=512, p=2, d=4) net = MultiscaleBlock_1(net, filters_1=512, filters_2=2048, filters_3=512, p=2, d=8) net = MultiscaleBlock_1(net, filters_1=512, filters_2=2048, filters_3=512, p=2, d=16) net = ConvBlock(net, n_filters=12, kernel_size=[1, 1]) net = Upsampling(net, scale=2) net = tf.add(skip_connection, net) net = Upsampling(net, scale=8) net = slim.conv2d(net, num_classes, [1, 1], activation_fn=None, scope='logits') return net
def FPABlock(inputs, n_filters=1024, pooling_type='MAX', rate=16): net_1 = conv2d(inputs, n_filters, kernel_size=[1, 1], activation_fn=None) net_7 = slim.pool(inputs, [2, 2], stride=[2, 2], pooling_type=pooling_type) net_7 = conv2d(net_7, n_filters, kernel_size=[7, 7]) net_5 = slim.pool(net_7, [2, 2], stride=[2, 2], pooling_type=pooling_type) net_5 = conv2d(net_5, n_filters, kernel_size=[5, 5]) net_3 = slim.pool(net_5, [2, 2], stride=[2, 2], pooling_type=pooling_type) net_3 = conv2d(net_3, n_filters, kernel_size=[3, 3]) net_3 = conv2d(net_3, n_filters, kernel_size=[3, 3]) net_3 = relu(net_3) net_3 = Upsample(net_3) net_5 = conv2d(net_5, n_filters, kernel_size=[5, 5]) net_5 = relu(net_5) net_5 = add(net_3, net_5) net_5 = UpsampleNear(net_5) net_7 = conv2d(net_7, n_filters, kernel_size=[5, 5]) net_7 = relu(net_7) net_7 += net_5 net_7 = UpsampleNear(net_7) net = tf.multiply(net_7, net_1) GAP = slim.pool(inputs, [rate, rate], stride=[rate, rate], padding='SAME', pooling_type='AVG') #test = inputs + GAP #GAP = tf.reduce_mean(GAP, axis=[1, 2]) #GAP = tf.reshape(GAP, (-1, 1, 1, n_filters)) #GAP = Upsample(GAP, rate=16) net_GAP = conv2d(GAP, n_filters, kernel_size=[1, 1]) net_GAP = UpsampleNear(net_GAP, rate=rate) net = add(net, net_GAP) return net
def strided_inference(self, images): tf.summary.image('input', images[..., 0:3], max_outputs=self.max_images) with tf.variable_scope('encode1'): net = self.dwscb(images, 64) net = self.dwscb(net, 64) net = slim.pool(net, [2, 2], stride=[2, 2], pooling_type='MAX') with tf.variable_scope('encode2'): net = self.dwscb(net, 128) net = self.dwscb(net, 128) net = slim.pool(net, [2, 2], stride=[2, 2], pooling_type='MAX') with tf.variable_scope('encode3'): net = self.dwscb(net, 256) net = self.dwscb(net, 256) net = self.dwscb(net, 256) net = slim.pool(net, [2, 2], stride=[2, 2], pooling_type='MAX') with tf.variable_scope('decode3'): net = self.ConvTRBlock(net, 256) net = self.dwscb(net, 256) net = self.dwscb(net, 256) net = self.dwscb(net, 256) with tf.variable_scope('decode2'): net = self.ConvTRBlock(net, 128) net = self.dwscb(net, 128) net = self.dwscb(net, 128) net = self.dwscb(net, 128) with tf.variable_scope('decode1'): net = self.ConvTRBlock(net, 64) net = self.dwscb(net, 64) net = self.dwscb(net, self.n) return net
def Custom_netD_discriminator_psloss(image_input,posenum=3,reuse=False): ''' 08-04修改,使用avgpool减小网络大小 08-05修改,inst_norm 替换为batchnorm :param image_input: :param posenum: :param reuse: :return: ''' with tf.variable_scope('discriminator/psloss',reuse=reuse) as vs: kernel_size=[3,3] filter_num=32 with slim.arg_scope([slim.conv2d],normalizer_fn=slim.batch_norm,activation_fn=tf.nn.elu,padding='SAME',weights_initializer=tf.truncated_normal_initializer(stddev=0.02)): #96 conv1 = slim.conv2d(image_input,filter_num,kernel_size,normalizer_fn=None,scope='conv1') conv2 = slim.conv2d(conv1,filter_num*2,kernel_size,scope='conv2') #48 # conv3 = slim.max_pool2d(conv2,[2,2],scope='max1') conv3 = slim.conv2d(conv2,filter_num*2,stride=2,kernel_size=kernel_size,scope='conv3') conv4 = slim.conv2d(conv3,filter_num*2,kernel_size,scope='conv4') conv5 = slim.conv2d(conv4,filter_num*4,kernel_size,scope='conv5') #24 # conv6 = slim.max_pool2d(conv5,[2,2],scope='max2') conv6 = slim.conv2d(conv5,filter_num*4,stride=2,kernel_size=kernel_size,scope='conv6') conv7 = slim.conv2d(conv6,filter_num*3,kernel_size,scope='conv7') conv8 = slim.conv2d(conv7,filter_num*6,kernel_size,scope='conv8') #12 # conv9 = slim.max_pool2d(conv8,[2,2],scope='max3') conv9 = slim.conv2d(conv8,filter_num*6,stride=2,kernel_size=kernel_size,scope='conv9') conv10= slim.conv2d(conv9,filter_num*4,kernel_size,scope='conv10') conv11= slim.conv2d(conv10,filter_num*8,kernel_size,scope='conv11') #6 # conv12= slim.max_pool2d(conv11,[2,2],scope='max4') conv12= slim.conv2d(conv11,filter_num*8,stride=2,kernel_size=kernel_size,scope='conv12') conv13= slim.conv2d(conv12,filter_num*6,kernel_size,scope='conv13') conv14= slim.conv2d(conv13,filter_num*10,kernel_size,scope='conv14') #two path -feature -W Omegapredict_r_label #avg出来之后应该是1*1*320的tensor #3 # conv15= slim.conv2d(conv14,filter_num*10,stride=2,kernel_size=kernel_size,scope='conv15') # conv16= slim.conv2d(conv15,filter_num*8,kernel_size,scope='conv16') # conv17= slim.conv2d(conv16,filter_num*12,kernel_size,scope='conv17') avgpool=slim.pool(conv14,[6,6],pooling_type="AVG",scope='avgpool') # shape_conv17 = tf.shape(conv17) # linear17 = tf.reshape(conv17, [-1,1,1, 3456],name='reshape_fc') pslogits = slim.fully_connected(avgpool,posenum,activation_fn=None,normalizer_fn=None,weights_initializer=tf.truncated_normal_initializer(stddev=0.02),scope='ps_soft') # variables = tf.contrib.framework.get_variables(vs) #conv11 means content structure feature return pslogits
def InterpBlock(net, level, feature_map_shape, pooling_type): # Compute the kernel and stride sizes according to how large the final feature map will be # When the kernel size and strides are equal, then we can compute the final feature map size # by simply dividing the current size by the kernel or stride size # The final feature map sizes are 1x1, 2x2, 3x3, and 6x6. We round to the closest integer kernel_size = [int(np.round(float(feature_map_shape[0]) / float(level))), int(np.round(float(feature_map_shape[1]) / float(level)))] stride_size = kernel_size net = slim.pool(net, kernel_size, stride=stride_size, pooling_type='MAX') net = slim.conv2d(net, 512, [1, 1], activation_fn=None) net = slim.batch_norm(net, fused=True) net = tf.nn.relu(net) net = Upsampling(net, feature_map_shape) return net
def Custom_netD_discriminator_adloss(image_input,reuse=False): with tf.variable_scope('discriminator/adloss',reuse=reuse) as vs: kernel_size=[3,3] filter_num=32 with slim.arg_scope([slim.conv2d],normalizer_fn=slim.batch_norm,activation_fn=tf.nn.elu,padding='SAME',weights_initializer=tf.truncated_normal_initializer(stddev=0.02)): #96 net = slim.conv2d(image_input,filter_num,kernel_size,normalizer_fn=None,scope='conv1') net = slim.conv2d(net,filter_num*2,kernel_size,scope='conv2') #48 # conv3 = slim.max_pool2d(conv2,[2,2],scope='max1') net = slim.conv2d(net,filter_num*2,stride=2,kernel_size=kernel_size,scope='conv3') net = slim.conv2d(net,filter_num*2,kernel_size,scope='conv4') net = slim.conv2d(net,filter_num*4,kernel_size,scope='conv5') # 24 # conv6 = slim.max_pool2d(conv5,[2,2],scope='max2') net = slim.conv2d(net,filter_num*4,stride=2,kernel_size=kernel_size,scope='conv6') net = slim.conv2d(net,filter_num*3,kernel_size,scope='conv7') net = slim.conv2d(net,filter_num*6,kernel_size,scope='conv8') #12 # conv9 = slim.max_pool2d(conv8,[2,2],scope='max3') net = slim.conv2d(net,filter_num*6,stride=2,kernel_size=kernel_size,scope='conv9') net= slim.conv2d(net,filter_num*4,kernel_size,scope='conv10') net= slim.conv2d(net,filter_num*8,kernel_size,scope='conv11') #6 # conv12= slim.max_pool2d(conv11,[2,2],scope='max4') net = slim.conv2d(net,filter_num*8,stride=2,kernel_size=kernel_size,scope='conv12') net = slim.conv2d(net,filter_num*6,kernel_size,scope='conv13') net = slim.conv2d(net,filter_num*10,kernel_size,scope='conv14') #two path -feature -W Omegapredict_r_label #avg出来之后应该是1*1*320的tensor #3 # conv15= slim.conv2d(conv14,filter_num*10,stride=2,kernel_size=kernel_size,scope='conv15') # conv16= slim.conv2d(conv15,filter_num*8,kernel_size,scope='conv16') # conv17= slim.conv2d(conv16,filter_num*12,kernel_size,scope='conv17') # net =slim.conv2d(net,filter_num*10,[1,1],scope='NiN1') # net = slim.conv2d(net,1, [1, 1], scope='NiN2') avgpool=slim.pool(net,[6,6],stride=6,pooling_type="AVG",scope='avgpool') # shape_conv17 = tf.shape(conv17) # linear17 = tf.reshape(conv17, [shape_conv17[0],1,1, shape_conv17[1] * shape_conv17[2] * shape_conv17[3]],name='reshape_fc') adlogits = slim.fully_connected(avgpool,1,activation_fn=None,normalizer_fn=None,weights_initializer=tf.truncated_normal_initializer(stddev=0.02),scope='ad_soft') # variables = tf.contrib.framework.get_variables(vs) # return tf.nn.softmax(adlogits),adlogits # [2,2]的预测 return adlogits
def FullResolutionResidualUnit(pool_stream, res_stream, n_filters_3, n_filters_1, pool_scale): """ A full resolution residual unit Arguments: pool_stream: The inputs from the pooling stream res_stream: The inputs from the residual stream n_filters_3: Number of output feature maps for each 3x3 conv n_filters_1: Number of output feature maps for each 1x1 conv pool_scale: scale of the pooling layer i.e window size and stride Returns: Output of full resolution residual block """ pool = slim.pool(res_stream, [pool_scale, pool_scale], stride=[pool_scale, pool_scale], pooling_type='MAX') # pool = tf.image.resize_image_with_crop_or_pad(pool, tf.shape(pool_stream)[1], tf.shape(pool_stream)[2]) G = tf.concat([pool_stream, pool], axis=-1) # First convolution layer net = slim.conv2d(G, n_filters_3, kernel_size=3, activation_fn=None) net = slim.batch_norm(net, fused=True) net = tf.nn.relu(net) # Second convolution layer net = slim.conv2d(net, n_filters_3, kernel_size=3, activation_fn=None) net = slim.batch_norm(net, fused=True) pool_stream_out = tf.nn.relu(net) # Conv1x1 and Upsample net = slim.conv2d(pool_stream_out, n_filters_1, kernel_size=1, activation_fn=None) res_stream_shape = tf.shape(res_stream) res_stream_out = Upsampling(net, scale=pool_scale, spatial_shape=(res_stream_shape[1], res_stream_shape[2])) # # Add to form next residual stream # res_stream_out = tf.add(res_stream, net) return pool_stream_out, res_stream_out
def interp_block(prev_layer, level, feature_map_shape, input_shape, is_training): kernel_strides_map = {1: 90, 2: 45, 3: 30, 6: 15} prev_layer = slim.pool(prev_layer, kernel_strides_map[level], padding='SAME', pooling_type='AVG', stride=kernel_strides_map[level]) prev_layer = slim.conv2d(prev_layer, 256, 1, stride=1, biases_initializer=None, activation_fn=None) prev_layer = slim.batch_norm(prev_layer, is_training=is_training) prev_layer = tf.nn.relu(prev_layer) prev_layer = tf.image.resize_bilinear(prev_layer, size=feature_map_shape) return prev_layer
def TransitionDown(inputs, n_filters, dropout_p=0.2, compression_rate=1, scope=None): """ Transition Down (TD) for FC-DenseNet Apply 1x1 BN + ReLU + conv then 2x2 max pooling """ with tf.name_scope(scope) as sc: l = preact_conv(inputs, np.ceil(compression_rate * n_filters), filter_size=[1, 1], dropout_p=dropout_p) l = slim.pool(l, [2, 2], stride=[2, 2], pooling_type='MAX', data_format='NCHW') return l
def get_pool(pool_4): pool_list = [] #pool_list.append(slim.pool(pool_4, [16, 16], stride=[1, 1], pooling_type='AVG')) #pool_list.append(slim.pool(pool_4, [15, 15], stride=[1, 1], pooling_type='AVG')) pool_list.append( slim.pool(pool_4, [14, 14], stride=[1, 1], pooling_type='AVG')) pool_list.append( slim.pool(pool_4, [13, 13], stride=[1, 1], pooling_type='AVG')) pool_list.append( slim.pool(pool_4, [12, 12], stride=[1, 1], pooling_type='AVG')) pool_list.append( slim.pool(pool_4, [11, 11], stride=[1, 1], pooling_type='AVG')) pool_list.append( slim.pool(pool_4, [9, 9], stride=[1, 1], pooling_type='AVG')) pool_list.append( slim.pool(pool_4, [8, 8], stride=[1, 1], pooling_type='AVG')) pool_list.append( slim.pool(pool_4, [3, 3], stride=[1, 1], pooling_type='AVG')) pool_list.append( slim.pool(pool_4, [1, 1], stride=[1, 1], pooling_type='AVG')) return pool_list
def build_encoder_decoder(inputs, num_classes, preset_model="Encoder-Decoder", dropout_p=0.5, scope=None): """ Builds the Encoder-Decoder model. Inspired by SegNet with some modifications Optionally includes skip connections Arguments: inputs: the input tensor n_classes: number of classes dropout_p: dropout rate applied after each convolution (0. for not using) Returns: Encoder-Decoder model """ if preset_model == "Encoder-Decoder": has_skip = False elif preset_model == "Encoder-Decoder-Skip": has_skip = True else: raise ValueError( "Unsupported Encoder-Decoder model '%s'. This function only supports Encoder-Decoder and Encoder-Decoder-Skip" % (preset_model)) ##################### # Downsampling path # ##################### net = conv_block(inputs, 64) net = conv_block(net, 64) net = slim.pool(net, [2, 2], stride=[2, 2], pooling_type='MAX') skip_1 = net net = conv_block(net, 128) net = conv_block(net, 128) net = slim.pool(net, [2, 2], stride=[2, 2], pooling_type='MAX') skip_2 = net net = conv_block(net, 256) net = conv_block(net, 256) net = conv_block(net, 256) net = slim.pool(net, [2, 2], stride=[2, 2], pooling_type='MAX') skip_3 = net net = conv_block(net, 512) net = conv_block(net, 512) net = conv_block(net, 512) net = slim.pool(net, [2, 2], stride=[2, 2], pooling_type='MAX') skip_4 = net net = conv_block(net, 512) net = conv_block(net, 512) net = conv_block(net, 512) net = slim.pool(net, [2, 2], stride=[2, 2], pooling_type='MAX') ##################### # Upsampling path # ##################### net = conv_transpose_block(net, 512) net = conv_block(net, 512) net = conv_block(net, 512) net = conv_block(net, 512) if has_skip: net = tf.add(net, skip_4) net = conv_transpose_block(net, 512) net = conv_block(net, 512) net = conv_block(net, 512) net = conv_block(net, 256) if has_skip: net = tf.add(net, skip_3) net = conv_transpose_block(net, 256) net = conv_block(net, 256) net = conv_block(net, 256) net = conv_block(net, 128) if has_skip: net = tf.add(net, skip_2) net = conv_transpose_block(net, 128) net = conv_block(net, 128) net = conv_block(net, 64) if has_skip: net = tf.add(net, skip_1) net = conv_transpose_block(net, 64) net = conv_block(net, 64) net = conv_block(net, 64) ##################### # Softmax # ##################### net = slim.conv2d(net, num_classes, [1, 1], activation_fn=None, scope='logits') return net
def create_model(self, model_input, vocab_size, num_frames, **unused_params): lstm_size = FLAGS.lstm_cells number_of_layers = FLAGS.lstm_layers stacked_lstm = tf.contrib.rnn.MultiRNNCell( [ tf.contrib.rnn.BasicLSTMCell( lstm_size, forget_bias=1.0) for _ in range(number_of_layers) ]) loss = 0.0 output, state = tf.nn.dynamic_rnn(stacked_lstm, model_input, sequence_length=num_frames, dtype=tf.float32) output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") # output = slim.convolution(output, 512, [3], stride = 1, padding = "SAME") output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None) output = slim.pool(output, [2], "MAX", stride=2) # output = slim.convolution(output, 512, [3], stride = 1, padding = "SAME") output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None) output = slim.pool(output, [2], "MAX", stride=2) output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None) output = slim.pool(output, [3], "MAX", stride=2) output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None) output = slim.pool(output, [3], "MAX", stride=2) output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None) output = slim.pool(output, [2], "MAX", stride=2) output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None) output = slim.pool(output, [2], "MAX", stride=1) output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None) output = slim.pool(output, [2], "MAX", stride=1) output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = slim.convolution(output, 1024, [3], stride=1, padding="SAME") output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None) output = slim.pool(output, [2], "MAX", stride=1) output = slim.convolution(output, 512, [3], stride=1, padding="SAME") output = slim.convolution(output, 512, [3], stride=1, padding="SAME") output = slim.convolution(output, 512, [3], stride=1, padding="SAME") output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None) output = slim.pool(output, [2], "MAX", stride=1) output = slim.flatten(output) output = slim.fully_connected(output, 4096) output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None) output = slim.dropout(output) output = slim.fully_connected(output, 4096) output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None) output = slim.dropout(output) output = slim.fully_connected(output, vocab_size, activation_fn=tf.nn.sigmoid) return {"predictions": output}
def create_model(self, model_input, vocab_size, num_frames, **unused_params): output = model_input hidden_size = 1024 output = slim.convolution(output, hidden_size, [8], stride = 2, padding = 'SAME') tmp_state = output output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME') output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME') output = output + tmp_state tmp_state = output output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME') output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME') output = output + tmp_state tmp_state = output output = slim.convolution(output, hidden_size, [3], stride=2, padding="SAME") output = slim.convolution(output, hidden_size, [3], stride=1, padding='SAME') tmp_state = slim.pool(tmp_state, [2], "AVG", stride=2, padding="SAME") output = output + tmp_state tmp_state = output output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME') output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME') output = output + tmp_state tmp_state = output output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME') output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME') output = output + tmp_state tmp_state = output output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME') output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME') output = output + tmp_state tmp_state = output output = slim.convolution(output, hidden_size, [3], stride=2, padding="SAME") output = slim.convolution(output, hidden_size, [3], stride=1, padding='SAME') tmp_state = slim.pool(tmp_state, [2], "AVG", stride=2, padding="SAME") output = output + tmp_state tmp_state = output output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME') output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME') output = output + tmp_state tmp_state = output output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME') output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME') output = output + tmp_state tmp_state = output output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME') output = slim.convolution(output, hidden_size, [3], stride = 1, padding = 'SAME') output = output + tmp_state tmp_state = output output = slim.convolution(output, hidden_size, [3], stride=2, padding="SAME") output = slim.convolution(output, hidden_size, [3], stride=1, padding='SAME') tmp_state = slim.pool(tmp_state, [2], "AVG", stride=2, padding="SAME") output = output + tmp_state tmp_state = output output = slim.convolution(output, hidden_size, [3], stride=1, padding='SAME') output = slim.convolution(output, hidden_size, [3], stride=1, padding='SAME') output = output + tmp_state tmp_state = output output = slim.convolution(output, hidden_size, [3], stride=1, padding='SAME') output = slim.convolution(output, hidden_size, [3], stride=1, padding='SAME') output = output + tmp_state # output = tf.contrib.layers.batch_norm(output, center=True, scale=True, is_training=True, scope=None) output = slim.pool(output, [2], "AVG", stride=2, padding="SAME") output = slim.flatten(output) output = slim.fully_connected(output, 2048) # output = tf.contrib.layers.batch_norm(output,center = True, scale = True, is_training = True, scope = None) output = slim.dropout(output) output = slim.fully_connected(output, 2048) # output = tf.contrib.layers.batch_norm(output,center = True, scale = True, is_training = True, scope = None) output = slim.dropout(output) output = slim.fully_connected(output, vocab_size, activation_fn = tf.nn.sigmoid) return {"predictions": output}