├── .idea
├── misc.xml
├── modules.xml
├── semantic_segmentation_contest_deeplabv3.iml
├── vcs.xml
└── workspace.xml
├── DataGenerate
└── __pycache__
│ ├── GetDataset.cpython-36.pyc
│ └── __init__.cpython-36.pyc
├── GeneratingBatchSize
├── GetDataset.py
└── __init__.py
├── GeneratingDatasets
└── get_new_dataset.py
├── NET
├── __init__.py
├── __pycache__
│ └── __init__.cpython-36.pyc
├── aaf
│ ├── __init__.py
│ ├── __pycache__
│ │ ├── __init__.cpython-36.pyc
│ │ └── layers.cpython-36.pyc
│ ├── layers.py
│ └── losses.py
├── deeplab_v3.py
├── deeplabv3_DA.py
├── deeplabv3_plus.py
├── pspnet.py
├── resnet_v2
│ ├── __init__.py
│ ├── __pycache__
│ │ ├── __init__.cpython-36.pyc
│ │ ├── resnet_utils.cpython-36.pyc
│ │ └── resnet_v2.cpython-36.pyc
│ ├── resnet_utils.py
│ └── resnet_v2.py
├── resnet_v2_psp
│ ├── __init__.py
│ ├── __pycache__
│ │ ├── __init__.cpython-36.pyc
│ │ ├── resnet_utils.cpython-36.pyc
│ │ └── resnet_v2.cpython-36.pyc
│ ├── resnet_utils.py
│ └── resnet_v2.py
└── self_attention_layers
│ ├── __init__.py
│ ├── __pycache__
│ ├── __init__.cpython-36.pyc
│ └── self_attention_layers.cpython-36.pyc
│ └── self_attention_layers.py
├── README.md
├── eval.py
├── resource
├── 1.png
├── 2.png
└── 语义分割比赛进展.pptx
├── test1000_stride_400.py
├── test_stride_400.py
├── tools_aaf.py
├── tools_deeplabv3.py
├── tools_deeplabv3_DA.py
├── tools_deeplabv3plus.py
├── tools_psp.py
├── train_aaf.py
├── train_deeplabv3.py
├── train_deeplabv3_DA.py
├── train_deeplabv3plus.py
├── train_deeplabv3plus_4chanel.py
├── train_psp.py
└── utils
├── __init__.py
├── __pycache__
└── __init__.cpython-36.pyc
└── preprocessing.py
/.idea/misc.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
--------------------------------------------------------------------------------
/.idea/modules.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/.idea/semantic_segmentation_contest_deeplabv3.iml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
--------------------------------------------------------------------------------
/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/.idea/workspace.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 | _NUM_CLASSES
34 |
35 |
36 |
37 |
38 |
39 |
40 |
48 |
49 |
50 |
58 |
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 |
71 |
72 |
73 |
14 | 
15 |
16 |
17 | 
18 |
19 |
20 | 总结：
21 | 第一步：做数据集（1000*1000）。（这期间出现了问题，我们使用cv2读取的RGB通道数据，取得了最好的成绩。但是cv2读取不了红外通道数据，然后我们换成libtiff
22 | 读取数据时，发现libtif数据的RGB数据与cv2不一样，然后我们使用libtiff的RGB跑出的结果又没有cv2的RGB数据高。最后我们由于时间的关系，只使用cv2的RGB数据）
23 | 第二步：选择网络，最开始我们使用unet,效果不好，后来就直接使用deeplabv3了，后来又用了v3+, DA的模块，pspnet, aaf等。
24 | 效果都不太好，deeplabv3效果是最好的。然后看结果找问题，找解决方法。
25 | 第三步：测试，我们只使用了一个1000*1000留下其中400*400的结果。
26 | 使用滚动引导滤波先预处理图像。（由于时间关系还没有做）
--------------------------------------------------------------------------------
/eval.py:
--------------------------------------------------------------------------------
1 | from utils import dataset_util
2 | from DataGenerate.GetDataset import eval_or_test_input_fn
3 | import tensorflow as tf
4 | import os
5 | import argparse
6 |
7 | evaluation_data_list = "./VOC2012_AUG/txt/val.txt"
8 | parser = argparse.ArgumentParser()
9 |
10 | #添加参数
11 | envarg = parser.add_argument_group('Training params')
12 | envarg.add_argument("--batch_norm_epsilon", type=float, default=1e-5, help="batch norm epsilon argument for batch normalization")
13 | envarg.add_argument('--batch_norm_decay', type=float, default=0.9997, help='batch norm decay argument for batch normalization.')
14 | envarg.add_argument("--number_of_classes", type=int, default=16, help="Number of classes to be predicted.")
15 | envarg.add_argument("--l2_regularizer", type=float, default=0.0001, help="l2 regularizer parameter.")
16 | envarg.add_argument('--starting_learning_rate', type=float, default=0.00001, help="initial learning rate.")
17 | envarg.add_argument('--learning_rate', type=float, default=0.00001, help="initial learning rate.")
18 | envarg.add_argument("--multi_grid", type=list, default=[1, 2, 4], help="Spatial Pyramid Pooling rates")
19 | envarg.add_argument("--output_stride", type=int, default=16, help="Spatial Pyramid Pooling rates")
20 | envarg.add_argument("--gpu_id", type=int, default=0, help="Id of the GPU to be used")
21 | envarg.add_argument("--crop_size", type=int, default=513, help="Image Cropsize.")
22 | envarg.add_argument("--resnet_model", default="resnet_v2_50", choices=["resnet_v2_50", "resnet_v2_101", "resnet_v2_152", "resnet_v2_200"], help="Resnet model to use as feature extractor. Choose one of: resnet_v2_50 or resnet_v2_101")
23 | envarg.add_argument('--learning_power', type=float, default=0.9, help='batch norm decay argument for batch normalization.')
24 | envarg.add_argument("--current_best_val_loss", type=int, default=99999, help="Best validation loss value.")
25 | envarg.add_argument("--accumulated_validation_miou", type=int, default=0, help="Accumulated validation intersection over union.")
26 | args = parser.parse_args()
27 | def main():
28 | os.environ['TF_ENABLE_WINOGRAD_NONFUSED'] = '0'
29 |
30 | # 获取数据
31 | examples = dataset_util.read_examples_list(FLAGS.evaluation_data_list)
32 | image_files = [os.path.join(FLAGS.image_data_dir, filename) + '.jpg' for filename in examples]
33 | label_files = [os.path.join(FLAGS.label_data_dir, filename) + '.png' for filename in examples]
34 |
35 | features, labels = eval_or_test_input_fn.eval_input_fn(image_files, label_files)
36 |
37 | # Manually load the latest checkpoint
38 | saver = tf.train.Saver()
39 | with tf.Session() as sess:
40 | ckpt = tf.train.get_checkpoint_state(FLAGS.model_dir)
41 | saver.restore(sess, ckpt.model_checkpoint_path)
42 |
43 |
44 |
45 | if __name__ == '__main__':
46 | tf.logging.set_verbosity(tf.logging.INFO)
47 | FLAGS, unparsed = parser.parse_known_args()
48 | tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)
--------------------------------------------------------------------------------
/resource/1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tangzhenjie/semantic_segmentation_contest/df3df24296f26209950a2455ed2f7751a9e046ca/resource/1.png
--------------------------------------------------------------------------------
/resource/2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tangzhenjie/semantic_segmentation_contest/df3df24296f26209950a2455ed2f7751a9e046ca/resource/2.png
--------------------------------------------------------------------------------
/resource/语义分割比赛进展.pptx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tangzhenjie/semantic_segmentation_contest/df3df24296f26209950a2455ed2f7751a9e046ca/resource/语义分割比赛进展.pptx
--------------------------------------------------------------------------------
/test1000_stride_400.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 | import cv2
3 | import os
4 | import argparse
5 | import tensorflow as tf
6 | from NET import deeplab_v3
7 | from utils.preprocessing import decode_labels
8 |
9 | checkpoint_path = "./checkpoint_1000/"
10 | image_size = 1000
11 | stride = 400
12 | def predict(TEST_SET, sess, prediction, imgs_batch):
13 | for n in range(len(TEST_SET)):
14 |
15 | path = TEST_SET[n] # load the image
16 | image = cv2.imread('/2T/tzj/semantic_segmentation_contest/DatasetNew/test/' + path, cv2.IMREAD_UNCHANGED)
17 | h, w, chanel = image.shape
18 |
19 | result = np.zeros((h, w, 3), dtype=np.uint8)
20 |
21 | padding_h = h + 600
22 | padding_w = w + 600
23 | padding_img = np.zeros((padding_h, padding_w, 3), dtype=np.uint8)
24 | padding_img[300:300 + h, 300:300 + w, :] = image[:, :, 0:3]
25 | mask_whole = np.zeros((padding_h, padding_w, 3), dtype=np.uint8)
26 | for i in range(((padding_h - 1000) // stride) + 1):
27 | for j in range(((padding_w - 1000) // stride) + 1):
28 | crop = padding_img[i * stride:i * stride + image_size, j * stride:j * stride + image_size, :]
29 | ch, cw, _ = crop.shape
30 | if ch != 1000 or cw != 1000:
31 | print('invalid size!')
32 | continue
33 | img_batch = np.expand_dims(crop, axis=0)
34 | pred = sess.run(prediction, feed_dict={imgs_batch: img_batch})
35 | pred = decode_labels(pred)
36 | mask_whole[300 + i * stride: 300 + i * stride + stride, 300 + j * stride: 300 + j * stride + stride, :] = pred[0][300:700, 300:700, :]
37 | print("i:%d" % i, "j:%d" % j)
38 | result[0:h, 0:w, :] = mask_whole[300:300 + h, 300:300 + w, :]
39 | result_bgr = result[..., ::-1]
40 | cv2.imwrite("./Result1000_stride_400/" + path.split(".")[0] + "_label.tif", result_bgr)
41 | print("./Result_stride_400/" + path.split(".")[0] + "_label.tif saved")
42 |
43 | #cv2.imwrite('./predict/pre' + str(n + 1) + '.png', mask_whole[0:h, 0:w])
44 | # 获取全部测试集图片
45 | TEST_SET = os.listdir('/2T/tzj/semantic_segmentation_contest/DatasetNew/test')
46 |
47 | parser = argparse.ArgumentParser()
48 |
49 | #添加参数
50 | envarg = parser.add_argument_group('Training params')
51 | # BN params
52 | envarg.add_argument("--batch_norm_epsilon", type=float, default=1e-5, help="batch norm epsilon argument for batch normalization")
53 | envarg.add_argument('--batch_norm_decay', type=float, default=0.9997, help='batch norm decay argument for batch normalization.')
54 | envarg.add_argument('--freeze_batch_norm', type=bool, default=False, help='Freeze batch normalization parameters during the training.')
55 | # the number of classes
56 | envarg.add_argument("--number_of_classes", type=int, default=16, help="Number of classes to be predicted.")
57 |
58 | # regularizer
59 | envarg.add_argument("--l2_regularizer", type=float, default=0.0001, help="l2 regularizer parameter.")
60 |
61 | # for deeplabv3
62 | envarg.add_argument("--multi_grid", type=list, default=[1, 2, 4], help="Spatial Pyramid Pooling rates")
63 | envarg.add_argument("--output_stride", type=int, default=16, help="Spatial Pyramid Pooling rates")
64 |
65 | # the base network
66 | envarg.add_argument("--resnet_model", default="resnet_v2_50", choices=["resnet_v2_50", "resnet_v2_101", "resnet_v2_152", "resnet_v2_200"], help="Resnet model to use as feature extractor. Choose one of: resnet_v2_50 or resnet_v2_101")
67 |
68 | # the pre_trained model for example resnet50 101 and so on
69 | envarg.add_argument('--pre_trained_model', type=str, default='./pre_trained_model/resnet_v2_50/resnet_v2_50.ckpt',
70 | help='Path to the pre-trained model checkpoint.')
71 |
72 | # max number of batch elements to tensorboard
73 | parser.add_argument('--tensorboard_images_max_outputs', type=int, default=6,
74 | help='Max number of batch elements to generate for Tensorboard.')
75 | # poly learn_rate
76 | parser.add_argument('--initial_learning_rate', type=float, default=7e-4,
77 | help='Initial learning rate for the optimizer.')
78 |
79 | parser.add_argument('--end_learning_rate', type=float, default=1e-6,
80 | help='End learning rate for the optimizer.')
81 |
82 | parser.add_argument('--initial_global_step', type=int, default=0,
83 | help='Initial global step for controlling learning rate when fine-tuning model.')
84 | parser.add_argument('--max_iter', type=int, default=25000,
85 | help='Number of maximum iteration used for "poly" learning rate policy.')
86 | args = parser.parse_args()
87 |
88 | img_batch = tf.placeholder("float32", shape=[None, 1000, 1000, 3], name="img_batch")
89 | # 损失
90 |
91 | logits = deeplab_v3.deeplab_v3(img_batch, args, is_training=False, reuse=False)
92 | prediction = tf.argmax(logits, axis=3)
93 | prediction = tf.expand_dims(prediction, axis=3)
94 |
95 | init_op = tf.group(
96 | tf.local_variables_initializer(),
97 | tf.global_variables_initializer()
98 | )
99 | saver = tf.train.Saver()
100 | # 运行图
101 | config = tf.ConfigProto()
102 | config.gpu_options.allow_growth = True
103 | with tf.Session(config=config) as sess:
104 | sess.run(init_op)
105 | # 恢复权重
106 | ckpt = tf.train.get_checkpoint_state(checkpoint_path)
107 | if ckpt and ckpt.model_checkpoint_path:
108 | saver.restore(sess, checkpoint_path + "model.ckpt-26")
109 | print("restored!!!")
110 | predict(TEST_SET=TEST_SET, sess=sess, prediction=prediction, imgs_batch=img_batch)
--------------------------------------------------------------------------------
/test_stride_400.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 | import cv2
3 | import os
4 | import argparse
5 | import tensorflow as tf
6 | from NET import deeplab_v3
7 | from utils.preprocessing import decode_labels
8 |
9 | checkpoint_path = "./checkpoint_1000/"
10 | image_size = 500
11 | stride = 400
12 | def predict(TEST_SET, sess, prediction, imgs_batch):
13 | for n in range(len(TEST_SET)):
14 |
15 | path = TEST_SET[n] # load the image
16 | image = cv2.imread('/2T/tzj/semantic_segmentation_contest/DatasetOrigin/val/' + path, cv2.IMREAD_UNCHANGED)
17 | h, w, chanel = image.shape
18 |
19 | result = np.zeros((h, w, 3), dtype=np.uint8)
20 |
21 | padding_h = h + 100
22 | padding_w = w + 100
23 | padding_img = np.zeros((padding_h, padding_w, 3), dtype=np.uint8)
24 | padding_img[50:50 + h, 50:50 + w, :] = image[:, :, 0:3]
25 | mask_whole = np.zeros((padding_h, padding_w, 3), dtype=np.uint8)
26 | for i in range(padding_h // stride):
27 | for j in range(padding_w // stride):
28 | crop = padding_img[i * stride:i * stride + image_size, j * stride:j * stride + image_size, :]
29 | ch, cw, _ = crop.shape
30 | if ch != 500 or cw != 500:
31 | print('invalid size!')
32 | continue
33 | img_batch = np.expand_dims(crop, axis=0)
34 | pred = sess.run(prediction, feed_dict={imgs_batch: img_batch})
35 | pred = decode_labels(pred)
36 | mask_whole[50 + i * stride: 50 + i * stride + stride, 50 + j * stride: 50 + j * stride + stride, :] = pred[0][50:450, 50:450, :]
37 | print("i:%d" % i, "j:%d" % j)
38 | result[0:h, 0:w, :] = mask_whole[50:50 + h, 50:50 + w, :]
39 | result_bgr = result[..., ::-1]
40 | cv2.imwrite("./Result_stride_400/" + path.split(".")[0] + "_label.tif", result_bgr)
41 | print("./Result_stride_400/" + path.split(".")[0] + "_label.tif saved")
42 |
43 | #cv2.imwrite('./predict/pre' + str(n + 1) + '.png', mask_whole[0:h, 0:w])
44 | # 获取全部测试集图片
45 | TEST_SET = os.listdir('/2T/tzj/semantic_segmentation_contest/DatasetOrigin/val')
46 |
47 | parser = argparse.ArgumentParser()
48 |
49 | #添加参数
50 | envarg = parser.add_argument_group('Training params')
51 | # BN params
52 | envarg.add_argument("--batch_norm_epsilon", type=float, default=1e-5, help="batch norm epsilon argument for batch normalization")
53 | envarg.add_argument('--batch_norm_decay', type=float, default=0.9997, help='batch norm decay argument for batch normalization.')
54 | envarg.add_argument('--freeze_batch_norm', type=bool, default=False, help='Freeze batch normalization parameters during the training.')
55 | # the number of classes
56 | envarg.add_argument("--number_of_classes", type=int, default=16, help="Number of classes to be predicted.")
57 |
58 | # regularizer
59 | envarg.add_argument("--l2_regularizer", type=float, default=0.0001, help="l2 regularizer parameter.")
60 |
61 | # for deeplabv3
62 | envarg.add_argument("--multi_grid", type=list, default=[1, 2, 4], help="Spatial Pyramid Pooling rates")
63 | envarg.add_argument("--output_stride", type=int, default=16, help="Spatial Pyramid Pooling rates")
64 |
65 | # the base network
66 | envarg.add_argument("--resnet_model", default="resnet_v2_50", choices=["resnet_v2_50", "resnet_v2_101", "resnet_v2_152", "resnet_v2_200"], help="Resnet model to use as feature extractor. Choose one of: resnet_v2_50 or resnet_v2_101")
67 |
68 | # the pre_trained model for example resnet50 101 and so on
69 | envarg.add_argument('--pre_trained_model', type=str, default='./pre_trained_model/resnet_v2_50/resnet_v2_50.ckpt',
70 | help='Path to the pre-trained model checkpoint.')
71 |
72 | # max number of batch elements to tensorboard
73 | parser.add_argument('--tensorboard_images_max_outputs', type=int, default=6,
74 | help='Max number of batch elements to generate for Tensorboard.')
75 | # poly learn_rate
76 | parser.add_argument('--initial_learning_rate', type=float, default=7e-4,
77 | help='Initial learning rate for the optimizer.')
78 |
79 | parser.add_argument('--end_learning_rate', type=float, default=1e-6,
80 | help='End learning rate for the optimizer.')
81 |
82 | parser.add_argument('--initial_global_step', type=int, default=0,
83 | help='Initial global step for controlling learning rate when fine-tuning model.')
84 | parser.add_argument('--max_iter', type=int, default=25000,
85 | help='Number of maximum iteration used for "poly" learning rate policy.')
86 | args = parser.parse_args()
87 |
88 | img_batch = tf.placeholder("float32", shape=[None, 500, 500, 3], name="img_batch")
89 | # 损失
90 |
91 | logits = deeplab_v3.deeplab_v3(img_batch, args, is_training=False, reuse=False)
92 | prediction = tf.argmax(logits, axis=3)
93 | prediction = tf.expand_dims(prediction, axis=3)
94 |
95 | init_op = tf.group(
96 | tf.local_variables_initializer(),
97 | tf.global_variables_initializer()
98 | )
99 | saver = tf.train.Saver()
100 | # 运行图
101 | config = tf.ConfigProto()
102 | config.gpu_options.allow_growth = True
103 | with tf.Session(config=config) as sess:
104 | sess.run(init_op)
105 | # 恢复权重
106 | ckpt = tf.train.get_checkpoint_state(checkpoint_path)
107 | if ckpt and ckpt.model_checkpoint_path:
108 | saver.restore(sess, checkpoint_path + "model.ckpt-10")
109 | predict(TEST_SET=TEST_SET, sess=sess, prediction=prediction, imgs_batch=img_batch)
--------------------------------------------------------------------------------
/tools_aaf.py:
--------------------------------------------------------------------------------
1 | from NET import deeplab_v3
2 | from utils import preprocessing
3 | import tensorflow as tf
4 | import numpy as np
5 | import NET.aaf.layers as nnx
6 |
7 | _WEIGHT_DECAY = 5e-4
8 |
9 |
10 | def get_loss_pre_metrics(x, y, is_training, batch_size, args):
11 | # 恢复图像
12 | images = tf.cast(x, tf.uint8)
13 |
14 | # 前向传播
15 | logits = tf.cond(is_training, true_fn=lambda: deeplab_v3.deeplab_v3(x, args, is_training=True, reuse=False),
16 | false_fn=lambda: deeplab_v3.deeplab_v3(x, args, is_training=False, reuse=True))
17 | pred_classes = tf.expand_dims(tf.argmax(logits, axis=3, output_type=tf.int32), axis=3)
18 |
19 | # 解码预测结果
20 | pred_decoded_labels = tf.py_func(preprocessing.decode_labels, [pred_classes, batch_size, args.number_of_classes], tf.uint8)
21 |
22 |
23 | # 解码标签
24 | gt_decoded_labels = tf.py_func(preprocessing.decode_labels, [y, batch_size, args.number_of_classes], tf.uint8)
25 |
26 |
27 | tf.summary.image('images', tf.concat(axis=2, values=[images, gt_decoded_labels, pred_decoded_labels]),
28 | max_outputs=args.tensorboard_images_max_outputs)
29 |
30 | # 求loss
31 | labels = tf.squeeze(y, axis=3) # reduce the channel dimension.
32 | logits_by_num_classes = tf.reshape(logits, [-1, args.number_of_classes])
33 | labels_flat = tf.reshape(labels, [-1, ])
34 |
35 | cross_entropy = tf.losses.sparse_softmax_cross_entropy(
36 | logits=logits_by_num_classes, labels=labels_flat)
37 |
38 | if not args.freeze_batch_norm:
39 | train_var_list = [v for v in tf.trainable_variables()]
40 | else:
41 | train_var_list = [v for v in tf.trainable_variables()
42 | if 'beta' not in v.name and 'gamma' not in v.name]
43 |
44 | global_step = tf.train.get_or_create_global_step()
45 | with tf.variable_scope("total_loss"):
46 | loss = cross_entropy + _WEIGHT_DECAY * tf.add_n(
47 | [tf.nn.l2_loss(v) for v in train_var_list])
48 | # affinity loss
49 | edge_loss, not_edge_loss = affinity_loss(labels=y, probs=logits,
50 | num_classes=args.number_of_classes,
51 | kld_margin=args.kld_margin)
52 |
53 | dec = tf.pow(10.0, tf.cast(-global_step / args.max_iter, tf.float32))
54 | aff_loss = tf.reduce_mean(edge_loss) * args.kld_lambda_1 * dec
55 | aff_loss += tf.reduce_mean(not_edge_loss) * args.kld_lambda_2 * dec
56 |
57 | total_loss = loss + aff_loss
58 | tf.summary.scalar('loss', total_loss)
59 | # 优化函数
60 | learning_rate = tf.train.polynomial_decay(
61 | args.initial_learning_rate,
62 | tf.cast(global_step, tf.int32) - args.initial_global_step,
63 | args.max_iter, args.end_learning_rate, power=0.9) # args.max_iter = 30000 args.initial_global_step=0
64 | tf.summary.scalar('learning_rate', learning_rate)
65 |
66 | optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=0.9)
67 |
68 | # Batch norm requires update ops to be added as a dependency to the train_op
69 | update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
70 | with tf.control_dependencies(update_ops):
71 | train_op = optimizer.minimize(total_loss, global_step, var_list=train_var_list)
72 |
73 | # metrics
74 | preds_flat = tf.reshape(pred_classes, [-1, ])
75 | confusion_matrix = tf.confusion_matrix(labels_flat, preds_flat, num_classes=args.number_of_classes)
76 |
77 | correct_pred = tf.equal(preds_flat, labels_flat)
78 | accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
79 | tf.summary.scalar('accuracy', accuracy)
80 |
81 | def compute_mean_iou(total_cm, name='mean_iou'):
82 | """Compute the mean intersection-over-union via the confusion matrix."""
83 | sum_over_row = tf.to_float(tf.reduce_sum(total_cm, 0))
84 | sum_over_col = tf.to_float(tf.reduce_sum(total_cm, 1))
85 | cm_diag = tf.to_float(tf.diag_part(total_cm))
86 | denominator = sum_over_row + sum_over_col - cm_diag
87 |
88 | # The mean is only computed over classes that appear in the
89 | # label or prediction tensor. If the denominator is 0, we need to
90 | # ignore the class.
91 | num_valid_entries = tf.reduce_sum(tf.cast(
92 | tf.not_equal(denominator, 0), dtype=tf.float32))
93 |
94 | # If the value of the denominator is 0, set it to 1 to avoid
95 | # zero division.
96 | denominator = tf.where(
97 | tf.greater(denominator, 0),
98 | denominator,
99 | tf.ones_like(denominator))
100 | iou = tf.div(cm_diag, denominator)
101 |
102 | for i in range(args.number_of_classes):
103 | tf.identity(iou[i], name='train_iou_class{}'.format(i))
104 | tf.summary.scalar('train_iou_class{}'.format(i), iou[i])
105 |
106 | # If the number of valid entries is 0 (no classes) we return 0.
107 | result = tf.where(
108 | tf.greater(num_valid_entries, 0),
109 | tf.reduce_sum(iou, name=name) / num_valid_entries,
110 | 0)
111 | return result
112 |
113 | mean_iou = compute_mean_iou(confusion_matrix)
114 |
115 | tf.summary.scalar('mean_iou', mean_iou)
116 |
117 | metrics = {'px_accuracy': accuracy, 'mean_iou': mean_iou, 'confusion_matrix': confusion_matrix}
118 |
119 | return total_loss, train_op, metrics
120 |
121 |
122 | # 没有对输入的合法性进行校验
123 | # 使用时需要注意
124 | def kappa(confusion_matrix):
125 | """计算kappa值系数"""
126 | confusion_matrix = confusion_matrix.astype(np.int64)
127 | pe_rows = np.sum(confusion_matrix, axis=0) # 每一类真实值
128 | pe_cols = np.sum(confusion_matrix, axis=1) # 预测出每一类的总数
129 | sum_total = sum(pe_cols) # 样本总数
130 | pe = np.dot(pe_rows, pe_cols) / float(sum_total * sum_total)
131 | po = np.trace(confusion_matrix) / float(sum_total)
132 | return (po - pe) / (1 - pe)
133 |
134 | def affinity_loss(labels,
135 | probs,
136 | num_classes,
137 | kld_margin):
138 | """Affinity Field (AFF) loss.
139 |
140 | This function computes AFF loss. There are several components in the
141 | function:
142 | 1) extracts edges from the ground-truth labels.
143 | 2) extracts ignored pixels and their paired pixels (the neighboring
144 | pixels on the eight corners).
145 | 3) extracts neighboring pixels on the eight corners from a 3x3 patch.
146 | 4) computes KL-Divergence between center pixels and their neighboring
147 | pixels from the eight corners.
148 |
149 | Args:
150 | labels: A tensor of size [batch_size, height_in, width_in], indicating
151 | semantic segmentation ground-truth labels.
152 | probs: A tensor of size [batch_size, height_in, width_in, num_classes],
153 | indicating segmentation predictions.
154 | num_classes: A number indicating the total number of valid classes.
155 | kld_margin: A number indicating the margin for KL-Divergence at edge.
156 |
157 | Returns:
158 | Two 1-D tensors value indicating the loss at edge and non-edge.
159 | """
160 | # Compute ignore map (e.g, label of 255 and their paired pixels).
161 | labels = tf.squeeze(labels, axis=-1) # NxHxW
162 | ignore = nnx.ignores_from_label(labels, num_classes, 1) # NxHxWx8
163 | not_ignore = tf.logical_not(ignore)
164 | not_ignore = tf.expand_dims(not_ignore, axis=3) # NxHxWx1x8 # 不是ignore是true
165 |
166 | # Compute edge map.
167 | one_hot_lab = tf.one_hot(labels, depth=num_classes)
168 | edge = nnx.edges_from_label(one_hot_lab, 1, 255) # NxHxWxCx8 # zhenjie不相等是ture
169 |
170 | # Remove ignored pixels from the edge/non-edge.
171 | edge = tf.logical_and(edge, not_ignore) # zhenjie NxHxWxCx8
172 | not_edge = tf.logical_and(tf.logical_not(edge), not_ignore) # zhenjie NxHxWxCx8
173 |
174 | edge_indices = tf.where(tf.reshape(edge, [-1]))
175 | not_edge_indices = tf.where(tf.reshape(not_edge, [-1]))
176 |
177 | # Extract eight corner from the center in a patch as paired pixels.
178 | probs_paired = nnx.eightcorner_activation(probs, 1) # NxHxWxCx8
179 | probs = tf.expand_dims(probs, axis=-1) # NxHxWxCx1
180 | bot_epsilon = tf.constant(1e-4, name='bot_epsilon')
181 | top_epsilon = tf.constant(1.0, name='top_epsilon')
182 | neg_probs = tf.clip_by_value(
183 | 1-probs, bot_epsilon, top_epsilon)
184 | probs = tf.clip_by_value(
185 | probs, bot_epsilon, top_epsilon)
186 | neg_probs_paired= tf.clip_by_value(
187 | 1-probs_paired, bot_epsilon, top_epsilon)
188 | probs_paired = tf.clip_by_value(
189 | probs_paired, bot_epsilon, top_epsilon)
190 |
191 | # Compute KL-Divergence.
192 | kldiv = probs_paired*tf.log(probs_paired/probs)
193 | kldiv += neg_probs_paired*tf.log(neg_probs_paired/neg_probs)
194 | not_edge_loss = kldiv
195 | edge_loss = tf.maximum(0.0, kld_margin-kldiv)
196 |
197 | not_edge_loss = tf.reshape(not_edge_loss, [-1])
198 | not_edge_loss = tf.gather(not_edge_loss, not_edge_indices)
199 | edge_loss = tf.reshape(edge_loss, [-1])
200 | edge_loss = tf.gather(edge_loss, edge_indices)
201 |
202 | return edge_loss, not_edge_loss
203 |
--------------------------------------------------------------------------------
/tools_deeplabv3.py:
--------------------------------------------------------------------------------
1 | from NET import deeplab_v3
2 | from utils import preprocessing
3 | import tensorflow as tf
4 | import numpy as np
5 |
6 | _WEIGHT_DECAY = 5e-4
7 |
8 |
9 | def get_loss_pre_metrics(x, y, is_training, batch_size, args):
10 | # 恢复图像
11 | images = tf.cast(x, tf.uint8)
12 |
13 | # 前向传播
14 | logits = tf.cond(is_training, true_fn=lambda: deeplab_v3.deeplab_v3(x, args, is_training=True, reuse=False),
15 | false_fn=lambda: deeplab_v3.deeplab_v3(x, args, is_training=False, reuse=True))
16 | pred_classes = tf.expand_dims(tf.argmax(logits, axis=3, output_type=tf.int32), axis=3)
17 |
18 | # 解码预测结果
19 | pred_decoded_labels = tf.py_func(preprocessing.decode_labels, [pred_classes, batch_size, args.number_of_classes], tf.uint8)
20 |
21 | # 解码标签
22 | gt_decoded_labels = tf.py_func(preprocessing.decode_labels, [y, batch_size, args.number_of_classes], tf.uint8)
23 |
24 |
25 | tf.summary.image('images', tf.concat(axis=2, values=[images, gt_decoded_labels, pred_decoded_labels]),
26 | max_outputs=args.tensorboard_images_max_outputs)
27 |
28 | # 求loss
29 | labels = tf.squeeze(y, axis=3) # reduce the channel dimension.
30 | logits_by_num_classes = tf.reshape(logits, [-1, args.number_of_classes])
31 | labels_flat = tf.reshape(labels, [-1, ])
32 |
33 | cross_entropy = tf.losses.sparse_softmax_cross_entropy(
34 | logits=logits_by_num_classes, labels=labels_flat)
35 |
36 | if not args.freeze_batch_norm:
37 | train_var_list = [v for v in tf.trainable_variables()]
38 | else:
39 | train_var_list = [v for v in tf.trainable_variables()
40 | if 'beta' not in v.name and 'gamma'not in v.name]
41 |
42 | #train_var_list = [v for v in tf.trainable_variables()]
43 | with tf.variable_scope("total_loss"):
44 | loss = cross_entropy + _WEIGHT_DECAY * tf.add_n(
45 | [tf.nn.l2_loss(v) for v in train_var_list])
46 | tf.summary.scalar('loss', loss)
47 |
48 | # 优化函数
49 | global_step = tf.train.get_or_create_global_step()
50 | learning_rate = tf.train.polynomial_decay(
51 | args.initial_learning_rate,
52 | tf.cast(global_step, tf.int32) - args.initial_global_step,
53 | args.max_iter, args.end_learning_rate, power=0.9) # args.max_iter = 30000 args.initial_global_step=0
54 | tf.summary.scalar('learning_rate', learning_rate)
55 |
56 | optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=0.9)
57 |
58 | # Batch norm requires update ops to be added as a dependency to the train_op
59 | update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
60 | with tf.control_dependencies(update_ops):
61 | train_op = optimizer.minimize(loss, global_step, var_list=train_var_list)
62 |
63 | # metrics
64 | preds_flat = tf.reshape(pred_classes, [-1, ])
65 | confusion_matrix = tf.confusion_matrix(labels_flat, preds_flat, num_classes=args.number_of_classes)
66 |
67 | correct_pred = tf.equal(preds_flat, labels_flat)
68 | accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
69 | tf.summary.scalar('accuracy', accuracy)
70 |
71 | def compute_mean_iou(total_cm, name='mean_iou'):
72 | """Compute the mean intersection-over-union via the confusion matrix."""
73 | sum_over_row = tf.to_float(tf.reduce_sum(total_cm, 0))
74 | sum_over_col = tf.to_float(tf.reduce_sum(total_cm, 1))
75 | cm_diag = tf.to_float(tf.diag_part(total_cm))
76 | denominator = sum_over_row + sum_over_col - cm_diag
77 |
78 | # The mean is only computed over classes that appear in the
79 | # label or prediction tensor. If the denominator is 0, we need to
80 | # ignore the class.
81 | num_valid_entries = tf.reduce_sum(tf.cast(
82 | tf.not_equal(denominator, 0), dtype=tf.float32))
83 |
84 | # If the value of the denominator is 0, set it to 1 to avoid
85 | # zero division.
86 | denominator = tf.where(
87 | tf.greater(denominator, 0),
88 | denominator,
89 | tf.ones_like(denominator))
90 | iou = tf.div(cm_diag, denominator)
91 |
92 | for i in range(args.number_of_classes):
93 | tf.identity(iou[i], name='train_iou_class{}'.format(i))
94 | tf.summary.scalar('train_iou_class{}'.format(i), iou[i])
95 |
96 | # If the number of valid entries is 0 (no classes) we return 0.
97 | result = tf.where(
98 | tf.greater(num_valid_entries, 0),
99 | tf.reduce_sum(iou, name=name) / num_valid_entries,
100 | 0)
101 | return result
102 |
103 | mean_iou = compute_mean_iou(confusion_matrix)
104 |
105 | tf.summary.scalar('mean_iou', mean_iou)
106 |
107 | metrics = {'px_accuracy': accuracy, 'mean_iou': mean_iou, 'confusion_matrix': confusion_matrix}
108 |
109 | return loss, train_op, metrics
110 |
111 |
112 | # 没有对输入的合法性进行校验
113 | # 使用时需要注意
114 | def kappa(confusion_matrix):
115 | """计算kappa值系数"""
116 | confusion_matrix = confusion_matrix.astype(np.int64)
117 | pe_rows = np.sum(confusion_matrix, axis=0) # 每一类真实值
118 | pe_cols = np.sum(confusion_matrix, axis=1) # 预测出每一类的总数
119 | sum_total = sum(pe_cols) # 样本总数
120 | pe = np.dot(pe_rows, pe_cols) / float(sum_total * sum_total)
121 | po = np.trace(confusion_matrix) / float(sum_total)
122 | return (po - pe) / (1 - pe)
--------------------------------------------------------------------------------
/tools_deeplabv3_DA.py:
--------------------------------------------------------------------------------
1 | from NET import deeplabv3_DA
2 | from utils import preprocessing
3 | import tensorflow as tf
4 | import numpy as np
5 |
6 | _WEIGHT_DECAY = 5e-4
7 |
8 |
9 | def get_loss_pre_metrics(x, y, is_training, batch_size, args):
10 | # 恢复图像
11 | images = tf.cast(x, tf.uint8)
12 |
13 | # 前向传播
14 | logits = tf.cond(is_training, true_fn=lambda: deeplabv3_DA.deeplabv3_DA(x, args, is_training=True, reuse=False),
15 | false_fn=lambda: deeplabv3_DA.deeplabv3_DA(x, args, is_training=False, reuse=True))
16 | pred_classes = tf.expand_dims(tf.argmax(logits, axis=3, output_type=tf.int32), axis=3)
17 |
18 | # 解码预测结果
19 | pred_decoded_labels = tf.py_func(preprocessing.decode_labels, [pred_classes, batch_size, args.number_of_classes], tf.uint8)
20 |
21 |
22 | # 解码标签
23 | gt_decoded_labels = tf.py_func(preprocessing.decode_labels, [y, batch_size, args.number_of_classes], tf.uint8)
24 |
25 |
26 | tf.summary.image('images', tf.concat(axis=2, values=[images, gt_decoded_labels, pred_decoded_labels]),
27 | max_outputs=args.tensorboard_images_max_outputs)
28 |
29 | # 求loss
30 | labels = tf.squeeze(y, axis=3) # reduce the channel dimension.
31 | logits_by_num_classes = tf.reshape(logits, [-1, args.number_of_classes])
32 | labels_flat = tf.reshape(labels, [-1, ])
33 |
34 | cross_entropy = tf.losses.sparse_softmax_cross_entropy(
35 | logits=logits_by_num_classes, labels=labels_flat)
36 |
37 | if not args.freeze_batch_norm:
38 | train_var_list = [v for v in tf.trainable_variables()]
39 | else:
40 | train_var_list = [v for v in tf.trainable_variables()
41 | if 'beta' not in v.name and 'gamma' not in v.name]
42 |
43 | #train_var_list = [v for v in tf.trainable_variables()]
44 | with tf.variable_scope("total_loss"):
45 | loss = cross_entropy + _WEIGHT_DECAY * tf.add_n(
46 | [tf.nn.l2_loss(v) for v in train_var_list])
47 | tf.summary.scalar('loss', loss)
48 |
49 | # 优化函数
50 | global_step = tf.train.get_or_create_global_step()
51 | learning_rate = tf.train.polynomial_decay(
52 | args.initial_learning_rate,
53 | tf.cast(global_step, tf.int32) - args.initial_global_step,
54 | args.max_iter, args.end_learning_rate, power=0.9) # args.max_iter = 30000 args.initial_global_step=0
55 | tf.summary.scalar('learning_rate', learning_rate)
56 |
57 | optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=0.9)
58 |
59 | # Batch norm requires update ops to be added as a dependency to the train_op
60 | update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
61 | with tf.control_dependencies(update_ops):
62 | train_op = optimizer.minimize(loss, global_step, var_list=train_var_list)
63 |
64 | # metrics
65 | preds_flat = tf.reshape(pred_classes, [-1, ])
66 | confusion_matrix = tf.confusion_matrix(labels_flat, preds_flat, num_classes=args.number_of_classes)
67 |
68 | correct_pred = tf.equal(preds_flat, labels_flat)
69 | accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
70 | tf.summary.scalar('accuracy', accuracy)
71 |
72 | def compute_mean_iou(total_cm, name='mean_iou'):
73 | """Compute the mean intersection-over-union via the confusion matrix."""
74 | sum_over_row = tf.to_float(tf.reduce_sum(total_cm, 0))
75 | sum_over_col = tf.to_float(tf.reduce_sum(total_cm, 1))
76 | cm_diag = tf.to_float(tf.diag_part(total_cm))
77 | denominator = sum_over_row + sum_over_col - cm_diag
78 |
79 | # The mean is only computed over classes that appear in the
80 | # label or prediction tensor. If the denominator is 0, we need to
81 | # ignore the class.
82 | num_valid_entries = tf.reduce_sum(tf.cast(
83 | tf.not_equal(denominator, 0), dtype=tf.float32))
84 |
85 | # If the value of the denominator is 0, set it to 1 to avoid
86 | # zero division.
87 | denominator = tf.where(
88 | tf.greater(denominator, 0),
89 | denominator,
90 | tf.ones_like(denominator))
91 | iou = tf.div(cm_diag, denominator)
92 |
93 | for i in range(args.number_of_classes):
94 | tf.identity(iou[i], name='train_iou_class{}'.format(i))
95 | tf.summary.scalar('train_iou_class{}'.format(i), iou[i])
96 |
97 | # If the number of valid entries is 0 (no classes) we return 0.
98 | result = tf.where(
99 | tf.greater(num_valid_entries, 0),
100 | tf.reduce_sum(iou, name=name) / num_valid_entries,
101 | 0)
102 | return result
103 |
104 | mean_iou = compute_mean_iou(confusion_matrix)
105 |
106 | tf.summary.scalar('mean_iou', mean_iou)
107 |
108 | metrics = {'px_accuracy': accuracy, 'mean_iou': mean_iou, 'confusion_matrix': confusion_matrix}
109 |
110 | return loss, train_op, metrics
111 |
112 |
113 | # 没有对输入的合法性进行校验
114 | # 使用时需要注意
115 | def kappa(confusion_matrix):
116 | """计算kappa值系数"""
117 | confusion_matrix = confusion_matrix.astype(np.int64)
118 | pe_rows = np.sum(confusion_matrix, axis=0) # 每一类真实值
119 | pe_cols = np.sum(confusion_matrix, axis=1) # 预测出每一类的总数
120 | sum_total = sum(pe_cols) # 样本总数
121 | pe = np.dot(pe_rows, pe_cols) / float(sum_total * sum_total)
122 | po = np.trace(confusion_matrix) / float(sum_total)
123 | return (po - pe) / (1 - pe)
--------------------------------------------------------------------------------
/tools_deeplabv3plus.py:
--------------------------------------------------------------------------------
1 | from NET import deeplabv3_plus
2 | from utils import preprocessing
3 | import tensorflow as tf
4 | import numpy as np
5 |
6 | _WEIGHT_DECAY = 5e-4
7 |
8 |
9 | def get_loss_pre_metrics(x, y, is_training, batch_size, args):
10 | # 恢复图像
11 | images = tf.cast(x, tf.uint8)
12 |
13 | # 前向传播
14 | logits = tf.cond(is_training, true_fn=lambda: deeplabv3_plus.deeplabv3_plus(x, args, is_training=True, reuse=False),
15 | false_fn=lambda: deeplabv3_plus.deeplabv3_plus(x, args, is_training=False, reuse=True))
16 | pred_classes = tf.expand_dims(tf.argmax(logits, axis=3, output_type=tf.int32), axis=3)
17 |
18 | # 解码预测结果
19 | pred_decoded_labels = tf.py_func(preprocessing.decode_labels, [pred_classes, batch_size, args.number_of_classes], tf.uint8)
20 |
21 | # 解码标签
22 | gt_decoded_labels = tf.py_func(preprocessing.decode_labels, [y, batch_size, args.number_of_classes], tf.uint8)
23 |
24 |
25 | tf.summary.image('images', tf.concat(axis=2, values=[images, gt_decoded_labels, pred_decoded_labels]),
26 | max_outputs=args.tensorboard_images_max_outputs)
27 |
28 | # 求loss
29 | labels = tf.squeeze(y, axis=3) # reduce the channel dimension.
30 | logits_by_num_classes = tf.reshape(logits, [-1, args.number_of_classes])
31 | labels_flat = tf.reshape(labels, [-1, ])
32 |
33 | cross_entropy = tf.losses.sparse_softmax_cross_entropy(
34 | logits=logits_by_num_classes, labels=labels_flat)
35 |
36 | if not args.freeze_batch_norm:
37 | train_var_list = [v for v in tf.trainable_variables()]
38 | else:
39 | train_var_list = [v for v in tf.trainable_variables()
40 | if 'beta' not in v.name and 'gamma' not in v.name]
41 |
42 | #train_var_list = [v for v in tf.trainable_variables()]
43 | with tf.variable_scope("total_loss"):
44 | loss = cross_entropy + _WEIGHT_DECAY * tf.add_n(
45 | [tf.nn.l2_loss(v) for v in train_var_list])
46 | tf.summary.scalar('loss', loss)
47 |
48 | # 优化函数
49 | global_step = tf.train.get_or_create_global_step()
50 | learning_rate = tf.train.polynomial_decay(
51 | args.initial_learning_rate,
52 | tf.cast(global_step, tf.int32) - args.initial_global_step,
53 | args.max_iter, args.end_learning_rate, power=0.9) # args.max_iter = 30000 args.initial_global_step=0
54 | tf.summary.scalar('learning_rate', learning_rate)
55 |
56 | optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=0.9)
57 |
58 | # Batch norm requires update ops to be added as a dependency to the train_op
59 | update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
60 | with tf.control_dependencies(update_ops):
61 | train_op = optimizer.minimize(loss, global_step, var_list=train_var_list)
62 |
63 | # metrics
64 | preds_flat = tf.reshape(pred_classes, [-1, ])
65 | confusion_matrix = tf.confusion_matrix(labels_flat, preds_flat, num_classes=args.number_of_classes)
66 |
67 | correct_pred = tf.equal(preds_flat, labels_flat)
68 | accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
69 | tf.summary.scalar('accuracy', accuracy)
70 |
71 | def compute_mean_iou(total_cm, name='mean_iou'):
72 | """Compute the mean intersection-over-union via the confusion matrix."""
73 | sum_over_row = tf.to_float(tf.reduce_sum(total_cm, 0))
74 | sum_over_col = tf.to_float(tf.reduce_sum(total_cm, 1))
75 | cm_diag = tf.to_float(tf.diag_part(total_cm))
76 | denominator = sum_over_row + sum_over_col - cm_diag
77 |
78 | # The mean is only computed over classes that appear in the
79 | # label or prediction tensor. If the denominator is 0, we need to
80 | # ignore the class.
81 | num_valid_entries = tf.reduce_sum(tf.cast(
82 | tf.not_equal(denominator, 0), dtype=tf.float32))
83 |
84 | # If the value of the denominator is 0, set it to 1 to avoid
85 | # zero division.
86 | denominator = tf.where(
87 | tf.greater(denominator, 0),
88 | denominator,
89 | tf.ones_like(denominator))
90 | iou = tf.div(cm_diag, denominator)
91 |
92 | for i in range(args.number_of_classes):
93 | tf.identity(iou[i], name='train_iou_class{}'.format(i))
94 | tf.summary.scalar('train_iou_class{}'.format(i), iou[i])
95 |
96 | # If the number of valid entries is 0 (no classes) we return 0.
97 | result = tf.where(
98 | tf.greater(num_valid_entries, 0),
99 | tf.reduce_sum(iou, name=name) / num_valid_entries,
100 | 0)
101 | return result
102 |
103 | mean_iou = compute_mean_iou(confusion_matrix)
104 |
105 | tf.summary.scalar('mean_iou', mean_iou)
106 |
107 | metrics = {'px_accuracy': accuracy, 'mean_iou': mean_iou, 'confusion_matrix': confusion_matrix}
108 |
109 | return loss, train_op, metrics
110 |
111 |
112 | # 没有对输入的合法性进行校验
113 | # 使用时需要注意
114 | def kappa(confusion_matrix):
115 | """计算kappa值系数"""
116 | confusion_matrix = confusion_matrix.astype(np.int64)
117 | pe_rows = np.sum(confusion_matrix, axis=0) # 每一类真实值
118 | pe_cols = np.sum(confusion_matrix, axis=1) # 预测出每一类的总数
119 | sum_total = sum(pe_cols) # 样本总数
120 | pe = np.dot(pe_rows, pe_cols) / float(sum_total * sum_total)
121 | po = np.trace(confusion_matrix) / float(sum_total)
122 | return (po - pe) / (1 - pe)
--------------------------------------------------------------------------------
/tools_psp.py:
--------------------------------------------------------------------------------
1 | from NET import pspnet
2 | from utils import preprocessing
3 | import tensorflow as tf
4 | import numpy as np
5 |
6 | _WEIGHT_DECAY = 1e-4
7 |
8 |
9 | def get_loss_pre_metrics(x, y, is_training, batch_size, args):
10 | # 恢复图像
11 | images = tf.cast(x, tf.uint8)
12 |
13 | # 前向传播
14 | logits = tf.cond(is_training, true_fn=lambda: pspnet.pspnet_resnet(x, args, is_training=True, reuse=False),
15 | false_fn=lambda: pspnet.pspnet_resnet(x, args, is_training=False, reuse=True))
16 | pred_classes = tf.expand_dims(tf.argmax(logits, axis=3, output_type=tf.int32), axis=3)
17 |
18 | # 解码预测结果
19 | pred_decoded_labels = tf.py_func(preprocessing.decode_labels, [pred_classes, batch_size, args.number_of_classes], tf.uint8)
20 |
21 |
22 | # 解码标签
23 | gt_decoded_labels = tf.py_func(preprocessing.decode_labels, [y, batch_size, args.number_of_classes], tf.uint8)
24 |
25 |
26 | tf.summary.image('images', tf.concat(axis=2, values=[images, gt_decoded_labels, pred_decoded_labels]),
27 | max_outputs=args.tensorboard_images_max_outputs)
28 |
29 | # 求loss
30 | labels = tf.squeeze(y, axis=3) # reduce the channel dimension.
31 | logits_by_num_classes = tf.reshape(logits, [-1, args.number_of_classes])
32 | labels_flat = tf.reshape(labels, [-1, ])
33 |
34 | cross_entropy = tf.losses.sparse_softmax_cross_entropy(
35 | logits=logits_by_num_classes, labels=labels_flat)
36 |
37 | if not args.freeze_batch_norm:
38 | train_var_list = [v for v in tf.trainable_variables()]
39 | else:
40 | train_var_list = [v for v in tf.trainable_variables()
41 | if 'beta' not in v.name and 'gamma' not in v.name]
42 |
43 | with tf.variable_scope("total_loss"):
44 | loss = cross_entropy + _WEIGHT_DECAY * tf.add_n(
45 | [tf.nn.l2_loss(v) for v in train_var_list])
46 | tf.summary.scalar('loss', loss)
47 |
48 | # 优化函数
49 | global_step = tf.train.get_or_create_global_step()
50 | learning_rate = tf.train.polynomial_decay(
51 | args.initial_learning_rate,
52 | tf.cast(global_step, tf.int32) - args.initial_global_step,
53 | args.max_iter, args.end_learning_rate, power=0.9) # args.max_iter = 30000 args.initial_global_step=0
54 | tf.summary.scalar('learning_rate', learning_rate)
55 |
56 | optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=0.9)
57 |
58 | # Batch norm requires update ops to be added as a dependency to the train_op
59 | update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
60 | with tf.control_dependencies(update_ops):
61 | train_op = optimizer.minimize(loss, global_step, var_list=train_var_list)
62 |
63 | # metrics
64 | preds_flat = tf.reshape(pred_classes, [-1, ])
65 | confusion_matrix = tf.confusion_matrix(labels_flat, preds_flat, num_classes=args.number_of_classes)
66 |
67 | correct_pred = tf.equal(preds_flat, labels_flat)
68 | accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
69 | tf.summary.scalar('accuracy', accuracy)
70 |
71 | def compute_mean_iou(total_cm, name='mean_iou'):
72 | """Compute the mean intersection-over-union via the confusion matrix."""
73 | sum_over_row = tf.to_float(tf.reduce_sum(total_cm, 0))
74 | sum_over_col = tf.to_float(tf.reduce_sum(total_cm, 1))
75 | cm_diag = tf.to_float(tf.diag_part(total_cm))
76 | denominator = sum_over_row + sum_over_col - cm_diag
77 |
78 | # The mean is only computed over classes that appear in the
79 | # label or prediction tensor. If the denominator is 0, we need to
80 | # ignore the class.
81 | num_valid_entries = tf.reduce_sum(tf.cast(
82 | tf.not_equal(denominator, 0), dtype=tf.float32))
83 |
84 | # If the value of the denominator is 0, set it to 1 to avoid
85 | # zero division.
86 | denominator = tf.where(
87 | tf.greater(denominator, 0),
88 | denominator,
89 | tf.ones_like(denominator))
90 | iou = tf.div(cm_diag, denominator)
91 |
92 | for i in range(args.number_of_classes):
93 | tf.identity(iou[i], name='train_iou_class{}'.format(i))
94 | tf.summary.scalar('train_iou_class{}'.format(i), iou[i])
95 |
96 | # If the number of valid entries is 0 (no classes) we return 0.
97 | result = tf.where(
98 | tf.greater(num_valid_entries, 0),
99 | tf.reduce_sum(iou, name=name) / num_valid_entries,
100 | 0)
101 | return result
102 |
103 | mean_iou = compute_mean_iou(confusion_matrix)
104 |
105 | tf.summary.scalar('mean_iou', mean_iou)
106 |
107 | metrics = {'px_accuracy': accuracy, 'mean_iou': mean_iou, 'confusion_matrix': confusion_matrix}
108 |
109 | return loss, train_op, metrics
110 |
111 |
112 | # 没有对输入的合法性进行校验
113 | # 使用时需要注意
114 | def kappa(confusion_matrix):
115 | """计算kappa值系数"""
116 | confusion_matrix = confusion_matrix.astype(np.int64)
117 | pe_rows = np.sum(confusion_matrix, axis=0) # 每一类真实值
118 | pe_cols = np.sum(confusion_matrix, axis=1) # 预测出每一类的总数
119 | sum_total = sum(pe_cols) # 样本总数
120 | pe = np.dot(pe_rows, pe_cols) / float(sum_total * sum_total)
121 | po = np.trace(confusion_matrix) / float(sum_total)
122 | return (po - pe) / (1 - pe)
--------------------------------------------------------------------------------
/train_aaf.py:
--------------------------------------------------------------------------------
1 | from GeneratingBatchSize.GetDataset import train_or_eval_input_fn
2 | import tensorflow as tf
3 | import os
4 | import argparse
5 | import tools_aaf
6 | import datetime
7 | import math
8 |
9 | os.environ['CUDA_VISIBLE_DEVICES'] = '0'
10 |
11 | batch_size = 4
12 | summary_path = "./summary_aff/"
13 | checkpoint_path_voc = ""
14 | checkpoint_path = "./checkpoint_aff/"
15 | EPOCHS = 50
16 | train_set_length = 5000
17 | eval_set_length = 500
18 |
19 | parser = argparse.ArgumentParser()
20 |
21 | #添加参数
22 | envarg = parser.add_argument_group('Training params')
23 | # BN params
24 | envarg.add_argument("--batch_norm_epsilon", type=float, default=1e-5, help="batch norm epsilon argument for batch normalization")
25 | envarg.add_argument('--batch_norm_decay', type=float, default=0.9997, help='batch norm decay argument for batch normalization.')
26 | envarg.add_argument('--freeze_batch_norm', type=bool, default=True, help='Freeze batch normalization parameters during the training.')
27 | # the number of classes
28 | envarg.add_argument("--number_of_classes", type=int, default=16, help="Number of classes to be predicted.")
29 |
30 | # regularizer
31 | envarg.add_argument("--l2_regularizer", type=float, default=0.0001, help="l2 regularizer parameter.")
32 |
33 | # for deeplabv3
34 | envarg.add_argument("--multi_grid", type=list, default=[1, 2, 4], help="Spatial Pyramid Pooling rates")
35 | envarg.add_argument("--output_stride", type=int, default=16, help="Spatial Pyramid Pooling rates")
36 |
37 | # the base network
38 | envarg.add_argument("--resnet_model", default="resnet_v2_50", choices=["resnet_v2_50", "resnet_v2_101", "resnet_v2_152", "resnet_v2_200"], help="Resnet model to use as feature extractor. Choose one of: resnet_v2_50 or resnet_v2_101")
39 |
40 | # the pre_trained model for example resnet50 101 and so on
41 | envarg.add_argument('--pre_trained_model', type=str, default='./pre_trained_model/resnet_v2_50/resnet_v2_50.ckpt',
42 | help='Path to the pre-trained model checkpoint.')
43 |
44 | # max number of batch elements to tensorboard
45 | parser.add_argument('--tensorboard_images_max_outputs', type=int, default=6,
46 | help='Max number of batch elements to generate for Tensorboard.')
47 | # poly learn_rate
48 | parser.add_argument('--initial_learning_rate', type=float, default=7e-4,
49 | help='Initial learning rate for the optimizer.')
50 |
51 | parser.add_argument('--end_learning_rate', type=float, default=1e-6,
52 | help='End learning rate for the optimizer.')
53 |
54 | parser.add_argument('--initial_global_step', type=int, default=0,
55 | help='Initial global step for controlling learning rate when fine-tuning model.')
56 | parser.add_argument('--max_iter', type=int, default=62500,
57 | help='Number of maximum iteration used for "poly" learning rate policy.')
58 |
59 | # aaf 参数
60 | parser.add_argument('--kld_margin', type=float, default=3.0, help='margin for affinity loss')
61 | parser.add_argument('--kld_lambda_1', type=float, default=1.0, help='Lambda for affinity loss at edge.')
62 | parser.add_argument('--kld_lambda_2', type=float, default=1.0, help='Lambda for affinity loss not at edge.')
63 | args = parser.parse_args()
64 |
65 | def main():
66 | os.environ['TF_ENABLE_WINOGRAD_NONFUSED'] = '0'
67 |
68 | is_train = tf.placeholder(tf.bool, shape=[])
69 | x = tf.placeholder(dtype=tf.float32, shape=[batch_size, 1000, 1000, 3], name="image_batch")
70 | y = tf.placeholder(dtype=tf.int32, shape=[batch_size, 1000, 1000, 1], name="label_batch")
71 |
72 | train_dataset = train_or_eval_input_fn(is_training=True,
73 | data_dir="./DatasetNew/train/", batch_size=batch_size)
74 | eval_dataset = train_or_eval_input_fn(is_training=False,
75 | data_dir="./DatasetNew/val/", batch_size=batch_size, num_epochs=1)
76 | iterator_train = tf.data.Iterator.from_structure(train_dataset.output_types, train_dataset.output_shapes)
77 | next_batch = iterator_train.get_next()
78 | training_init_op = iterator_train.make_initializer(train_dataset)
79 | evaling_init_op = iterator_train.make_initializer(eval_dataset)
80 |
81 | loss, train_op, metrics = tools_aaf.get_loss_pre_metrics(x, y, is_train, batch_size, args)
82 |
83 | accuracy = metrics["px_accuracy"]
84 | mean_iou = metrics["mean_iou"]
85 | confusion_matrix = metrics['confusion_matrix']
86 |
87 | summary_op = tf.summary.merge_all()
88 | init_op = tf.group(
89 | tf.local_variables_initializer(),
90 | tf.global_variables_initializer()
91 | )
92 | # 首次运行从deeplabv3中获取权重需要剔除logits层
93 | exclude = ['global_step']
94 | variables_to_restore = tf.contrib.slim.get_variables_to_restore(exclude=exclude)
95 |
96 | saver_first = tf.train.Saver(variables_to_restore)
97 | saver = tf.train.Saver(max_to_keep=50)
98 | summary_writer_train = tf.summary.FileWriter(summary_path + "train/")
99 | summary_writer_val = tf.summary.FileWriter(summary_path + "val/")
100 | # 运行图
101 | config = tf.ConfigProto()
102 | config.gpu_options.allow_growth = True
103 | with tf.Session() as sess:
104 | sess.run(init_op, feed_dict={is_train: True})
105 | ckpt = tf.train.get_checkpoint_state(checkpoint_path_voc)
106 | if ckpt and ckpt.model_checkpoint_path:
107 | saver_first.restore(sess, ckpt.model_checkpoint_path)
108 | sess.graph.finalize()
109 |
110 | train_batches_of_epoch = int(math.ceil(train_set_length / batch_size))
111 | val_batches_of_epoch = int(math.floor(eval_set_length / batch_size))
112 | for epoch in range(EPOCHS):
113 | sess.run(training_init_op)
114 | print("{} Epoch number: {}".format(datetime.datetime.now(), epoch + 1))
115 | # step = 1 (epoch * train_batches_of_epoch), ((epoch + 1) * train_batches_of_epoch)
116 | for step in range((epoch * train_batches_of_epoch), ((epoch + 1) * train_batches_of_epoch)):
117 | img_batch, label_batch = sess.run(next_batch)
118 | sess.run([train_op], feed_dict={x: img_batch, y: label_batch, is_train: True})
119 |
120 | if (step + 1) % 625 == 0:
121 | loss_value, acc, m_iou, merge, con_matrix = sess.run(
122 | [loss, accuracy, mean_iou, summary_op, confusion_matrix],
123 | feed_dict={x: img_batch, y: label_batch, is_train: True})
124 | kappa = tools_aaf.kappa(con_matrix)
125 | print("{} {} loss = {:.4f}".format(datetime.datetime.now(), step + 1, loss_value))
126 | print("accuracy{}".format(acc))
127 | print("miou{}".format(m_iou))
128 | print("kappa{}".format(kappa))
129 | summary_writer_train.add_summary(merge, step + 1)
130 | saver.save(sess, checkpoint_path + "model.ckpt", epoch + 1)
131 | print("checkpoint saved")
132 |
133 | # 验证过程
134 | sess.run(evaling_init_op)
135 | print("{} Start validation".format(datetime.datetime.now()))
136 | test_acc = 0.0
137 | test_miou = 0.0
138 | test_kappa = 0.0
139 | test_count = 0
140 | for tag in range(val_batches_of_epoch):
141 | img_batch, label_batch = sess.run(next_batch)
142 | acc, m_iou, merge, con_matrix = sess.run(
143 | [accuracy, mean_iou, summary_op, confusion_matrix],
144 | feed_dict={x: img_batch, y: label_batch, is_train: False})
145 | kappa = tools_aaf.kappa(con_matrix)
146 | test_kappa += kappa
147 | test_acc += acc
148 | test_miou += m_iou
149 | test_count += 1
150 | test_acc /= test_count
151 | test_miou /= test_count
152 | test_kappa /= test_count
153 | s = tf.Summary(value=[
154 | tf.Summary.Value(tag="validation_accuracy", simple_value=test_acc),
155 | tf.Summary.Value(tag="validation_miou", simple_value=test_miou),
156 | tf.Summary.Value(tag="validation_kappa", simple_value=test_kappa)
157 | ])
158 | summary_writer_val.add_summary(s, epoch + 1)
159 | print("{} Validation Accuracy = {:.4f}".format(datetime.datetime.now(), test_acc))
160 | print("{} Validation miou = {:.4f}".format(datetime.datetime.now(), test_miou))
161 | print("{} Validation kappa = {:.4f}".format(datetime.datetime.now(), test_kappa))
162 |
163 | if __name__ == '__main__':
164 | tf.logging.set_verbosity(tf.logging.INFO)
165 | main()
--------------------------------------------------------------------------------
/train_deeplabv3.py:
--------------------------------------------------------------------------------
1 | from GeneratingBatchSize.GetDataset import train_or_eval_input_fn
2 | import tensorflow as tf
3 | import os
4 | import argparse
5 | import tools_deeplabv3
6 | import datetime
7 | import math
8 |
9 | os.environ['CUDA_VISIBLE_DEVICES'] = '0'
10 |
11 | batch_size = 4
12 | summary_path = "./summary_v3/"
13 | checkpoint_path_voc = ""
14 | checkpoint_path = "./checkpoint_v3/"
15 | EPOCHS = 100
16 | train_set_length = 5000
17 | eval_set_length = 500
18 |
19 | parser = argparse.ArgumentParser()
20 |
21 | #添加参数
22 | envarg = parser.add_argument_group('Training params')
23 | # BN params
24 | envarg.add_argument("--batch_norm_epsilon", type=float, default=1e-5, help="batch norm epsilon argument for batch normalization")
25 | envarg.add_argument('--batch_norm_decay', type=float, default=0.9997, help='batch norm decay argument for batch normalization.')
26 | envarg.add_argument('--freeze_batch_norm', type=bool, default=True, help='Freeze batch normalization parameters during the training.')
27 | # the number of classes
28 | envarg.add_argument("--number_of_classes", type=int, default=16, help="Number of classes to be predicted.")
29 |
30 | # regularizer
31 | envarg.add_argument("--l2_regularizer", type=float, default=0.0001, help="l2 regularizer parameter.")
32 |
33 | # for deeplabv3
34 | envarg.add_argument("--multi_grid", type=list, default=[1, 2, 4], help="Spatial Pyramid Pooling rates")
35 | envarg.add_argument("--output_stride", type=int, default=16, help="Spatial Pyramid Pooling rates")
36 |
37 | # the base network
38 | envarg.add_argument("--resnet_model", default="resnet_v2_50", choices=["resnet_v2_50", "resnet_v2_101", "resnet_v2_152", "resnet_v2_200"], help="Resnet model to use as feature extractor. Choose one of: resnet_v2_50 or resnet_v2_101")
39 |
40 | # the pre_trained model for example resnet50 101 and so on
41 | envarg.add_argument('--pre_trained_model', type=str, default='./pre_trained_model/resnet_v2_50/resnet_v2_50.ckpt',
42 | help='Path to the pre-trained model checkpoint.')
43 |
44 | # max number of batch elements to tensorboard
45 | parser.add_argument('--tensorboard_images_max_outputs', type=int, default=6,
46 | help='Max number of batch elements to generate for Tensorboard.')
47 | # poly learn_rate
48 | parser.add_argument('--initial_learning_rate', type=float, default=1e-4,
49 | help='Initial learning rate for the optimizer.')
50 |
51 | parser.add_argument('--end_learning_rate', type=float, default=5e-6,
52 | help='End learning rate for the optimizer.')
53 |
54 | parser.add_argument('--initial_global_step', type=int, default=0,
55 | help='Initial global step for controlling learning rate when fine-tuning model.')
56 | parser.add_argument('--max_iter', type=int, default=125000,
57 | help='Number of maximum iteration used for "poly" learning rate policy.')
58 | args = parser.parse_args()
59 |
60 | def main():
61 | os.environ['TF_ENABLE_WINOGRAD_NONFUSED'] = '0'
62 |
63 | is_train = tf.placeholder(tf.bool, shape=[])
64 | x = tf.placeholder(dtype=tf.float32, shape=[None, 1000, 1000, 3], name="image_batch")
65 | y = tf.placeholder(dtype=tf.int32, shape=[None, 1000, 1000, 1], name="label_batch")
66 |
67 | train_dataset = train_or_eval_input_fn(is_training=True,
68 | data_dir="./DatasetNew/train/", batch_size=batch_size)
69 | eval_dataset = train_or_eval_input_fn(is_training=False,
70 | data_dir="./DatasetNew/val/", batch_size=batch_size, num_epochs=1)
71 | iterator_train = tf.data.Iterator.from_structure(train_dataset.output_types, train_dataset.output_shapes)
72 | next_batch = iterator_train.get_next()
73 | training_init_op = iterator_train.make_initializer(train_dataset)
74 | evaling_init_op = iterator_train.make_initializer(eval_dataset)
75 |
76 | loss, train_op, metrics = tools_deeplabv3.get_loss_pre_metrics(x, y, is_train, batch_size, args)
77 |
78 | accuracy = metrics["px_accuracy"]
79 | mean_iou = metrics["mean_iou"]
80 | confusion_matrix = metrics['confusion_matrix']
81 |
82 | summary_op = tf.summary.merge_all()
83 | init_op = tf.group(
84 | tf.local_variables_initializer(),
85 | tf.global_variables_initializer()
86 | )
87 | # 首次运行从deeplabv3中获取权重需要剔除logits层
88 | exclude = [args.resnet_model + '/logits', 'DeepLab_v3/logits', 'global_step']
89 | variables_to_restore = tf.contrib.slim.get_variables_to_restore(exclude=exclude)
90 |
91 | saver_first = tf.train.Saver(variables_to_restore)
92 | saver = tf.train.Saver(max_to_keep=100)
93 | summary_writer_train = tf.summary.FileWriter(summary_path + "train/")
94 | summary_writer_val = tf.summary.FileWriter(summary_path + "val/")
95 | # 运行图
96 | config = tf.ConfigProto()
97 | config.gpu_options.allow_growth = True
98 | with tf.Session(config=config) as sess:
99 | sess.run(init_op, feed_dict={is_train: True})
100 | ckpt = tf.train.get_checkpoint_state(checkpoint_path_voc)
101 | if ckpt and ckpt.model_checkpoint_path:
102 | saver_first.restore(sess, ckpt.model_checkpoint_path)
103 | sess.graph.finalize()
104 |
105 | train_batches_of_epoch = int(math.ceil(train_set_length / batch_size))
106 | val_batches_of_epoch = int(math.ceil(eval_set_length / batch_size))
107 | for epoch in range(EPOCHS):
108 | sess.run(training_init_op)
109 | print("{} Epoch number: {}".format(datetime.datetime.now(), epoch + 1))
110 | for step in range((epoch * train_batches_of_epoch), ((epoch + 1) * train_batches_of_epoch)):
111 | img_batch, label_batch = sess.run(next_batch)
112 | sess.run([train_op], feed_dict={x: img_batch, y: label_batch, is_train: True})
113 | if (step + 1) % 625 == 0:
114 | loss_value, acc, m_iou, con_matrix = sess.run(
115 | [loss, accuracy, mean_iou, confusion_matrix],
116 | feed_dict={x: img_batch, y: label_batch, is_train: True})
117 | kappa = tools_deeplabv3.kappa(con_matrix)
118 | print("{} {} loss = {:.4f}".format(datetime.datetime.now(), step + 1, loss_value))
119 | print("accuracy{}".format(acc))
120 | print("miou{}".format(m_iou))
121 | print("kappa{}".format(kappa))
122 | merge = sess.run(summary_op, feed_dict={x: img_batch, y: label_batch, is_train: True})
123 | summary_writer_train.add_summary(merge, step + 1)
124 | saver.save(sess, checkpoint_path + "model.ckpt", epoch + 1)
125 | print("checkpoint saved")
126 |
127 | # 验证过程
128 | sess.run(evaling_init_op)
129 | print("{} Start validation".format(datetime.datetime.now()))
130 | test_acc = 0.0
131 | test_miou = 0.0
132 | test_kappa = 0.0
133 | test_count = 0
134 | for tag in range(val_batches_of_epoch):
135 | img_batch, label_batch = sess.run(next_batch)
136 | acc, m_iou, con_matrix = sess.run(
137 | [accuracy, mean_iou, confusion_matrix],
138 | feed_dict={x: img_batch, y: label_batch, is_train: False})
139 |
140 | kappa = tools_deeplabv3.kappa(con_matrix)
141 | test_kappa += kappa
142 | test_acc += acc
143 | test_miou += m_iou
144 | test_count += 1
145 | test_acc /= test_count
146 | test_miou /= test_count
147 | test_kappa /= test_count
148 | s = tf.Summary(value=[
149 | tf.Summary.Value(tag="validation_accuracy", simple_value=test_acc),
150 | tf.Summary.Value(tag="validation_miou", simple_value=test_miou),
151 | tf.Summary.Value(tag="validation_kappa", simple_value=test_kappa)
152 | ])
153 | summary_writer_val.add_summary(s, epoch + 1)
154 | print("{} Validation Accuracy = {:.4f}".format(datetime.datetime.now(), test_acc))
155 | print("{} Validation miou = {:.4f}".format(datetime.datetime.now(), test_miou))
156 | print("{} Validation kappa = {:.4f}".format(datetime.datetime.now(), test_kappa))
157 |
158 | if __name__ == '__main__':
159 | tf.logging.set_verbosity(tf.logging.INFO)
160 | main()
--------------------------------------------------------------------------------
/train_deeplabv3_DA.py:
--------------------------------------------------------------------------------
1 | from GeneratingBatchSize.GetDataset import train_or_eval_input_fn
2 | import tensorflow as tf
3 | import os
4 | import argparse
5 | import tools_deeplabv3_DA
6 | import datetime
7 | import math
8 |
9 | os.environ['CUDA_VISIBLE_DEVICES'] = '0'
10 |
11 | batch_size = 3
12 | summary_path = "./summary_position/"
13 | checkpoint_path_first = "./first_checkpoint/"
14 | checkpoint_path = "./checkpoint_position/"
15 | EPOCHS = 50
16 | train_set_length = 5000
17 | eval_set_length = 500
18 |
19 | parser = argparse.ArgumentParser()
20 |
21 | #添加参数
22 | envarg = parser.add_argument_group('Training params')
23 | # BN params
24 | envarg.add_argument("--batch_norm_epsilon", type=float, default=1e-5, help="batch norm epsilon argument for batch normalization")
25 | envarg.add_argument('--batch_norm_decay', type=float, default=0.9997, help='batch norm decay argument for batch normalization.')
26 | envarg.add_argument('--freeze_batch_norm', type=bool, default=True, help='Freeze batch normalization parameters during the training.')
27 | # the number of classes
28 | envarg.add_argument("--number_of_classes", type=int, default=16, help="Number of classes to be predicted.")
29 |
30 | # regularizer
31 | envarg.add_argument("--l2_regularizer", type=float, default=0.0001, help="l2 regularizer parameter.")
32 |
33 | # for deeplabv3
34 | envarg.add_argument("--multi_grid", type=list, default=[1, 2, 4], help="Spatial Pyramid Pooling rates")
35 | envarg.add_argument("--output_stride", type=int, default=16, help="Spatial Pyramid Pooling rates")
36 |
37 | # the base network
38 | envarg.add_argument("--resnet_model", default="resnet_v2_50", choices=["resnet_v2_50", "resnet_v2_101", "resnet_v2_152", "resnet_v2_200"], help="Resnet model to use as feature extractor. Choose one of: resnet_v2_50 or resnet_v2_101")
39 |
40 | # the pre_trained model for example resnet50 101 and so on
41 | envarg.add_argument('--pre_trained_model', type=str, default='./pre_trained_model/resnet_v2_50/resnet_v2_50.ckpt',
42 | help='Path to the pre-trained model checkpoint.')
43 |
44 | # max number of batch elements to tensorboard
45 | parser.add_argument('--tensorboard_images_max_outputs', type=int, default=6,
46 | help='Max number of batch elements to generate for Tensorboard.')
47 | # poly learn_rate
48 | parser.add_argument('--initial_learning_rate', type=float, default=7e-4,
49 | help='Initial learning rate for the optimizer.')
50 |
51 | parser.add_argument('--end_learning_rate', type=float, default=1e-6,
52 | help='End learning rate for the optimizer.')
53 |
54 | parser.add_argument('--initial_global_step', type=int, default=0,
55 | help='Initial global step for controlling learning rate when fine-tuning model.')
56 | parser.add_argument('--max_iter', type=int, default=83333,
57 | help='Number of maximum iteration used for "poly" learning rate policy.')
58 | args = parser.parse_args()
59 |
60 | def main():
61 | os.environ['TF_ENABLE_WINOGRAD_NONFUSED'] = '0'
62 |
63 | is_train = tf.placeholder(tf.bool, shape=[])
64 | x = tf.placeholder(dtype=tf.float32, shape=[None, 1000, 1000, 3], name="image_batch")
65 | y = tf.placeholder(dtype=tf.int32, shape=[None, 1000, 1000, 1], name="label_batch")
66 |
67 | train_dataset = train_or_eval_input_fn(is_training=True,
68 | data_dir="./DatasetNew/train/", batch_size=batch_size)
69 | eval_dataset = train_or_eval_input_fn(is_training=False,
70 | data_dir="./DatasetNew/val/", batch_size=batch_size, num_epochs=1)
71 | iterator_train = tf.data.Iterator.from_structure(train_dataset.output_types, train_dataset.output_shapes)
72 | next_batch = iterator_train.get_next()
73 | training_init_op = iterator_train.make_initializer(train_dataset)
74 | evaling_init_op = iterator_train.make_initializer(eval_dataset)
75 |
76 | loss, train_op, metrics = tools_deeplabv3_DA.get_loss_pre_metrics(x, y, is_train, batch_size, args)
77 |
78 | accuracy = metrics["px_accuracy"]
79 | mean_iou = metrics["mean_iou"]
80 | confusion_matrix = metrics['confusion_matrix']
81 |
82 | summary_op = tf.summary.merge_all()
83 | init_op = tf.group(
84 | tf.local_variables_initializer(),
85 | tf.global_variables_initializer()
86 | )
87 | # 首次运行从deeplabv3中获取权重需要剔除logits层
88 | exclude = ['global_step', 'DeepLab_v3/ASPP_layer/image_level_conv_1x1', 'DeepLab_v3/ASPP_layer/reduce_chanel', 'DeepLab_v3/ASPP_layer/position_module']
89 | variables_to_restore = tf.contrib.slim.get_variables_to_restore(exclude=exclude)
90 |
91 | saver_first = tf.train.Saver(variables_to_restore)
92 | saver = tf.train.Saver(max_to_keep=100)
93 | summary_writer_train = tf.summary.FileWriter(summary_path + "train/")
94 | summary_writer_val = tf.summary.FileWriter(summary_path + "val/")
95 | # 运行图
96 | config = tf.ConfigProto()
97 | config.gpu_options.allow_growth = True
98 | with tf.Session(config=config) as sess:
99 | sess.run(init_op, feed_dict={is_train: True})
100 | ckpt = tf.train.get_checkpoint_state(checkpoint_path_first)
101 | if ckpt and ckpt.model_checkpoint_path:
102 | saver_first.restore(sess, ckpt.model_checkpoint_path)
103 | sess.graph.finalize()
104 |
105 | train_batches_of_epoch = int(math.ceil(train_set_length / batch_size))
106 | val_batches_of_epoch = int(math.ceil(eval_set_length / batch_size))
107 | for epoch in range(EPOCHS):
108 | sess.run(training_init_op)
109 | print("{} Epoch number: {}".format(datetime.datetime.now(), epoch + 1))
110 | # step = 1 (epoch * train_batches_of_epoch), ((epoch + 1) * train_batches_of_epoch)
111 | for step in range((epoch * train_batches_of_epoch), ((epoch + 1) * train_batches_of_epoch)):
112 | img_batch, label_batch = sess.run(next_batch)
113 | loss_value, _, acc, m_iou, con_matrix = sess.run(
114 | [loss, train_op, accuracy, mean_iou, confusion_matrix],
115 | feed_dict={x: img_batch, y: label_batch, is_train: True})
116 |
117 | if (step + 1) % 833 == 0:
118 | kappa = tools_deeplabv3_DA.kappa(con_matrix)
119 | print("{} {} loss = {:.4f}".format(datetime.datetime.now(), step + 1, loss_value))
120 | print("accuracy{}".format(acc))
121 | print("miou{}".format(m_iou))
122 | print("kappa{}".format(kappa))
123 | merge = sess.run(summary_op, feed_dict={x: img_batch, y: label_batch, is_train: True})
124 | summary_writer_train.add_summary(merge, step + 1)
125 | saver.save(sess, checkpoint_path + "model.ckpt", epoch + 1)
126 | print("checkpoint saved")
127 |
128 | # 验证过程
129 | sess.run(evaling_init_op)
130 | print("{} Start validation".format(datetime.datetime.now()))
131 | test_acc = 0.0
132 | test_miou = 0.0
133 | test_kappa = 0.0
134 | test_count = 0
135 | for tag in range(val_batches_of_epoch):
136 | img_batch, label_batch = sess.run(next_batch)
137 | acc, m_iou, con_matrix = sess.run(
138 | [accuracy, mean_iou, confusion_matrix],
139 | feed_dict={x: img_batch, y: label_batch, is_train: False})
140 |
141 | kappa = tools_deeplabv3_DA.kappa(con_matrix)
142 | test_kappa += kappa
143 | test_acc += acc
144 | test_miou += m_iou
145 | test_count += 1
146 | test_acc /= test_count
147 | test_miou /= test_count
148 | test_kappa /= test_count
149 | s = tf.Summary(value=[
150 | tf.Summary.Value(tag="validation_accuracy", simple_value=test_acc),
151 | tf.Summary.Value(tag="validation_miou", simple_value=test_miou),
152 | tf.Summary.Value(tag="validation_kappa", simple_value=test_kappa)
153 | ])
154 | summary_writer_val.add_summary(s, epoch + 1)
155 | print("{} Validation Accuracy = {:.4f}".format(datetime.datetime.now(), test_acc))
156 | print("{} Validation miou = {:.4f}".format(datetime.datetime.now(), test_miou))
157 | print("{} Validation kappa = {:.4f}".format(datetime.datetime.now(), test_kappa))
158 |
159 | if __name__ == '__main__':
160 | tf.logging.set_verbosity(tf.logging.INFO)
161 | main()
--------------------------------------------------------------------------------
/train_deeplabv3plus.py:
--------------------------------------------------------------------------------
1 | from GeneratingBatchSize.GetDataset import train_or_eval_input_fn
2 | import tensorflow as tf
3 | import os
4 | import argparse
5 | import tools_deeplabv3plus
6 | import datetime
7 | import math
8 |
9 | os.environ['CUDA_VISIBLE_DEVICES'] = '0'
10 |
11 | batch_size = 3
12 | summary_path = "./summary_deeplabv3plus/"
13 | checkpoint_path = "./checkpoint_deeplabv3plus/"
14 | EPOCHS = 50
15 | train_set_length = 5000
16 | eval_set_length = 500
17 |
18 | parser = argparse.ArgumentParser()
19 |
20 | #添加参数
21 | envarg = parser.add_argument_group('Training params')
22 | # BN params
23 | envarg.add_argument("--batch_norm_epsilon", type=float, default=1e-5, help="batch norm epsilon argument for batch normalization")
24 | envarg.add_argument('--batch_norm_decay', type=float, default=0.9997, help='batch norm decay argument for batch normalization.')
25 | envarg.add_argument('--freeze_batch_norm', type=bool, default=False, help='Freeze batch normalization parameters during the training.')
26 | # the number of classes
27 | envarg.add_argument("--number_of_classes", type=int, default=16, help="Number of classes to be predicted.")
28 |
29 | # regularizer
30 | envarg.add_argument("--l2_regularizer", type=float, default=0.0001, help="l2 regularizer parameter.")
31 |
32 | # for deeplabv3
33 | envarg.add_argument("--multi_grid", type=list, default=[1, 2, 4], help="Spatial Pyramid Pooling rates")
34 | envarg.add_argument("--output_stride", type=int, default=16, help="Spatial Pyramid Pooling rates")
35 |
36 | # the base network
37 | envarg.add_argument("--resnet_model", default="resnet_v2_50", choices=["resnet_v2_50", "resnet_v2_101", "resnet_v2_152", "resnet_v2_200"], help="Resnet model to use as feature extractor. Choose one of: resnet_v2_50 or resnet_v2_101")
38 |
39 | # the pre_trained model for example resnet50 101 and so on
40 | envarg.add_argument('--pre_trained_model', type=str, default='./pre_trained_model/resnet_v2_50/resnet_v2_50.ckpt',
41 | help='Path to the pre-trained model checkpoint.')
42 |
43 | # max number of batch elements to tensorboard
44 | parser.add_argument('--tensorboard_images_max_outputs', type=int, default=6,
45 | help='Max number of batch elements to generate for Tensorboard.')
46 | # poly learn_rate
47 | parser.add_argument('--initial_learning_rate', type=float, default=7e-3,
48 | help='Initial learning rate for the optimizer.')
49 |
50 | parser.add_argument('--end_learning_rate', type=float, default=1e-6,
51 | help='End learning rate for the optimizer.')
52 |
53 | parser.add_argument('--initial_global_step', type=int, default=0,
54 | help='Initial global step for controlling learning rate when fine-tuning model.')
55 | parser.add_argument('--max_iter', type=int, default=83333,
56 | help='Number of maximum iteration used for "poly" learning rate policy.')
57 | args = parser.parse_args()
58 |
59 | def main():
60 | os.environ['TF_ENABLE_WINOGRAD_NONFUSED'] = '0'
61 |
62 | is_train = tf.placeholder(tf.bool, shape=[])
63 | x = tf.placeholder(dtype=tf.float32, shape=[None, 1000, 1000, 3], name="image_batch")
64 | y = tf.placeholder(dtype=tf.int32, shape=[None, 1000, 1000, 1], name="label_batch")
65 |
66 | train_dataset = train_or_eval_input_fn(is_training=True,
67 | data_dir="./DatasetNew/train/", batch_size=batch_size)
68 | eval_dataset = train_or_eval_input_fn(is_training=False,
69 | data_dir="./DatasetNew/val/", batch_size=batch_size, num_epochs=1)
70 | iterator_train = tf.data.Iterator.from_structure(train_dataset.output_types, train_dataset.output_shapes)
71 | next_batch = iterator_train.get_next()
72 | training_init_op = iterator_train.make_initializer(train_dataset)
73 | evaling_init_op = iterator_train.make_initializer(eval_dataset)
74 |
75 | loss, train_op, metrics = tools_deeplabv3plus.get_loss_pre_metrics(x, y, is_train, batch_size, args)
76 |
77 | accuracy = metrics["px_accuracy"]
78 | mean_iou = metrics["mean_iou"]
79 | confusion_matrix = metrics['confusion_matrix']
80 |
81 | summary_op = tf.summary.merge_all()
82 | init_op = tf.group(
83 | tf.local_variables_initializer(),
84 | tf.global_variables_initializer()
85 | )
86 | saver = tf.train.Saver(max_to_keep=40)
87 | summary_writer_train = tf.summary.FileWriter(summary_path + "train/")
88 | summary_writer_val = tf.summary.FileWriter(summary_path + "val/")
89 | # 运行图
90 | config = tf.ConfigProto()
91 | config.gpu_options.allow_growth = True
92 | with tf.Session(config=config) as sess:
93 | sess.run(init_op, feed_dict={is_train: True})
94 | ckpt = tf.train.get_checkpoint_state(checkpoint_path)
95 | if ckpt and ckpt.model_checkpoint_path:
96 | saver.restore(sess, ckpt.model_checkpoint_path)
97 | sess.graph.finalize()
98 | train_batches_of_epoch = int(math.ceil(train_set_length / batch_size))
99 | val_batches_of_epoch = int(math.ceil(eval_set_length / batch_size))
100 | for epoch in range(18, EPOCHS):
101 | sess.run(training_init_op)
102 | print("{} Epoch number: {}".format(datetime.datetime.now(), epoch + 1))
103 | # step = 1
104 | for step in range((epoch * train_batches_of_epoch), ((epoch + 1) * train_batches_of_epoch)):
105 | img_batch, label_batch = sess.run(next_batch)
106 | sess.run([train_op], feed_dict={x: img_batch, y: label_batch, is_train: True})
107 | if (step + 1) % 833 == 0:
108 | loss_value, acc, m_iou, con_matrix, merge = sess.run(
109 | [loss, accuracy, mean_iou, confusion_matrix, summary_op],
110 | feed_dict={x: img_batch, y: label_batch, is_train: True})
111 | kappa = tools_deeplabv3plus.kappa(con_matrix)
112 | print("{} {} loss = {:.4f}".format(datetime.datetime.now(), step + 1, loss_value))
113 | print("accuracy{}".format(acc))
114 | print("miou{}".format(m_iou))
115 | print("kappa{}".format(kappa))
116 | summary_writer_train.add_summary(merge, step + 1)
117 | saver.save(sess, checkpoint_path + "model.ckpt", epoch + 1)
118 | print("checkpoint saved")
119 |
120 | # 验证过程
121 | sess.run(evaling_init_op)
122 | print("{} Start validation".format(datetime.datetime.now()))
123 | test_acc = 0.0
124 | test_miou = 0.0
125 | test_kappa = 0.0
126 | test_count = 0
127 | for tag in range(val_batches_of_epoch):
128 | img_batch, label_batch = sess.run(next_batch)
129 | acc, m_iou, con_matrix = sess.run(
130 | [accuracy, mean_iou, confusion_matrix],
131 | feed_dict={x: img_batch, y: label_batch, is_train: False})
132 |
133 | kappa = tools_deeplabv3plus.kappa(con_matrix)
134 | test_kappa += kappa
135 | test_acc += acc
136 | test_miou += m_iou
137 | test_count += 1
138 | test_acc /= test_count
139 | test_miou /= test_count
140 | test_kappa /= test_count
141 | s = tf.Summary(value=[
142 | tf.Summary.Value(tag="validation_accuracy", simple_value=test_acc),
143 | tf.Summary.Value(tag="validation_miou", simple_value=test_miou),
144 | tf.Summary.Value(tag="validation_kappa", simple_value=test_kappa)
145 | ])
146 | summary_writer_val.add_summary(s, epoch + 1)
147 | print("{} Validation Accuracy = {:.4f}".format(datetime.datetime.now(), test_acc))
148 | print("{} Validation miou = {:.4f}".format(datetime.datetime.now(), test_miou))
149 | print("{} Validation kappa = {:.4f}".format(datetime.datetime.now(), test_kappa))
150 |
151 | if __name__ == '__main__':
152 | tf.logging.set_verbosity(tf.logging.INFO)
153 | main()
--------------------------------------------------------------------------------
/train_deeplabv3plus_4chanel.py:
--------------------------------------------------------------------------------
1 | from GeneratingBatchSize.GetDataset import train_or_eval_input_fn
2 | from tensorflow.python import pywrap_tensorflow
3 | import tensorflow as tf
4 | import os
5 | import argparse
6 | import tools_deeplabv3plus
7 | import datetime
8 | import math
9 | import numpy as np
10 |
11 | os.environ['CUDA_VISIBLE_DEVICES'] = '0'
12 |
13 | batch_size = 4
14 | summary_path = "./summary_deeplabv3plus_4/"
15 | checkpoint_path_first = "./checkpoint_deeplabv3plus/" # 训练好的三通道deeplabv3+
16 | checkpoint_path = "./checkpoint_deeplabv3plus_4/"
17 | EPOCHS = 30
18 | train_set_length = 5000
19 | eval_set_length = 500
20 |
21 | parser = argparse.ArgumentParser()
22 |
23 | #添加参数
24 | envarg = parser.add_argument_group('Training params')
25 | # BN params
26 | envarg.add_argument("--batch_norm_epsilon", type=float, default=1e-5, help="batch norm epsilon argument for batch normalization")
27 | envarg.add_argument('--batch_norm_decay', type=float, default=0.9997, help='batch norm decay argument for batch normalization.')
28 | envarg.add_argument('--freeze_batch_norm', type=bool, default=False, help='Freeze batch normalization parameters during the training.')
29 | # the number of classes
30 | envarg.add_argument("--number_of_classes", type=int, default=16, help="Number of classes to be predicted.")
31 |
32 | # regularizer
33 | envarg.add_argument("--l2_regularizer", type=float, default=0.0001, help="l2 regularizer parameter.")
34 |
35 | # for deeplabv3
36 | envarg.add_argument("--multi_grid", type=list, default=[1, 2, 4], help="Spatial Pyramid Pooling rates")
37 | envarg.add_argument("--output_stride", type=int, default=16, help="Spatial Pyramid Pooling rates")
38 |
39 | # the base network
40 | envarg.add_argument("--resnet_model", default="resnet_v2_50", choices=["resnet_v2_50", "resnet_v2_101", "resnet_v2_152", "resnet_v2_200"], help="Resnet model to use as feature extractor. Choose one of: resnet_v2_50 or resnet_v2_101")
41 |
42 | # the pre_trained model for example resnet50 101 and so on
43 | envarg.add_argument('--pre_trained_model', type=str, default='./pre_trained_model/resnet_v2_50/resnet_v2_50.ckpt',
44 | help='Path to the pre-trained model checkpoint.')
45 |
46 | # max number of batch elements to tensorboard
47 | parser.add_argument('--tensorboard_images_max_outputs', type=int, default=6,
48 | help='Max number of batch elements to generate for Tensorboard.')
49 | # poly learn_rate
50 | parser.add_argument('--initial_learning_rate', type=float, default=4e-3,
51 | help='Initial learning rate for the optimizer.')
52 |
53 | parser.add_argument('--end_learning_rate', type=float, default=1e-6,
54 | help='End learning rate for the optimizer.')
55 |
56 | parser.add_argument('--initial_global_step', type=int, default=0,
57 | help='Initial global step for controlling learning rate when fine-tuning model.')
58 | parser.add_argument('--max_iter', type=int, default=37500,
59 | help='Number of maximum iteration used for "poly" learning rate policy.')
60 | args = parser.parse_args()
61 |
62 | def main():
63 | os.environ['TF_ENABLE_WINOGRAD_NONFUSED'] = '0'
64 |
65 | is_train = tf.placeholder(tf.bool, shape=[])
66 | x = tf.placeholder(dtype=tf.float32, shape=[None, 1000, 1000, 4], name="image_batch")
67 | y = tf.placeholder(dtype=tf.int32, shape=[None, 1000, 1000, 1], name="label_batch")
68 |
69 | train_dataset = train_or_eval_input_fn(is_training=True,
70 | data_dir="./DatasetNew/train/", batch_size=batch_size)
71 | eval_dataset = train_or_eval_input_fn(is_training=False,
72 | data_dir="./DatasetNew/val/", batch_size=batch_size, num_epochs=1)
73 | iterator_train = tf.data.Iterator.from_structure(train_dataset.output_types, train_dataset.output_shapes)
74 | next_batch = iterator_train.get_next()
75 | training_init_op = iterator_train.make_initializer(train_dataset)
76 | evaling_init_op = iterator_train.make_initializer(eval_dataset)
77 |
78 | loss, train_op, metrics = tools_deeplabv3plus.get_loss_pre_metrics(x, y, is_train, batch_size, args)
79 |
80 | accuracy = metrics["px_accuracy"]
81 | mean_iou = metrics["mean_iou"]
82 | confusion_matrix = metrics['confusion_matrix']
83 |
84 | summary_op = tf.summary.merge_all()
85 | init_op = tf.group(
86 | tf.local_variables_initializer(),
87 | tf.global_variables_initializer()
88 | )
89 | # 首次运行从deeplabv3+中获取权重需要剔除logits层
90 | exclude = [args.resnet_model + '/conv1', 'global_step']
91 | variables_to_restore = tf.contrib.slim.get_variables_to_restore(exclude=exclude)
92 |
93 | with tf.variable_scope("resnet_v2_50", reuse=True):
94 | conv1_weight_restored = tf.get_variable("conv1/weights")
95 | conv1_biase_restored = tf.get_variable("conv1/biases")
96 | # 获得变量值
97 | checkpoint_path_restored = os.path.join(checkpoint_path_first, "model.ckpt-58")
98 | reader_restored = pywrap_tensorflow.NewCheckpointReader(checkpoint_path_restored)
99 | conv1_weight_value = reader_restored.get_tensor("resnet_v2_50/conv1/weights")
100 | conv1_weight_value_4 = np.sum(conv1_weight_value, axis=2, keepdims=True)
101 | conv1_weight_value_4 = np.true_divide(conv1_weight_value_4, 3)
102 | conv1_weight_value = np.concatenate((conv1_weight_value_4, conv1_weight_value), axis=2)
103 | conv1_biase_value = reader_restored.get_tensor("resnet_v2_50/conv1/biases")
104 | conv1_weight_op = tf.assign(conv1_weight_restored, conv1_weight_value)
105 | conv1_biase_op = tf.assign(conv1_biase_restored, conv1_biase_value)
106 |
107 |
108 | saver_first = tf.train.Saver(variables_to_restore)
109 | saver = tf.train.Saver(max_to_keep=50)
110 | summary_writer_train = tf.summary.FileWriter(summary_path + "train/")
111 | summary_writer_val = tf.summary.FileWriter(summary_path + "val/")
112 | # 运行图
113 | config = tf.ConfigProto()
114 | config.gpu_options.allow_growth = True
115 | with tf.Session(config=config) as sess:
116 | sess.run(init_op, feed_dict={is_train: True})
117 | ckpt = tf.train.get_checkpoint_state(checkpoint_path_first)
118 | if ckpt and ckpt.model_checkpoint_path:
119 | saver_first.restore(sess, checkpoint_path_first+"model.ckpt-58")
120 | sess.graph.finalize()
121 |
122 | sess.run([conv1_weight_op, conv1_biase_op])
123 |
124 | train_batches_of_epoch = int(math.ceil(train_set_length / batch_size))
125 | val_batches_of_epoch = int(math.ceil(eval_set_length / batch_size))
126 | for epoch in range(EPOCHS):
127 | sess.run(training_init_op)
128 | print("{} Epoch number: {}".format(datetime.datetime.now(), epoch + 1))
129 | # step = 1
130 | for step in range((epoch * train_batches_of_epoch), ((epoch + 1) * train_batches_of_epoch)):
131 | img_batch, label_batch = sess.run(next_batch)
132 | sess.run([train_op], feed_dict={x: img_batch, y: label_batch, is_train: True})
133 | if (step + 1) % 625 == 0:
134 | loss_value, acc, m_iou, con_matrix, merge = sess.run(
135 | [loss, accuracy, mean_iou, confusion_matrix, summary_op],
136 | feed_dict={x: img_batch, y: label_batch, is_train: True})
137 | kappa = tools_deeplabv3plus.kappa(con_matrix)
138 | print("{} {} loss = {:.4f}".format(datetime.datetime.now(), step + 1, loss_value))
139 | print("accuracy{}".format(acc))
140 | print("miou{}".format(m_iou))
141 | print("kappa{}".format(kappa))
142 | summary_writer_train.add_summary(merge, step + 1)
143 | saver.save(sess, checkpoint_path + "model.ckpt", epoch + 1)
144 | print("checkpoint saved")
145 |
146 | # 验证过程
147 | sess.run(evaling_init_op)
148 | print("{} Start validation".format(datetime.datetime.now()))
149 | test_acc = 0.0
150 | test_miou = 0.0
151 | test_kappa = 0.0
152 | test_count = 0
153 | for tag in range(val_batches_of_epoch):
154 | img_batch, label_batch = sess.run(next_batch)
155 | acc, m_iou, con_matrix = sess.run(
156 | [accuracy, mean_iou, confusion_matrix],
157 | feed_dict={x: img_batch, y: label_batch, is_train: False})
158 |
159 | kappa = tools_deeplabv3plus.kappa(con_matrix)
160 | test_kappa += kappa
161 | test_acc += acc
162 | test_miou += m_iou
163 | test_count += 1
164 | test_acc /= test_count
165 | test_miou /= test_count
166 | test_kappa /= test_count
167 | s = tf.Summary(value=[
168 | tf.Summary.Value(tag="validation_accuracy", simple_value=test_acc),
169 | tf.Summary.Value(tag="validation_miou", simple_value=test_miou),
170 | tf.Summary.Value(tag="validation_kappa", simple_value=test_kappa)
171 | ])
172 | summary_writer_val.add_summary(s, epoch + 1)
173 | print("{} Validation Accuracy = {:.4f}".format(datetime.datetime.now(), test_acc))
174 | print("{} Validation miou = {:.4f}".format(datetime.datetime.now(), test_miou))
175 | print("{} Validation kappa = {:.4f}".format(datetime.datetime.now(), test_kappa))
176 |
177 | if __name__ == '__main__':
178 | tf.logging.set_verbosity(tf.logging.INFO)
179 | main()
--------------------------------------------------------------------------------
/train_psp.py:
--------------------------------------------------------------------------------
1 | from GeneratingBatchSize.GetDataset import train_or_eval_input_fn
2 | import tensorflow as tf
3 | import os
4 | import argparse
5 | import tools_psp
6 | import datetime
7 | import math
8 |
9 | os.environ['CUDA_VISIBLE_DEVICES'] = '0'
10 |
11 | batch_size = 3
12 | summary_path = "./summary_psp/"
13 | checkpoint_path = "./checkpoint_psp/"
14 | EPOCHS = 50
15 | train_set_length = 5000
16 | eval_set_length = 500
17 |
18 | parser = argparse.ArgumentParser()
19 |
20 | #添加参数
21 | envarg = parser.add_argument_group('Training params')
22 | # BN params
23 | envarg.add_argument("--batch_norm_epsilon", type=float, default=1e-5, help="batch norm epsilon argument for batch normalization")
24 | envarg.add_argument('--batch_norm_decay', type=float, default=0.9997, help='batch norm decay argument for batch normalization.')
25 | envarg.add_argument('--freeze_batch_norm', type=bool, default=False, help='Freeze batch normalization parameters during the training.')
26 | # the number of classes
27 | envarg.add_argument("--number_of_classes", type=int, default=16, help="Number of classes to be predicted.")
28 |
29 | # regularizer
30 | envarg.add_argument("--l2_regularizer", type=float, default=0.0001, help="l2 regularizer parameter.")
31 |
32 | # the base network
33 | envarg.add_argument("--resnet_model", default="resnet_v2_50", choices=["resnet_v2_50", "resnet_v2_101", "resnet_v2_152", "resnet_v2_200"], help="Resnet model to use as feature extractor. Choose one of: resnet_v2_50 or resnet_v2_101")
34 |
35 | # the pre_trained model for example resnet50 101 and so on
36 | envarg.add_argument('--pre_trained_model', type=str, default='./pre_trained_model/resnet_v2_50/resnet_v2_50.ckpt',
37 | help='Path to the pre-trained model checkpoint.')
38 |
39 | # max number of batch elements to tensorboard
40 | parser.add_argument('--tensorboard_images_max_outputs', type=int, default=4,
41 | help='Max number of batch elements to generate for Tensorboard.')
42 | # poly learn_rate
43 | parser.add_argument('--initial_learning_rate', type=float, default=7e-3,
44 | help='Initial learning rate for the optimizer.')
45 |
46 | parser.add_argument('--end_learning_rate', type=float, default=1e-6,
47 | help='End learning rate for the optimizer.')
48 |
49 | parser.add_argument('--initial_global_step', type=int, default=0,
50 | help='Initial global step for controlling learning rate when fine-tuning model.')
51 | parser.add_argument('--max_iter', type=int, default=83333,
52 | help='Number of maximum iteration used for "poly" learning rate policy.')
53 | args = parser.parse_args()
54 |
55 | def main():
56 | os.environ['TF_ENABLE_WINOGRAD_NONFUSED'] = '0'
57 |
58 | is_train = tf.placeholder(tf.bool, shape=[])
59 | x = tf.placeholder(dtype=tf.float32, shape=[None, 1000, 1000, 3], name="image_batch")
60 | y = tf.placeholder(dtype=tf.int32, shape=[None, 1000, 1000, 1], name="label_batch")
61 |
62 | train_dataset = train_or_eval_input_fn(is_training=True,
63 | data_dir="./DatasetNew/train/", batch_size=batch_size)
64 | eval_dataset = train_or_eval_input_fn(is_training=False,
65 | data_dir="./DatasetNew/val/", batch_size=batch_size, num_epochs=1)
66 | iterator_train = tf.data.Iterator.from_structure(train_dataset.output_types, train_dataset.output_shapes)
67 | next_batch = iterator_train.get_next()
68 | training_init_op = iterator_train.make_initializer(train_dataset)
69 | evaling_init_op = iterator_train.make_initializer(eval_dataset)
70 |
71 | loss, train_op, metrics = tools_psp.get_loss_pre_metrics(x, y, is_train, batch_size, args)
72 |
73 | accuracy = metrics["px_accuracy"]
74 | mean_iou = metrics["mean_iou"]
75 | confusion_matrix = metrics['confusion_matrix']
76 |
77 | summary_op = tf.summary.merge_all()
78 | init_op = tf.group(
79 | tf.local_variables_initializer(),
80 | tf.global_variables_initializer()
81 | )
82 |
83 | saver = tf.train.Saver(max_to_keep=100)
84 | summary_writer_train = tf.summary.FileWriter(summary_path + "train/")
85 | summary_writer_val = tf.summary.FileWriter(summary_path + "val/")
86 | # 运行图
87 | config = tf.ConfigProto()
88 | config.gpu_options.allow_growth = True
89 | with tf.Session(config=config) as sess:
90 | sess.run(init_op, feed_dict={is_train: True})
91 | ckpt = tf.train.get_checkpoint_state(checkpoint_path)
92 | if ckpt and ckpt.model_checkpoint_path:
93 | saver.restore(sess, ckpt.model_checkpoint_path)
94 | print("restored")
95 | sess.graph.finalize()
96 |
97 | train_batches_of_epoch = int(math.ceil(train_set_length / batch_size))
98 | val_batches_of_epoch = int(math.ceil(eval_set_length / batch_size))
99 | for epoch in range(EPOCHS):
100 | sess.run(training_init_op)
101 | print("{} Epoch number: {}".format(datetime.datetime.now(), epoch + 1))
102 | # step = 1
103 | for step in range((epoch * train_batches_of_epoch), ((epoch + 1) * train_batches_of_epoch)):
104 | img_batch, label_batch = sess.run(next_batch)
105 | sess.run([train_op], feed_dict={x: img_batch, y: label_batch, is_train: True})
106 |
107 | if (step + 1) % 833 == 0:
108 | loss_value, acc, m_iou, con_matrix = sess.run(
109 | [loss, accuracy, mean_iou, confusion_matrix],
110 | feed_dict={x: img_batch, y: label_batch, is_train: True})
111 | kappa = tools_psp.kappa(con_matrix)
112 | print("{} {} loss = {:.4f}".format(datetime.datetime.now(), step + 1, loss_value))
113 | print("accuracy{}".format(acc))
114 | print("miou{}".format(m_iou))
115 | print("kappa{}".format(kappa))
116 | merge = sess.run(summary_op, feed_dict={x: img_batch, y: label_batch, is_train: True})
117 | summary_writer_train.add_summary(merge, step + 1)
118 | saver.save(sess, checkpoint_path + "model.ckpt", epoch + 1)
119 | print("checkpoint saved")
120 |
121 | # 验证过程
122 | sess.run(evaling_init_op)
123 | print("{} Start validation".format(datetime.datetime.now()))
124 | test_acc = 0.0
125 | test_miou = 0.0
126 | test_kappa = 0.0
127 | test_count = 0
128 | for tag in range(val_batches_of_epoch):
129 | img_batch, label_batch = sess.run(next_batch)
130 | acc, m_iou, con_matrix = sess.run(
131 | [accuracy, mean_iou, confusion_matrix],
132 | feed_dict={x: img_batch, y: label_batch, is_train: False})
133 |
134 | kappa = tools_psp.kappa(con_matrix)
135 | test_kappa += kappa
136 | test_acc += acc
137 | test_miou += m_iou
138 | test_count += 1
139 | test_acc /= test_count
140 | test_miou /= test_count
141 | test_kappa /= test_count
142 | s = tf.Summary(value=[
143 | tf.Summary.Value(tag="validation_accuracy", simple_value=test_acc),
144 | tf.Summary.Value(tag="validation_miou", simple_value=test_miou),
145 | tf.Summary.Value(tag="validation_kappa", simple_value=test_kappa)
146 | ])
147 | summary_writer_val.add_summary(s, epoch + 1)
148 | print("{} Validation Accuracy = {:.4f}".format(datetime.datetime.now(), test_acc))
149 | print("{} Validation miou = {:.4f}".format(datetime.datetime.now(), test_miou))
150 | print("{} Validation kappa = {:.4f}".format(datetime.datetime.now(), test_kappa))
151 |
152 | if __name__ == '__main__':
153 | tf.logging.set_verbosity(tf.logging.INFO)
154 | main()
--------------------------------------------------------------------------------
/utils/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tangzhenjie/semantic_segmentation_contest/df3df24296f26209950a2455ed2f7751a9e046ca/utils/__init__.py
--------------------------------------------------------------------------------
/utils/__pycache__/__init__.cpython-36.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tangzhenjie/semantic_segmentation_contest/df3df24296f26209950a2455ed2f7751a9e046ca/utils/__pycache__/__init__.cpython-36.pyc
--------------------------------------------------------------------------------
/utils/preprocessing.py:
--------------------------------------------------------------------------------
1 | """Utility functions for preprocessing data sets."""
2 |
3 | from PIL import Image
4 | import numpy as np
5 | import tensorflow as tf
6 |
7 | _R_MEAN = 78.51
8 | _G_MEAN = 114.00
9 | _B_MEAN = 110.00
10 |
11 | # Colour map.
12 | label_colours = [(0, 0, 0)
13 | # 0=其他
14 | ,(0, 200, 0), (150, 250, 0), (150, 200, 150), (200, 0, 200), (150, 0, 250)
15 | # 1=水田, 2=水浇地, 3=旱耕地, 4=园地, 5=乔木林地
16 | , (150, 150, 250), (250, 200, 0), (200, 200, 0), (200, 0, 0), (250, 0, 150)
17 | # 6=灌木林地, 7=天然草地, 8=人工草地, 9=工业用地, 10=城市住宅
18 | , (200, 150, 150), (250, 150, 150), (0, 0, 200), (0, 150, 200), (0, 200, 250)]
19 | # 11=村镇住宅, 12=交通运输, 13=河流, 14=湖泊, 15=坑塘]
20 |
21 |
22 | def decode_labels(mask, num_images=1, num_classes=16):
23 | """Decode batch of segmentation masks.
24 |
25 | Args:
26 | mask: result of inference after taking argmax.
27 | num_images: number of images to decode from the batch.
28 | num_classes: number of classes to predict (including background).
29 |
30 | Returns:
31 | A batch with num_images RGB images of the same size as the input.
32 | """
33 | n, h, w, c = mask.shape
34 | assert (n >= num_images), 'Batch size %d should be greater or equal than number of images to save %d.' \
35 | % (n, num_images)
36 | outputs = np.zeros((num_images, h, w, 3), dtype=np.uint8)
37 | for i in range(num_images):
38 | img = Image.new('RGB', (len(mask[i, 0]), len(mask[i])))
39 | pixels = img.load()
40 | for j_, j in enumerate(mask[i, :, :, 0]):
41 | for k_, k in enumerate(j):
42 | if k < num_classes:
43 | pixels[k_, j_] = label_colours[k]
44 | outputs[i] = np.array(img)
45 | return outputs
46 |
47 |
48 | def mean_image_addition(image, means=(_R_MEAN, _G_MEAN, _B_MEAN)):
49 | """Adds the given means from each image channel.
50 |
51 | For example:
52 | means = [123.68, 116.779, 103.939]
53 | image = _mean_image_subtraction(image, means)
54 |
55 | Note that the rank of `image` must be known.
56 |
57 | Args:
58 | image: a tensor of size [height, width, C].
59 | means: a C-vector of values to subtract from each channel.
60 |
61 | Returns:
62 | the centered image.
63 |
64 | Raises:
65 | ValueError: If the rank of `image` is unknown, if `image` has a rank other
66 | than three or if the number of channels in `image` doesn't match the
67 | number of values in `means`.
68 | """
69 | if image.get_shape().ndims != 3:
70 | raise ValueError('Input must be of size [height, width, C>0]')
71 | num_channels = image.get_shape().as_list()[-1]
72 | if len(means) != num_channels:
73 | raise ValueError('len(means) must match the number of channels')
74 |
75 | channels = tf.split(axis=2, num_or_size_splits=num_channels, value=image)
76 | for i in range(num_channels):
77 | channels[i] += means[i]
78 | return tf.concat(axis=2, values=channels)
79 |
80 |
81 | def mean_image_subtraction(image, means=(_R_MEAN, _G_MEAN, _B_MEAN)):
82 | """Subtracts the given means from each image channel.
83 |
84 | For example:
85 | means = [123.68, 116.779, 103.939]
86 | image = _mean_image_subtraction(image, means)
87 |
88 | Note that the rank of `image` must be known.
89 |
90 | Args:
91 | image: a tensor of size [height, width, C].
92 | means: a C-vector of values to subtract from each channel.
93 |
94 | Returns:
95 | the centered image.
96 |
97 | Raises:
98 | ValueError: If the rank of `image` is unknown, if `image` has a rank other
99 | than three or if the number of channels in `image` doesn't match the
100 | number of values in `means`.
101 | """
102 | if image.get_shape().ndims != 3:
103 | raise ValueError('Input must be of size [height, width, C>0]')
104 | num_channels = image.get_shape().as_list()[-1]
105 | if len(means) != num_channels:
106 | raise ValueError('len(means) must match the number of channels')
107 |
108 | channels = tf.split(axis=2, num_or_size_splits=num_channels, value=image)
109 | for i in range(num_channels):
110 | channels[i] -= means[i]
111 | return tf.concat(axis=2, values=channels)
112 |
113 |
114 | def random_rescale_image_and_label(image, label, min_scale, max_scale):
115 | """Rescale an image and label with in target scale.
116 |
117 | Rescales an image and label within the range of target scale.
118 |
119 | Args:
120 | image: 3-D Tensor of shape `[height, width, channels]`.
121 | label: 3-D Tensor of shape `[height, width, 1]`.
122 | min_scale: Min target scale.
123 | max_scale: Max target scale.
124 |
125 | Returns:
126 | Cropped and/or padded image.
127 | If `images` was 3-D, a 3-D float Tensor of shape
128 | `[new_height, new_width, channels]`.
129 | If `labels` was 3-D, a 3-D float Tensor of shape
130 | `[new_height, new_width, 1]`.
131 | """
132 | if min_scale <= 0:
133 | raise ValueError('\'min_scale\' must be greater than 0.')
134 | elif max_scale <= 0:
135 | raise ValueError('\'max_scale\' must be greater than 0.')
136 | elif min_scale >= max_scale:
137 | raise ValueError('\'max_scale\' must be greater than \'min_scale\'.')
138 |
139 | shape = tf.shape(image)
140 | height = tf.to_float(shape[0])
141 | width = tf.to_float(shape[1])
142 | scale = tf.random_uniform(
143 | [], minval=min_scale, maxval=max_scale, dtype=tf.float32)
144 | new_height = tf.to_int32(height * scale)
145 | new_width = tf.to_int32(width * scale)
146 | image = tf.image.resize_images(image, [new_height, new_width],
147 | method=tf.image.ResizeMethod.BILINEAR)
148 | # Since label classes are integers, nearest neighbor need to be used.
149 | label = tf.image.resize_images(label, [new_height, new_width],
150 | method=tf.image.ResizeMethod.NEAREST_NEIGHBOR)
151 |
152 | return image, label
153 |
154 |
155 | def random_crop_or_pad_image_and_label(image, label, crop_height, crop_width, ignore_label):
156 | """Crops and/or pads an image to a target width and height.
157 |
158 | Resizes an image to a target width and height by rondomly
159 | cropping the image or padding it evenly with zeros.
160 |
161 | Args:
162 | image: 3-D Tensor of shape `[height, width, channels]`.
163 | label: 3-D Tensor of shape `[height, width, 1]`.
164 | crop_height: The new height.
165 | crop_width: The new width.
166 | ignore_label: Label class to be ignored.
167 |
168 | Returns:
169 | Cropped and/or padded image.
170 | If `images` was 3-D, a 3-D float Tensor of shape
171 | `[new_height, new_width, channels]`.
172 | """
173 | label = tf.to_float(label)
174 | image_height = tf.shape(image)[0]
175 | image_width = tf.shape(image)[1]
176 | image_and_label = tf.concat([image, label], axis=2)
177 | image_and_label_pad = tf.image.pad_to_bounding_box(
178 | image_and_label, 0, 0,
179 | tf.maximum(crop_height, image_height),
180 | tf.maximum(crop_width, image_width))
181 | image_and_label_crop = tf.random_crop(
182 | image_and_label_pad, [crop_height, crop_width, 4])
183 |
184 | image_crop = image_and_label_crop[:, :, :3]
185 | label_crop = image_and_label_crop[:, :, 3:]
186 | label_crop = tf.to_int32(label_crop)
187 |
188 | return image_crop, label_crop
189 |
190 |
191 | def random_flip_left_right_image_and_label(image, label):
192 | """Randomly flip an image and label horizontally (left to right).
193 |
194 | Args:
195 | image: A 3-D tensor of shape `[height, width, channels].`
196 | label: A 3-D tensor of shape `[height, width, 1].`
197 |
198 | Returns:
199 | A 3-D tensor of the same type and shape as `image`.
200 | A 3-D tensor of the same type and shape as `label`.
201 | """
202 | uniform_random = tf.random_uniform([], 0, 1.0)
203 | mirror_cond = tf.less(uniform_random, .5)
204 | image = tf.cond(mirror_cond, lambda: tf.reverse(image, [1]), lambda: image)
205 | label = tf.cond(mirror_cond, lambda: tf.reverse(label, [1]), lambda: label)
206 |
207 | return image, label
208 |
209 |
210 | def eval_input_fn(image_filenames, label_filenames=None, batch_size=1):
211 | """An input function for evaluation and inference.
212 |
213 | Args:
214 | image_filenames: The file names for the inferred images.
215 | label_filenames: The file names for the grand truth labels.
216 | batch_size: The number of samples per batch. Need to be 1
217 | for the images of different sizes.
218 |
219 | Returns:
220 | A tuple of images and labels.
221 | """
222 | # Reads an image from a file, decodes it into a dense tensor
223 | def _parse_function(filename, is_label):
224 | if not is_label:
225 | image_filename, label_filename = filename, None
226 | else:
227 | image_filename, label_filename = filename
228 |
229 | image_string = tf.read_file(image_filename)
230 | image = tf.image.decode_image(image_string)
231 | image = tf.to_float(tf.image.convert_image_dtype(image, dtype=tf.uint8))
232 | image.set_shape([None, None, 3])
233 |
234 | image = mean_image_subtraction(image)
235 |
236 | if not is_label:
237 | return image
238 | else:
239 | label_string = tf.read_file(label_filename)
240 | label = tf.image.decode_image(label_string)
241 | label = tf.to_int32(tf.image.convert_image_dtype(label, dtype=tf.uint8))
242 | label.set_shape([None, None, 1])
243 |
244 | return image, label
245 |
246 | if label_filenames is None:
247 | input_filenames = image_filenames
248 | else:
249 | input_filenames = (image_filenames, label_filenames)
250 |
251 | dataset = tf.data.Dataset.from_tensor_slices(input_filenames)
252 | if label_filenames is None:
253 | dataset = dataset.map(lambda x: _parse_function(x, False))
254 | else:
255 | dataset = dataset.map(lambda x, y: _parse_function((x, y), True))
256 | dataset = dataset.prefetch(batch_size)
257 | dataset = dataset.batch(batch_size)
258 | iterator = dataset.make_one_shot_iterator()
259 |
260 | if label_filenames is None:
261 | images = iterator.get_next()
262 | labels = None
263 | else:
264 | images, labels = iterator.get_next()
265 |
266 | return images, labels
267 |
--------------------------------------------------------------------------------