def __init__(self,
data_dir,
split='train',
transform=None,
img_size=416,
rtn_path=False,
keep_difficult=False):
"""Dataset for VOC data.
Args:
data_dir: the root of the VOC2007 or VOC2012 dataset, the directory contains the following sub-directories:
Annotations, ImageSets, JPEGImages, SegmentationClass, SegmentationObject.
"""
self.rtn_path = rtn_path
if split == 'train':
transform = [
ConvertFromInts(),
PhotometricDistort(),
Expand([123, 117, 104]),
RandomSampleCrop(),
RandomMirror(),
ToPercentCoords(),
Resize(img_size),
SubtractMeans([123, 117, 104]),
ToTensor(),
]
else:
transform = [
Resize(img_size),
#ToPercentCoords(),
SubtractMeans([123, 117, 104]),
ToTensor()
]
self.transform = Compose(transform)
self.data_dir = data_dir
self.split = split
if split != 'test':
image_sets_file = [
os.path.join(self.data_dir, f'VOC{year}', "ImageSets", "Main",
"%s.txt" % self.split) for year in [2007, 2012]
]
self.ids = VOCDataset._read_image_ids(image_sets_file)
else:
image_sets_file = [
os.path.join(self.data_dir, f'VOC{year}', "ImageSets", "Main",
"%s.txt" % self.split) for year in [2007]
]
self.ids = VOCDataset._read_image_ids(image_sets_file)
self.keep_difficult = keep_difficult
self.batch_count = 0
self.img_size = 416
self.min_size = self.img_size - 3 * 32
self.max_size = self.img_size + 3 * 32
self.class_dict = {
class_name: i
for i, class_name in enumerate(self.class_names)
}
def transform_factory(transformation):
if(transformation == "RC"):
train_transform = transforms.Compose([Resize(size=256), RandomCrop(size=224), RandomHorizontalFlip()])
elif(transformation == "R"):
train_transform = transforms.Compose([Resize(size=224)])
elif(transformation == "RF"):
train_transform = transforms.Compose([Resize(size=224), RandomHorizontalFlip()])
return train_transform
def build_transforms(cfg):
transforms = Compose([
Resize(cfg.TRANSFORMS.RESIZE_SIZE),
ToTensor(),
Normalize(mean=cfg.TRANSFORMS.MEAN, std=cfg.TRANSFORMS.STD)
])
return transforms
def create_datasets(config):
image_size = config.get('image_size', (224, 224))
train_dataset = ConcatenatedSegmentationDataset([
EG1800Dataset('datasets/EG1800/', config=config),
NukkiDataset('datasets/Nukki/baidu_V1/', config=config),
NukkiDataset('datasets/Nukki/baidu_V2/', config=config),
])
data_info_path = 'datasets/data_info.pt'
if osp.exists(data_info_path):
data_info = torch.load(data_info_path)
else:
mean, std = determine_mean_and_std(train_dataset)
data_info = {'mean': mean.T, 'std': std.T}
torch.save(data_info, 'datasets/data_info.pt')
train_transforms = (Resize(image_size, mask_scale=config.get('mask_scale', 1)),
T.RandomAffine(45, scale=(0.5, 1.5)),
T.RandomHorizontalFlip(),
ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.1),
GaussianBlur(5),
T.ToTensor(),
RandomNoise(scale=10.0),
T.Normalize(data_info['mean'].reshape((3, 1, 1)) / 255.,
data_info['std'].reshape((3, 1, 1)) / 255.),
)
train_transforms = SegTrans(T.Compose([SegTrans(m) for m in train_transforms]))
train_dataset.transforms = train_transforms
val_transforms = (
Resize(image_size, mask_scale=config.get('mask_scale', 1)),
T.ToTensor(),
T.Normalize(data_info['mean'].reshape((3, 1, 1)) / 255., data_info['std'].reshape((3, 1, 1)) / 255.),
)
val_transforms = SegTrans(T.Compose([SegTrans(m) for m in val_transforms]))
val_dataset = ConcatenatedSegmentationDataset([
# NukkiDataset('datasets/Nukki/baidu_V1/', mode='val'),
# NukkiDataset('datasets/Nukki/baidu_V2/', mode='val'),
EG1800Dataset('datasets/EG1800/', mode='val'),
], transforms=val_transforms)
return {'train': train_dataset, 'val': val_dataset}
# --- Hyperparameters ---
batch_size = 3
num_classes = 32
input_height = 256
input_width = 256
output_height = 256
output_width = 256
# --- Predict data ---
image_dir = "/Users/Akash_Sengupta/Documents/4th_year_project_datasets/up-s31/trial/images3/train"
label_dir = "/Users/Akash_Sengupta/Documents/4th_year_project_datasets/up-s31/trial/masks3/train"
eval_transforms = transforms.Compose([
PadToSquare(),
Resize(input_height, input_width, output_height, output_width),
ToTensor()
])
eval_dataset = UPS31Dataset(image_dir=image_dir,
label_dir=label_dir,
transform=eval_transforms)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print('Eval images found: {}'.format(len(eval_dataset)))
print('Device: {}'.format(device))
# --- Model and Loss---
model = PSPNet(num_classes)
saved_model_path = "./saved_models/pspnet_test.tar"
criterion = nn.CrossEntropyLoss(weight=None)
def main():
global args, best_prec
args = parser.parse_args()
random.seed(seed)
torch.manual_seed(seed)
np.random.seed(seed)
if not args.cpu:
torch.cuda.manual_seed_all(seed)
data = DatasetReader(root_dir=args.data, data_name=args.data_name)
assert args.kfold < args.split, "kfold index must be less than the split size!"
folds = fold(args.split, data)
for i in range(args.kfold):
next(folds)
(train_dataset, val_dataset) = next(folds)
def transform_factory(transformation):
if(transformation == "RC"):
train_transform = transforms.Compose([Resize(size=256), RandomCrop(size=224), RandomHorizontalFlip()])
elif(transformation == "R"):
train_transform = transforms.Compose([Resize(size=224)])
elif(transformation == "RF"):
train_transform = transforms.Compose([Resize(size=224), RandomHorizontalFlip()])
return train_transform
train_transformations = transforms.Compose([transform_factory(args.transform), SelectFrames(num_frames=20), FrameDifference(dim=0), Normalize(), ToTensor()])
val_transformations = transforms.Compose([Resize(size=224), SelectFrames(num_frames=20), FrameDifference(dim=0), Normalize(), ToTensor()])
train_dataset = DatasetTransform(train_dataset, train_transformations)
val_dataset = DatasetTransform(val_dataset, val_transformations)
train_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=args.batch_size, shuffle=True,
num_workers=args.workers, pin_memory=True)
val_loader = torch.utils.data.DataLoader(
val_dataset, batch_size=args.batch_size, shuffle=False,
num_workers=args.workers, pin_memory=True)
# create model
print("=> creating model '{}'".format(args.arch))
VP = network_factory(args.arch)
model = VP()
if not args.cpu:
model = model.cuda()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), args.lr,
weight_decay=args.weight_decay)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
if args.evaluate:
validate(val_loader, model)
return
run_training(train_loader, val_loader, model, criterion, optimizer, best_prec)
def main():
args.exp_name = utils.create_exp_name(args)
args.save_root += args.dataset + '/'
args.data_root += args.dataset + '/'
args.save_root = args.save_root + 'cache/' + args.exp_name + '/'
if not os.path.isdir(
args.save_root): #if save directory doesn't exist create it
os.makedirs(args.save_root)
source_dir = args.save_root + '/source/' # where to save the source
utils.copy_source(
source_dir
) # make a copy of source files used for training as a snapshot
print('\nLoading Datasets')
train_transform = transforms.Compose([
Resize(args.min_size, args.max_size),
transforms.ToTensor(),
transforms.Normalize(mean=args.means, std=args.stds)
])
train_dataset = DetectionDataset(root=args.data_root,
train=True,
input_sets=['train/set1', 'train/set2'],
transform=train_transform)
print('Done Loading Dataset Train Dataset :::>>>\n',
train_dataset.print_str)
val_transform = transforms.Compose([
Resize(args.min_size, args.max_size),
transforms.ToTensor(),
transforms.Normalize(mean=args.means, std=args.stds)
])
val_dataset = DetectionDataset(root=args.data_root,
train=False,
input_sets=['val/obj'],
transform=val_transform,
full_test=False)
print('Done Loading Dataset Validation Dataset :::>>>\n',
val_dataset.print_str)
args.num_classes = len(train_dataset.classes) + 1
args.classes = train_dataset.classes
args.use_bias = args.use_bias > 0
args.head_size = 256
net = build_retinanet_shared_heads(args).cuda()
# print(net)
if args.multi_gpu:
print('\nLets do dataparallel\n')
net = torch.nn.DataParallel(net)
if args.fbn:
if args.multi_gpu:
net.module.backbone_net.apply(utils.set_bn_eval)
else:
net.backbone_net.apply(utils.set_bn_eval)
optimizer, scheduler, solver_print_str = get_optim(args, net)
train(args, net, optimizer, scheduler, train_dataset, val_dataset,
solver_print_str)
def main():
args.exp_name = utils.create_exp_name(args)
args.data_root += args.dataset+'/'
args.save_root += args.dataset+'/'
args.save_root += 'cache/'+args.exp_name+'/'
val_transform = transforms.Compose([
Resize(args.min_size, args.max_size),
transforms.ToTensor(),
transforms.Normalize(mean=args.means,std=args.stds)])
if True: # while validating
val_dataset = DetectionDataset(root= args.data_root, train=False, input_sets=['val/obj'], transform=val_transform, full_test=False)
else: # while testing
val_dataset = DetectionDataset(root= args.data_root, train=False, input_sets=['test/obj'], transform=val_transform, full_test=True)
print('Done Loading Dataset Validation Dataset :::>>>\n',val_dataset.print_str)
args.data_dir = val_dataset.root
args.num_classes = len(val_dataset.classes) + 1
args.classes = val_dataset.classes
args.head_size = 256
net = build_retinanet_shared_heads(args).cuda()
if args.multi_gpu>0:
print('\nLets do dataparallel\n')
net = torch.nn.DataParallel(net)
net.eval()
for iteration in args.eval_iters:
args.det_itr = iteration
log_file = open("{pt:s}/testing-{it:06d}-{date:%m-%d-%Hx}.log".format(pt=args.save_root, it=iteration, date=datetime.datetime.now()), "w", 1)
log_file.write(args.exp_name + '\n')
submission_file = open("{pt:s}/submission-{it:06d}-{date:%m-%d-%Hx}.txt".format(pt=args.save_root, it=iteration, date=datetime.datetime.now()), "w", 1)
args.model_path = args.save_root + 'model_{:06d}.pth'.format(iteration)
log_file.write(args.model_path+'\n')
net.load_state_dict(torch.load(args.model_path))
print('Finished loading model %d !' % iteration)
# Load dataset
val_data_loader = data_utils.DataLoader(val_dataset, int(args.batch_size), num_workers=args.num_workers,
shuffle=False, pin_memory=True, collate_fn=custum_collate)
# evaluation
torch.cuda.synchronize()
tt0 = time.perf_counter()
log_file.write('Testing net \n')
net.eval() # switch net to evaluation mode
if len(args.iou_threshs)>2:
args.iou_threshs = [float(th) for th in args.iou_threshs.split(',')]
else:
args.iou_threshs = [th for th in np.arange(0.05,0.951,0.05)]
# print(args.iou_threshs)
result_list = validate(args, net, val_data_loader, val_dataset, iteration, submission_file, args.iou_threshs)
for result in result_list:
[iou_thresh, mAP, ap_all, ap_strs] = result
ptr_str = '\n\nIOU Threshold: {:0.2f}:: \n\n'.format(iou_thresh)
print(ptr_str)
log_file.write(ptr_str)
for ap_str in ap_strs:
print(ap_str)
log_file.write(ap_str+'\n')
ptr_str = '\nMEANAP:::=>{:0.4f}\n\n'.format(mAP*100)
print(ptr_str)
log_file.write(ptr_str)
ptr_str = 'printing the on mAP results again \n'
print(ptr_str)
log_file.write(ptr_str)
for result in result_list:
[iou_thresh, mAP, ap_all, ap_strs] = result
ptr_str = '\n\nIOU Threshold: {:0.2f}:: \n\n'.format(iou_thresh)
print(ptr_str)
log_file.write(ptr_str)
ptr_str = '\nMEANAP:::=>{:0.4f}\n\n'.format(mAP*100)
print(ptr_str)
log_file.write(ptr_str)
torch.cuda.synchronize()
print('Complete set time {:0.2f}'.format(time.perf_counter() - tt0))
log_file.close()
def main():
args.exp_name = utils.create_exp_name(args)
args.data_root += args.dataset + '/'
args.save_root += args.dataset + '/'
args.save_root += 'cache/' + args.exp_name + '/'
val_transform = transforms.Compose([
Resize(args.min_size, args.max_size),
transforms.ToTensor(),
transforms.Normalize(mean=args.means, std=args.stds)
])
if False: # while validating
val_dataset = DetectionDataset(root=args.data_root,
train=False,
input_sets=['val/obj'],
transform=val_transform,
full_test=False)
else: # while testing
val_dataset = DetectionDataset(root=args.data_root,
train=False,
input_sets=['testC'],
transform=val_transform,
full_test=True)
print('Done Loading Dataset Validation Dataset :::>>>\n',
val_dataset.print_str)
args.data_dir = val_dataset.root
args.num_classes = len(val_dataset.classes) + 1
args.classes = val_dataset.classes
args.head_size = 256
net = build_retinanet_shared_heads(args).cuda()
if args.multi_gpu > 0:
print('\nLets do dataparallel\n')
net = torch.nn.DataParallel(net)
net.eval()
if len(args.iou_threshs) > 2:
args.iou_threshs = [float(th) for th in args.iou_threshs.split(',')]
else:
args.iou_threshs = [th for th in np.arange(0.05, 0.951, 0.05)]
overal_json_object = {}
for iteration in args.eval_iters:
args.det_itr = iteration
args.model_path = args.save_root + 'model_{:06d}.pth'.format(iteration)
if not os.path.isfile(args.model_path):
continue
log_file = open(
"{pt:s}/testing-{it:06d}.log".format(pt=args.save_root,
it=iteration), "w", 1)
log_file.write(args.exp_name + '\n')
submission_file = open(
"{pt:s}/submission.txt".format(pt=args.save_root), "w", 1)
log_file.write(args.model_path + '\n')
net.load_state_dict(torch.load(args.model_path))
print('Finished loading model %d !' % iteration)
# Load dataset
val_data_loader = data_utils.DataLoader(val_dataset,
int(args.batch_size),
num_workers=args.num_workers,
shuffle=False,
pin_memory=True,
collate_fn=custum_collate)
# evaluation
torch.cuda.synchronize()
tt0 = time.perf_counter()
log_file.write('Testing net \n')
net.eval() # switch net to evaluation mode
# print(args.iou_threshs)
result_list = validate(args, net, val_data_loader, val_dataset,
iteration, submission_file, args.iou_threshs)
for result in result_list:
[iou_thresh, mAP, ap_all, ap_strs] = result
ptr_str = '\n\nIOU Threshold: {:0.2f}:: \n'.format(iou_thresh)
print(ptr_str)
log_file.write(ptr_str)
for ap_str in ap_strs:
print(ap_str)
log_file.write(ap_str + '\n')
ptr_str = '\nMEANAP:::=>{:0.4f}\n'.format(mAP * 100)
print(ptr_str)
log_file.write(ptr_str)
ptr_str = 'printing the on mAP results again \n'
print(ptr_str)
log_file.write(ptr_str)
thmap_dict = {'30': 0, '10': 0, '50': 0, 'mean': 0}
summap = 0
for result in result_list:
[iou_thresh, mAP, ap_all, ap_strs] = result
thstr = str(int(iou_thresh * 100))
if thstr in thmap_dict:
thmap_dict[thstr] = mAP * 100
summap += mAP * 100
ptr_str = '\nIOUTH : mAP :: {:0.2f} : {:0.2f}\n'.format(
iou_thresh, mAP * 100)
print(ptr_str)
log_file.write(ptr_str)
thmap_dict['mean'] = summap / 3.0
overal_json_object[str(int(iteration))] = thmap_dict
torch.cuda.synchronize()
print('Complete set time {:0.2f}'.format(time.perf_counter() - tt0))
log_file.close()
result_name = 'results/test-frameAP-{:s}-{:s}-{:d}'.format(
args.loss_type, args.basenet, args.min_size)
with open(result_name + '.json', 'w') as f:
json.dump(overal_json_object, f)
fid = open(result_name + '.txt', 'w')
fid.write('{:s} {:s} {:d}\n'.format(args.loss_type, args.basenet,
args.min_size))
for iter in sorted(overal_json_object.keys()):
res = overal_json_object[iter]
fid.write('{:s} {:0.1f} {:0.1f} {:0.1f} {:0.1f}\n'.format(
iter, res['10'], res['30'], res['50'], res['mean']))
fid.close()
def main():
args.exp_name = utils.create_exp_name(args)
args.save_root += args.dataset + '/'
args.save_root = args.save_root + 'cache/' + args.exp_name + '/'
val_transform = transforms.Compose([
Resize(args.min_size, args.max_size),
transforms.ToTensor(),
transforms.Normalize(mean=args.means, std=args.stds)
])
val_dataset = DetectionDataset(args,
train=False,
image_sets=args.val_sets,
transform=val_transform,
full_test=False)
print('Done Loading Dataset Validation Dataset :::>>>\n',
val_dataset.print_str)
args.data_dir = val_dataset.root
args.num_classes = len(val_dataset.classes) + 1
args.classes = val_dataset.classes
args.head_size = 256
net = build_retinanet_shared_heads(args).cuda()
if args.multi_gpu > 0:
print('\nLets do dataparallel\n')
net = torch.nn.DataParallel(net)
net.eval()
for iteration in args.eval_iters:
args.det_itr = iteration
log_file = open(
"{pt:s}/testing-{it:06d}-{date:%m-%d-%Hx}.log".format(
pt=args.save_root, it=iteration, date=datetime.datetime.now()),
"w", 10)
log_file.write(args.exp_name + '\n')
args.model_path = args.save_root + 'model_{:06d}.pth'.format(iteration)
log_file.write(args.model_path + '\n')
net.load_state_dict(torch.load(args.model_path))
print('Finished loading model %d !' % iteration)
# Load dataset
val_data_loader = data_utils.DataLoader(val_dataset,
int(args.batch_size),
num_workers=args.num_workers,
shuffle=False,
pin_memory=True,
collate_fn=custum_collate)
# evaluation
torch.cuda.synchronize()
tt0 = time.perf_counter()
log_file.write('Testing net \n')
net.eval() # switch net to evaluation mode
if args.dataset != 'coco':
mAP, ap_all, ap_strs, det_boxes = validate(
args,
net,
val_data_loader,
val_dataset,
iteration,
iou_thresh=args.iou_thresh)
else:
mAP, ap_all, ap_strs, det_boxes = validate_coco(
args,
net,
val_data_loader,
val_dataset,
iteration,
log_file,
iou_thresh=args.iou_thresh)
for ap_str in ap_strs:
print(ap_str)
log_file.write(ap_str + '\n')
ptr_str = '\nMEANAP:::=>' + str(mAP) + '\n'
print(ptr_str)
log_file.write(ptr_str)
torch.cuda.synchronize()
print('Complete set time {:0.2f}'.format(time.perf_counter() - tt0))
log_file.close()