def eval(self):
self.metric.reset()
self.model.eval()
logger.info("Start validation, Total sample: {:d}".format(
len(self.val_loader)))
for i, (image, target, filename) in enumerate(self.val_loader):
image = image.to(self.device)
target = target.to(self.device)
with torch.no_grad():
outputs = self.model(image)
self.metric.update(outputs[0], target)
pixAcc, mIoU = self.metric.get()
logger.info(
"Sample: {:d}, validation pixAcc: {:.3f}, mIoU: {:.3f}".format(
i + 1, pixAcc * 100, mIoU * 100))
if self.args.save_pred:
pred = torch.argmax(outputs[0], 1)
pred = pred.cpu().data.numpy()
predict = pred.squeeze(0)
mask = get_color_pallete(predict, args.dataset)
mask.save(
os.path.join(outdir,
os.path.splitext(filename[0])[0] + '.png'))
synchronize()
def run_model(args):
# args = parse_args()
# reference maskrcnn-benchmark
num_gpus = int(
os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1
args.num_gpus = num_gpus
args.distributed = num_gpus > 1
if not args.no_cuda and torch.cuda.is_available():
cudnn.benchmark = True
args.device = "cuda"
else:
args.distributed = False
args.device = "cpu"
if args.distributed:
torch.cuda.set_device(args.local_rank)
torch.distributed.init_process_group(backend="nccl",
init_method="env://")
synchronize()
args.lr = args.lr * num_gpus
logger = setup_logger("semantic_segmentation",
args.log_dir,
get_rank(),
filename='{}_{}_{}_log.txt'.format(
args.model, args.backbone, args.dataset))
logger.info("Using {} GPUs".format(num_gpus))
logger.info(args)
trainer = Trainer(args)
trainer.train()
torch.cuda.empty_cache()
def validation(self):
# total_inter, total_union, total_correct, total_label = 0, 0, 0, 0
is_best = False
self.metric.reset()
if self.args.distributed:
model = self.model.module
else:
model = self.model
torch.cuda.empty_cache() # TODO check if it helps
model.eval()
for i, (image, target, filename) in enumerate(self.val_loader):
image = image.to(self.device)
target = target.to(self.device)
with torch.no_grad():
outputs = model(image)
self.metric.update(outputs[0], target)
pixAcc, mIoU = self.metric.get()
logger.info(
"Sample: {:d}, Validation pixAcc: {:.3f}, mIoU: {:.3f}".format(
i + 1, pixAcc, mIoU))
new_pred = (pixAcc + mIoU) / 2
if new_pred > self.best_pred:
is_best = True
self.best_pred = new_pred
save_checkpoint(self.model, self.args, is_best)
synchronize()
def eval(self):
#self.metric.reset()
self.model.eval()
if self.args.distributed:
model = self.model.module
else:
model = self.model
logger.info("Start validation, Total sample: {:d}".format(
len(self.val_loader)))
counter = 0
for i, (image, target) in enumerate(self.val_loader):
oimage = cv2.imread("../dataset/rgb/train/1.png", 1)
oimage = cv2.cvtColor(oimage, cv2.COLOR_BGR2RGB)
oimage = np.transpose(oimage, (2, 0, 1))
oimage = oimage.astype(np.float32) / 255.
oimage = oimage[np.newaxis, ...]
oimage = torch.tensor(oimage).cuda()
#print(oimage.shape)
#from PIL import Image
#oimage = Image.open("../dataset/rgb/val/1.png").convert('RGB')
#image_transform = transforms.Compose([transforms.ToTensor()])
#oimage = image_transform(oimage).unsqueeze(0)
#oimage = oimage.to(self.device)
#print(oimage.shape)
image = image.to(self.device)
#print(image)
#print(type(image), image.shape)
#target = target.to(self.device)
with torch.no_grad():
import time
time_start = time.time()
for i in range(100):
outputs = model(image)
print((time.time() - time_start) / 100.)
#self.metric.update(outputs[0], target)
#pixAcc, mIoU = self.metric.get()
#logger.info("Sample: {:d}, validation pixAcc: {:.3f}, mIoU: {:.3f}".format(
# i + 1, pixAcc * 100, mIoU * 100))
if self.args.save_pred:
pred = torch.argmax(outputs[0], 1)
pred = pred.cpu().data.numpy()
predict = pred.squeeze(0)
#predict = cv2.resize(predict, (oimage.shape[1], oimage.shape[0]), interpolation = cv2.INTER_NEAREST)
mask = get_color_pallete(predict, self.args.dataset)
#cv2.imshow("image", np.array(mask, dtype=np.uint8))
#cv2.waitKey(2000)
cv2.imwrite(
os.path.join(outdir, 'test_mask_' + str(counter) + '.png'),
np.array(predict * 20, dtype=np.uint8))
mask.save(os.path.join(outdir,
'test_' + str(counter) + '.png'))
counter += 1
synchronize()
def eval(self):
self.metric.reset()
self.model.eval()
if self.args.distributed:
model = self.model.module
else:
model = self.model
logger.info("Start validation, Total sample: {:d}".format(
len(self.val_loader)))
all_pixAcc = 0
all_mIoU = 0
all_IoU_0 = 0
all_IoU_1 = 0
all_IoU_2 = 0
for i, (image, target, filename) in enumerate(self.val_loader):
image = image.to(self.device)
target = target.to(self.device)
with torch.no_grad():
outputs = model(image)
self.metric.update(outputs[0], target)
#pixAcc, mIoU = self.metric.get()
pixAcc, mIoU, IoU_0, IoU_1, IoU_2 = self.metric.get()
#logger.info("Sample: {:d}, validation pixAcc: {:.3f}, mIoU: {:.3f}".format(
# i + 1, pixAcc * 100, mIoU * 100))
logger.info(
"Sample: {:d}, validation pixAcc: {:.3f}, mIoU: {:.3f}, IoU_0: {:.3f}, IoU_1: {:.3f}, IoU_2: {:.3f}"
.format(i + 1, pixAcc * 100, mIoU * 100, IoU_0 * 100,
IoU_1 * 100, IoU_2 * 100))
all_pixAcc = all_pixAcc + pixAcc
all_mIoU = all_mIoU + mIoU
all_IoU_0 = all_IoU_0 + IoU_0
all_IoU_1 = all_IoU_1 + IoU_1
all_IoU_2 = all_IoU_2 + IoU_2
if self.args.save_pred:
pred = torch.argmax(outputs[0], 1)
pred = pred.cpu().data.numpy()
predict = pred.squeeze(0)
mask = get_color_pallete(predict, self.args.dataset)
mask.save(
os.path.join(outdir,
os.path.splitext(filename[0])[0] + '.png'))
print('mean pixAcc: ', all_pixAcc / len(self.val_loader))
print('mean mIoU: ', all_mIoU / len(self.val_loader))
print('mean IoU_0: ', all_IoU_0 / len(self.val_loader))
print('mean IoU_1: ', all_IoU_1 / len(self.val_loader))
print('mean IoU_2: ', all_IoU_2 / len(self.val_loader))
synchronize()
def eval(self):
self.metric.reset()
self.model.eval()
rles = []
images = []
filenames = []
if self.run_config['distributed']:
model = self.model.module
else:
model = self.model
logger.info("Start validation, Total sample: {:d}".format(
len(self.val_loader)))
for i, (image, filename) in enumerate(self.val_loader):
print(i)
image = image.to(self.device)
# target = target.to(self.device)
with torch.no_grad():
outputs = model(image)
# self.metric.update(outputs[0], target)
# pixAcc, mIoU = self.metric.get()
# logger.info("Sample: {:d}, validation pixAcc: {:.3f}, mIoU: {:.3f}".format(
# i + 1, pixAcc * 100, mIoU * 100))
if self.run_config['save_pred']:
pred = torch.argmax(outputs[0], 1)
pred = pred.cpu().data.numpy()
for predict, f_name in zip(pred, filename):
# predict = p.squeeze(0)
images.append(predict)
filenames.append(f_name.split('.pn')[0])
# mask = get_color_pallete(predict, self.data_config['dataset_name'])
# mask.save(os.path.join(run_config['path']['pred_pic'], os.path.splitext(filename[0])[0] + '.png'))
synchronize()
try:
pool = Pool(8)
for rle in tqdm(pool.map(mask2rle, images), total=len(rles)):
rles.append(rle)
#pool.map(process_image, mdlParams['im_paths']) # process data_inputs iterable with pool
finally: # To make sure processes are closed in the end, even if errors happen
pool.close()
pool.join()
# ids = [o.split('.pn')[0] for o in filenames]
sub_df = pd.DataFrame({'ImageId': filenames, 'EncodedPixels': rles})
sub_df.loc[sub_df.EncodedPixels == '', 'EncodedPixels'] = '-1'
sub_df.to_csv('submission.csv', index=False)
def eval(self):
self.metric.reset()
self.model.eval()
if self.args.distributed:
model = self.model.module
else:
model = self.model
logger.info("Start validation, Total sample: {:d}".format(
len(self.val_loader)))
fps_sum = 0.0
for i, (image, target, filename) in enumerate(self.val_loader):
start = time.time()
image = image.to(self.device)
target = target.to(self.device)
with torch.no_grad():
outputs = model(image)
self.metric.update(outputs[0], target)
pixAcc, mIoU = self.metric.get()
end = time.time()
fps = 1.0 / (end - start)
fps_sum = fps_sum + fps
logger.info(
"Sample: {:d}, validation pixAcc: {:.3f}, mIoU: {:.3f}, FPS: {:.3f}"
.format(i + 1, pixAcc * 100, mIoU * 100, fps))
if self.args.save_pred:
pred = torch.argmax(outputs[0], 1)
pred = pred.cpu().data.numpy()
predict = pred.squeeze(0)
mask = get_color_pallete(predict, self.args.dataset)
mask.save(
os.path.join(outdir,
os.path.splitext(filename[0])[0] + '.png'))
#danet 显存不足
#if i + 1 > 302: break
avg_fps = fps_sum / len(self.val_loader)
logger.info("avgFPS: {:.3f}".format(avg_fps))
synchronize()
if __name__ == '__main__':
args = parse_args()
num_gpus = int(
os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1
args.distributed = num_gpus > 1
if not args.no_cuda and torch.cuda.is_available():
cudnn.benchmark = True
args.device = "cuda"
else:
args.distributed = False
args.device = "cpu"
if args.distributed:
torch.cuda.set_device(args.local_rank)
torch.distributed.init_process_group(backend="nccl",
init_method="env://")
synchronize()
# TODO: optim code
args.save_pred = True
if args.save_pred:
outdir = '../runs/pred_pic/{}_{}_{}'.format(args.model, args.backbone,
args.dataset)
if not os.path.exists(outdir):
os.makedirs(outdir)
logger = setup_logger("semantic_segmentation",
args.log_dir,
get_rank(),
filename='{}_{}_{}_log.txt'.format(
args.model, args.backbone, args.dataset),
mode='a+')
def eval(self):
self.metric.reset()
self.model.eval()
if self.args.distributed:
model = self.model.module
else:
model = self.model
logger.info("Start validation, Total sample: {:d}".format(
len(self.val_loader)))
all_pixAcc = 0
all_mIoU = 0
all_IoU_0 = 0
all_IoU_1 = 0
all_IoU_2 = 0
for i, (image, target, filename) in enumerate(self.val_loader):
image = image.to(self.device)
target = target.to(self.device)
with torch.no_grad():
#outputs = model(image)
outputs, mat_result_512, mat_result_3 = model(image)
mat_result_512 = mat_result_512.transpose((1, 2, 0))
mat_result_3 = mat_result_3.transpose((1, 2, 0))
print('mat_result_512.type:', type(mat_result_512))
print('mat_result_512.shape:', mat_result_512.shape)
print('mat_result_3.type:', type(mat_result_3))
print('mat_result_3.shape:', mat_result_3.shape)
filename_mat = os.path.splitext(filename[0])[0] + '.mat'
print('This is:', filename_mat)
datapath_512 = '/home/pzn/pzncode/non-local/awesome-semantic-segmentation-pytorch/runs/mat_result_512_121/' + filename_mat
print(datapath_512)
result_512 = {'pzn_feature_512': mat_result_512}
scio.savemat(datapath_512, {'feature512': result_512},
appendmat=True,
do_compression=True)
print('This is:', filename_mat)
datapath_3 = '/home/pzn/pzncode/non-local/awesome-semantic-segmentation-pytorch/runs/mat_result_3_121/' + filename_mat
print(datapath_3)
result_3 = {'pzn_feature_3': mat_result_3}
scio.savemat(datapath_3, {'feature3': result_3},
appendmat=True,
do_compression=True)
self.metric.update(outputs[0], target)
#pixAcc, mIoU = self.metric.get()
pixAcc, mIoU, IoU_0, IoU_1, IoU_2 = self.metric.get()
#logger.info("Sample: {:d}, validation pixAcc: {:.3f}, mIoU: {:.3f}".format(
# i + 1, pixAcc * 100, mIoU * 100))
logger.info(
"Sample: {:d}, validation pixAcc: {:.3f}, mIoU: {:.3f}, IoU_0: {:.3f}, IoU_1: {:.3f}, IoU_2: {:.3f}"
.format(i + 1, pixAcc * 100, mIoU * 100, IoU_0 * 100,
IoU_1 * 100, IoU_2 * 100))
all_pixAcc = all_pixAcc + pixAcc
all_mIoU = all_mIoU + mIoU
all_IoU_0 = all_IoU_0 + IoU_0
all_IoU_1 = all_IoU_1 + IoU_1
all_IoU_2 = all_IoU_2 + IoU_2
if self.args.save_pred:
pred = torch.argmax(outputs[0], 1)
pred = pred.cpu().data.numpy()
predict = pred.squeeze(0)
mask = get_color_pallete(predict, self.args.dataset)
mask.save(
os.path.join(outdir,
os.path.splitext(filename[0])[0] + '.png'))
print('mean pixAcc: ', all_pixAcc / len(self.val_loader))
print('mean mIoU: ', all_mIoU / len(self.val_loader))
print('mean IoU_0: ', all_IoU_0 / len(self.val_loader))
print('mean IoU_1: ', all_IoU_1 / len(self.val_loader))
print('mean IoU_2: ', all_IoU_2 / len(self.val_loader))
synchronize()
def eval(self):
self.metric.reset()
self.model.eval()
if self.args.distributed:
model = self.model.module
else:
model = self.model
logger.info("Start validation, Total sample: {:d}".format(
len(self.val_loader)))
name_list = []
mIOU_list = []
acc_list = []
all_pixAcc = 0
all_mIoU = 0
all_IoU_0 = 0
all_IoU_1 = 0
all_IoU_2 = 0
for i, (image, target, filename) in enumerate(self.val_loader):
image = image.to(self.device)
target = target.to(self.device)
with torch.no_grad():
outputs = model(image)
self.metric.update(outputs[0], target)
#pixAcc, mIoU = self.metric.get()
pixAcc, mIoU, IoU_0, IoU_1, IoU_2 = self.metric.get()
#logger.info("Sample: {:d}, validation pixAcc: {:.3f}, mIoU: {:.3f}".format(
# i + 1, pixAcc * 100, mIoU * 100))
logger.info(
"Sample: {:d}, validation pixAcc: {:.3f}, mIoU: {:.3f}, IoU_0: {:.3f}, IoU_1: {:.3f}, IoU_2: {:.3f}"
.format(i + 1, pixAcc * 100, mIoU * 100, IoU_0 * 100,
IoU_1 * 100, IoU_2 * 100))
all_pixAcc = all_pixAcc + pixAcc
all_mIoU = all_mIoU + mIoU
all_IoU_0 = all_IoU_0 + IoU_0
all_IoU_1 = all_IoU_1 + IoU_1
all_IoU_2 = all_IoU_2 + IoU_2
mIOU_list.append(mIoU)
acc_list.append(pixAcc)
print('image_pre_i:', filename)
name_list.append(filename[0])
if self.args.save_pred:
pred = torch.argmax(outputs[0], 1)
pred = pred.cpu().data.numpy()
predict = pred.squeeze(0)
mask = get_color_pallete(predict, self.args.dataset)
mask.save(
os.path.join(outdir,
os.path.splitext(filename[0])[0] + '.png'))
print('mean pixAcc: ', all_pixAcc / len(self.val_loader))
print('mean mIoU: ', all_mIoU / len(self.val_loader))
print('mean IoU_0: ', all_IoU_0 / len(self.val_loader))
print('mean IoU_1: ', all_IoU_1 / len(self.val_loader))
print('mean IoU_2: ', all_IoU_2 / len(self.val_loader))
print('name_list: ', name_list)
print('mIOU_list: ', mIOU_list)
print('acc_list: ', acc_list)
df_data = name_list + mIOU_list + acc_list
title_name = ['image_name']
df = pd.DataFrame(columns=title_name, data=df_data)
df.to_csv('name_demo.csv')
synchronize()