def evalidate(flag, args): with tf.Graph().as_default(): queue_loader = data_loader(False, batch_size=args.bsize, num_epochs=args.ep, dataset_dir=args.dataset_dir) with slim.arg_scope(resnet_v2.resnet_arg_scope()): logits, end_points = resnet_v2.resnet_v2_101(queue_loader.images, num_classes=764, is_training=flag) names_to_values, names_to_updates = slim.metrics.aggregate_metric_map({ "accuracy": slim.metrics.accuracy(np.argmax(logits, 1), queue_loader.labels) }) for name, value in names_to_values.items(): op_name = 'eval_{}'.format(name) op = tf.summary.scalar(op_name, value) tf.add_to_collection(tf.GraphKeys.SUMMARIES, op) slim.evaluation.evaluate_once( master='', checkpoint_path=args.modelpath, logdir=args.evallog, num_evals=queue_loader.num_batches, eval_op=list(names_to_updates.values()), variables_to_restore=slim.get_variables_to_restore())
def forward(datas_train,is_training): if FLAGS.typenets == 'vggnet16': net = vggnet(datas_train) net = slim.fully_connected(net,num_classes,activation_fn=None,scope='fc1') #the last layer outputs = slim.softmax(net, scope='predictions') #outputs = tf.nn.softmax(net,namescope='output') elif FLAGS.typenets == 'resnet50': with slim.arg_scope(resnet_v2.resnet_arg_scope(is_training=is_training)): net,_ = resnet_v2.resnet_v2_50(datas_train,num_classes=num_classes) net = slim.flatten(net,scope='flat2') outputs = slim.softmax(net, scope='predictions') elif FLAGS.typenets == 'resnet101': with slim.arg_scope(resnet_v2.resnet_arg_scope(is_training=is_training)): net,_ = resnet_v2.resnet_v2_101(datas_train,num_classes=num_classes) net = slim.flatten(net,scope='flat2') outputs = slim.softmax(net, scope='predictions') elif FLAGS.typenets == 'resnet152': with slim.arg_scope(resnet_v2.resnet_arg_scope(is_training=is_training)): net,_ = resnet_v2.resnet_v2_152(datas_train,num_classes=num_classes) net = slim.flatten(net,scope='flat2') outputs = slim.softmax(net, scope='predictions') elif FLAGS.typenets == 'resnet200': with slim.arg_scope(resnet_v2.resnet_arg_scope(is_training=is_training)): net,_ = resnet_v2.resnet_v2_200(datas_train,num_classes=num_classes) net = slim.flatten(net,scope='flat2') outputs = slim.softmax(net, scope='predictions') elif FLAGS.typenets == 'simple': outputs = forward_simple(datas_train,is_training) return outputs
def build_frontend(inputs, frontend, is_training=True, pretrained_dir="models"): if frontend == 'ResNet50': with slim.arg_scope(resnet_v2.resnet_arg_scope()): logits, end_points = resnet_v2.resnet_v2_50( inputs, is_training=is_training, scope='resnet_v2_50') frontend_scope = 'resnet_v2_50' init_fn = slim.assign_from_checkpoint_fn( model_path=os.path.join(pretrained_dir, 'resnet_v2_50.ckpt'), var_list=slim.get_model_variables('resnet_v2_50'), ignore_missing_vars=True) elif frontend == 'ResNet101': with slim.arg_scope(resnet_v2.resnet_arg_scope()): logits, end_points = resnet_v2.resnet_v2_101( inputs, is_training=is_training, scope='resnet_v2_101') frontend_scope = 'resnet_v2_101' init_fn = slim.assign_from_checkpoint_fn( model_path=os.path.join(pretrained_dir, 'resnet_v2_101.ckpt'), var_list=slim.get_model_variables('resnet_v2_101'), ignore_missing_vars=True) elif frontend == 'ResNet152': with slim.arg_scope(resnet_v2.resnet_arg_scope()): logits, end_points = resnet_v2.resnet_v2_152( inputs, is_training=is_training, scope='resnet_v2_152') frontend_scope = 'resnet_v2_152' init_fn = slim.assign_from_checkpoint_fn( model_path=os.path.join(pretrained_dir, 'resnet_v2_152.ckpt'), var_list=slim.get_model_variables('resnet_v2_152'), ignore_missing_vars=True) elif frontend == 'MobileNetV2': with slim.arg_scope(mobilenet_v2.training_scope()): logits, end_points = mobilenet_v2.mobilenet( inputs, is_training=is_training, scope='mobilenet_v2', base_only=True) frontend_scope = 'mobilenet_v2' init_fn = slim.assign_from_checkpoint_fn( model_path=os.path.join(pretrained_dir, 'mobilenet_v2_1.4_224.ckpt'), var_list=slim.get_model_variables('mobilenet_v2'), ignore_missing_vars=True) elif frontend == 'InceptionV4': with slim.arg_scope(inception_v4.inception_v4_arg_scope()): logits, end_points = inception_v4.inception_v4( inputs, is_training=is_training, scope='inception_v4') frontend_scope = 'inception_v4' init_fn = slim.assign_from_checkpoint_fn( model_path=os.path.join(pretrained_dir, 'inception_v4.ckpt'), var_list=slim.get_model_variables('inception_v4'), ignore_missing_vars=True) else: raise ValueError( "Unsupported fronetnd model '%s'. This function only supports ResNet50, ResNet101, ResNet152, and MobileNetV2" % (frontend)) return logits, end_points, frontend_scope, init_fn
def build_deeplabv3_plus(inputs, num_classes, preset_model='DeepLabV3+-Res50', weight_decay=1e-5, is_training=True, pretrained_dir="models"): """ Builds the DeepLabV3 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: DeepLabV3 model """ if preset_model == 'DeepLabV3_plus-Res50': with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)): logits, end_points = resnet_v2.resnet_v2_50(inputs, is_training=is_training, scope='resnet_v2_50') resnet_scope='resnet_v2_50' # DeepLabV3 requires pre-trained ResNet weights init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_50.ckpt'), slim.get_model_variables('resnet_v2_50')) elif preset_model == 'DeepLabV3_plus-Res101': with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)): logits, end_points = resnet_v2.resnet_v2_101(inputs, is_training=is_training, scope='resnet_v2_101') resnet_scope='resnet_v2_101' # DeepLabV3 requires pre-trained ResNet weights init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_101.ckpt'), slim.get_model_variables('resnet_v2_101')) elif preset_model == 'DeepLabV3_plus-Res152': with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)): logits, end_points = resnet_v2.resnet_v2_152(inputs, is_training=is_training, scope='resnet_v2_152') resnet_scope='resnet_v2_152' # DeepLabV3 requires pre-trained ResNet weights init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_152.ckpt'), slim.get_model_variables('resnet_v2_152')) else: raise ValueError("Unsupported ResNet model '%s'. This function only supports ResNet 50, ResNet 101, and ResNet 152" % (preset_model)) label_size = tf.shape(inputs)[1:3] encoder_features = end_points['pool2'] net = AtrousSpatialPyramidPoolingModule(end_points['pool4']) net = slim.conv2d(net, 256, [1, 1], scope="conv_1x1_output", activation_fn=None) decoder_features = Upsampling(net, label_size / 4) encoder_features = slim.conv2d(encoder_features, 48, [1, 1], activation_fn=tf.nn.relu, normalizer_fn=None) net = tf.concat((encoder_features, decoder_features), axis=3) net = slim.conv2d(net, 256, [3, 3], activation_fn=tf.nn.relu, normalizer_fn=None) net = slim.conv2d(net, 256, [3, 3], activation_fn=tf.nn.relu, normalizer_fn=None) net = Upsampling(net, label_size) net = slim.conv2d(net, num_classes, [1, 1], activation_fn=None, scope='logits') return net, init_fn
def _build(self): reuse = True if self.built else None with slim.arg_scope(resnet_v2.resnet_arg_scope()): logits, end_points = resnet_v2.resnet_v2_101( self.input, num_classes=self.num_classes, is_training=False, reuse=reuse) self.built = True self.end_points = end_points self.logits = logits if not self.ckpt_loaded: saver = tf.train.Saver() saver.restore(self.sess, ckpt_dir + 'resnet_v2_101.ckpt') self.ckpt_loaded = True
def encoder_resnet101(input_x=None, n_classes=20, is_training=True): with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=1e-5)): logits, end_points = resnet_v2.resnet_v2_101(input_x, is_training=is_training, scope='resnet_v2_101') x = tf.keras.layers.GlobalAveragePooling2D()(logits) x = tf.keras.layers.Dense(n_classes, activation=None, name='predictions_no_softmax')(x) ''' same on tensorflow pure # Global average pooling x = tf.reduce_mean(x6_, [1,2]) # Last layer x = tf.layers.dense(x, n_classes) ''' return x
def build_pspnet(inputs, label_size, num_classes, preset_model='PSPNet-Res50', pooling_type="MAX", weight_decay=1e-5, upscaling_method="conv", is_training=True, pretrained_dir="models"): """ Builds the PSPNet model. Arguments: inputs: The input tensor label_size: Size of the final label tensor. We need to know this for proper upscaling preset_model: Which model you want to use. Select which ResNet model to use for feature extraction num_classes: Number of classes pooling_type: Max or Average pooling Returns: PSPNet model """ if preset_model == 'PSPNet-Res50': with slim.arg_scope( resnet_v2.resnet_arg_scope(weight_decay=weight_decay)): logits, end_points = resnet_v2.resnet_v2_50( inputs, is_training=is_training, scope='resnet_v2_50') resnet_scope = 'resnet_v2_50' # PSPNet requires pre-trained ResNet weights init_fn = slim.assign_from_checkpoint_fn( os.path.join(pretrained_dir, 'resnet_v2_50.ckpt'), slim.get_model_variables('resnet_v2_50')) elif preset_model == 'PSPNet-Res101': with slim.arg_scope( resnet_v2.resnet_arg_scope(weight_decay=weight_decay)): logits, end_points = resnet_v2.resnet_v2_101( inputs, is_training=is_training, scope='resnet_v2_101') resnet_scope = 'resnet_v2_101' # PSPNet requires pre-trained ResNet weights init_fn = slim.assign_from_checkpoint_fn( os.path.join(pretrained_dir, 'resnet_v2_101.ckpt'), slim.get_model_variables('resnet_v2_101')) elif preset_model == 'PSPNet-Res152': with slim.arg_scope( resnet_v2.resnet_arg_scope(weight_decay=weight_decay)): logits, end_points = resnet_v2.resnet_v2_152( inputs, is_training=is_training, scope='resnet_v2_152') resnet_scope = 'resnet_v2_152' # PSPNet requires pre-trained ResNet weights init_fn = slim.assign_from_checkpoint_fn( os.path.join(pretrained_dir, 'resnet_v2_152.ckpt'), slim.get_model_variables('resnet_v2_152')) else: raise ValueError( "Unsupported ResNet model '%s'. This function only supports ResNet 50, ResNet 101, and ResNet 152" % (preset_model)) feature_map_shape = [int(x / 8.0) for x in label_size] print(feature_map_shape) psp = PyramidPoolingModule(end_points['pool3'], feature_map_shape=feature_map_shape, pooling_type=pooling_type) net = slim.conv2d(psp, 512, [3, 3], activation_fn=None) net = slim.batch_norm(net, fused=True) net = tf.nn.relu(net) if upscaling_method.lower() == "conv": net = ConvUpscaleBlock(net, 256, kernel_size=[3, 3], scale=2) net = ConvBlock(net, 256) net = ConvUpscaleBlock(net, 128, kernel_size=[3, 3], scale=2) net = ConvBlock(net, 128) net = ConvUpscaleBlock(net, 64, kernel_size=[3, 3], scale=2) net = ConvBlock(net, 64) elif upscaling_method.lower() == "bilinear": net = Upsampling(net, label_size) net = slim.conv2d(net, num_classes, [1, 1], activation_fn=None, scope='logits') return net, init_fn
def build_gcn(inputs, num_classes, preset_model='GCN-Res101', weight_decay=1e-5, is_training=True, upscaling_method="bilinear", pretrained_dir="models"): """ Builds the GCN 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: GCN model """ inputs = mean_image_subtraction(inputs) if preset_model == 'GCN-Res50': with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)): logits, end_points = resnet_v2.resnet_v2_50(inputs, is_training=is_training, scope='resnet_v2_50') resnet_scope = 'resnet_v2_50' # GCN requires pre-trained ResNet weights init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_50.ckpt'), slim.get_model_variables('resnet_v2_50')) elif preset_model == 'GCN-Res101': with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)): logits, end_points = resnet_v2.resnet_v2_101(inputs, is_training=is_training, scope='resnet_v2_101') resnet_scope = 'resnet_v2_101' # GCN requires pre-trained ResNet weights init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_101.ckpt'), slim.get_model_variables('resnet_v2_101')) elif preset_model == 'GCN-Res152': with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)): logits, end_points = resnet_v2.resnet_v2_152(inputs, is_training=is_training, scope='resnet_v2_152') resnet_scope = 'resnet_v2_152' # GCN requires pre-trained ResNet weights init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_152.ckpt'), slim.get_model_variables('resnet_v2_152')) else: raise ValueError("Unsupported ResNet model '%s'. This function only supports ResNet 101 and ResNet 152" % (preset_model)) res = [end_points['pool5'], end_points['pool4'], end_points['pool3'], end_points['pool2']] down_5 = GlobalConvBlock(res[0], n_filters=21, size=3) down_5 = BoundaryRefinementBlock(down_5, n_filters=21, kernel_size=[3, 3]) down_5 = ConvUpscaleBlock(down_5, n_filters=21, kernel_size=[3, 3], scale=2) down_4 = GlobalConvBlock(res[1], n_filters=21, size=3) down_4 = BoundaryRefinementBlock(down_4, n_filters=21, kernel_size=[3, 3]) down_4 = tf.add(down_4, down_5) down_4 = BoundaryRefinementBlock(down_4, n_filters=21, kernel_size=[3, 3]) down_4 = ConvUpscaleBlock(down_4, n_filters=21, kernel_size=[3, 3], scale=2) down_3 = GlobalConvBlock(res[2], n_filters=21, size=3) down_3 = BoundaryRefinementBlock(down_3, n_filters=21, kernel_size=[3, 3]) down_3 = tf.add(down_3, down_4) down_3 = BoundaryRefinementBlock(down_3, n_filters=21, kernel_size=[3, 3]) down_3 = ConvUpscaleBlock(down_3, n_filters=21, kernel_size=[3, 3], scale=2) down_2 = GlobalConvBlock(res[3], n_filters=21, size=3) down_2 = BoundaryRefinementBlock(down_2, n_filters=21, kernel_size=[3, 3]) down_2 = tf.add(down_2, down_3) down_2 = BoundaryRefinementBlock(down_2, n_filters=21, kernel_size=[3, 3]) down_2 = ConvUpscaleBlock(down_2, n_filters=21, kernel_size=[3, 3], scale=2) net = BoundaryRefinementBlock(down_2, n_filters=21, kernel_size=[3, 3]) net = ConvUpscaleBlock(net, n_filters=21, kernel_size=[3, 3], scale=2) net = BoundaryRefinementBlock(net, n_filters=21, kernel_size=[3, 3]) net = slim.conv2d(net, num_classes, [1, 1], activation_fn=None, scope='logits') return net, init_fn
def test_resnet(device, num_classes, num_layers, dataset, normalization, checkpoint): """ Computes accuracy for the test dataset Inputs: device - gpu device num_classes - number of output classes num_layers - number of layers selected for ResNet dataset - dataset selected, options are val and test normalization - normalization used options are standard z-score normalization or unet normalization checkpoint - file where graph model weights are stored Output: None """ print dataset os.environ['CUDA_VISIBLE_DEVICES'] = str(device) # use nvidia-smi to see available options '0' means first gpu config = GleasonConfig() # loads pathology configuration if dataset == 'val': print "Using val..." config.test_fn = os.path.join(config.main_dir, 'tfrecords/val.tfrecords') elif dataset == 'test': print "Using test..." config.test_fn = os.path.join(config.main_dir, 'tfrecords/test.tfrecords') else: config.test_fn = None config.test_checkpoint = checkpoint print "Loading checkpoint: {0}".format(checkpoint) if int(num_classes) == 2: print "Converting to Output Shape to Binary..." config.output_shape = 2 elif int(num_classes) == 4: config.output_shape = 4 else: raise Exception('Invalid number of classes!') batch_size = 128 # loading test data test_meta = np.load(tfrecord2metafilename(config.test_fn)) print 'Using {0} tfrecords: {1} | {2} images'.format(dataset, config.test_fn, len(test_meta['labels'])) test_filename_queue = tf.train.string_input_producer([config.test_fn] , num_epochs=1) # 1 epoch, passing through the # the dataset once test_img, test_t_l, test_f_p = read_and_decode(filename_queue = test_filename_queue, img_dims = config.input_image_size, model_dims = config.model_image_size, size_of_batch = batch_size, augmentations_dic = config.val_augmentations_dic, num_of_threads = 4, shuffle = False) if int(num_classes) == 2: print "Converting labels to Binary..." test_t_l = tf.clip_by_value(test_t_l, 0, 1) if num_layers == "50": print "Loading Resnet 50..." if normalization == "standard": print "Using standard normalization..." test_img = normalize(test_img) elif normalization == "unet": print "Using unet normalization..." test_img,_ = unet_preprocess.unet(test_img, is_training = False, is_batch_norm = False, num_channels = 1) else: raise Exception('Not known normalization! Options are: standard and unet.') with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay = config.l2_reg)): test_target_logits, _ = resnet_v2.resnet_v2_50(inputs = test_img, num_classes = config.output_shape, is_training = False) elif num_layers == "101": print "Loading Resnet 101..." if normalization == "standard": print "Using standard normalization..." test_img = normalize(test_img) elif normalization == "unet": print "Using unet normalization..." test_img,_ = unet_preprocess.unet(test_img, is_training = False, is_batch_norm = False, num_channels = 1) else: raise Exception('Not known normalization! Options are: standard and unet.') with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay = config.l2_reg)): test_target_logits, _ = resnet_v2.resnet_v2_101(inputs = test_img, num_classes = config.output_shape, is_training = False) else: raise Expection("Wrong number of layers! allowed numbers are 50 and 101.") target_prob = tf.nn.softmax(test_target_logits) prob_and_label_files = [target_prob, test_t_l, test_f_p] restorer = tf.train.Saver() print "Variables stored in checkpoint:" print_tensors_in_checkpoint_file(file_name=config.test_checkpoint, tensor_name='', all_tensors='') with tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) as sess: sess.run(tf.group(tf.global_variables_initializer(),tf.local_variables_initializer())) restorer.restore(sess, config.test_checkpoint) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) all_predictions_target = [] all_predictions_t_n = [] all_labels = [] all_files = [] batch_num = 1 try: print "Total number of batch iterations needed: {0}".format(int(math.ceil(len(test_meta['labels'])/batch_size))) while not coord.should_stop(): np_prob_and_label_files = sess.run(prob_and_label_files) target_probs = np_prob_and_label_files[0] labels = np_prob_and_label_files[1] files = np_prob_and_label_files[2] all_labels += list(labels) all_files += list(files) all_predictions_target += list(np.argmax(target_probs, axis=1)) print "evaluating current batch number: {0}".format(batch_num) batch_num +=1 except tf.errors.OutOfRangeError: print "{0} accuracy: {1:.2f}".format(dataset, (metrics.accuracy_score(all_labels, all_predictions_target)*100)) if int(num_classes) == 2: print "{0} precision: {1:.2f}".format(dataset, (metrics.precision_score(all_labels, all_predictions_target)*100)) print "{0} recall: {1:.2f}".format(dataset, (metrics.recall_score(all_labels, all_predictions_target)*100)) print finally: coord.request_stop() coord.join(threads)
def encoder(self, x_ph, reuse=False, trainable=True): with tf.variable_scope(self.name): x_reshape = tf.tile(x_ph, [1,1,1,3]) with slim.arg_scope(resnet_v2.resnet_arg_scope()): logits, _ = resnet_v2.resnet_v2_101(x_reshape, 1001, is_training=True) return logits
def build_refinenet(inputs, num_classes, preset_model='RefineNet-Res101', weight_decay=1e-5, is_training=True, upscaling_method="bilinear", pretrained_dir="models"): """ Builds the RefineNet 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: RefineNet model """ if preset_model == 'RefineNet-Res50': with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)): logits, end_points = resnet_v2.resnet_v2_50(inputs, is_training=is_training, scope='resnet_v2_50') # RefineNet requires pre-trained ResNet weights init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_50.ckpt'), slim.get_model_variables('resnet_v2_50')) elif preset_model == 'RefineNet-Res101': with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)): logits, end_points = resnet_v2.resnet_v2_101(inputs, is_training=is_training, scope='resnet_v2_101') # RefineNet requires pre-trained ResNet weights init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_101.ckpt'), slim.get_model_variables('resnet_v2_101')) elif preset_model == 'RefineNet-Res152': with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)): logits, end_points = resnet_v2.resnet_v2_152(inputs, is_training=is_training, scope='resnet_v2_152') # RefineNet requires pre-trained ResNet weights init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_152.ckpt'), slim.get_model_variables('resnet_v2_152')) else: raise ValueError("Unsupported ResNet model '%s'. This function only supports ResNet 101 and ResNet 152" % (preset_model)) high = [end_points['pool5'], end_points['pool4'], end_points['pool3'], end_points['pool2']] low = [None, None, None, None] # Get the feature maps to the proper size with bottleneck high[0]=slim.conv2d(high[0], 512, 1) high[1]=slim.conv2d(high[1], 256, 1) high[2]=slim.conv2d(high[2], 256, 1) high[3]=slim.conv2d(high[3], 256, 1) # RefineNet low[0]=RefineBlock(high_inputs=high[0],low_inputs=None) # Only input ResNet 1/32 low[1]=RefineBlock(high[1],low[0]) # High input = ResNet 1/16, Low input = Previous 1/16 low[2]=RefineBlock(high[2],low[1]) # High input = ResNet 1/8, Low input = Previous 1/8 low[3]=RefineBlock(high[3],low[2]) # High input = ResNet 1/4, Low input = Previous 1/4 # g[3]=Upsampling(g[3],scale=4) net = low[3] net = ResidualConvUnit(net) net = ResidualConvUnit(net) if upscaling_method.lower() == "conv": net = ConvUpscaleBlock(net, 128, kernel_size=[3, 3], scale=2) net = ConvBlock(net, 128) net = ConvUpscaleBlock(net, 64, kernel_size=[3, 3], scale=2) net = ConvBlock(net, 64) elif upscaling_method.lower() == "bilinear": net = Upsampling(net, scale=4) net = slim.conv2d(net, num_classes, [1, 1], activation_fn=None, scope='logits') return net, init_fn
def build_icnet(inputs, label_size, num_classes, preset_model='ICNet-Res50', pooling_type = "MAX", weight_decay=1e-5, is_training=True, pretrained_dir="models"): """ Builds the ICNet model. Arguments: inputs: The input tensor label_size: Size of the final label tensor. We need to know this for proper upscaling preset_model: Which model you want to use. Select which ResNet model to use for feature extraction num_classes: Number of classes pooling_type: Max or Average pooling Returns: ICNet model """ inputs_4 = tf.image.resize_bilinear(inputs, size=[tf.shape(inputs)[1]*4, tf.shape(inputs)[2]*4]) inputs_2 = tf.image.resize_bilinear(inputs, size=[tf.shape(inputs)[1]*2, tf.shape(inputs)[2]*2]) inputs_1 = inputs if preset_model == 'ICNet-Res50': with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)): logits_32, end_points_32 = resnet_v2.resnet_v2_50(inputs_4, is_training=is_training, scope='resnet_v2_50') logits_16, end_points_16 = resnet_v2.resnet_v2_50(inputs_2, is_training=is_training, scope='resnet_v2_50') logits_8, end_points_8 = resnet_v2.resnet_v2_50(inputs_1, is_training=is_training, scope='resnet_v2_50') resnet_scope='resnet_v2_50' # ICNet requires pre-trained ResNet weights init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_50.ckpt'), slim.get_model_variables('resnet_v2_50')) elif preset_model == 'ICNet-Res101': with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)): logits_32, end_points_32 = resnet_v2.resnet_v2_101(inputs_4, is_training=is_training, scope='resnet_v2_101') logits_16, end_points_16 = resnet_v2.resnet_v2_101(inputs_2, is_training=is_training, scope='resnet_v2_101') logits_8, end_points_8 = resnet_v2.resnet_v2_101(inputs_1, is_training=is_training, scope='resnet_v2_101') resnet_scope='resnet_v2_101' # ICNet requires pre-trained ResNet weights init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_101.ckpt'), slim.get_model_variables('resnet_v2_101')) elif preset_model == 'ICNet-Res152': with slim.arg_scope(resnet_v2.resnet_arg_scope(weight_decay=weight_decay)): logits_32, end_points_32 = resnet_v2.resnet_v2_152(inputs_4, is_training=is_training, scope='resnet_v2_152') logits_16, end_points_16 = resnet_v2.resnet_v2_152(inputs_2, is_training=is_training, scope='resnet_v2_152') logits_8, end_points_8 = resnet_v2.resnet_v2_152(inputs_1, is_training=is_training, scope='resnet_v2_152') resnet_scope='resnet_v2_152' # ICNet requires pre-trained ResNet weights init_fn = slim.assign_from_checkpoint_fn(os.path.join(pretrained_dir, 'resnet_v2_152.ckpt'), slim.get_model_variables('resnet_v2_152')) else: raise ValueError("Unsupported ResNet model '%s'. This function only supports ResNet 50, ResNet 101, and ResNet 152" % (preset_model)) feature_map_shape = [int(x / 32.0) for x in label_size] block_32 = PyramidPoolingModule(end_points_32['pool3'], feature_map_shape=feature_map_shape, pooling_type=pooling_type) out_16, block_16 = CFFBlock(psp_32, end_points_16['pool3']) out_8, block_8 = CFFBlock(block_16, end_points_8['pool3']) out_4 = Upsampling_by_scale(out_8, scale=2) out_4 = slim.conv2d(out_4, num_classes, [1, 1], activation_fn=None) out_full = Upsampling_by_scale(out_4, scale=2) out_full = slim.conv2d(out_full, num_classes, [1, 1], activation_fn=None, scope='logits') net = tf.concat([out_16, out_8, out_4, out_final]) return net, init_fn
def build_deeplabv3(inputs, num_classes, preset_model='DeepLabV3-Res50', upscaling_method="bilinear", weight_decay=1e-5, is_training=True, pretrained_dir="models"): """ Builds the DeepLabV3 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: DeepLabV3 model """ inputs = mean_image_subtraction(inputs) if preset_model == 'DeepLabV3-Res50': with slim.arg_scope( resnet_v2.resnet_arg_scope(weight_decay=weight_decay)): logits, end_points = resnet_v2.resnet_v2_50( inputs, is_training=is_training, scope='resnet_v2_50') resnet_scope = 'resnet_v2_50' # DeepLabV3 requires pre-trained ResNet weights init_fn = slim.assign_from_checkpoint_fn( os.path.join(pretrained_dir, 'resnet_v2_50.ckpt'), slim.get_model_variables('resnet_v2_50')) elif preset_model == 'DeepLabV3-Res101': with slim.arg_scope( resnet_v2.resnet_arg_scope(weight_decay=weight_decay)): logits, end_points = resnet_v2.resnet_v2_101( inputs, is_training=is_training, scope='resnet_v2_101') resnet_scope = 'resnet_v2_101' # DeepLabV3 requires pre-trained ResNet weights init_fn = slim.assign_from_checkpoint_fn( os.path.join(pretrained_dir, 'resnet_v2_101.ckpt'), slim.get_model_variables('resnet_v2_101')) elif preset_model == 'DeepLabV3-Res152': with slim.arg_scope( resnet_v2.resnet_arg_scope(weight_decay=weight_decay)): logits, end_points = resnet_v2.resnet_v2_152( inputs, is_training=is_training, scope='resnet_v2_152') resnet_scope = 'resnet_v2_152' # DeepLabV3 requires pre-trained ResNet weights init_fn = slim.assign_from_checkpoint_fn( os.path.join(pretrained_dir, 'resnet_v2_152.ckpt'), slim.get_model_variables('resnet_v2_152')) else: raise ValueError( "Unsupported ResNet model '%s'. This function only supports ResNet 50, ResNet 101, and ResNet 152" % (preset_model)) label_size = tf.shape(inputs)[1:3] net = AtrousSpatialPyramidPoolingModule(end_points['pool5']) if upscaling_method.lower() == "conv": net = ConvUpscaleBlock(net, 256, kernel_size=[3, 3], scale=2) net = ConvBlock(net, 256) net = ConvUpscaleBlock(net, 128, kernel_size=[3, 3], scale=2) net = ConvBlock(net, 128) net = ConvUpscaleBlock(net, 64, kernel_size=[3, 3], scale=2) net = ConvBlock(net, 64) elif upscaling_method.lower() == "bilinear": net = Upsampling(net, label_size) net = slim.conv2d(net, num_classes, [1, 1], activation_fn=None, scope='logits') return net, init_fn
def train(flag, args): tf.reset_default_graph() queue_loader = data_loader(flag, batch_size=args.bsize, num_epochs=args.ep, dataset_dir=args.dataset_dir) with slim.arg_scope(resnet_v2.resnet_arg_scope()): logits, end_points = resnet_v2.resnet_v2_101(queue_loader.images, 764, is_training=flag) g_step = tf.Variable(0, trainable=False, dtype=tf.int64, name='g_step') # g_step = tf.train.create_global_step() decay_steps = int(math.floor(43971 / args.bsize * 2.0)) lr = tf.train.exponential_decay(args.lr, global_step=g_step, decay_steps=decay_steps, decay_rate=0.94, staircase=True) # loss_AuxLogits = tf.losses.sparse_softmax_cross_entropy( labels=queue_loader.labels, logits=end_points['AuxLogits'], weights=0.4) total_loss = tf.losses.sparse_softmax_cross_entropy( labels=queue_loader.labels, logits=logits, weights=1.0) # total_loss = tf.losses.get_total_loss(add_regularization_losses=False) # train_op = tf.train.RMSPropOptimizer(lr).minimize(total_loss) labels = queue_loader.labels correct = tf.equal(tf.argmax(logits, 1), labels) accuracy = tf.reduce_mean(tf.cast(correct, tf.float32)) # tf.summary.scalar('AuxLogits loss', loss_AuxLogits) tf.summary.scalar('accuracy', accuracy) tf.summary.scalar('total loss', total_loss) tf.summary.scalar('learnning_rate', lr) merged_op = tf.summary.merge_all() # for var in slim.get_model_variables(): # if var.op.name.startswith("Variabl"): # print(var) with tf.variable_scope('Adam_vars'): # optimizer = tf.train.AdamOptimizer(lr).minimize(loss_op,global_step=global_step) optimizer = tf.train.AdamOptimizer(lr) grads_vars_tuple_list = optimizer.compute_gradients(total_loss) grads, vars = zip(*grads_vars_tuple_list) new_grads, _ = tf.clip_by_global_norm(grads, 5) new_grads_vars_tuple_list = zip(new_grads, vars) train_op = optimizer.apply_gradients(new_grads_vars_tuple_list, global_step=g_step) # optimizer = tf.train.AdamOptimizer(lr) # grads_and_vars = optimizer.compute_gradients(loss_op) # for i,(grad,var) in enumerate(grads_and_vars): # if grad is not None: # grads_and_vars[i] = (tf.clip_by_norm(grad,5),var) # train_op = optimizer.apply_gradients(grads_and_vars,global_step=global_step) if len(os.listdir(args.modelpath)) > 0: var_to_restore = slim.get_model_variables() ckpt_path = tf.train.latest_checkpoint(args.modelpath) print('###########################ckpt_path', ckpt_path) else: # var_to_restore = slim.get_variables_to_restore(exclude=['InceptionV3/AuxLogits/Conv2d_1b_1x1', # 'InceptionV3/Logits/Conv2d_1b_1x1/Conv2d_1c_1x1']) var_to_restore = slim.get_variables_to_restore( exclude=['resnet_v2_101/logits', 'Adam_vars', 'g_step']) # 'InceptionV4/AuxLogits/Conv2d_1b_1x1/BatchNorm/beta/Adam', # 'InceptionV4/AuxLogits/Conv2d_1b_1x1/weights/Adam' # Aux_logit = slim.get_variables_to_restore(include=['InceptionV4/AuxLogits/Aux_logits']) # Logit = slim.get_variables_to_restore(include=['InceptionV4/Logits/Logits']) # adam = slim.get_variables_to_restore(include=['Adam_vars']) ckpt_path = tf.train.latest_checkpoint(args.dataset_dir2) print('###########################ckpt_path', ckpt_path) # Aux_logit_init = tf.variables_initializer(Aux_logit) # Logit_init = tf.variables_initializer(Logit) # adam_init = tf.variables_initializer(adam) init_func = slim.assign_from_checkpoint_fn(ckpt_path, var_to_restore) saver = tf.train.Saver(max_to_keep=1) config = tf.ConfigProto() config.gpu_options.allow_growth = True sess = tf.Session(config=config) writer = tf.summary.FileWriter(args.trainlog, sess.graph) sess.run( tf.group(tf.global_variables_initializer(), tf.local_variables_initializer())) # sess.run(Aux_logit_init) # sess.run(Logit_init) # sess.run(adam_init) init_func(sess) print( '###################################### restore checkpoint sucessful#######################' ) print('Start training') print('batch size: %d, epoch: %d, initial learning rate: %.3f' % (args.bsize, args.ep, args.lr)) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) try: ep = 1 correct_all = 0 start = datetime.now() while not coord.should_stop(): # logit, loss, correct_list, _, summary,acc,g_s= sess.run([ # logits,loss_op,correct, train_op, merged_op,accuracy,global_step]) logit, loss, correct_list, _, summary, acc, g_s, l = sess.run([ logits, total_loss, correct, train_op, merged_op, accuracy, g_step, lr ]) writer.add_summary(summary, g_s) # print('argmax logits',np.argmax(logits,1),sess.run(queue_loader.labels)) # print('correct.sum : ',correct.sum()) correct_all += correct_list.sum() # step_accuracy = correct_list.sum()*100.0/args.bsize if g_s % 10 == 0: end_time = datetime.now() print( 'epoch: %2d, globle_step: %3d,accuracy : %.2f%%,loss: %.3f, cost time : %s sec' % (ep, g_s, acc * 100.0, loss, end_time - start)) start = datetime.now() if g_s != 0 and g_s % queue_loader.num_batches == 0: print('EPOCH %2d is end, ACCURACY: %.2f%%.' % (ep, correct_all * 100.0 / (queue_loader.num_batches * args.bsize))) saver.save(sess, os.path.join(args.modelpath, 'model.ckpt'), global_step=g_s) ep += 1 correct_all = 0 except tf.errors.OutOfRangeError: print('\nDone training, epoch limit: %d reached.' % (ep)) finally: coord.request_stop() coord.join(threads) sess.close() print('Done')
def build_refinenet(inputs, num_classes, preset_model='RefineNet-Res101', weight_decay=1e-5, is_training=True, upscaling_method="bilinear", pretrained_dir="models"): """ Builds the RefineNet 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: RefineNet model """ inputs = mean_image_subtraction(inputs) if preset_model == 'RefineNet-Res50': with slim.arg_scope( resnet_v2.resnet_arg_scope(weight_decay=weight_decay)): logits, end_points = resnet_v2.resnet_v2_50( inputs, is_training=is_training, scope='resnet_v2_50') # RefineNet requires pre-trained ResNet weights init_fn = slim.assign_from_checkpoint_fn( os.path.join(pretrained_dir, 'resnet_v2_50.ckpt'), slim.get_model_variables('resnet_v2_50')) elif preset_model == 'RefineNet-Res101': with slim.arg_scope( resnet_v2.resnet_arg_scope(weight_decay=weight_decay)): logits, end_points = resnet_v2.resnet_v2_101( inputs, is_training=is_training, scope='resnet_v2_101') # RefineNet requires pre-trained ResNet weights init_fn = slim.assign_from_checkpoint_fn( os.path.join(pretrained_dir, 'resnet_v2_101.ckpt'), slim.get_model_variables('resnet_v2_101')) elif preset_model == 'RefineNet-Res152': with slim.arg_scope( resnet_v2.resnet_arg_scope(weight_decay=weight_decay)): logits, end_points = resnet_v2.resnet_v2_152( inputs, is_training=is_training, scope='resnet_v2_152') # RefineNet requires pre-trained ResNet weights init_fn = slim.assign_from_checkpoint_fn( os.path.join(pretrained_dir, 'resnet_v2_152.ckpt'), slim.get_model_variables('resnet_v2_152')) else: raise ValueError( "Unsupported ResNet model '%s'. This function only supports ResNet 101 and ResNet 152" % (preset_model)) f = [ end_points['pool5'], end_points['pool4'], end_points['pool3'], end_points['pool2'] ] g = [None, None, None, None] h = [None, None, None, None] for i in range(4): h[i] = slim.conv2d(f[i], 256, 1) g[0] = RefineBlock(high_inputs=None, low_inputs=h[0]) g[1] = RefineBlock(g[0], h[1]) g[2] = RefineBlock(g[1], h[2]) g[3] = RefineBlock(g[2], h[3]) # g[3]=Upsampling(g[3],scale=4) net = g[3] if upscaling_method.lower() == "conv": net = ConvUpscaleBlock(net, 256, kernel_size=[3, 3], scale=2) net = ConvBlock(net, 256) net = ConvUpscaleBlock(net, 128, kernel_size=[3, 3], scale=2) net = ConvBlock(net, 128) net = ConvUpscaleBlock(net, 64, kernel_size=[3, 3], scale=2) net = ConvBlock(net, 64) elif upscaling_method.lower() == "bilinear": net = Upsampling(net, scale=4) net = slim.conv2d(net, num_classes, [1, 1], activation_fn=None, scope='logits') return net, init_fn
def _resnet_v2(self, is_training): with slim.arg_scope(resnet_arg_scope()): pool, _ = resnet_v2_101(self._image, is_training=is_training) return pool