def main():
"""Create the model and start the evaluation process."""
args = get_arguments()
update_config(config, args)
print (args)
if not os.path.exists(args.save_dir):
os.makedirs(args.save_dir)
os.environ["CUDA_VISIBLE_DEVICES"]=args.gpu
gpus = [int(i) for i in args.gpu.split(',')]
h, w = map(int, args.input_size.split(','))
input_size = (h, w)
model = get_cls_net(config=config, num_classes=20, is_train=False)
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform = transforms.Compose([
transforms.ToTensor(),
normalize,
])
lip_dataset = LIPDataSet(args.data_dir, 'val', crop_size=input_size, transform=transform)
num_samples = len(lip_dataset)
valloader = data.DataLoader(lip_dataset, batch_size=args.batch_size * len(gpus),
shuffle=False, pin_memory=True)
restore_from = args.restore_from
state_dict = model.state_dict().copy()
state_dict_old = torch.load(restore_from)
state_dict_old = state_dict_old['state_dict']
for key, nkey in zip(state_dict_old.keys(), state_dict.keys()):
if key != nkey:
# remove the 'module.' in the 'key'
state_dict[key[7:]] = deepcopy(state_dict_old[key])
else:
state_dict[key] = deepcopy(state_dict_old[key])
model.load_state_dict(state_dict)
model.eval()
model.cuda()
parsing_preds, scales, centers,time_list= valid(model, valloader, input_size, num_samples, len(gpus))
mIoU = compute_mean_ioU(parsing_preds, scales, centers, args.num_classes, args.data_dir, input_size)
# write_results(parsing_preds, scales, centers, args.data_dir, 'val', args.save_dir, input_size=input_size)
# write_logits(parsing_logits, scales, centers, args.data_dir, 'val', args.save_dir, input_size=input_size)
print(mIoU)
print('total time is ',sum(time_list))
print('avg time is ',sum(time_list)/len(time_list))
def main():
torch.multiprocessing.set_start_method("spawn", force=True)
"""Create the model and start the evaluation process."""
args = get_arguments()
os.environ["CUDA_VISIBLE_DEVICES"]=args.gpu
gpus = [int(i) for i in args.gpu.split(',')]
h, w = map(int, args.input_size.split(','))
input_size = (h, w)
deeplab = CorrPM_Model(args.num_classes, args.num_points)
if len(gpus) > 1:
model = DataParallelModel(deeplab)
else:
model = deeplab
if not os.path.exists(args.save_dir):
os.makedirs(args.save_dir)
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform = transforms.Compose([
transforms.ToTensor(),
normalize,
])
if args.data_name == 'lip':
lip_dataset = LIPDataSet(args.data_dir, VAL_POSE_ANNO_FILE, args.dataset, crop_size=input_size, transform=transform)
num_samples = len(lip_dataset)
valloader = data.DataLoader(lip_dataset, batch_size=args.batch_size * len(gpus),
shuffle=False, num_workers=4, pin_memory=True)
restore_from = args.restore_from
state_dict = model.state_dict().copy()
state_dict_old = torch.load(restore_from)
for key in state_dict.keys():
if key not in state_dict_old.keys():
print(key)
for key, nkey in zip(state_dict_old.keys(), state_dict.keys()):
if key != nkey:
state_dict[key[7:]] = deepcopy(state_dict_old[key])
else:
state_dict[key] = deepcopy(state_dict_old[key])
model.load_state_dict(state_dict)
model.eval()
model.cuda()
parsing_preds, scales, centers = valid(model, valloader, input_size, num_samples, len(gpus))
mIoU = compute_mean_ioU(parsing_preds, scales, centers, args.num_classes, args.data_dir, input_size, args.dataset)
print(mIoU)
end = datetime.datetime.now()
print(end - start, 'seconds')
print(end)
def main():
"""Create the model and start the evaluation process."""
args = get_arguments()
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
gpus = [int(i) for i in args.gpu.split(',')]
h, w = map(int, args.input_size.split(','))
input_size = (h, w)
model = Res_Deeplab(num_classes=args.num_classes)
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform = transforms.Compose([
transforms.ToTensor(),
normalize,
])
lip_dataset = LIPDataSet(args.data_dir,
'val',
crop_size=input_size,
transform=transform)
num_samples = len(lip_dataset)
valloader = data.DataLoader(lip_dataset,
batch_size=args.batch_size * len(gpus),
shuffle=False,
pin_memory=True)
restore_from = args.restore_from
state_dict = model.state_dict().copy()
state_dict_old = torch.load(restore_from)
for key, nkey in zip(state_dict_old.keys(), state_dict.keys()):
if key != nkey:
# remove the 'module.' in the 'key'
state_dict[key[7:]] = deepcopy(state_dict_old[key])
else:
state_dict[key] = deepcopy(state_dict_old[key])
model.load_state_dict(state_dict)
model.eval()
model.cuda()
parsing_preds, scales, centers = valid(model, valloader, input_size,
num_samples, len(gpus))
mIoU = compute_mean_ioU(parsing_preds, scales, centers, args.num_classes,
args.data_dir, input_size)
print(mIoU)
def main():
"""Create the model and start the evaluation process."""
args = get_arguments()
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
gpus = [int(i) for i in args.gpu.split(',')]
h, w = map(int, args.input_size.split(','))
input_size = (h, w)
model = EAGRNet(args.num_classes, InPlaceABN)
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform = transforms.Compose([
transforms.ToTensor(),
normalize,
])
dataset = HelenDataSet(args.data_dir,
args.dataset,
crop_size=input_size,
transform=transform)
num_samples = len(dataset)
valloader = data.DataLoader(dataset,
batch_size=args.batch_size,
shuffle=False,
pin_memory=True)
restore_from = args.restore_from
state_dict_old = torch.load(restore_from, map_location='cuda:0')
model.load_state_dict(state_dict_old)
model.cuda()
model.eval()
save_path = os.path.join(args.data_dir, 'full')
if not os.path.exists(save_path):
os.makedirs(save_path)
parsing_preds, scales, centers = valid(model, valloader, input_size,
num_samples, save_path)
mIoU, f1 = compute_mean_ioU(parsing_preds,
scales,
centers,
args.num_classes,
args.data_dir,
input_size,
'test',
reverse=True)
print(mIoU)
print(f1)
def main():
"""Create the model and start the evaluation process."""
args = get_arguments()
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
gpus = [int(i) for i in args.gpu.split(',')]
if not args.gpu == 'None':
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
h, w = map(int, args.input_size.split(','))
input_size = [h, w]
NUM_CLASSES = 7 # parsing
NUM_HEATMAP = 15 # pose
NUM_PAFS = 28 # pafs
model = ParsingNet(num_classes=NUM_CLASSES,
num_heatmaps=NUM_HEATMAP,
num_pafs=NUM_PAFS)
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform = transforms.Compose([
transforms.ToTensor(),
normalize,
])
valdataset = VOCSegmentation(DATA_DIRECTORY,
args.dataset,
crop_size=input_size,
transform=transform)
num_samples = len(valdataset)
num_classes = NUM_CLASSES
valloader = data.DataLoader(
valdataset,
batch_size=args.batch_size * len(gpus), #batchsize
shuffle=False,
pin_memory=True)
restore_from = args.restore_from
try:
state_dict = torch.load(restore_from)['state_dict']
load_state(model, state_dict)
model.eval()
model.cuda()
parsing_preds, scales, centers = valid(model, valloader, input_size,
num_samples, gpus)
mIoU = compute_mean_ioU(parsing_preds, scales, centers, num_classes,
args.data_dir, input_size)
print(str(mIoU))
except:
print("load model error")
def main():
"""Create the model and start the evaluation process."""
args = get_arguments()
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
gpus = [int(i) for i in args.gpu.split(',')]
print(args.gpu)
h, w = map(int, args.input_size.split(','))
input_size = (h, w)
cudnn.benchmark = True
cudnn.enabled = True
model = dml_csr.DML_CSR(args.num_classes, InPlaceABN, False)
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform = transforms.Compose([
transforms.ToTensor(),
normalize,
])
dataset = datasets.FaceDataSet(args.data_dir, args.dataset, \
crop_size=input_size, transform=transform)
num_samples = len(dataset)
valloader = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size, \
shuffle=False, pin_memory=True)
restore_from = args.restore_from
print(restore_from)
state_dict = torch.load(restore_from, map_location='cuda:0')
model.load_state_dict(state_dict)
model.cuda()
model.eval()
save_path = os.path.join(args.out_dir, args.dataset, 'parsing')
if not os.path.exists(save_path):
os.makedirs(save_path)
parsing_preds, scales, centers = valid(model, valloader, input_size,
num_samples, save_path)
mIoU, f1 = miou.compute_mean_ioU(parsing_preds, scales, centers, args.num_classes, args.data_dir, \
input_size, args.dataset, reverse=True)
print(mIoU)
print(f1)
def main():
"""start multiprocessing method"""
try:
mp.set_start_method('spawn')
except RuntimeError:
pass
"""Create the model and start the training."""
if not os.path.exists(args.snapshot_dir):
os.makedirs(args.snapshot_dir)
gpus = [int(i) for i in args.gpu.split(',')]
if not args.gpu == 'None':
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
h, w = map(int, args.input_size.split(','))
input_size = [h, w]
cudnn.enabled = True
# cudnn related setting
cudnn.benchmark = True
torch.backends.cudnn.deterministic = True #False
torch.backends.cudnn.enabled = True
torch.cuda.empty_cache()
deeplab = CorrPM_Model(num_classes=args.num_classes)
saved_state_dict = torch.load(args.restore_from)
new_params = deeplab.state_dict().copy()
i = 0
print("Now is loading pre-trained res101 model!")
for i in saved_state_dict:
i_parts = i.split('.')
if not i_parts[0] == 'fc':
new_params['.'.join(i_parts[0:])] = saved_state_dict[i]
deeplab.load_state_dict(new_params)
criterion = CriterionPoseEdge()
criterion = DataParallelCriterion(criterion)
criterion.cuda()
snapshot_fname = osp.join(args.snapshot_dir, 'LIP_epoch_')
snapshot_best_fname = osp.join(args.snapshot_dir, 'LIP_best.pth')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform = transforms.Compose([
transforms.ToTensor(),
normalize,
])
dataset_lip = LIPDataSet(args.data_dir,
args.pose_anno_file,
args.dataset,
crop_size=input_size,
dataset_list=args.dataset_list,
transform=transform)
trainloader = data.DataLoader(dataset_lip,
batch_size=args.batch_size * len(gpus),
shuffle=True,
num_workers=1,
pin_memory=True)
lip_dataset = LIPDataSet(args.data_dir,
VAL_ANNO_FILE,
'val',
crop_size=input_size,
dataset_list=args.dataset_list,
transform=transform)
num_samples = len(lip_dataset)
valloader = data.DataLoader(lip_dataset,
batch_size=args.batch_size * len(gpus),
shuffle=False,
num_workers=0,
pin_memory=True)
optimizer = optim.SGD(deeplab.parameters(),
lr=args.learning_rate,
momentum=args.momentum,
weight_decay=args.weight_decay)
model = DataParallelModel(deeplab)
model.cuda()
optimizer.zero_grad()
total_iters = args.epochs * len(trainloader)
total_iter_per_batch = len(trainloader)
print("total iters:", total_iters)
best_iou = 0
i_iter = 0
temp = time.time()
for epoch in range(args.start_epoch, args.epochs):
model.train()
for i_iter, batch in enumerate(trainloader):
iter_lr = i_iter + epoch * len(trainloader)
lr = adjust_learning_rate(optimizer, iter_lr, total_iters)
images, labels, pose, edge, _ = batch
labels = labels.long().cuda(non_blocking=True)
edge = edge.long().cuda(non_blocking=True)
pose = pose.float().cuda(non_blocking=True)
preds = model(images)
loss = criterion(preds, [labels, edge, pose])
optimizer.zero_grad()
loss.backward()
optimizer.step()
if i_iter % 500 == 0:
tim = time.time()
print('iter:{}/{},loss:{:.3f},lr:{:.3e},time:{:.1f}'.format(
i_iter, total_iter_per_batch,
loss.data.cpu().numpy(), lr, tim - temp))
temp = tim
h = time.time()
if epoch % 5 == 0:
print("----->Epoch:", epoch)
parsing_preds, scales, centers = valid(model, valloader,
input_size, num_samples,
len(gpus), criterion, args)
if args.dataset_list == '_id.txt':
mIoU = compute_mean_ioU(parsing_preds, scales, centers,
args.num_classes, args.data_dir,
input_size)
miou = mIoU['Mean IU']
is_best_iou = miou > best_iou
best_iou = max(miou, best_iou)
torch.save(model.state_dict(), snapshot_fname + '.pth')
if is_best_iou:
print("Best iou epoch: ", epoch)
shutil.copyfile(snapshot_fname + '.pth', snapshot_best_fname)
end = datetime.datetime.now()
print(end - start, 'seconds')
print(end)
def main():
"""Create the model and start the evaluation process."""
args = get_arguments()
multi_scales = [float(i) for i in args.multi_scales.split(',')]
gpus = [int(i) for i in args.gpu.split(',')]
assert len(gpus) == 1
if not args.gpu == 'None':
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
cudnn.benchmark = True
cudnn.enabled = True
h, w = map(int, args.input_size.split(','))
input_size = [h, w]
model = networks.init_model(args.arch,
num_classes=args.num_classes,
pretrained=None)
IMAGE_MEAN = model.mean
IMAGE_STD = model.std
INPUT_SPACE = model.input_space
print('image mean: {}'.format(IMAGE_MEAN))
print('image std: {}'.format(IMAGE_STD))
print('input space:{}'.format(INPUT_SPACE))
if INPUT_SPACE == 'BGR':
print('BGR Transformation')
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=IMAGE_MEAN, std=IMAGE_STD),
])
if INPUT_SPACE == 'RGB':
print('RGB Transformation')
transform = transforms.Compose([
transforms.ToTensor(),
BGR2RGB_transform(),
transforms.Normalize(mean=IMAGE_MEAN, std=IMAGE_STD),
])
# Data loader
lip_test_dataset = LIPDataValSet(args.data_dir,
'val',
crop_size=input_size,
transform=transform,
flip=args.flip)
num_samples = len(lip_test_dataset)
print('Totoal testing sample numbers: {}'.format(num_samples))
testloader = data.DataLoader(lip_test_dataset,
batch_size=args.batch_size,
shuffle=False,
pin_memory=True)
# Load model weight
state_dict = torch.load(args.model_restore)['state_dict']
from collections import OrderedDict
new_state_dict = OrderedDict()
for k, v in state_dict.items():
name = k[7:] # remove `module.`
new_state_dict[name] = v
model.load_state_dict(new_state_dict)
model.cuda()
model.eval()
sp_results_dir = os.path.join(args.log_dir, 'sp_results')
if not os.path.exists(sp_results_dir):
os.makedirs(sp_results_dir)
palette = get_palette(20)
parsing_preds = []
scales = np.zeros((num_samples, 2), dtype=np.float32)
centers = np.zeros((num_samples, 2), dtype=np.int32)
with torch.no_grad():
for idx, batch in enumerate(tqdm(testloader)):
image, meta = batch
if (len(image.shape) > 4):
image = image.squeeze()
im_name = meta['name'][0]
c = meta['center'].numpy()[0]
s = meta['scale'].numpy()[0]
w = meta['width'].numpy()[0]
h = meta['height'].numpy()[0]
scales[idx, :] = s
centers[idx, :] = c
parsing, logits = multi_scale_testing(model,
image.cuda(),
crop_size=input_size,
flip=args.flip,
multi_scales=multi_scales)
if args.save_results:
parsing_result = transform_parsing(parsing, c, s, w, h,
input_size)
parsing_result_path = os.path.join(sp_results_dir,
im_name + '.png')
output_im = PILImage.fromarray(
np.asarray(parsing_result, dtype=np.uint8))
output_im.putpalette(palette)
output_im.save(parsing_result_path)
parsing_preds.append(parsing)
assert len(parsing_preds) == num_samples
mIoU = compute_mean_ioU(parsing_preds, scales, centers, args.num_classes,
args.data_dir, input_size)
print(mIoU)
return
def main():
"""Create the model and start the training."""
if not os.path.exists(args.snapshot_dir):
os.makedirs(args.snapshot_dir)
h, w = map(int, args.input_size.split(','))
input_size = [h, w]
best_f1 = 0
torch.cuda.set_device(args.local_rank)
try:
world_size = int(os.environ['WORLD_SIZE'])
distributed = world_size > 1
except:
distributed = False
world_size = 1
if distributed:
dist.init_process_group(backend=args.dist_backend,
init_method='env://')
rank = 0 if not distributed else dist.get_rank()
writer = SummaryWriter(osp.join(args.snapshot_dir,
TIMESTAMP)) if rank == 0 else None
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform = transforms.Compose([
transforms.ToTensor(),
normalize,
])
if args.type == 'Helen':
train_dataset = HelenDataSet('dataset/Helen_align_with_hair',
args.dataset,
crop_size=input_size,
transform=transform)
val_dataset = HelenDataSet('dataset/Helen_align_with_hair',
'test',
crop_size=input_size,
transform=transform)
args.num_classes = 11
elif args.type == 'LaPa':
train_dataset = LapaDataset('dataset/LaPa/origin',
args.dataset,
crop_size=input_size,
transform=transform)
val_dataset = LapaDataset('dataset/LaPa/origin',
'test',
crop_size=input_size,
transform=transform)
args.num_classes = 11
elif args.type == 'Celeb':
train_dataset = CelebAMaskHQDataSet('dataset/CelebAMask-HQ',
args.dataset,
crop_size=input_size,
transform=transform)
val_dataset = CelebAMaskHQDataSet('dataset/CelebAMask-HQ',
'test',
crop_size=input_size,
transform=transform)
args.num_classes = 19
elif args.type == 'LIP':
train_dataset = LIPDataSet('dataset/LIP',
args.dataset,
crop_size=input_size,
transform=transform)
val_dataset = LIPDataSet('dataset/LIP',
'val',
crop_size=input_size,
transform=transform)
args.num_classes = 20
if distributed:
train_sampler = torch.utils.data.distributed.DistributedSampler(
train_dataset)
else:
train_sampler = None
trainloader = data.DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=False,
num_workers=2,
pin_memory=True,
drop_last=True,
sampler=train_sampler)
num_samples = len(val_dataset)
valloader = data.DataLoader(val_dataset,
batch_size=args.batch_size,
shuffle=False,
pin_memory=True,
drop_last=False)
cudnn.enabled = True
# cudnn related setting
cudnn.benchmark = True
torch.backends.cudnn.deterministic = False
torch.backends.cudnn.enabled = True
if distributed:
model = AGRNet(args.num_classes)
else:
model = AGRNet(args.num_classes, InPlaceABN)
if args.restore_from is not None:
model.load_state_dict(
torch.load(args.restore_from,
map_location='cuda:{}'.format(args.local_rank)), True)
else:
resnet_params = torch.load(
os.path.join(args.snapshot_dir, 'resnet101-imagenet.pth'))
new_params = model.state_dict().copy()
for i in resnet_params:
i_parts = i.split('.')
# print(i_parts)
if not i_parts[0] == 'fc':
new_params['.'.join(i_parts[0:])] = resnet_params[i]
model.load_state_dict(new_params)
model.cuda()
if distributed:
model = torch.nn.parallel.DistributedDataParallel(
model,
device_ids=[args.local_rank],
output_device=args.local_rank,
find_unused_parameters=True)
else:
model = SingleGPU(model)
# CriterionCrossEntropyEdgeParsing_boundary_agrnet_loss for AGRNet, CriterionCrossEntropyEdgeParsing_boundary_eagrnet_loss for EAGRNet
criterion = CriterionCrossEntropyEdgeParsing_boundary_agrnet_loss(
loss_weight=[args.l1, args.l2, args.l3, args.l4],
num_classes=args.num_classes)
criterion.cuda()
optimizer = optim.SGD(model.parameters(),
lr=args.learning_rate,
momentum=args.momentum,
weight_decay=args.weight_decay)
optimizer.zero_grad()
total_iters = args.epochs * len(trainloader)
for epoch in range(args.start_epoch, args.epochs):
model.train()
if distributed:
train_sampler.set_epoch(epoch)
for i_iter, batch in enumerate(trainloader):
i_iter += len(trainloader) * epoch
lr = adjust_learning_rate(optimizer, i_iter, total_iters)
images, labels, edges, _ = batch
labels = labels.long().cuda(non_blocking=True)
edges = edges.long().cuda(non_blocking=True)
preds = model(images)
loss = criterion(preds, [labels, edges])
optimizer.zero_grad()
loss.backward()
optimizer.step()
with torch.no_grad():
loss = loss.detach() * labels.shape[0]
count = labels.new_tensor([labels.shape[0]], dtype=torch.long)
if dist.is_initialized():
dist.all_reduce(count, dist.ReduceOp.SUM)
dist.all_reduce(loss, dist.ReduceOp.SUM)
loss /= count.item()
if not dist.is_initialized() or dist.get_rank() == 0:
if i_iter % 50 == 0:
writer.add_scalar('learning_rate', lr, i_iter)
writer.add_scalar('loss', loss.data.cpu().numpy(), i_iter)
if i_iter % 500 == 0:
images_inv = inv_preprocess(images, args.save_num_images)
labels_colors = decode_parsing(labels,
args.save_num_images,
args.num_classes,
is_pred=False)
edges_colors = decode_parsing(edges,
args.save_num_images,
2,
is_pred=False)
if isinstance(preds, list):
preds = preds[0]
preds_colors = decode_parsing(preds[0],
args.save_num_images,
args.num_classes,
is_pred=True)
pred_edges = decode_parsing(preds[1],
args.save_num_images,
2,
is_pred=True)
img = vutils.make_grid(images_inv,
normalize=False,
scale_each=True)
lab = vutils.make_grid(labels_colors,
normalize=False,
scale_each=True)
pred = vutils.make_grid(preds_colors,
normalize=False,
scale_each=True)
edge = vutils.make_grid(edges_colors,
normalize=False,
scale_each=True)
pred_edge = vutils.make_grid(pred_edges,
normalize=False,
scale_each=True)
writer.add_image('Images/', img, i_iter)
writer.add_image('Labels/', lab, i_iter)
writer.add_image('Preds/', pred, i_iter)
writer.add_image('Edge/', edge, i_iter)
writer.add_image('Pred_edge/', pred_edge, i_iter)
print('iter = {} of {} completed, loss = {}'.format(
i_iter, total_iters,
loss.data.cpu().numpy()))
if not dist.is_initialized() or dist.get_rank() == 0:
save_path = os.path.join(args.data_dir, TIMESTAMP)
if not os.path.exists(save_path):
os.makedirs(save_path)
parsing_preds, scales, centers = valid(
model, valloader, input_size, num_samples,
osp.join(args.snapshot_dir, save_path))
mIoU, f1 = compute_mean_ioU(parsing_preds,
scales,
centers,
args.num_classes,
val_dataset,
input_size,
'test',
True,
type=args.type)
if f1['mean'] > best_f1:
torch.save(model.module.state_dict(),
osp.join(args.snapshot_dir, TIMESTAMP, 'best.pth'))
best_f1 = f1['mean']
print(mIoU)
print(f1)
writer.add_scalars('mIoU', mIoU, epoch)
writer.add_scalars('f1', f1, epoch)
if epoch % args.test_fre == 0:
torch.save(
model.module.state_dict(),
osp.join(args.snapshot_dir, TIMESTAMP,
'epoch_' + str(epoch) + '.pth'))
end = timeit.default_timer()
print(end - start, 'seconds')
def main():
"""Create the model and start the training."""
if not os.path.exists(args.snapshot_dir):
os.makedirs(args.snapshot_dir)
writer = SummaryWriter(args.snapshot_dir)
gpus = [int(i) for i in args.gpu.split(',')]
if not args.gpu == 'None':
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
h, w = [int(i) for i in args.input_size.split(',')]
input_size = [h, w]
cudnn.enabled = True
# cudnn related setting
cudnn.benchmark = False
torch.backends.cudnn.deterministic = False ##为何使用了非确定性的卷积
torch.backends.cudnn.enabled = True
NUM_CLASSES = 7 # parsing
NUM_HEATMAP = 15 # pose
NUM_PAFS = 28 # pafs
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform = transforms.Compose([
transforms.ToTensor(),
normalize,
])
# load dataset
num_samples = 0
trainloader = data.DataLoader(VOCSegmentation(args.data_dir,
args.dataset,
crop_size=input_size,
stride=args.stride,
transform=transform),
batch_size=args.batch_size * len(gpus),
shuffle=True,
num_workers=2,
pin_memory=True)
valloader = None
if args.print_val != 0:
valdataset = VOCSegmentation(args.data_dir,
'val',
crop_size=input_size,
transform=transform)
num_samples = len(valdataset)
valloader = data.DataLoader(
valdataset,
batch_size=8 * len(gpus), # batchsize
shuffle=False,
pin_memory=True)
parsingnet = ParsingNet(num_classes=NUM_CLASSES,
num_heatmaps=NUM_HEATMAP,
num_pafs=NUM_PAFS)
criterion_parsing = Criterion()
criterion_parsing = DataParallelCriterion(criterion_parsing)
criterion_parsing.cuda()
optimizer_parsing = optim.SGD(parsingnet.parameters(),
lr=args.learning_rate,
momentum=args.momentum,
weight_decay=args.weight_decay)
optimizer_parsing.zero_grad()
# 加载预训练参数
print(args.train_continue)
if not args.train_continue:
checkpoint = torch.load(RESNET_IMAGENET)
load_state(parsingnet, checkpoint)
else:
checkpoint = torch.load(args.restore_from_parsing)
if 'current_epoch' in checkpoint:
current_epoch = checkpoint['current_epoch']
args.start_epoch = current_epoch
if 'state_dict' in checkpoint:
checkpoint = checkpoint['state_dict']
load_state(parsingnet, checkpoint)
parsingnet = DataParallelModel(parsingnet).cuda()
total_iters = args.epochs * len(trainloader)
for epoch in range(args.start_epoch, args.epochs):
parsingnet.train()
for i_iter, batch in enumerate(trainloader):
i_iter += len(trainloader) * epoch
lr = adjust_parsing_lr(optimizer_parsing, i_iter, total_iters)
images, labels, edges, heatmap, pafs, heatmap_mask, pafs_mask, _ = batch
images = images.cuda()
labels = labels.long().cuda(non_blocking=True)
edges = edges.long().cuda(non_blocking=True)
heatmap = heatmap.cuda()
pafs = pafs.cuda()
heatmap_mask = heatmap_mask.cuda()
pafs_mask = pafs_mask.cuda()
preds = parsingnet(images)
loss_parsing = criterion_parsing(
preds, [labels, edges, heatmap, pafs, heatmap_mask, pafs_mask],
writer, i_iter, total_iters)
optimizer_parsing.zero_grad()
loss_parsing.backward()
optimizer_parsing.step()
if i_iter % 100 == 0:
writer.add_scalar('parsing_lr', lr, i_iter)
writer.add_scalar('loss_total', loss_parsing.item(), i_iter)
if i_iter % 500 == 0:
if len(gpus) > 1:
preds = preds[0]
images_inv = inv_preprocess(images, args.save_num_images)
parsing_labels_c = decode_parsing(labels,
args.save_num_images,
is_pred=False)
preds_colors = decode_parsing(preds[0][-1],
args.save_num_images,
is_pred=True)
edges_colors = decode_parsing(edges,
args.save_num_images,
is_pred=False)
pred_edges = decode_parsing(preds[1][-1],
args.save_num_images,
is_pred=True)
img = vutils.make_grid(images_inv,
normalize=False,
scale_each=True)
parsing_lab = vutils.make_grid(parsing_labels_c,
normalize=False,
scale_each=True)
pred_v = vutils.make_grid(preds_colors,
normalize=False,
scale_each=True)
edge = vutils.make_grid(edges_colors,
normalize=False,
scale_each=True)
pred_edges = vutils.make_grid(pred_edges,
normalize=False,
scale_each=True)
writer.add_image('Images/', img, i_iter)
writer.add_image('Parsing_labels/', parsing_lab, i_iter)
writer.add_image('Parsing_Preds/', pred_v, i_iter)
writer.add_image('Edges/', edge, i_iter)
writer.add_image('Edges_preds/', pred_edges, i_iter)
if (epoch + 1) % 15 == 0:
if args.print_val != 0:
parsing_preds, scales, centers = valid(parsingnet, valloader,
input_size, num_samples,
gpus)
mIoU = compute_mean_ioU(parsing_preds, scales, centers,
NUM_CLASSES, args.data_dir, input_size)
f = open(os.path.join(args.snapshot_dir, "val_res.txt"), "a+")
f.write(str(epoch) + str(mIoU) + '\n')
f.close()
snapshot_name_parsing = osp.join(
args.snapshot_dir,
'PASCAL_parsing_' + str(epoch) + '' + '.pth')
torch.save(
{
'state_dict': parsingnet.state_dict(),
'optimizer': optimizer_parsing.state_dict(),
'current_epoch': epoch
}, snapshot_name_parsing)
end = timeit.default_timer()
print(end - start, 'seconds')
def main():
"""Create the model and start the training."""
cycle_n = 0
start_epoch = args.start_epoch
writer = SummaryWriter(osp.join(args.snapshot_dir, TIMESTAMP))
if not os.path.exists(args.snapshot_dir):
os.makedirs(args.snapshot_dir)
h, w = map(int, args.input_size.split(','))
input_size = [h, w]
best_f1 = 0
torch.cuda.set_device(args.local_rank)
try:
world_size = int(os.environ['WORLD_SIZE'])
distributed = world_size > 1
except:
distributed = False
world_size = 1
if distributed:
dist.init_process_group(backend=args.dist_backend,
init_method='env://')
rank = 0 if not distributed else dist.get_rank()
log_file = args.snapshot_dir + '/' + TIMESTAMP + 'output.log'
logger = get_root_logger(log_file=log_file, log_level='INFO')
logger.info(f'Distributed training: {distributed}')
cudnn.enabled = True
cudnn.benchmark = True
torch.backends.cudnn.deterministic = False
torch.backends.cudnn.enabled = True
if distributed:
model = dml_csr.DML_CSR(args.num_classes)
schp_model = dml_csr.DML_CSR(args.num_classes)
else:
model = dml_csr.DML_CSR(args.num_classes, InPlaceABN)
schp_model = dml_csr.DML_CSR(args.num_classes, InPlaceABN)
if args.restore_from is not None:
print('Resume training from {}'.format(args.restore_from))
model.load_state_dict(torch.load(args.restore_from), True)
start_epoch = int(float(
args.restore_from.split('.')[0].split('_')[-1])) + 1
else:
resnet_params = torch.load(RESTORE_FROM)
new_params = model.state_dict().copy()
for i in resnet_params:
i_parts = i.split('.')
if not i_parts[0] == 'fc':
new_params['.'.join(i_parts[0:])] = resnet_params[i]
model.load_state_dict(new_params)
model.cuda()
args.schp_restore = osp.join(args.snapshot_dir, TIMESTAMP, 'best.pth')
if os.path.exists(args.schp_restore):
print('Resume schp checkpoint from {}'.format(args.schp_restore))
schp_model.load_state_dict(torch.load(args.schp_restore), True)
else:
schp_resnet_params = torch.load(RESTORE_FROM)
schp_new_params = schp_model.state_dict().copy()
for i in schp_resnet_params:
i_parts = i.split('.')
if not i_parts[0] == 'fc':
schp_new_params['.'.join(i_parts[0:])] = schp_resnet_params[i]
schp_model.load_state_dict(schp_new_params)
schp_model.cuda()
if distributed:
model = torch.nn.parallel.DistributedDataParallel(
model,
device_ids=[args.local_rank],
output_device=args.local_rank,
find_unused_parameters=True)
schp_model = torch.nn.parallel.DistributedDataParallel(
schp_model,
device_ids=[args.local_rank],
output_device=args.local_rank,
find_unused_parameters=True)
else:
model = SingleGPU(model)
schp_model = SingleGPU(schp_model)
criterion = Criterion(loss_weight=[1, 1, 1, 4, 1],
lambda_1=args.lambda_s,
lambda_2=args.lambda_e,
lambda_3=args.lambda_c,
num_classes=args.num_classes)
criterion.cuda()
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform = transforms.Compose([transforms.ToTensor(), normalize])
train_dataset = FaceDataSet(args.data_dir,
args.train_dataset,
crop_size=input_size,
transform=transform)
if distributed:
train_sampler = torch.utils.data.distributed.DistributedSampler(
train_dataset)
else:
train_sampler = None
trainloader = data.DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=False,
num_workers=2,
pin_memory=True,
drop_last=True,
sampler=train_sampler)
val_dataset = datasets[str(args.model_type)](args.data_dir,
args.valid_dataset,
crop_size=input_size,
transform=transform)
num_samples = len(val_dataset)
valloader = data.DataLoader(val_dataset,
batch_size=args.batch_size,
shuffle=False,
pin_memory=True,
drop_last=False)
# Optimizer Initialization
optimizer = optim.SGD(model.parameters(),
lr=args.learning_rate,
momentum=args.momentum,
weight_decay=args.weight_decay)
lr_scheduler = SGDRScheduler(optimizer,
total_epoch=args.epochs,
eta_min=args.learning_rate / 100,
warmup_epoch=10,
start_cyclical=args.schp_start,
cyclical_base_lr=args.learning_rate / 2,
cyclical_epoch=args.cycle_epochs)
optimizer.zero_grad()
total_iters = args.epochs * len(trainloader)
start = timeit.default_timer()
for epoch in range(start_epoch, args.epochs):
model.train()
if distributed:
train_sampler.set_epoch(epoch)
for i_iter, batch in enumerate(trainloader):
i_iter += len(trainloader) * epoch
if epoch < args.schp_start:
lr = adjust_learning_rate(optimizer, i_iter, total_iters)
else:
lr = lr_scheduler.get_lr()[0]
images, labels, edges, semantic_edges, _ = batch
labels = labels.long().cuda(non_blocking=True)
edges = edges.long().cuda(non_blocking=True)
semantic_edges = semantic_edges.long().cuda(non_blocking=True)
preds = model(images)
if cycle_n >= 1:
with torch.no_grad():
soft_preds, soft_edges, soft_semantic_edges = schp_model(
images)
else:
soft_preds = None
soft_edges = None
soft_semantic_edges = None
loss = criterion(preds, [
labels, edges, semantic_edges, soft_preds, soft_edges,
soft_semantic_edges
], cycle_n)
optimizer.zero_grad()
loss.backward()
optimizer.step()
lr_scheduler.step()
with torch.no_grad():
loss = loss.detach() * labels.shape[0]
count = labels.new_tensor([labels.shape[0]], dtype=torch.long)
if dist.is_initialized():
dist.all_reduce(count, dist.ReduceOp.SUM)
dist.all_reduce(loss, dist.ReduceOp.SUM)
loss /= count.item()
if not dist.is_initialized() or dist.get_rank() == 0:
if i_iter % 50 == 0:
writer.add_scalar('learning_rate', lr, i_iter)
writer.add_scalar('loss', loss.data.cpu().numpy(), i_iter)
if i_iter % 500 == 0:
images_inv = inv_preprocess(images, args.save_num_images)
labels_colors = decode_parsing(labels,
args.save_num_images,
args.num_classes,
is_pred=False)
edges_colors = decode_parsing(edges,
args.save_num_images,
2,
is_pred=False)
semantic_edges_colors = decode_parsing(
semantic_edges,
args.save_num_images,
args.num_classes,
is_pred=False)
if isinstance(preds, list):
preds = preds[0]
preds_colors = decode_parsing(preds[0],
args.save_num_images,
args.num_classes,
is_pred=True)
pred_edges = decode_parsing(preds[1],
args.save_num_images,
2,
is_pred=True)
pred_semantic_edges_colors = decode_parsing(
preds[2],
args.save_num_images,
args.num_classes,
is_pred=True)
img = vutils.make_grid(images_inv,
normalize=False,
scale_each=True)
lab = vutils.make_grid(labels_colors,
normalize=False,
scale_each=True)
pred = vutils.make_grid(preds_colors,
normalize=False,
scale_each=True)
edge = vutils.make_grid(edges_colors,
normalize=False,
scale_each=True)
pred_edge = vutils.make_grid(pred_edges,
normalize=False,
scale_each=True)
pred_semantic_edges = vutils.make_grid(
pred_semantic_edges_colors,
normalize=False,
scale_each=True)
writer.add_image('Images/', img, i_iter)
writer.add_image('Labels/', lab, i_iter)
writer.add_image('Preds/', pred, i_iter)
writer.add_image('Edge/', edge, i_iter)
writer.add_image('Pred_edge/', pred_edge, i_iter)
cur_loss = loss.data.cpu().numpy()
logger.info(
f'iter = {i_iter} of {total_iters} completed, loss = {cur_loss}, lr = {lr}'
)
if (epoch + 1) % (args.eval_epochs) == 0:
parsing_preds, scales, centers = valid(model, valloader,
input_size, num_samples)
mIoU, f1 = compute_mean_ioU(parsing_preds, scales, centers,
args.num_classes, args.data_dir,
input_size, args.valid_dataset, True)
if not dist.is_initialized() or dist.get_rank() == 0:
torch.save(
model.module.state_dict(),
osp.join(args.snapshot_dir, TIMESTAMP,
'checkpoint_{}.pth'.format(epoch + 1)))
if 'Helen' in args.data_dir:
if f1['overall'] > best_f1:
torch.save(
model.module.state_dict(),
osp.join(args.snapshot_dir, TIMESTAMP, 'best.pth'))
best_f1 = f1['overall']
else:
if f1['Mean_F1'] > best_f1:
torch.save(
model.module.state_dict(),
osp.join(args.snapshot_dir, TIMESTAMP, 'best.pth'))
best_f1 = f1['Mean_F1']
writer.add_scalars('mIoU', mIoU, epoch)
writer.add_scalars('f1', f1, epoch)
logger.info(
f'mIoU = {mIoU}, and f1 = {f1} of epoch = {epoch}, util now, best_f1 = {best_f1}'
)
if (epoch + 1) >= args.schp_start and (
epoch + 1 - args.schp_start) % args.cycle_epochs == 0:
logger.info(f'Self-correction cycle number {cycle_n}')
schp.moving_average(schp_model, model, 1.0 / (cycle_n + 1))
cycle_n += 1
schp.bn_re_estimate(trainloader, schp_model)
parsing_preds, scales, centers = valid(schp_model, valloader,
input_size, num_samples)
mIoU, f1 = compute_mean_ioU(parsing_preds, scales, centers,
args.num_classes, args.data_dir,
input_size, args.valid_dataset,
True)
if not dist.is_initialized() or dist.get_rank() == 0:
torch.save(
schp_model.module.state_dict(),
osp.join(args.snapshot_dir, TIMESTAMP,
'schp_{}_checkpoint.pth'.format(cycle_n)))
if 'Helen' in args.data_dir:
if f1['overall'] > best_f1:
torch.save(
schp_model.module.state_dict(),
osp.join(args.snapshot_dir, TIMESTAMP,
'best.pth'))
best_f1 = f1['overall']
else:
if f1['Mean_F1'] > best_f1:
torch.save(
schp_model.module.state_dict(),
osp.join(args.snapshot_dir, TIMESTAMP,
'best.pth'))
best_f1 = f1['Mean_F1']
writer.add_scalars('mIoU', mIoU, epoch)
writer.add_scalars('f1', f1, epoch)
logger.info(
f'mIoU = {mIoU}, and f1 = {f1} of epoch = {epoch}, util now, best_f1 = {best_f1}'
)
torch.cuda.empty_cache()
end = timeit.default_timer()
print('epoch = {} of {} completed using {} s'.format(
epoch, args.epochs, (end - start) / (epoch - start_epoch + 1)))
end = timeit.default_timer()
print(end - start, 'seconds')
def main():
"""Create the model and start the training."""
if not os.path.exists(args.snapshot_dir):
os.makedirs(args.snapshot_dir)
timestramp = args.date
writer = SummaryWriter(os.path.join(args.snapshot_dir, timestramp))
gpus = [int(i) for i in args.gpu.split(',')]
if not args.gpu == 'None':
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
h, w = map(int, args.input_size.split(','))
input_size = [h, w]
cudnn.enabled = True
# cudnn related setting
cudnn.benchmark = True
torch.backends.cudnn.deterministic = False
torch.backends.cudnn.enabled = True
deeplab = Res_Deeplab(num_classes=args.num_classes)
# dump_input = torch.rand((args.batch_size, 3, input_size[0], input_size[1]))
# writer.add_graph(deeplab.cuda(), dump_input.cuda(), verbose=False)
model = DataParallelModel(deeplab)
if args.resume:
# when restore form the same network, it is useful here
checkpoint = torch.load(args.restore_from)
model.load_state_dict(checkpoint['net'])
args.start_epoch = checkpoint['epoch']
else:
saved_state_dict = torch.load(args.restore_from)
new_params = deeplab.state_dict().copy()
for i in saved_state_dict:
i_parts = i.split('.')
if not i_parts[0] == 'fc':
new_params['.'.join(i_parts[0:])] = saved_state_dict[i]
deeplab.load_state_dict(new_params)
model.cuda()
criterion = CriterionAll()
criterion = DataParallelCriterion(criterion)
criterion.cuda()
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform = transforms.Compose([
transforms.ToTensor(),
normalize,
])
trainloader = data.DataLoader(LIPDataSet(args.data_dir,
args.dataset,
crop_size=input_size,
transform=transform),
batch_size=args.batch_size * len(gpus),
shuffle=True,
num_workers=2,
pin_memory=True)
lip_dataset = LIPDataSet(args.data_dir,
'val',
crop_size=input_size,
transform=transform)
num_samples = len(lip_dataset)
valloader = data.DataLoader(lip_dataset,
batch_size=args.batch_size * len(gpus),
shuffle=False,
pin_memory=True)
optimizer = optim.SGD(model.parameters(),
lr=args.learning_rate,
momentum=args.momentum,
weight_decay=args.weight_decay)
optimizer.zero_grad()
total_iters = args.epochs * len(trainloader)
log = Logger(os.path.join(args.log_dir, '{}_train.log'.format(timestramp)),
level='debug')
for epoch in range(args.start_epoch, args.epochs):
model.train()
#lr = adjust_learning_rate_pose(optimizer, epoch)
for i_iter, batch in enumerate(trainloader):
i_iter += len(trainloader) * epoch
lr = adjust_learning_rate(optimizer, i_iter, total_iters)
images, labels, r1, r2, r3, r4, l0, l1, l2, l3, l4, l5, _ = batch
labels = labels.long().cuda(non_blocking=True)
r1 = r1.long().cuda(non_blocking=True)
r2 = r2.long().cuda(non_blocking=True)
r3 = r3.long().cuda(non_blocking=True)
r4 = r4.long().cuda(non_blocking=True)
l0 = l0.long().cuda(non_blocking=True)
l1 = l1.long().cuda(non_blocking=True)
l2 = l2.long().cuda(non_blocking=True)
l3 = l3.long().cuda(non_blocking=True)
l4 = l4.long().cuda(non_blocking=True)
l5 = l5.long().cuda(non_blocking=True)
preds = model(images)
loss = criterion(
preds, [[labels], [r1, r2, r3, r4], [l0, l1, l2, l3, l4, l5]])
optimizer.zero_grad()
loss.backward()
optimizer.step()
if i_iter % 100 == 0:
writer.add_scalar('learning_rate', lr, i_iter)
writer.add_scalar('loss', loss.data.cpu().numpy(), i_iter)
if i_iter % 10 == 0:
log.logger.info(
'epoch = {} iter = {} of {} completed, lr = {}, loss = {}'.
format(epoch, i_iter, total_iters, lr,
loss.data.cpu().numpy()))
parsing_preds, scales, centers = valid(model, valloader, input_size,
num_samples, len(gpus))
mIoU = compute_mean_ioU(parsing_preds, scales, centers,
args.num_classes, args.data_dir, input_size)
log.logger.info('epoch = {}'.format(epoch))
log.logger.info(str(mIoU))
writer.add_scalars('mIoU', mIoU, epoch)
# save the model snapshot
state = {"net": model.module.state_dict(), "epoch": epoch}
torch.save(
state,
osp.join(args.snapshot_dir, timestramp,
'LIP_epoch_' + str(epoch) + '.pth'))
end = timeit.default_timer()
print(end - start, 'seconds')
def main():
"""Create the model and start the training."""
if not os.path.exists(args.snapshot_dir):
os.makedirs(args.snapshot_dir)
writer = SummaryWriter(args.snapshot_dir)
gpus = [int(i) for i in args.gpu.split(',')]
if not args.gpu == 'None':
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
h, w = map(int, args.input_size.split(','))
input_size = [h, w]
cudnn.enabled = True
# cudnn related setting
cudnn.benchmark = True
torch.backends.cudnn.deterministic = False
torch.backends.cudnn.enabled = True
deeplab = Res_Deeplab(num_classes=args.num_classes)
print(type(deeplab))
# dump_input = torch.rand((args.batch_size, 3, input_size[0], input_size[1]))
# writer.add_graph(deeplab.cuda(), dump_input.cuda(), verbose=False)
"""
HOW DOES IT LOAD ONLY RESNET101 AND NOT THE RSTE OF THE NET ?
"""
# UNCOMMENT THE FOLLOWING COMMENTARY TO INITIALYZE THE WEIGHTS
# Load resnet101 weights trained on imagenet and copy it in new_params
saved_state_dict = torch.load(args.restore_from)
new_params = deeplab.state_dict().copy()
# CHECK IF WEIGHTS BELONG OR NOT TO THE MODEL
# belongs = 0
# doesnt_b = 0
# for key in saved_state_dict:
# if key in new_params:
# belongs+=1
# print('key=', key)
# else:
# doesnt_b+=1
# # print('key=', key)
# print('belongs = ', belongs, 'doesnt_b=', doesnt_b)
# print('res101 len',len(saved_state_dict))
# print('new param len',len(new_params))
for i in saved_state_dict:
i_parts = i.split('.')
# print('i_parts:', i_parts)
# exp : i_parts: ['layer2', '3', 'bn2', 'running_mean']
# The deeplab weight modules have diff name than args.restore_from weight modules
if i_parts[0] == 'module' and not i_parts[1] == 'fc' :
if new_params['.'.join(i_parts[1:])].size() == saved_state_dict[i].size():
new_params['.'.join(i_parts[1:])] = saved_state_dict[i]
else:
if not i_parts[0] == 'fc':
if new_params['.'.join(i_parts[0:])].size() == saved_state_dict[i].size():
new_params['.'.join(i_parts[0:])] = saved_state_dict[i]
deeplab.load_state_dict(new_params)
# UNCOMMENT UNTIL HERE
model = DataParallelModel(deeplab)
model.cuda()
criterion = CriterionAll()
criterion = DataParallelCriterion(criterion)
criterion.cuda()
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform = transforms.Compose([
transforms.ToTensor(),
normalize,
])
trainloader = data.DataLoader(cartoonDataSet(args.data_dir, args.dataset, crop_size=input_size, transform=transform),
batch_size=args.batch_size * len(gpus), shuffle=True, num_workers=8,
pin_memory=True)
#mIoU for Val set
val_dataset = cartoonDataSet(args.data_dir, 'val', crop_size=input_size, transform=transform)
numVal_samples = len(val_dataset)
valloader = data.DataLoader(val_dataset, batch_size=args.batch_size * len(gpus),
shuffle=False, pin_memory=True)
#mIoU for trainTest set
trainTest_dataset = cartoonDataSet(args.data_dir, 'trainTest', crop_size=input_size, transform=transform)
numTest_samples = len(trainTest_dataset)
testloader = data.DataLoader(trainTest_dataset, batch_size=args.batch_size * len(gpus),
shuffle=False, pin_memory=True)
optimizer = optim.SGD(
model.parameters(),
lr=args.learning_rate,
momentum=args.momentum,
weight_decay=args.weight_decay
)
optimizer.zero_grad()
# valBatch_idx = 0
total_iters = args.epochs * len(trainloader)
for epoch in range(args.start_epoch, args.epochs):
model.train()
for i_iter, batch in enumerate(trainloader):
i_iter += len(trainloader) * epoch
lr = adjust_learning_rate(optimizer, i_iter, total_iters)
images, labels, _, _ = batch
labels = labels.long().cuda(non_blocking=True)
preds = model(images)
# print('preds size in batch', len(preds))
# print('Size of Segmentation1 tensor output:',preds[0][0].size())
# print('Segmentation2 tensor output:',preds[0][-1].size())
# print('Size of Edge tensor output:',preds[1][-1].size())
loss = criterion(preds, [labels])
optimizer.zero_grad()
loss.backward()
optimizer.step()
if i_iter % 100 == 0:
writer.add_scalar('learning_rate', lr, i_iter)
writer.add_scalar('loss', loss.data.cpu().numpy(), i_iter)
if i_iter % 500 == 0:
# print('In iter%500 Size of Segmentation2 GT: ', labels.size())
# print('In iter%500 Size of edges GT: ', edges.size())
images_inv = inv_preprocess(images, args.save_num_images)
# print(labels[0])
labels_colors = decode_parsing(labels, args.save_num_images, args.num_classes, is_pred=False)
# if isinstance(preds, list):
# print(len(preds))
# preds = preds[0]
# val_images, _ = valloader[valBatch_idx]
# valBatch_idx += 1
# val_sampler = torch.utils.data.RandomSampler(val_dataset,replacement=True, num_samples=args.batch_size * len(gpus))
# sample_valloader = data.DataLoader(val_dataset, batch_size=args.batch_size * len(gpus),
# shuffle=False, sampler=val_sampler , pin_memory=True)
# val_images, _ = sample_valloader
# preds_val = model(val_images)
# With multiple GPU, preds return a list, therefore we extract the tensor in the list
if len(gpus)>1:
preds= preds[0]
# preds_val = preds_val[0]
# print('In iter%500 Size of Segmentation2 tensor output:',preds[0][0][-1].size())
# preds[0][-1] cause model returns [[seg1, seg2], [edge]]
preds_colors = decode_parsing(preds[0][-1], args.save_num_images, args.num_classes, is_pred=True)
# preds_val_colors = decode_parsing(preds_val[0][-1], args.save_num_images, args.num_classes, is_pred=True)
# print("preds type:",type(preds)) #list
# print("preds shape:", len(preds)) #2
# hello = preds[0][-1]
# print("preds type [0][-1]:",type(hello)) #<class 'torch.Tensor'>
# print("preds len [0][-1]:", len(hello)) #12
# print("preds len [0][-1]:", hello.shape)#torch.Size([12, 8, 96, 96])
# print("preds color's type:",type(preds_colors))#torch.tensor
# print("preds color's shape:",preds_colors.shape) #([2,3,96,96])
# print('IMAGE', images_inv.size())
img = vutils.make_grid(images_inv, normalize=False, scale_each=True)
lab = vutils.make_grid(labels_colors, normalize=False, scale_each=True)
pred = vutils.make_grid(preds_colors, normalize=False, scale_each=True)
# print("preD type:",type(pred)) #<class 'torch.Tensor'>
# print("preD len:", len(pred))# 3
# print("preD shape:", pred.shape)#torch.Size([3, 100, 198])
# 1=head red, 2=body green , 3=left_arm yellow, 4=right_arm blue, 5=left_leg pink
# 6=right_leg skuBlue, 7=tail grey
writer.add_image('Images/', img, i_iter)
writer.add_image('Labels/', lab, i_iter)
writer.add_image('Preds/', pred, i_iter)
print('iter = {} of {} completed, loss = {}'.format(i_iter, total_iters, loss.data.cpu().numpy()))
print('end epoch:', epoch)
if epoch%99 == 0:
torch.save(model.state_dict(), osp.join(args.snapshot_dir, 'DFPnet_epoch_' + str(epoch) + '.pth'))
if epoch%5 == 0 and epoch<500:
# mIou for Val set
parsing_preds, scales, centers = valid(model, valloader, input_size, numVal_samples, len(gpus))
'''
Insert a sample of prediction of a val image on tensorboard
'''
# generqte a rand number between len(parsing_preds)
sample = random.randint(0, len(parsing_preds)-1)
#loader resize and convert to tensor the image
loader = transforms.Compose([
transforms.Resize(input_size),
transforms.ToTensor()
])
# get val segmentation path and open the file
list_path = os.path.join(args.data_dir, 'val' + '_id.txt')
val_id = [i_id.strip() for i_id in open(list_path)]
gt_path = os.path.join(args.data_dir, 'val' + '_segmentations', val_id[sample] + '.png')
gt =Image.open(gt_path)
gt = loader(gt)
#put gt back from 0 to 255
gt = (gt*255).int()
# convert pred from ndarray to PIL image then to tensor
display_preds = Image.fromarray(parsing_preds[sample])
tensor_display_preds = transforms.ToTensor()(display_preds)
#put gt back from 0 to 255
tensor_display_preds = (tensor_display_preds*255).int()
# color them
val_preds_colors = decode_parsing(tensor_display_preds, num_images=1, num_classes=args.num_classes, is_pred=False)
gt_color = decode_parsing(gt, num_images=1, num_classes=args.num_classes, is_pred=False)
# put in grid
pred_val = vutils.make_grid(val_preds_colors, normalize=False, scale_each=True)
gt_val = vutils.make_grid(gt_color, normalize=False, scale_each=True)
writer.add_image('Preds_val/', pred_val, epoch)
writer.add_image('Gt_val/', gt_val, epoch)
mIoUval = compute_mean_ioU(parsing_preds, scales, centers, args.num_classes, args.data_dir, input_size, 'val')
print('For val set', mIoUval)
writer.add_scalars('mIoUval', mIoUval, epoch)
# mIou for trainTest set
parsing_preds, scales, centers = valid(model, testloader, input_size, numTest_samples, len(gpus))
mIoUtest = compute_mean_ioU(parsing_preds, scales, centers, args.num_classes, args.data_dir, input_size, 'trainTest')
print('For trainTest set', mIoUtest)
writer.add_scalars('mIoUtest', mIoUtest, epoch)
else:
if epoch%20 == 0 and epoch>=500:
# mIou for Val set
parsing_preds, scales, centers = valid(model, valloader, input_size, numVal_samples, len(gpus))
'''
Insert a sample of prediction of a val image on tensorboard
'''
# generqte a rand number between len(parsing_preds)
sample = random.randint(0, len(parsing_preds)-1)
#loader resize and convert to tensor the image
loader = transforms.Compose([
transforms.Resize(input_size),
transforms.ToTensor()
])
# get val segmentation path and open the file
list_path = os.path.join(args.data_dir, 'val' + '_id.txt')
val_id = [i_id.strip() for i_id in open(list_path)]
gt_path = os.path.join(args.data_dir, 'val' + '_segmentations', val_id[sample] + '.png')
gt =Image.open(gt_path)
gt = loader(gt)
#put gt back from 0 to 255
gt = (gt*255).int()
# convert pred from ndarray to PIL image then to tensor
display_preds = Image.fromarray(parsing_preds[sample])
tensor_display_preds = transforms.ToTensor()(display_preds)
#put gt back from 0 to 255
tensor_display_preds = (tensor_display_preds*255).int()
# color them
val_preds_colors = decode_parsing(tensor_display_preds, num_images=1, num_classes=args.num_classes, is_pred=False)
gt_color = decode_parsing(gt, num_images=1, num_classes=args.num_classes, is_pred=False)
# put in grid
pred_val = vutils.make_grid(val_preds_colors, normalize=False, scale_each=True)
gt_val = vutils.make_grid(gt_color, normalize=False, scale_each=True)
writer.add_image('Preds_val/', pred_val, epoch)
writer.add_image('Gt_val/', gt_val, epoch)
mIoUval = compute_mean_ioU(parsing_preds, scales, centers, args.num_classes, args.data_dir, input_size, 'val')
print('For val set', mIoUval)
writer.add_scalars('mIoUval', mIoUval, epoch)
# mIou for trainTest set
parsing_preds, scales, centers = valid(model, testloader, input_size, numTest_samples, len(gpus))
mIoUtest = compute_mean_ioU(parsing_preds, scales, centers, args.num_classes, args.data_dir, input_size, 'trainTest')
print('For trainTest set', mIoUtest)
writer.add_scalars('mIoUtest', mIoUtest, epoch)
end = timeit.default_timer()
print(end - start, 'seconds')
