def __init__(self, tensor, keep_prob=1.0, num_classes=1001, retrain_layer=[], weights_path='./weights/resnet_v2_101.ckpt'): # Call the parent class Model.__init__(self, tensor, keep_prob, num_classes, retrain_layer, weights_path) # Create the Graph is_training = True if retrain_layer else False with slim.arg_scope(resnet_arg_scope()): self.final, self.endpoints = resnet_v2_101( self.tensor, num_classes=num_classes, is_training=is_training, global_pool=True # True: both height_out and width_out equal one )
def __init__(self, tensor, keep_prob=1.0, num_classes=1001, retrain_layer=[], weights_path='./weights/resnet_v2_101.ckpt'): # Call the parent class Model.__init__(self, tensor, keep_prob, num_classes, retrain_layer, weights_path) # TODO This implementation has a problem while validation (is still set to training) is_training = True if retrain_layer else False with slim.arg_scope(resnet_arg_scope()): self.final, self.endpoints = resnet_v2_101(self.tensor, num_classes=num_classes, is_training=is_training)
def __call__(self, inputs): inputs = ((inputs / 255.0) - 0.5) * 2.0 with tf.contrib.slim.arg_scope(resnet_arg_scope()): image_features, end_points = resnet_v2_101( inputs, num_classes=self.num_classes, is_training=self.is_training, global_pool=self.global_pool, output_stride=self.output_stride, reuse=self.reuse, scope=self.scope) self.reuse = True return image_features
def get_model(input_pls, is_training, bn=False, bn_decay=None, img_size=224, FLAGS=None): if FLAGS.act == "relu": activation_fn = tf.nn.relu elif FLAGS.act == "elu": activation_fn = tf.nn.elu input_imgs = input_pls['imgs'] input_pnts = input_pls['pnts'] input_gvfs = input_pls['gvfs'] input_onedge = input_pls['onedge'] input_trans_mat = input_pls['trans_mats'] input_obj_rot_mats = input_pls['obj_rot_mats'] batch_size = input_imgs.get_shape()[0].value # endpoints end_points = {} end_points['pnts'] = input_pnts if FLAGS.rot: end_points['gt_gvfs_xyz'] = tf.matmul(input_gvfs, input_obj_rot_mats) end_points['pnts_rot'] = tf.matmul(input_pnts, input_obj_rot_mats) else: end_points['gt_gvfs_xyz'] = input_gvfs #* 10 end_points['pnts_rot'] = input_pnts if FLAGS.edgeweight != 1.0: end_points['onedge'] = input_onedge input_pnts_rot = end_points['pnts_rot'] end_points['imgs'] = input_imgs # B*H*W*3|4 # Image extract features if input_imgs.shape[1] != img_size or input_imgs.shape[2] != img_size: if FLAGS.alpha: ref_img_rgb = tf.compat.v1.image.resize_bilinear( input_imgs[:, :, :, :3], [img_size, img_size]) ref_img_alpha = tf.image.resize_nearest_neighbor( tf.expand_dims(input_imgs[:, :, :, 3], axis=-1), [img_size, img_size]) ref_img = tf.concat([ref_img_rgb, ref_img_alpha], axis=-1) else: ref_img = tf.compat.v1.image.resize_bilinear( input_imgs, [img_size, img_size]) else: ref_img = input_imgs end_points['resized_ref_img'] = ref_img if FLAGS.encoder[:6] == "vgg_16": vgg.vgg_16.default_image_size = img_size with slim.arg_scope([slim.conv2d], weights_regularizer=slim.l2_regularizer(FLAGS.wd)): ref_feats_embedding, encdr_end_points = vgg.vgg_16( ref_img, num_classes=FLAGS.num_classes, is_training=False, scope='vgg_16', spatial_squeeze=False) elif FLAGS.encoder == "sim_res": ref_feats_embedding, encdr_end_points = res_sim_encoder.res_sim_encoder( ref_img, FLAGS.batch_size, is_training=is_training, activation_fn=activation_fn, bn=bn, bn_decay=bn_decay, wd=FLAGS.wd) elif FLAGS.encoder == "resnet_v1_50": resnet_v1.default_image_size = img_size with slim.arg_scope(resnet_v1.resnet_arg_scope()): ref_feats_embedding, encdr_end_points = resnet_v1.resnet_v1_50( ref_img, FLAGS.num_classes, is_training=is_training, scope='resnet_v1_50') scopelst = [ "resnet_v1_50/block1", "resnet_v1_50/block2", "resnet_v1_50/block3", 'resnet_v1_50/block4' ] elif FLAGS.encoder == "resnet_v1_101": resnet_v1.default_image_size = img_size with slim.arg_scope(resnet_v1.resnet_arg_scope()): ref_feats_embedding, encdr_end_points = resnet_v1.resnet_v1_101( ref_img, FLAGS.num_classes, is_training=is_training, scope='resnet_v1_101') scopelst = [ "resnet_v1_101/block1", "resnet_v1_101/block2", "resnet_v1_101/block3", 'resnet_v1_101/block4' ] elif FLAGS.encoder == "resnet_v2_50": resnet_v2.default_image_size = img_size with slim.arg_scope(resnet_v1.resnet_arg_scope()): ref_feats_embedding, encdr_end_points = resnet_v2.resnet_v2_50( ref_img, FLAGS.num_classes, is_training=is_training, scope='resnet_v2_50') scopelst = [ "resnet_v2_50/block1", "resnet_v2_50/block2", "resnet_v2_50/block3", 'resnet_v2_50/block4' ] elif FLAGS.encoder == "resnet_v2_101": resnet_v2.default_image_size = img_size with slim.arg_scope(resnet_v1.resnet_arg_scope()): ref_feats_embedding, encdr_end_points = resnet_v2.resnet_v2_101( ref_img, FLAGS.num_classes, is_training=is_training, scope='resnet_v2_101') scopelst = [ "resnet_v2_101/block1", "resnet_v2_101/block2", "resnet_v2_101/block3", 'resnet_v2_101/block4' ] end_points['img_embedding'] = ref_feats_embedding point_img_feat = None gvfs_feat = None sample_img_points = get_img_points(input_pnts, input_trans_mat) # B * N * 2 if FLAGS.img_feat_onestream: with tf.compat.v1.variable_scope("sdfimgfeat") as scope: if FLAGS.encoder[:3] == "vgg": conv1 = tf.compat.v1.image.resize_bilinear( encdr_end_points['vgg_16/conv1/conv1_2'], (FLAGS.img_h, FLAGS.img_w)) point_conv1 = tf.contrib.resampler.resampler( conv1, sample_img_points) conv2 = tf.compat.v1.image.resize_bilinear( encdr_end_points['vgg_16/conv2/conv2_2'], (FLAGS.img_h, FLAGS.img_w)) point_conv2 = tf.contrib.resampler.resampler( conv2, sample_img_points) conv3 = tf.compat.v1.image.resize_bilinear( encdr_end_points['vgg_16/conv3/conv3_3'], (FLAGS.img_h, FLAGS.img_w)) point_conv3 = tf.contrib.resampler.resampler( conv3, sample_img_points) if FLAGS.encoder[-7:] != "smaller": conv4 = tf.compat.v1.image.resize_bilinear( encdr_end_points['vgg_16/conv4/conv4_3'], (FLAGS.img_h, FLAGS.img_w)) point_conv4 = tf.contrib.resampler.resampler( conv4, sample_img_points) point_img_feat = tf.concat(axis=2, values=[ point_conv1, point_conv2, point_conv3, point_conv4 ]) # small else: print("smaller vgg") point_img_feat = tf.concat( axis=2, values=[point_conv1, point_conv2, point_conv3]) # small elif FLAGS.encoder[:3] == "res": # print(encdr_end_points.keys()) conv1 = tf.compat.v1.image.resize_bilinear( encdr_end_points[scopelst[0]], (FLAGS.img_h, FLAGS.img_w)) point_conv1 = tf.contrib.resampler.resampler( conv1, sample_img_points) conv2 = tf.compat.v1.image.resize_bilinear( encdr_end_points[scopelst[1]], (FLAGS.img_h, FLAGS.img_w)) point_conv2 = tf.contrib.resampler.resampler( conv2, sample_img_points) conv3 = tf.compat.v1.image.resize_bilinear( encdr_end_points[scopelst[2]], (FLAGS.img_h, FLAGS.img_w)) point_conv3 = tf.contrib.resampler.resampler( conv3, sample_img_points) # conv4 = tf.compat.v1.image.resize_bilinear(encdr_end_points[scopelst[3]], (FLAGS.img_h, FLAGS.img_w)) # point_conv4 = tf.contrib.resampler.resampler(conv4, sample_img_points) point_img_feat = tf.concat( axis=2, values=[point_conv1, point_conv2, point_conv3]) else: conv1 = tf.compat.v1.image.resize_bilinear( encdr_end_points[0], (FLAGS.img_h, FLAGS.img_w)) point_conv1 = tf.contrib.resampler.resampler( conv1, sample_img_points) conv2 = tf.compat.v1.image.resize_bilinear( encdr_end_points[1], (FLAGS.img_h, FLAGS.img_w)) point_conv2 = tf.contrib.resampler.resampler( conv2, sample_img_points) conv3 = tf.compat.v1.image.resize_bilinear( encdr_end_points[2], (FLAGS.img_h, FLAGS.img_w)) point_conv3 = tf.contrib.resampler.resampler( conv3, sample_img_points) # conv4 = tf.compat.v1.image.resize_bilinear(encdr_end_points[scopelst[3]], (FLAGS.img_h, FLAGS.img_w)) # point_conv4 = tf.contrib.resampler.resampler(conv4, sample_img_points) point_img_feat = tf.concat( axis=2, values=[point_conv1, point_conv2, point_conv3]) print("point_img_feat.shape", point_img_feat.get_shape()) point_img_feat = tf.expand_dims(point_img_feat, axis=2) if FLAGS.decoder == "att": gvfs_feat = gvfnet.get_gvf_att_imgfeat( input_pnts_rot, ref_feats_embedding, point_img_feat, is_training, batch_size, bn, bn_decay, wd=FLAGS.wd, activation_fn=activation_fn) elif FLAGS.decoder == "skip": gvfs_feat = gvfnet.get_gvf_basic_imgfeat_onestream_skip( input_pnts_rot, ref_feats_embedding, point_img_feat, is_training, batch_size, bn, bn_decay, wd=FLAGS.wd, activation_fn=activation_fn) else: gvfs_feat = gvfnet.get_gvf_basic_imgfeat_onestream( input_pnts_rot, ref_feats_embedding, point_img_feat, is_training, batch_size, bn, bn_decay, wd=FLAGS.wd, activation_fn=activation_fn) else: if not FLAGS.multi_view: with tf.compat.v1.variable_scope("sdfprediction") as scope: gvfs_feat = gvfnet.get_gvf_basic(input_pnts_rot, ref_feats_embedding, is_training, batch_size, bn, bn_decay, wd=FLAGS.wd, activation_fn=activation_fn) end_points['pred_gvfs_xyz'], end_points['pred_gvfs_dist'], end_points[ 'pred_gvfs_direction'] = None, None, None if FLAGS.XYZ: end_points['pred_gvfs_xyz'] = gvfnet.xyz_gvfhead( gvfs_feat, batch_size, wd=FLAGS.wd, activation_fn=activation_fn) end_points['pred_gvfs_dist'] = tf.sqrt( tf.reduce_sum(tf.square(end_points['pred_gvfs_xyz']), axis=2, keepdims=True)) end_points[ 'pred_gvfs_direction'] = end_points['pred_gvfs_xyz'] / tf.maximum( end_points['pred_gvfs_dist'], 1e-6) else: end_points['pred_gvfs_dist'], end_points[ 'pred_gvfs_direction'] = gvfnet.dist_direct_gvfhead( gvfs_feat, batch_size, wd=FLAGS.wd, activation_fn=activation_fn) end_points['pred_gvfs_xyz'] = end_points[ 'pred_gvfs_direction'] * end_points['pred_gvfs_dist'] end_points["sample_img_points"] = sample_img_points # end_points["ref_feats_embedding"] = ref_feats_embedding end_points["point_img_feat"] = point_img_feat return end_points
shape=(None, shape1, shape2, 4), name='x_features') y_ = tf.placeholder(tf.int64, shape=[None, kind_num], name='y_') keep_prob = tf.placeholder("float", name='keep_prob') training = tf.placeholder(tf.bool, name='training') n_batch = len(data.train_indices) // batch_size # prelogits, end_points = network_incep.inference(x, keep_prob, # phase_train=training , bottleneck_layer_size=128, # weight_decay=0.0) #logits = densenet.densenet_inference(x, training, keep_prob) # prelogits, end_points = resnet.resnet_v1_101(x , is_training=training) prelogits, end_points = resnet_v2.resnet_v2_101(x, is_training=training) prelogits = tf.layers.flatten(prelogits) #logits = densenet.densenet_inference(x, training, keep_prob) logits = slim.fully_connected( prelogits, kind_num, activation_fn=None, weights_initializer=tf.truncated_normal_initializer(stddev=0.1), # weights_regularizer=slim.l2_regularizer(0.0), scope='Logits', reuse=False) #logits = tf.identity(logits, 'logits') y_conv = tf.nn.softmax(logits, name='Softmax')
def model(inputs): batch_size, height, width = config.BATCH_SIZE, config.IMAGE_SHAPE[ 0], config.IMAGE_SHAPE[1] with slim.arg_scope(resnet_v2.resnet_arg_scope()): #net, end_points = resnet_v2.resnet_v2_101(inputs, 1001, is_training=False) net, end_points = resnet_v2.resnet_v2_101( inputs, 64, is_training=True, global_pool=False, output_stride=config.OUTPUT_STRIDE) # print(net) kp_maps = tf.contrib.layers.conv2d(net, num_outputs=config.NUM_KP, kernel_size=(1, 1), activation_fn=tf.nn.sigmoid, stride=1, scope='kp_maps') short_offsets = tf.contrib.layers.conv2d(net, num_outputs=2 * config.NUM_KP, kernel_size=(1, 1), activation_fn=None, stride=1, scope='short_offsets') mid_offsets = tf.contrib.layers.conv2d(net, num_outputs=4 * config.NUM_EDGES, kernel_size=(1, 1), activation_fn=None, stride=1, scope='mid_offsets') long_offsets = tf.contrib.layers.conv2d(net, num_outputs=2 * config.NUM_KP, kernel_size=(1, 1), activation_fn=None, stride=1, scope='long_offsets') seg_mask = tf.contrib.layers.conv2d(net, num_outputs=1, kernel_size=(1, 1), activation_fn=tf.nn.sigmoid, stride=1, scope='seg_mask') kp_maps = tf.image.resize_bilinear(kp_maps, (height, width), align_corners=True) short_offsets = tf.image.resize_bilinear(short_offsets, (height, width), align_corners=True) mid_offsets = tf.image.resize_bilinear(mid_offsets, (height, width), align_corners=True) long_offsets = tf.image.resize_bilinear(long_offsets, (height, width), align_corners=True) seg_mask = tf.image.resize_bilinear(seg_mask, (height, width), align_corners=True) ''' with tf.name_scope('kp_maps_deconv') as scope: wt = tf.Variable(tf.truncated_normal([9, 9, config.NUM_KP, config.NUM_KP])) kp_maps = tf.nn.conv2d_transpose(kp_maps, wt, [batch_size, height, width, config.NUM_KP], [1, 8, 8, 1], 'SAME') with tf.name_scope('short_offsets_deconv') as scope: wt = tf.Variable(tf.truncated_normal([9, 9, 2*config.NUM_KP, 2*config.NUM_KP])) short_offsets = tf.nn.conv2d_transpose(short_offsets, wt, [batch_size, height, width, 2*config.NUM_KP], [1, 8, 8, 1], 'SAME') with tf.name_scope('mid_offsets_deconv') as scope: wt = tf.Variable(tf.truncated_normal([9, 9, 4*config.NUM_EDGES, 4*config.NUM_EDGES])) mid_offsets = tf.nn.conv2d_transpose(mid_offsets, wt, [batch_size, height, width, 4*config.NUM_EDGES], [1, 8, 8, 1], 'SAME') with tf.name_scope('long_offsets_deconv') as scope: wt = tf.Variable(tf.truncated_normal([9, 9, 2*config.NUM_KP, 2*config.NUM_KP])) long_offsets = tf.nn.conv2d_transpose(long_offsets, wt, [batch_size, height, width, 2*config.NUM_KP], [1, 8, 8, 1], 'SAME') with tf.name_scope('seg_mask_deconv') as scope: wt = tf.Variable(tf.truncated_normal([9, 9, 1, 1])) seg_mask = tf.nn.conv2d_transpose(seg_mask, wt, [batch_size, height, width, 1], [1, 8, 8, 1], 'SAME') ''' mid_offsets = split_and_refine_mid_offsets(mid_offsets, short_offsets) long_offsets = split_and_refine_long_offsets(long_offsets, short_offsets) outputs = [kp_maps, short_offsets, mid_offsets, long_offsets, seg_mask] return outputs
def build_model(self): # 默认参数 FILTER_SIZE = (5, 5) Z_DIM = 2048 STRIDE = (2, 2) DEPTHS = [64, 128, 256, 256, 128, 32] CHANNELS = 4 N_CLASS = self.config.nclass def encoder(input, z_dim=Z_DIM, is_training=False): net = conv2d_BN(input, DEPTHS[0], FILTER_SIZE, is_training, stride=STRIDE, name='conv_1', kernel_initializer=tf.truncated_normal_initializer( stddev=0.01)) net = conv2d_BN(net, DEPTHS[1], FILTER_SIZE, is_training, stride=STRIDE, name='conv_2', kernel_initializer=tf.truncated_normal_initializer( stddev=0.01)) net = conv2d_BN(net, DEPTHS[2], FILTER_SIZE, is_training, stride=STRIDE, name='conv_3', kernel_initializer=tf.truncated_normal_initializer( stddev=0.01)) z = tf.layers.dense( tf.layers.flatten(net), z_dim, kernel_initializer=tf.truncated_normal_initializer( stddev=0.01)) z = tf.nn.relu(tf.layers.batch_normalization(z, training=is_training), name='enc') return z self.x = tf.placeholder(tf.float32, shape=[None] + self.config.input_shape, name="input") self.y = tf.placeholder(tf.int32, shape=[None], name="label") self.is_training = tf.placeholder(tf.bool, name="is_training") # network architecture batch_norm_decay = 0.997 if self.config.get( 'bn_decay') == None else self.config.bn_decay output_stride = self.config.get('output_stride') if self.config.model == "resnet": with slim.arg_scope( resnet_v2.resnet_arg_scope( batch_norm_decay=batch_norm_decay)): net, end_points = resnet_v2.resnet_v2_50( self.x, N_CLASS, is_training=self.is_training, output_stride=output_stride) logits = tf.squeeze(end_points["resnet_v2_50/logits"], axis=[1, 2]) pred = tf.nn.softmax(logits, "pred") elif self.config.model == "resnet_101": with slim.arg_scope( resnet_v2.resnet_arg_scope( batch_norm_decay=batch_norm_decay)): pred, end_points = resnet_v2.resnet_v2_101( self.x, N_CLASS, is_training=self.is_training, output_stride=output_stride) logits = tf.squeeze(end_points["resnet_v2_101/logits"], axis=[1, 2]) pred = tf.nn.softmax(logits) elif self.config.model == "resnet_v1_50": with slim.arg_scope( resnet_v2.resnet_arg_scope( batch_norm_decay=batch_norm_decay)): pred, end_points = resnet_v1.resnet_v1_50( self.x, N_CLASS, is_training=self.is_training, output_stride=output_stride) logits = tf.squeeze(end_points["resnet_v1_50/logits"], axis=[1, 2]) pred = tf.nn.softmax(logits) else: z = encoder(self.x, z_dim=Z_DIM, is_training=self.is_training) logits = tf.layers.dense( z, N_CLASS, kernel_initializer=tf.truncated_normal_initializer( stddev=0.01)) pred = tf.nn.softmax(logits) self.pred = pred with tf.name_scope("loss"): self.loss = tf.reduce_mean(tf.losses.sparse_softmax_cross_entropy( labels=self.y, logits=logits), name='cross_entropy') update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) print(update_ops) with tf.control_dependencies(update_ops): self.train_op = tf.train.AdamOptimizer( self.config.learning_rate).minimize( self.loss, global_step=self.global_step_tensor) correct_prediction = tf.equal( tf.argmax(pred, 1, output_type=tf.int32), self.y) self.acc = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
#!/usr/bin/env python # -*- coding: utf-8 -*- # @ File ResNetDemo.py # @ Description : # @ Author alexchung # @ Time 21/1/2019 09:52 import tensorflow as tf import tensorflow.contrib.slim as slim from tensorflow.contrib.slim.python.slim.nets import resnet_v2 images = tf.Variable(initial_value=tf.random_uniform(shape=(5, 299, 299, 3), minval=0, maxval=3), dtype=tf.float32) num_classes = tf.constant(value=5, dtype=tf.int32) # is_training = True if __name__ == "__main__": init = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) with tf.Session() as sess: # images, class_num = sess.run([images, class_num]) sess.run(init) with slim.arg_scope(resnet_v2.resnet_arg_scope()): logits, end_points = resnet_v2.resnet_v2_101(images, num_classes=num_classes.eval(), is_training=True) for var in tf.model_variables(): print(var.name, var.shape)