def inicializar_segsem():
print("Loading Semantic Segmentation Model:")
start = time.time()
global loader
global device
global model
device = torch.device("cuda")
model_name = "hardnet"
data_loader = get_loader("ade20k")
loader = data_loader(root=None,
is_transform=True,
img_norm=True,
test_mode=True)
n_classes = loader.n_classes
# Setup Model
model_dict = {"arch": model_name}
model = get_model(model_dict, n_classes, version="ade20k")
state = convert_state_dict(
torch.load(
"/home/socialab/FCHarDNet/runs/config./cur/hardnet_ade20k_best_model.pkl",
)["model_state"])
model.load_state_dict(state)
model.eval()
model.to(device)
end = time.time()
print(" (time): " + str(end - start))
def get_dataset_loader():
args=edict()
args.dataset_name = 'cityscapes'
args.config_path = os.path.join('/home/yzbx/git/gnu/pytorch-semseg', 'config.json')
args.img_rows=224
args.img_cols=224
args.img_norm=True
args.batch_size=2
data_loader = get_loader(args.dataset_name)
data_path = get_data_path(args.dataset_name, args.config_path)
t_loader = data_loader(data_path, is_transform=True, split='train', img_size=(
args.img_rows, args.img_cols), augmentations=None, img_norm=args.img_norm)
v_loader = data_loader(data_path, is_transform=True, split='val', img_size=(
args.img_rows, args.img_cols), img_norm=args.img_norm)
n_classes = t_loader.n_classes
print('class number is',n_classes)
trainloader = data.DataLoader(
t_loader, batch_size=args.batch_size, num_workers=8, shuffle=True)
valloader = data.DataLoader(
v_loader, batch_size=args.batch_size, num_workers=8)
return trainloader,valloader
def train(args):
# Setup Dataloader
data_loader = get_loader(args.dataset)
data_path = get_data_path(args.dataset, config_file=args.config_file)
loader = data_loader(data_path,
is_transform=True,
img_size=(args.img_rows, args.img_cols))
n_classes = loader.n_classes
# must use 1 worker for AWS sagemaker without ipc="host" or larger shared memory size
trainloader = data.DataLoader(loader,
batch_size=args.batch_size,
num_workers=1,
shuffle=True)
# Setup Model
model = get_model(args.arch, n_classes)
# Setup log dir / logging
if not os.path.exists(args.log_dir):
os.makedirs(args.log_dir)
configure(args.log_dir)
model = torch.nn.DataParallel(model,
device_ids=range(torch.cuda.device_count()))
model.cuda()
optimizer = torch.optim.SGD(model.parameters(),
lr=args.l_rate,
momentum=0.9,
weight_decay=5e-4)
step = 0
for epoch in range(args.n_epoch):
start_time = time.time()
for i, (images, labels) in enumerate(trainloader):
images = Variable(images.cuda())
labels = Variable(labels.cuda())
optimizer.zero_grad()
outputs = model(images)
loss = cross_entropy2d(outputs, labels)
loss.backward()
optimizer.step()
log_value('Loss', loss.data[0], step)
step += 1
if (i + 1) % 20 == 0:
print("Epoch [%d/%d] Loss: %.4f" %
(epoch + 1, args.n_epoch, loss.data[0]),
flush=True)
end_time = time.time()
print('Epoch run time: %s' % (end_time - start_time))
torch.save(
model, args.log_dir + "{}_{}_{}_{}.pt".format(
args.arch, args.dataset, args.feature_scale, epoch))
def validate(args):
# Setup Dataloader
data_loader = get_loader(args.dataset)
data_path = get_data_path(args.dataset)
loader = data_loader(data_path, split=args.split, is_transform=True, img_size=(args.img_rows, args.img_cols))
n_classes = loader.n_classes
valloader = data.DataLoader(loader, batch_size=args.batch_size, num_workers=4)
running_metrics = runningScore(n_classes)
# Setup Model
model = get_model(args.model_path[:args.model_path.find('_')], n_classes)
state = convert_state_dict(torch.load(args.model_path)['model_state'])
model.load_state_dict(state)
model.eval()
for i, (images, labels) in tqdm(enumerate(valloader)):
model.cuda()
images = Variable(images.cuda(), volatile=True)
labels = Variable(labels.cuda(), volatile=True)
outputs = model(images)
pred = outputs.data.max(1)[1].cpu().numpy()
gt = labels.data.cpu().numpy()
running_metrics.update(gt, pred)
score, class_iou = running_metrics.get_scores()
for k, v in score.items():
print(k, v)
for i in range(n_classes):
print(i, class_iou[i])
def test(args):
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model_file_name = os.path.split(args.model_path)[1]
model_name = model_file_name[:model_file_name.find("_")]
# Setup image
print("Read Input Image from : {}".format(args.img_path))
img = misc.imread(args.img_path)
data_loader = get_loader(args.dataset)
loader = data_loader(root=None,
is_transform=True,
img_norm=args.img_norm,
test_mode=True)
n_classes = loader.n_classes
resized_img = misc.imresize(img, (loader.img_size[0], loader.img_size[1]),
interp="bicubic")
orig_size = img.shape[:-1]
if model_name in ["pspnet", "icnet", "icnetBN"]:
# uint8 with RGB mode, resize width and height which are odd numbers
img = misc.imresize(
img, (orig_size[0] // 2 * 2 + 1, orig_size[1] // 2 * 2 + 1))
else:
img = misc.imresize(img, (loader.img_size[0], loader.img_size[1]))
img = img[:, :, ::-1]
img = img.astype(np.float64)
img -= loader.mean
if args.img_norm:
img = img.astype(float) / 255.0
# NHWC -> NCHW
img = img.transpose(2, 0, 1)
img = np.expand_dims(img, 0)
img = torch.from_numpy(img).float()
# Setup Model
model_dict = {"arch": model_name}
model = get_model(model_dict, n_classes, version=args.dataset)
state = convert_state_dict(torch.load(args.model_path)["model_state"])
model.load_state_dict(state)
model.eval()
model.to(device)
images = img.to(device)
outputs = model(images)
pred = np.squeeze(outputs.data.max(1)[1].cpu().numpy(), axis=0)
if model_name in ["pspnet", "icnet", "icnetBN"]:
pred = pred.astype(np.float32)
# float32 with F mode, resize back to orig_size
pred = misc.imresize(pred, orig_size, "nearest", mode="F")
print("Classes found: ", np.unique(pred))
misc.imsave(args.out_path, pred.astype('uint8'))
print("Segmentation Mask Saved at: {}".format(args.out_path))
def test(args, cfg):
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model_file_name = os.path.split(args.model_path)[1]
model_name = model_file_name[:model_file_name.find("_")]
IMG_Path = Path(args.img_path)
IMG_File = natsort.natsorted(list(IMG_Path.glob("*.png")),
alg=natsort.PATH)
IMG_Str = []
for i in IMG_File:
IMG_Str.append(str(i))
# Setup image
print("Read Input Image from : {}".format(args.img_path))
data_loader = get_loader(args.dataset)
data_path = get_data_path(args.dataset, config_file=cfg)
loader = data_loader(data_path, is_transform=True, img_norm=args.img_norm)
n_classes = loader.n_classes
# Setup Model
model = get_model(cfg['model'], n_classes)
state = convert_state_dict(torch.load(args.model_path)["model_state"])
# state=torch.load(args.model_path)["model_state"]
model.load_state_dict(state)
model.eval()
model.to(device)
for j in tqdm(range(len(IMG_Str))):
img_path = IMG_Str[j]
img = misc.imread(img_path)
# img = img[:, :, ::-1]
img = img.astype(np.float64)
# img -= loader.mean
if args.img_norm:
img = img.astype(float) / 255.0
# NHWC -> NCHW
img = img.transpose(2, 0, 1)
img = np.expand_dims(img, 0)
img = torch.from_numpy(img).float()
images = img.to(device)
outputs = model(images)
outputs_probability = F.softmax(outputs)
data = outputs_probability.data
data_max = data.max(1)
prob = data_max[0]
prob_img_format = np.squeeze(prob.cpu().numpy(), axis=0)
avg_prob = np.mean(prob_img_format)
print("Confidence Score for %s: \n%f" % (img_path, avg_prob))
pred = np.squeeze(outputs.data.max(1)[1].cpu().numpy(), axis=0)
decoded = loader.decode_segmap(pred)
out_path = "test_out/test_confidence/out/" + Path(img_path).name
decoded_bgr = cv.cvtColor(decoded, cv.COLOR_RGB2BGR)
# misc.imsave(out_path, decoded)
cv.imwrite(out_path, decoded_bgr)
def test(args, cfg):
os.environ["CUDA_VISIBLE_DEVICES"] = "1"
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model_file_name = os.path.split(args.model_path)[1]
model_name = model_file_name[:model_file_name.find("_")]
IMG_Path = Path(args.img_path)
IMG_File = natsort.natsorted(list(IMG_Path.glob("*.tif")),
alg=natsort.PATH)
IMG_Str = []
for i in IMG_File:
IMG_Str.append(str(i))
# Setup image
print("Read Input Image from : {}".format(args.img_path))
data_loader = get_loader(args.dataset)
data_path = get_data_path(args.dataset, config_file=cfg)
loader = data_loader(data_path, is_transform=True, img_norm=args.img_norm)
n_classes = loader.n_classes
v_loader = data_loader(
data_path,
is_transform=True,
split=cfg['data']['val_split'],
img_size=(cfg['data']['img_rows'], cfg['data']['img_cols']),
)
valloader = data.DataLoader(v_loader,
batch_size=cfg['training']['batch_size'],
num_workers=cfg['training']['n_workers'])
# Setup Model
model = get_model(cfg['model'], n_classes)
state = convert_state_dict(torch.load(args.model_path)["model_state"])
# state=torch.load(args.model_path)["model_state"]
model.load_state_dict(state)
model.eval()
model.to(device)
with torch.no_grad():
for i_val, (img_path, images_val,
labels_val) in tqdm(enumerate(valloader)):
img_name = img_path[0]
images_val = images_val.to(device)
outputs = model(images_val)
pred = np.squeeze(outputs.data.max(1)[1].cpu().numpy(), axis=0)
decoded = loader.decode_segmap(pred)
out_path = "test_out/CAN_res50_4band_data07/" + Path(
img_name).stem + ".png"
decoded_bgr = cv.cvtColor(decoded, cv.COLOR_RGB2BGR)
# misc.imsave(out_path, decoded)
cv.imwrite(out_path, decoded_bgr)
def validate(cfg, args):
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# Setup Dataloader
data_loader = get_loader(cfg["data"]["dataset"])
data_path = cfg["data"]["path"]
loader = data_loader(
data_path,
split=cfg["data"]["val_split"],
is_transform=True,
img_size=(cfg["data"]["img_rows"], cfg["data"]["img_cols"]),
)
n_classes = loader.n_classes
valloader = data.DataLoader(loader,
batch_size=cfg["training"]["batch_size"],
num_workers=8)
running_metrics = runningScore(n_classes)
# Setup Model
model = get_model(cfg["model"], n_classes).to(device)
state = convert_state_dict(torch.load(args.model_path)["model_state"])
model.load_state_dict(state)
model.eval()
model.to(device)
for i, (images, labels) in enumerate(valloader):
images = images.to(device)
gt = labels.numpy()
outputs = model(images).data.cpu().numpy()
flipped_images = torch.flip(images, dims=(3, ))
outputs_flipped = model(flipped_images)
outputs_flipped = torch.flip(outputs_flipped,
dims=(3, )).data.cpu().numpy()
outputs = (outputs + outputs_flipped) / 2.0
pred = np.argmax(outputs, axis=1)
running_metrics.update(gt, pred)
score, class_iou = running_metrics.get_scores()
for k, v in score.items():
print(k, v)
for i in range(n_classes):
print(i, class_iou[i])
def test(cfg, args):
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# Setup Dataloader
data_loader = get_loader(cfg['data']['dataset'], cfg['task'])
data_path = cfg['data']['path']
loader = data_loader(
data_path,
split=cfg['data']['test_split'],
is_transform=True,
img_size=(cfg['data']['img_rows'],
cfg['data']['img_cols']),
img_norm=cfg['data']['img_norm']
)
n_classes = loader.n_classes
testloader = data.DataLoader(loader,
batch_size=cfg['training']['batch_size'],
num_workers=0)
# Setup Model
model = get_model(cfg['model'], cfg['task'], n_classes=n_classes).to(device)
weights = torch.load(cfg['testing']['trained_model'], map_location=lambda storage, loc: storage)
model.load_state_dict(weights["model_state"])
model.eval()
model.to(device)
for i, (images, labels, img_path) in tqdm(enumerate(testloader)):
images = images.to(device)
outputs = model(images)
pred = np.squeeze(outputs.data.max(1)[1].cpu().numpy(), axis=0)
decoded = loader.decode_segmap_tocolor(pred) # color segmentation mask
decoded_labelID = loader.decode_segmap_tolabelId(pred) # segmentation mask of labelIDs for online test
print("Classes found: ", np.unique(decoded_labelID))
# m.imsave("output.png", decoded)
out_file_name = [img_path[0][39:-16], '*.png']
out_file_name = ''.join(out_file_name)
out_path = os.path.join(args.out_path, out_file_name)
decoded_labelID = m.imresize(decoded_labelID, (1024, 2048), "nearest", mode="F")
m.toimage(decoded_labelID, high=np.max(decoded_labelID), low=np.min(decoded_labelID)).save(out_path)
print("Segmentation Mask Saved at: {}".format(out_path))
def validate(args):
# Setup Dataloader
data_loader = get_loader(args.dataset)
data_path = get_data_path(args.dataset)
loader = data_loader(data_path,
split=args.split,
is_transform=True,
img_size=(args.img_rows, args.img_cols))
n_classes = loader.n_classes
valloader = data.DataLoader(loader,
batch_size=args.batch_size,
num_workers=4)
# Setup Model
model = torch.load(args.model_path)
model.eval()
if torch.cuda.is_available():
model.cuda(args.gpu)
gts, preds = [], []
for i, (images, labels) in tqdm(enumerate(valloader)):
if torch.cuda.is_available():
images = Variable(images.cuda(args.gpu))
labels = Variable(labels.cuda(args.gpu))
else:
images = Variable(images)
labels = Variable(labels)
outputs = model(images)
pred = outputs.data.max(1)[1].cpu().numpy()
pred = np.squeeze(pred)
pred = cv2.resize(pred,
labels.size()[1:][::-1],
interpolation=cv2.INTER_NEAREST)
pred = np.expand_dims(pred, axis=0)
gt = labels.data.cpu().numpy()
for gt_, pred_ in zip(gt, pred):
gts.append(gt_)
preds.append(pred_)
score, class_iou = scores(gts, preds, n_class=n_classes)
for k, v in score.items():
print k, v
for i in range(n_classes):
print i, class_iou[i]
def validate():
# Setup Dataloader
data_loader = get_loader(args.dataset)
data_path = get_data_path(args.dataset)
loader = data_loader(data_path, img_size=args.img_size)
n_classes = loader.n_classes
n_channels = loader.n_channels
valloader = data.DataLoader(loader,
batch_size=args.batch_size,
num_workers=4,
shuffle=True)
# Setup Model
model = torch.load(args.model_path)
model.eval()
if torch.cuda.is_available():
model.cuda(0)
gts, preds = [], []
for i, (images, labels) in tqdm(enumerate(valloader)):
if i >= args.max_samples:
break
if torch.cuda.is_available():
images = Variable(images.cuda(0))
labels = Variable(labels.cuda(0))
else:
images = Variable(images)
labels = Variable(labels)
outputs = model(images)
pred = np.squeeze((torch.max(outputs.data, 1,
keepdim=True))[1].cpu().numpy())
gt = np.squeeze(labels.data.cpu().numpy())
for gt_, pred_ in zip(gt, pred):
gts.append(gt_)
preds.append(pred_)
score, class_iou = scores(gts, preds, n_class=n_classes)
for k, v in score.items():
print(k, v)
for i in range(n_classes):
print(i, class_iou[i])
def test(args):
model_file_name = os.path.split(args.model_path)[1]
model_name = model_file_name[:model_file_name.find('_')]
print("Building " + model_name)
data_loader = get_loader(args.dataset)
data_path = get_data_path(args.dataset)
loader = data_loader(data_path, phase='test')
im_paths = loader.im_paths()
n_classes = loader.n_classes
testloader = data.DataLoader(loader,
batch_size=1,
num_workers=1,
shuffle=False)
# Setup Model
model = get_model(model_name, n_classes)
state = torch.load(args.model_path)['model_state']
model.load_state_dict(state)
model.eval()
model.cuda()
# Run test for KITTI Road dataset
for i, (image, tr_image, lidar, tr_lidar) in enumerate(testloader):
im_name_splits = im_paths[i].split('/')[-1].split('.')[0].split('_')
task = im_name_splits[0]
print('processing %d-th image' % i)
t0 = time.time()
orig_h, orig_w = image.shape[1:3]
with torch.no_grad():
tr_image = Variable(tr_image.cuda())
tr_lidar = Variable(tr_lidar.cuda())
outputs = model([tr_image, tr_lidar])
outputs = outputs.cpu().numpy().transpose((2, 3, 1, 0)).squeeze()
outputs = cv2.resize(outputs, (orig_w, orig_h))
outputs = outputs[:, :, 1]
print('Time({:d}'.format(i) + ') {0:.3f}'.format(time.time() - t0))
output_fg = outputs * 255.
output_fg[output_fg > 255] = 255
output_fg = output_fg.astype(np.uint8)
cv2.imwrite(
'./outputs/results/' + im_name_splits[0] + '_road_' +
im_name_splits[1] + '.png', output_fg)
print('write to ./outputs/results/' + im_name_splits[0] + '_road_' +
im_name_splits[1] + '.png')
def test(cfg, args):
# Setup device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# Setup Dataloader
data_loader = get_loader(cfg['data']['dataset'], cfg['task'])
data_path = cfg['data']['path']
loader = data_loader(data_path,
split=cfg['data']['test_split'],
is_transform=True,
img_size=(cfg['data']['img_rows'],
cfg['data']['img_cols']),
img_norm=cfg['data']['img_norm'])
n_classes = 0
running_metrics_val = runningScoreDepth(cfg['data']['dataset'])
testloader = data.DataLoader(loader,
batch_size=cfg['training']['batch_size'],
num_workers=0)
# Load Model
model = get_model(cfg['model'], cfg['task'],
n_classes=n_classes).to(device)
#weights = torch.load(cfg['testing']['trained_model'])
weights = torch.load(cfg['testing']['trained_model'],
map_location=lambda storage, loc: storage)
model.load_state_dict(weights["model_state"])
model.eval()
model.to(device)
with torch.no_grad():
for i, (images, labels, img_path) in tqdm(enumerate(testloader)):
images = images.to(device)
labels = labels.to(device)
outputs = model(images) # [batch_size, n_classes, height, width]
if cfg['model']['arch'] == "dispnet" and cfg['task'] == "depth":
outputs = 1 / outputs
pred = outputs.squeeze(1).data.cpu().numpy()
gt = labels.data.squeeze(1).cpu().numpy()
running_metrics_val.update(gt=gt, pred=pred)
val_result = running_metrics_val.get_scores()
for k, v in val_result.items():
print(k, v)
def __init__(self,
indices,
n_init=100,
output_dir=None,
train=True,
queries_name='queries.txt'):
self.data_path = os.path.join(DATA_ROOT, f'VOCdevkit/VOC2012')
self.sbd_path = os.path.join(DATA_ROOT, f'benchmark_RELEASE')
self.data_aug = get_composed_augmentations(None)
self.data_loader = get_loader('pascal')
self.init_dataset = self._get_initial_dataset(train)
super().__init__(self.get_dataset(indices),
n_init=n_init,
output_dir=output_dir,
queries_name=queries_name)
def test(args):
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model_file_name = os.path.split(args.model_path)[1]
model_name = model_file_name[:model_file_name.find("_")]
# Setup image
print("Read Input Image from : {}".format(args.img_path))
img = misc.imread(args.img_path)
data_loader = get_loader(args.dataset)
data_path = get_data_path(args.dataset)
loader = data_loader(data_path, is_transform=True, img_norm=args.img_norm)
n_classes = loader.n_classes
img = img[:, :, ::-1]
img = img.astype(np.float64)
img -= loader.mean
if args.img_norm:
img = img.astype(float) / 255.0
# NHWC -> NCHW
img = img.transpose(2, 0, 1)
img = np.expand_dims(img, 0)
img = torch.from_numpy(img).float()
# Setup Model
model_dict = {"arch": model_name}
model = get_model(model_dict, n_classes, version=args.dataset)
state = convert_state_dict(torch.load(args.model_path)["model_state"])
model.load_state_dict(state)
model.eval()
model.to(device)
images = img.to(device)
outputs = model(images)
if args.mask_path:
print("Read Image Mask from : {}".format(args.mask_path))
mask = torch.load(args.mask_path)
mask = mask.to(device)
outputs = to_super_to_pixels(outputs, mask)
pred = np.squeeze(outputs.data.max(1)[1].cpu().numpy(), axis=0)
decoded = loader.decode_segmap(pred)
print("Classes found: ", np.unique(pred))
misc.imsave(args.out_path, decoded)
print("Segmentation Mask Saved at: {}".format(args.out_path))
def _load_model(self, cfg):
self.device = torch.device(cfg['device'])
data_loader = get_loader('vistas')
self.loader = data_loader(root=cfg['testing']['config_path'],
is_transform=True,
test_mode=True)
n_classes = self.loader.n_classes
# Setup Model
model_dict = {"arch": 'icnetBN'}
model = get_model(model_dict, n_classes)
state = convert_state_dict(
torch.load(cfg['testing']['model_path'])["model_state"])
model.load_state_dict(state)
model.eval()
model.to(self.device)
return model
def test(args):
# Setup image
print("Read Input Image from : {}".format(args.img_path))
orig_img = misc.imread(args.img_path)
data_loader = get_loader(args.dataset)
data_path = get_data_path(args.dataset)
loader = data_loader(data_path, is_transform=True)
n_classes = loader.n_classes
img = orig_img[:, :, ::-1]
img = img.astype(np.float64)
img -= loader.mean
img = misc.imresize(img, (loader.img_size[0], loader.img_size[1]))
img = img.astype(float) / 255.0
# NHWC -> NCWH
img = img.transpose(2, 0, 1)
img = np.expand_dims(img, 0)
img = torch.from_numpy(img).float()
# Setup Model
model = get_model(args.arch, n_classes)
model.load_state_dict(torch.load(args.model_path)['state_dict'])
model = torch.nn.DataParallel(model,
device_ids=range(
torch.cuda.device_count())).cuda()
model.eval()
if torch.cuda.is_available():
model.cuda(0)
images = Variable(img.cuda(0))
else:
images = Variable(img)
outputs = model(images)
pred = np.squeeze(outputs.data.max(1)[1].cpu().numpy(), axis=0)
decoded = loader.decode_segmap(pred)
if args.alpha_blend:
orig_img = misc.imresize(orig_img,
(loader.img_size[0], loader.img_size[1]))
out_img = ALPHA * orig_img + (1 - ALPHA) * decoded
else:
out_img = decoded
print(np.unique(pred))
misc.imsave(args.out_path, out_img)
print("Segmentation Mask Saved at: {}".format(args.out_path))
def validate(args):
data_loader = get_loader(args.dataset)
data_path = get_data_path(args.dataset)
loader = data_loader(data_path,
split=args.split,
is_transform=True,
img_size=None,
img_norm=args.img_norm)
n_classes = loader.n_classes
valloader = data.DataLoader(loader,
batch_size=args.batch_size,
num_workers=4)
running_metrics = runningScore(n_classes)
# Setup Model
from pytorchgo.model.deeplab_resnet import Res_Deeplab
model = Res_Deeplab(NoLabels=n_classes, pretrained=False)
state = torch.load("/home/hutao/MS_DeepLab_resnet_trained_VOC.pth")
model.load_state_dict(state)
model.eval()
model.cuda()
print "pra"
for i, (images, labels) in tqdm(enumerate(valloader), desc="validation"):
start_time = timeit.default_timer()
img_large = torch.Tensor(np.zeros((1, 3, 513, 513)))
img_large[:, :, :images.shape[2], :images.shape[3]] = images
output = model(Variable(img_large, volatile=True).cuda())
output = output.data.max(1)[1].cpu().numpy()
pred = output[:, :images.shape[2], :images.shape[3]]
gt = labels.numpy()
if args.measure_time:
elapsed_time = timeit.default_timer() - start_time
print('Inference time (iter {0:5d}): {1:3.5f} fps'.format(
i + 1, pred.shape[0] / elapsed_time))
running_metrics.update(gt, pred)
score, class_iou = running_metrics.get_scores()
for k, v in score.items():
print(k, v)
for i in range(n_classes):
print(i, class_iou[i])
def test(args):
# Setup image
print("Read Input Image from : ", args.img_path)
data_loader = get_loader(args.dataset)
data_path = get_data_path(args.dataset)
loader = data_loader(data_path, is_transform=True)
n_classes = loader.n_classes
img = img[:, :, ::-1]
img = img.astype(np.float64)
img -= loader.mean
# print(loader.img_size[0], loader.img_size[1])
# img = misc.imresize(img, (loader.img_size[0], loader.img_size[1]))
img = img.astype(float) / 255.0
# NHWC -> NCWH
img = img.transpose(2, 0, 1)
img = np.expand_dims(img, 0)
img = torch.from_numpy(img).float()
# Setup Model
model = torch.load(args.model_path)
model.eval()
if torch.cuda.is_available():
model.cuda(0)
images = Variable(img.cuda(0))
else:
images = Variable(img)
outputs = model(images)
log('the size of outputs is '.format(outputs.size()))
log('the size of outputs is ', outputs.data.max(1)[1].size())
pred = np.squeeze(outputs.data.cpu().numpy(), axis=0)
pred = pred[0, :, :] > pred[1, :, :]
pred = pred * 255
pred = outputs.data.cpu().numpy()
log('The prediction shape is {}'.format(pred.shape))
# print('the size of pred is ', pred.shape())
# fig = plt.figure()
# plt.imshow(pred[1,:,:])
# plt.title('testing result')
# plt.show()
pred = pred * 255
misc.imsave(args.out_path, pred[0, :, :])
print("Segmentation Mask Saved at: ", args.out_path)
def validate(cfg, args):
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# Setup Dataloader
data_loader = get_loader(cfg['data']['dataset'], cfg['task'])
data_path = cfg['data']['path']
loader = data_loader(
data_path,
split=cfg['data']['val_split'],
is_transform=True,
img_norm=cfg['data']['img_norm'],
img_size=(cfg['data']['img_rows'], cfg['data']['img_cols']),
)
n_classes = loader.n_classes
valloader = data.DataLoader(loader,
batch_size=cfg['training']['batch_size'],
num_workers=0)
running_metrics = runningScoreSeg(n_classes)
# Setup Model
model = get_model(cfg['model'], cfg['task'], n_classes).to(device)
state = torch.load(args.model_path)["model_state"]
#state = torch.load(args.model_path, map_location=lambda storage, loc: storage)["model_state"]
model.load_state_dict(state)
model.to(device)
model.eval()
with torch.no_grad():
for i, (images, labels, images_path) in enumerate(valloader):
images = images.to(device)
outputs = model(images)
pred = outputs.data.max(1)[1].cpu().numpy()
gt = labels.numpy()
running_metrics.update(gt, pred)
score, class_iou = running_metrics.get_scores()
for k, v in score.items():
print(k, v)
for i in range(n_classes):
print(i, class_iou[i])
def validate(args):
# Setup Dataloader
data_loader = get_loader(args.dataset)
data_path = get_data_path(args.dataset)
loader = data_loader(data_path,
split=args.split,
is_transform=True,
img_size=(args.img_rows, args.img_cols))
n_classes = loader.n_classes
valloader = data.DataLoader(loader,
batch_size=args.batch_size,
num_workers=4)
# Setup Model
model = torch.load(args.model_path)
model.eval()
gts, preds = [], []
for i, (images, labels) in tqdm(enumerate(valloader)):
if torch.cuda.is_available():
model = torch.nn.DataParallel(model,
device_ids=range(
torch.cuda.device_count()))
images = Variable(images.cuda(0))
labels = Variable(labels.cuda(0))
else:
images = Variable(images)
labels = Variable(labels)
outputs = model(images)
pred = np.squeeze(outputs.data.max(1)[1].cpu().numpy(), axis=1)
gt = labels.data.cpu().numpy()
for gt_, pred_ in zip(gt, pred):
gts.append(gt_)
preds.append(pred_)
score, class_iou = scores(gts, preds, n_class=n_classes)
for k, v in score.items():
print(k, v)
for i in range(n_classes):
print(i, class_iou[i])
def get_sem_mask(model_file_name):
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
#img_path = input('Image path: ')
img_path = 'results/munich_000009_000019_leftImg8bit.png'
if len(img_path):
if img_path[-3:] == 'png' or img_path[-3:] == 'jpg':
print("Read Input Image from : %s" % (img_path))
else:
raise Exception('Non PNG or JPG image!')
else:
img_path = 'results/munich_000009_000019_leftImg8bit.png'
img = cv2.imread(img_path)
img_orig = img
model_name = model_file_name[:model_file_name.find("_")]
data_loader = get_loader('cityscapes')
loader = data_loader(root=None, is_transform=True, test_mode=True)
n_classes = loader.n_classes
img = image_preproc(img, loader.img_size)
model_dict = {"arch": model_name}
model = get_model(model_dict, n_classes, version='cityscapes')
try:
state = convert_state_dict(torch.load(model_file_name)["model_state"])
except:
state = convert_state_dict(
torch.load(model_file_name, map_location='cpu')["model_state"])
model.load_state_dict(state)
model.eval()
model.to(device)
images = img.to(device)
outputs = model(images)
pred = np.squeeze(outputs.data.max(1)[1].cpu().numpy(), axis=0)
return pred, img_orig
def init_model(args):
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
data_loader = get_loader("icboard")
loader = data_loader(root=None,
is_transform=True,
img_size=eval(args.size),
test_mode=True)
n_classes = loader.n_classes
# Setup Model
model = get_model({"arch": "hardnet"}, n_classes)
state = convert_state_dict(
torch.load(args.model_path, map_location=device)["model_state"])
model.load_state_dict(state)
model.eval()
model.to(device)
return device, model, loader
def validate(args):
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpus
# Setup Dataloader
data_loader = get_loader(args.dataset)
data_path = get_data_path(args.dataset)
loader = data_loader(data_path,
split=args.split,
is_transform=True,
img_size=(args.img_rows, args.img_cols))
n_classes = loader.n_classes
valloader = data.DataLoader(loader,
batch_size=args.batch_size,
num_workers=4)
running_metrics = runningScore(n_classes)
# Setup Model
model = get_model(args.arch, n_classes)
checkpoint = torch.load(args.model_path)
state = convert_state_dict(checkpoint['model_state'])
model.load_state_dict(state)
print("Loaded checkpoint '{}' (epoch {})".format(args.model_path,
checkpoint['epoch']))
model.eval()
for i, (images, labels) in tqdm(enumerate(valloader)):
model.cuda()
images = Variable(images.cuda(), volatile=True)
labels = Variable(labels.cuda(), volatile=True)
outputs = model(images)
pred = outputs.data.max(1)[1].cpu().numpy()
gt = labels.data.cpu().numpy()
running_metrics.update(gt, pred)
score, class_iou = running_metrics.get_scores()
for k, v in score.items():
print(k, v)
for i in range(n_classes):
print(i, classes[i], class_iou[i])
print('\t'.join([str(class_iou[i]) for i in range(n_classes)]))
def test(cfg):
device = torch.device(cfg['device'])
data_loader = get_loader('vistas')
loader = data_loader(root=cfg['testing']['config_path'],
is_transform=True,
test_mode=True)
n_classes = loader.n_classes
# Setup Model
model_dict = {"arch": 'icnetBN'}
model = get_model(model_dict, n_classes)
state = convert_state_dict(
torch.load(cfg['testing']['model_path'])["model_state"])
model.load_state_dict(state)
model.eval()
model.to(device)
for img_name in os.listdir(cfg['testing']['img_fold']):
img_path = os.path.join(cfg['testing']['img_fold'], img_name)
img = misc.imread(img_path)
orig_size = img.shape[:-1]
# uint8 with RGB mode, resize width and height which are odd numbers
# img = misc.imresize(img, (orig_size[0] // 2 * 2 + 1, orig_size[1] // 2 * 2 + 1))
img = misc.imresize(
img, (cfg['testing']['img_rows'], cfg['testing']['img_cols']))
img = img.astype(np.float64)
img = img.astype(float) / 255.0
# NHWC -> NCHW
img = img.transpose(2, 0, 1)
img = np.expand_dims(img, 0)
img = torch.from_numpy(img).float()
img = img.to(device)
outputs = model(img)
outputs = np.squeeze(outputs.data.max(1)[1].cpu().numpy(), axis=0)
outputs = outputs.astype(np.float32)
# float32 with F mode, resize back to orig_size
outputs = misc.imresize(outputs, orig_size, "nearest", mode="F")
decoded = loader.decode_segmap(outputs)
output_path = os.path.join(cfg['testing']['output_fold'],
'mask_%s.png' % img_name.split('.')[0])
misc.imsave(output_path, decoded)
def test(args, cfg):
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
data_loader = get_loader(cfg['data']['dataset'])
data_path = get_data_path(cfg['data']['dataset'], config_file=cfg)
loader = data_loader(data_path, is_transform=True, img_norm=args.img_norm)
n_classes = loader.n_classes
t_loader = data_loader(
data_path,
is_transform=True,
split='test',
img_size=(cfg['data']['img_rows'], cfg['data']['img_cols']),
)
testloader = data.DataLoader(t_loader,
batch_size=1,
num_workers=cfg['training']['n_workers'])
# Setup Model
model = get_model(cfg['model'], n_classes)
state = convert_state_dict(torch.load(args.model_path)["model_state"])
# state=torch.load(args.model_path)["model_state"]
model.load_state_dict(state)
model.eval()
model.to(device)
with torch.no_grad():
for i_val, (img_path, image_src,
image_dst) in tqdm(enumerate(testloader)):
img_name = img_path[0]
image_src = image_src.to(device)
image_dst = image_dst.to(device)
outputs = model(image_src, image_dst)
pred = np.squeeze(outputs.data.max(1)[1].cpu().numpy(), axis=0)
decoded = loader.decode_segmap(pred)
out_path = "test_out/changenet_change_det/" + Path(
img_name).stem + ".png"
decoded_bgr = cv.cvtColor(decoded, cv.COLOR_RGB2BGR)
# misc.imsave(out_path, decoded)
cv.imwrite(out_path, decoded_bgr)
def test(args):
args.img_path = '/home/shehabk/dataSets/CKPLUS/unet_256/A/test/S077_007_00000029.png'
args.dataset = 'ckplus'
args.out_path = '/home/shehabk/Desktop/' + os.path.basename(args.img_path)
# args.arch = 'segnet'
args.model_path = 'unet2_ckplus_1_99.pkl'
# Setup image
print("Read Input Image from : {}".format(args.img_path))
img = misc.imread(args.img_path,mode = 'RGB')
data_loader = get_loader(args.dataset)
data_path = get_data_path(args.dataset)
loader = data_loader(data_path, is_transform=True)
n_classes = loader.n_classes
img = img[:, :, ::-1]
img = img.astype(np.float64)
img -= loader.mean
img = misc.imresize(img, (loader.img_size[0], loader.img_size[1]))
img = img.astype(float) / 255.0
# NHWC -> NCWH
img = img.transpose(2, 0, 1)
img = np.expand_dims(img, 0)
img = torch.from_numpy(img).float()
# Setup Model
model = torch.load(args.model_path)
model.eval()
if torch.cuda.is_available():
model.cuda(0)
images = Variable(img.cuda(0))
else:
images = Variable(img)
outputs = model(images)
pred = np.squeeze(outputs.data.max(1 , keepdim=True )[1].cpu().numpy(), axis=1)
decoded = loader.decode_segmap(pred[0])
print(np.unique(pred))
misc.imsave(args.out_path, decoded)
print("Segmentation Mask Saved at: {}".format(args.out_path))
def test(args):
# Setup image
print("Read Input Image from : {}".format(args.img_path))
img = misc.imread(args.img_path)
data_loader = get_loader(args.dataset)
data_path = get_data_path(args.dataset, config_file=args.config_file)
loader = data_loader(data_path, is_transform=True)
n_classes = loader.n_classes
img = img[:, :, ::-1]
img = img.astype(np.float64)
img -= loader.mean
img = misc.imresize(img, (loader.img_size[0], loader.img_size[1]))
img = img.astype(float) / 255.0
# NHWC -> NCWH
img = img.transpose(2, 0, 1)
img = np.expand_dims(img, 0)
img = torch.from_numpy(img).float()
# Setup Model
model = torch.load(args.model_path)
model.eval()
#if torch.cuda.is_available():
# model.cuda(0)
# images = Variable(img.cuda(0))
#else:
images = Variable(img)
import time
start_time = time.clock()
outputs = model(images)
print('Time: {time}'.format(time=(time.clock() - start_time)))
pred = outputs[0].cpu().data.numpy()
if args.label:
pred = pred[args.label]
else:
pred = pred.argmax(0)
misc.imsave(args.out_path, pred)
print("Segmentation Mask Saved at: {}".format(args.out_path))
def test():
# Setup Dataloader
data_loader = get_loader(args.dataset)
data_path = get_data_path(args.dataset)
loader = data_loader(data_path, img_size=args.img_size)
n_classes = loader.n_classes
n_channels = loader.n_channels
valloader = data.DataLoader(loader,
batch_size=args.batch_size,
num_workers=4,
shuffle=True)
# Setup Model
model = torch.load(args.model_path)
model.eval()
if torch.cuda.is_available():
model.cuda(0)
for i, (images, labels) in enumerate(tqdm(valloader)):
if torch.cuda.is_available():
images = Variable(images.cuda(0))
labels = Variable(labels.cuda(0))
else:
images = Variable(images)
labels = Variable(labels)
outputs = model(images)
pred = np.squeeze(outputs.data.max(1)[1].cpu().numpy(), axis=1)
gt = labels.data.cpu().numpy()
for gt_, pred_ in zip(gt, pred):
gt_path = args.out_dir + "gt{}.png".format(i)
pred_path = args.out_dir + "pred{}.png".format(i)
decoded_gt = loader.decode_segmap(gt_)
decoded_pred = loader.decode_segmap(pred_)
misc.imsave(gt_path, decoded_gt)
misc.imsave(pred_path, decoded_pred)
def test(args):
# Setup image
print("Read Input Image from : {}".format(args.img_path))
img = misc.imread(args.img_path)
data_loader = get_loader(args.dataset)
data_path = get_data_path(args.dataset)
loader = data_loader(data_path, is_transform=True)
n_classes = loader.n_classes
img = img[:, :, ::-1]
img = img.astype(np.float64)
img -= loader.mean
img = misc.imresize(img, (loader.img_size[0], loader.img_size[1]))
img = img.astype(float) / 255.0
# NHWC -> NCWH
img = img.transpose(2, 0, 1)
img = np.expand_dims(img, 0)
img = torch.from_numpy(img).float()
# Setup Model
model = torch.load(args.model_path)
model.eval()
if torch.cuda.is_available():
model.cuda(0)
images = Variable(img.cuda(0))
else:
images = Variable(img)
outputs = model(images)
pred = np.squeeze(outputs.data.max(1)[1].cpu().numpy(), axis=1)
decoded = loader.decode_segmap(pred[0])
print(np.unique(pred))
misc.imsave(args.out_path, decoded)
print("Segmentation Mask Saved at: {}".format(args.out_path))
def test(args):
# Setup image
print("Read Input Image from : {}".format(args.img_path))
img = misc.imread(args.img_path)
data_loader = get_loader(args.dataset)
data_path = get_data_path(args.dataset)
loader = data_loader(data_path, is_transform=True)
n_classes = loader.n_classes
resized_img = misc.imresize(img, (loader.img_size[0], loader.img_size[1]), interp='bicubic')
img = img[:, :, ::-1]
img = img.astype(np.float64)
img -= loader.mean
img = misc.imresize(img, (loader.img_size[0], loader.img_size[1]))
img = img.astype(float) / 255.0
# NHWC -> NCWH
img = img.transpose(2, 0, 1)
img = np.expand_dims(img, 0)
img = torch.from_numpy(img).float()
# Setup Model
model = get_model(args.model_path[:args.model_path.find('_')], n_classes)
state = convert_state_dict(torch.load(args.model_path)['model_state'])
model.load_state_dict(state)
model.eval()
model.cuda(0)
images = Variable(img.cuda(0), volatile=True)
outputs = F.softmax(model(images), dim=1)
if args.dcrf == "True":
unary = outputs.data.cpu().numpy()
unary = np.squeeze(unary, 0)
unary = -np.log(unary)
unary = unary.transpose(2, 1, 0)
w, h, c = unary.shape
unary = unary.transpose(2, 0, 1).reshape(loader.n_classes, -1)
unary = np.ascontiguousarray(unary)
resized_img = np.ascontiguousarray(resized_img)
d = dcrf.DenseCRF2D(w, h, loader.n_classes)
d.setUnaryEnergy(unary)
d.addPairwiseBilateral(sxy=5, srgb=3, rgbim=resized_img, compat=1)
q = d.inference(50)
mask = np.argmax(q, axis=0).reshape(w, h).transpose(1, 0)
decoded_crf = loader.decode_segmap(np.array(mask, dtype=np.uint8))
dcrf_path = args.out_path[:-4] + '_drf.png'
misc.imsave(dcrf_path, decoded_crf)
print("Dense CRF Processed Mask Saved at: {}".format(dcrf_path))
if torch.cuda.is_available():
model.cuda(0)
images = Variable(img.cuda(0), volatile=True)
else:
images = Variable(img, volatile=True)
pred = np.squeeze(outputs.data.max(1)[1].cpu().numpy(), axis=0)
decoded = loader.decode_segmap(pred)
print('Classes found: ', np.unique(pred))
misc.imsave(args.out_path, decoded)
print("Segmentation Mask Saved at: {}".format(args.out_path))
def train(args):
# Setup Augmentations
data_aug= Compose([RandomRotate(10),
RandomHorizontallyFlip()])
# Setup Dataloader
data_loader = get_loader(args.dataset)
data_path = get_data_path(args.dataset)
t_loader = data_loader(data_path, is_transform=True, img_size=(args.img_rows, args.img_cols), augmentations=data_aug)
v_loader = data_loader(data_path, is_transform=True, split='val', img_size=(args.img_rows, args.img_cols))
n_classes = t_loader.n_classes
trainloader = data.DataLoader(t_loader, batch_size=args.batch_size, num_workers=8, shuffle=True)
valloader = data.DataLoader(v_loader, batch_size=args.batch_size, num_workers=8)
# Setup Metrics
running_metrics = runningScore(n_classes)
# Setup visdom for visualization
if args.visdom:
vis = visdom.Visdom()
loss_window = vis.line(X=torch.zeros((1,)).cpu(),
Y=torch.zeros((1)).cpu(),
opts=dict(xlabel='minibatches',
ylabel='Loss',
title='Training Loss',
legend=['Loss']))
# Setup Model
model = get_model(args.arch, n_classes)
model = torch.nn.DataParallel(model, device_ids=range(torch.cuda.device_count()))
model.cuda()
# Check if model has custom optimizer / loss
if hasattr(model.module, 'optimizer'):
optimizer = model.module.optimizer
else:
optimizer = torch.optim.SGD(model.parameters(), lr=args.l_rate, momentum=0.99, weight_decay=5e-4)
if hasattr(model.module, 'loss'):
print('Using custom loss')
loss_fn = model.module.loss
else:
loss_fn = cross_entropy2d
if args.resume is not None:
if os.path.isfile(args.resume):
print("Loading model and optimizer from checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
model.load_state_dict(checkpoint['model_state'])
optimizer.load_state_dict(checkpoint['optimizer_state'])
print("Loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
else:
print("No checkpoint found at '{}'".format(args.resume))
best_iou = -100.0
for epoch in range(args.n_epoch):
model.train()
for i, (images, labels) in enumerate(trainloader):
images = Variable(images.cuda())
labels = Variable(labels.cuda())
optimizer.zero_grad()
outputs = model(images)
loss = loss_fn(input=outputs, target=labels)
loss.backward()
optimizer.step()
if args.visdom:
vis.line(
X=torch.ones((1, 1)).cpu() * i,
Y=torch.Tensor([loss.data[0]]).unsqueeze(0).cpu(),
win=loss_window,
update='append')
if (i+1) % 20 == 0:
print("Epoch [%d/%d] Loss: %.4f" % (epoch+1, args.n_epoch, loss.data[0]))
model.eval()
for i_val, (images_val, labels_val) in tqdm(enumerate(valloader)):
images_val = Variable(images_val.cuda(), volatile=True)
labels_val = Variable(labels_val.cuda(), volatile=True)
outputs = model(images_val)
pred = outputs.data.max(1)[1].cpu().numpy()
gt = labels_val.data.cpu().numpy()
running_metrics.update(gt, pred)
score, class_iou = running_metrics.get_scores()
for k, v in score.items():
print(k, v)
running_metrics.reset()
if score['Mean IoU : \t'] >= best_iou:
best_iou = score['Mean IoU : \t']
state = {'epoch': epoch+1,
'model_state': model.state_dict(),
'optimizer_state' : optimizer.state_dict(),}
torch.save(state, "{}_{}_best_model.pkl".format(args.arch, args.dataset))
