def __init__(self, args):
self.args = args
self.vs = vs(args.nice)
#Dataloader
kwargs = {"num_workers": args.workers, 'pin_memory': True}
if self.args.dataset == 'bdd':
_, _, self.test_loader, self.nclass = make_data_loader(
args, **kwargs)
else: #self.args.dataset == 'nice':
self.test_loader, self.nclass = make_data_loader(args, **kwargs)
#else:
# raise NotImplementedError
### Load models
#backs = ["resnet", "resnet152"]
backs = ["resnet", "ibn", "resnet152"]
check = './ckpt'
checks = ["herbrand.pth.tar", "ign85.12.pth.tar", "r152_85.20.pth.tar"]
self.models = []
self.M = len(backs)
# define models
for i in range(self.M):
model = DeepLab(num_classes=self.nclass,
backbone=backs[i],
output_stride=16,
Norm=gn,
freeze_bn=False)
self.models.append(model)
self.models[i] = torch.nn.DataParallel(
self.models[i], device_ids=self.args.gpu_ids)
patch_replication_callback(self.models[i])
self.models[i] = self.models[i].cuda()
# load checkpoints
for i in range(self.M):
resume = os.path.join(check, checks[i])
if not os.path.isfile(resume):
raise RuntimeError(
"=> no checkpoint found at '{}'".format(resume))
checkpoint = torch.load(resume)
dicts = checkpoint['state_dict']
model_dict = {}
state_dict = self.models[i].module.state_dict()
for k, v in dicts.items():
if k in state_dict:
model_dict[k] = v
state_dict.update(model_dict)
self.models[i].module.load_state_dict(state_dict)
print("{} loaded successfully".format(checks[i]))
def __init__(self, args, logger):
self.args = args
self.logger = logger
self.time_train = []
self.args.evaluate = True
self.args.merge = True
kwargs = {'num_workers': args.workers, 'pin_memory': False}
_, self.val_loader, _, self.num_class = make_data_loader(
args, **kwargs)
print('un_classes:' + str(self.num_class))
self.resize = args.crop_size if args.crop_size else [512, 1024]
self.evaluator = Evaluator(self.num_class, self.logger)
self.model = EDCNet(self.args.rgb_dim,
args.event_dim,
num_classes=self.num_class,
use_bn=True)
if args.cuda:
self.model = torch.nn.DataParallel(self.model,
device_ids=self.args.gpu_ids)
self.model = self.model.to(self.args.device)
cudnn.benchmark = True
print('Model loaded successfully!')
assert os.path.exists(
args.weight_path), 'weight-path:{} doesn\'t exit!'.format(
args.weight_path)
self.new_state_dict = torch.load(os.path.join(args.weight_path),
map_location='cuda:0')
self.model = load_my_state_dict(self.model.module,
self.new_state_dict['state_dict'])
def __init__(self, args):
self.args = args
self.time_train = []
# Define Dataloader
kwargs = {'num_workers': args.workers, 'pin_memory': False}
_, self.val_loader, _, self.num_class = make_data_loader(
args, **kwargs)
print('un_classes:' + str(self.num_class))
# Define evaluator
self.evaluator = Evaluator(self.num_class)
# Define network
self.resnet = resnet18(pretrained=True, efficient=False, use_bn=True)
self.model = RFNet(self.resnet,
num_classes=self.num_class,
use_bn=True)
if args.cuda:
self.model = torch.nn.DataParallel(self.model,
device_ids=self.args.gpu_ids)
self.model = self.model.cuda()
cudnn.benchmark = True # accelarate speed
print('Model loaded successfully!')
# Load weights
assert os.path.exists(
args.weight_path), 'weight-path:{} doesn\'t exit!'.format(
args.weight_path)
self.new_state_dict = torch.load(
os.path.join(args.weight_path, 'model_best.pth'))
self.model = load_my_state_dict(self.model.module,
self.new_state_dict['state_dict'])
def __init__(self, args):
self.args = args
# Define Dataloader
kwargs = {'num_workers': args.workers, 'pin_memory': True}
_, _, self.test_loader, self.nclass = make_data_loader(args, **kwargs)
self.model = None
# Define network
if self.args.backbone == 'unet':
self.model = UNet(in_channels=4, n_classes=self.nclass)
print("using UNet")
if self.args.backbone == 'unetNested':
self.model = UNetNested(in_channels=4, n_classes=self.nclass)
print("using UNetNested")
# Using cuda
if args.cuda:
self.model = self.model.cuda()
if not os.path.isfile(args.checkpoint_file):
raise RuntimeError("=> no checkpoint found at '{}'".format(
args.checkpoint_file))
checkpoint = torch.load(args.checkpoint_file)
self.model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}'".format(args.checkpoint_file))
def __init__(self, args):
self.args = args
# configure datasetpath
self.baseroot = None
if args.dataset == 'pascal':
self.baseroot = '/path/to/your/VOCdevkit/VOC2012/'
''' no support,
# if you want train on these
# you need modefy here
# refer to /dataloader/datasets/pascal to
#implement the corresponding constructor to dataset
elif args.dataset == 'cityscapes':
self.baseroot = '/path/to/your/cityscapes/'
elif args.dataset == 'sbd':
self.baseroot = '/path/to/your/sbd/'
elif args.dataset == 'coco':
self.baseroot = '/path/to/your/coco/'
'''
# Define Dataloader
kwargs = {'num_workers': args.workers, 'pin_memory': True}
self.test_loader, self.nclass = make_data_loader(
self.baseroot, args, **kwargs)
#define net model
self.model = DeepLab(num_classes=self.nclass,
backbone=args.backbone,
output_stride=args.out_stride,
sync_bn=False,
freeze_bn=False).cuda()
# self.model.module.load_state_dict(torch.load('./model_best.pth.tar', map_location='cpu'))
self.evaluator = Evaluator(self.nclass)
if args.cuda:
self.model = torch.nn.DataParallel(self.model,
device_ids=self.args.gpu_ids)
patch_replication_callback(self.model)
self.model = self.model.cuda()
self.best_pred = 0.0
if not os.path.isfile(args.resume):
raise RuntimeError("=> no checkpoint found at '{}'".format(
args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
if args.cuda:
self.model.module.load_state_dict(checkpoint['state_dict'])
else:
self.model.load_state_dict(checkpoint['state_dict'])
self.best_pred = checkpoint['best_pred']
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
def __init__(self):
init_seeds(opt.seed)
self.best_pred = 0.
self.cutoff = -1 # backbone reaches to cutoff layer
# Define Saver
self.saver = Saver(opt, hyp, mode='val')
# visualize
if opt.visualize:
self.summary = TensorboardSummary(self.saver.experiment_dir)
self.writer = self.summary.create_summary()
if 'pw' not in opt.arc: # remove BCELoss positive weights
hyp['cls_pw'] = 1.
hyp['obj_pw'] = 1.
self.img_size = opt.img_size
# Define Dataloader
self.val_dataset, self.val_loader = make_data_loader(opt,
hyp,
train=False)
self.num_classes = self.val_dataset.num_classes
self.vnb = len(self.val_loader)
# Initialize model
self.model = Darknet(opt.cfg, self.img_size, opt.arc).to(opt.device)
self.model.nc = self.num_classes # attach number of classes to model
self.model.arc = opt.arc # attach yolo architecture
self.model.hyp = hyp # attach hyperparameters to model
# load weight
if os.path.isfile(opt.pre):
print("=> loading checkpoint '{}'".format(opt.pre))
checkpoint = torch.load(opt.pre)
self.epoch = checkpoint['epoch']
self.best_pred = checkpoint['best_pred']
self.model.load_state_dict(checkpoint['state_dict'])
# self.optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})".format(
opt.pre, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(opt.pre))
# Mixed precision training https://github.com/NVIDIA/apex
if mixed_precision:
self.model, self.optimizer = amp.initialize(self.model,
self.optimizer,
opt_level='O1',
verbosity=0)
# Initialize distributed training
if len(opt.gpu_id) > 1:
print("Using multiple gpu")
self.model = torch.nn.DataParallel(self.model,
device_ids=opt.gpu_id)
def __init__(self, args):
self.args = args
# Define Saver
self.saver = Saver(args)
self.saver.save_experiment_config()
# Define Tensorboard Summary
self.summary = TensorboardSummary(self.saver.experiment_dir)
self.writer = self.summary.create_summary()
# Define Dataloader
kwargs = {'num_workers': args.workers, 'pin_memory': True}
self.train_loader, self.val_loader, self.test_loader, self.nclass = make_data_loader(
args, **kwargs)
# Define weight
self.temporal_weight = args.temporal_weight
self.spatial_weight = args.spatial_weight
# Define network
temporal_model = Model(name='vgg16_bn', num_classes=101,
is_flow=True).get_model()
spatial_model = Model(name='vgg16_bn', num_classes=101,
is_flow=False).get_model()
# Define Optimizer
#optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay)
temporal_optimizer = torch.optim.Adam(temporal_model.parameters(),
lr=args.temporal_lr)
spatial_optimizer = torch.optim.Adam(spatial_model.parameters(),
lr=args.spatial_lr)
# Define Criterion
self.temporal_criterion = nn.BCELoss().cuda()
self.spatial_criterion = nn.BCELoss().cuda()
self.temporal_model, self.temporal_optimizer = temporal_model, temporal_optimizer
self.spatial_model, self.spatial_optimizer = spatial_model, spatial_optimizer
# Define Evaluator
self.top1_eval = Evaluator(self.nclass)
# Using cuda
if args.cuda:
self.temporal_model = torch.nn.DataParallel(
self.temporal_model, device_ids=self.args.gpu_ids)
patch_replication_callback(self.temporal_model)
self.temporal_model = self.temporal_model.cuda()
self.spatial_model = torch.nn.DataParallel(
self.spatial_model, device_ids=self.args.gpu_ids)
patch_replication_callback(self.spatial_model)
self.spatial_model = self.spatial_model.cuda()
# Resuming checkpoint
self.best_accuracy = 0.0
'''
def main():
args = arguments()
seed(args)
model = DeepLab(backbone='mobilenet',
output_stride=16,
num_classes=21,
sync_bn=False)
model.eval()
from aimet_torch import batch_norm_fold
from aimet_torch import utils
args.input_shape = (1, 3, 513, 513)
batch_norm_fold.fold_all_batch_norms(model, args.input_shape)
utils.replace_modules_of_type1_with_type2(model, torch.nn.ReLU6,
torch.nn.ReLU)
if args.checkpoint_path:
model.load_state_dict(torch.load(args.checkpoint_path))
else:
raise ValueError('checkpoint path {} must be specified'.format(
args.checkpoint_path))
data_loader_kwargs = {'worker_init_fn': work_init, 'num_workers': 0}
train_loader, val_loader, test_loader, num_class = make_data_loader(
args, **data_loader_kwargs)
eval_func_quant = model_eval(args, val_loader)
eval_func = model_eval(args, val_loader)
from aimet_common.defs import QuantScheme
from aimet_torch.quantsim import QuantizationSimModel
if hasattr(args, 'quant_scheme'):
if args.quant_scheme == 'range_learning_tf':
quant_scheme = QuantScheme.training_range_learning_with_tf_init
elif args.quant_scheme == 'range_learning_tfe':
quant_scheme = QuantScheme.training_range_learning_with_tf_enhanced_init
elif args.quant_scheme == 'tf':
quant_scheme = QuantScheme.post_training_tf
elif args.quant_scheme == 'tf_enhanced':
quant_scheme = QuantScheme.post_training_tf_enhanced
else:
raise ValueError("Got unrecognized quant_scheme: " +
args.quant_scheme)
kwargs = {
'quant_scheme': quant_scheme,
'default_param_bw': args.default_param_bw,
'default_output_bw': args.default_output_bw,
'config_file': args.config_file
}
print(kwargs)
sim = QuantizationSimModel(model.cpu(),
input_shapes=args.input_shape,
**kwargs)
sim.compute_encodings(eval_func_quant, (1024, True))
post_quant_top1 = eval_func(sim.model.cuda(), (99999999, True))
print("Post Quant mIoU :", post_quant_top1)
def __init__(self, args):
self.args = args
self.saver = Saver(args)
self.saver.save_experiment_config()
self.summary = TensorboardSummary(self.saver.experiment_dir)
self.writer = self.summary.create_summary()
self.logger = self.saver.create_logger()
kwargs = {'num_workers': args.workers, 'pin_memory': False}
self.train_loader, self.val_loader, self.test_loader, self.nclass = make_data_loader(args, **kwargs)
self.model = EDCNet(args.rgb_dim, args.event_dim, num_classes=self.nclass, use_bn=True)
train_params = [{'params': self.model.random_init_params(),
'lr': 10*args.lr, 'weight_decay': 10*args.weight_decay},
{'params': self.model.fine_tune_params(),
'lr': args.lr, 'weight_decay': args.weight_decay}]
self.optimizer = torch.optim.Adam(train_params, lr=args.lr, weight_decay=args.weight_decay)
if args.cuda:
self.model = torch.nn.DataParallel(self.model, device_ids=self.args.gpu_ids)
patch_replication_callback(self.model)
self.model = self.model.to(self.args.device)
if args.use_balanced_weights:
root_dir = Path.db_root_dir(args.dataset)[0] if isinstance(Path.db_root_dir(args.dataset), list) else Path.db_root_dir(args.dataset)
classes_weights_path = os.path.join(root_dir,
args.dataset + '_classes_weights.npy')
if os.path.isfile(classes_weights_path):
weight = np.load(classes_weights_path)
else:
weight = calculate_weigths_labels(args.dataset, self.train_loader, self.nclass, classes_weights_path)
weight = torch.from_numpy(weight.astype(np.float32))
else:
weight = None
self.criterion = SegmentationLosses(weight=weight, cuda=args.cuda).build_loss(mode=args.loss_type)
self.criterion_event = SegmentationLosses(weight=weight, cuda=args.cuda).build_loss(mode='event')
self.scheduler = LR_Scheduler(args.lr_scheduler, args.lr, args.epochs, len(self.train_loader), warmup_epochs=5)
self.evaluator = Evaluator(self.nclass, self.logger)
self.saver.save_model_summary(self.model)
self.best_pred = 0.0
if args.resume is not None:
if not os.path.isfile(args.resume):
raise RuntimeError("=> no checkpoint found at '{}'".format(args.resume))
checkpoint = torch.load(args.resume, map_location='cuda:0')
args.start_epoch = checkpoint['epoch']
if args.cuda:
self.model.module.load_state_dict(checkpoint['state_dict'])
else:
self.model.load_state_dict(checkpoint['state_dict'])
if not args.ft:
self.optimizer.load_state_dict(checkpoint['optimizer'])
self.best_pred = checkpoint['best_pred']
print("=> loaded checkpoint '{}' (epoch {})".format(args.resume, checkpoint['epoch']))
if args.ft:
args.start_epoch = 0
def __init__(self, args):
kwargs = {'num_workers': 4, 'pin_memory': True}
self.source_loader, self.target_loader, self.test_loader, self.nclass = make_data_loader(
args, **kwargs)
self.tbar = tqdm(self.test_loader, desc='\r')
self.trainer = adda_trainer(args, 2)
self.evaluator = Evaluator(2)
self.best_IoU = {'disc': 0.77, 'cup': 0.65}
self.attempt = 3
self.validation(args, self.trainer.target_model, self.tbar)
self.trainer_dda(args)
def __init__(self, args):
self.args = args
# Define Saver
self.saver = Saver(args)
self.saver.save_experiment_config()
# Define Tensorboard Summary
self.summary = TensorboardSummary(self.saver.experiment_dir)
self.writer = self.summary.create_summary()
# PATH = args.path
# Define Dataloader
kwargs = {'num_workers': args.workers, 'pin_memory': True}
self.train_loader, self.val_loader, self.test_loader, self.nclass = make_data_loader(args, **kwargs)
# Define network
model = SCNN(nclass=self.nclass,backbone=args.backbone,output_stride=args.out_stride,cuda = args.cuda)
# Define Optimizer
optimizer = torch.optim.SGD(model.parameters(),args.lr, momentum=args.momentum,
weight_decay=args.weight_decay, nesterov=args.nesterov)
# Define Criterion
weight = None
self.criterion = SegmentationLosses(weight=weight, cuda=args.cuda).build_loss(mode=args.loss_type)
self.model, self.optimizer = model, optimizer
# Define Evaluator
self.evaluator = Evaluator(self.nclass)
# Define lr scheduler
self.scheduler = LR_Scheduler(args.lr_scheduler, args.lr,
args.epochs, len(self.train_loader))
# Using cuda
if args.cuda:
self.model = torch.nn.DataParallel(self.model, device_ids=self.args.gpu_ids)
# patch_replication_callback(self.model)
self.model = self.model.cuda()
# Resuming checkpoint
self.best_pred = 0.0
if args.resume is not None:
if not os.path.isfile(args.resume):
raise RuntimeError("=> no checkpoint found at '{}'" .format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
if args.cuda:
self.model.module.load_state_dict(checkpoint['state_dict'])
else:
self.model.load_state_dict(checkpoint['state_dict'])
if not args.ft:
self.optimizer.load_state_dict(checkpoint['optimizer'])
self.best_pred = checkpoint['best_pred']
print("=> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
def create_dataloader(opt, path, imgsz, stride, hyp=None, pad=0.0, prefix='',
void_classes=[], valid_classes=[], cache=False, rect=False, rank=-1):
cfg = get_cfg_defaults()
cfg.merge_from_file('../dataloaders/configs/sunrgbd.yaml')
cfg.merge_from_list(['DATASET.ANNOTATION_TYPE', 'bbox',
'DATASET.NO_TRANSFORMS', True,
'TRAIN.BATCH_SIZE', 1])
train_loader, val_loader, test_loader, num_class = make_data_loader(cfg)
dataloader = train_loader
return dataloader, dataloader.dataset
def __init__(self, args):
self.args = args
self.path = Path()
# Saver
self.saver = Saver(args, self.path.event) # Define Saver
# Define Dataloader
kwargs = {'num_workers': args.workers, 'pin_memory': True}
self.train_loader, self.val_loader = make_data_loader(args, **kwargs)
# Define network
self.model = mymodels.resnet152(pretrained=True)
# self.model = mymodels.resnet50(pretrained=True)
# if args.pretrained:
# self.model = mymodels.resnet101(pretrained=True)
# else:
# self.model = mymodels.resnet101()
# Binary classification
num_ftrs = self.model.fc.in_features
self.model.fc = nn.Linear(num_ftrs, 2) # len(class_names) = 2
del self.model.maxpool
# Resuming checkpoint
if args.resume is not None: # path to resuming file
if not os.path.isfile(args.resume):
raise RuntimeError("=> no checkpoint found at '{}'".format(
args.resume))
state_dict = torch.load(args.resume)
print('=>load pre-trained model from')
print(args.resume)
best_acc = state_dict['best_acc'] # accuracy
print('=>model top 1 accuracy: %0.3f' % best_acc)
self.model.load_state_dict(state_dict['state_dict'])
# Using cuda
if args.cuda:
self.model = self.model.cuda()
# define loss function (criterion) and optimizer
self.criterion = nn.CrossEntropyLoss().cuda() #交叉熵损失函数
self.optimizer = torch.optim.SGD(self.model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
# Define lr scheduler
self.scheduler = lr_scheduler.StepLR(self.optimizer,
step_size=10,
gamma=0.1)
# Record
self.best_acc = 0.0
def test_model(cfg, report_file, confusion_file=None):
torch.manual_seed(cfg.SYSTEM.SEED)
train_loader, val_loader, test_loader, num_classes = make_data_loader(cfg)
tester = Tester(cfg)
output, mat, metrics = tester.run(val_loader, num_classes)
with open(report_file, 'w') as f:
f.write(output)
if confusion_file is not None:
sio.savemat(confusion_file, {'confusion': mat})
return metrics
def __init__(self,args):
warnings.filterwarnings('ignore')
assert torch.cuda.is_available()
torch.backends.cudnn.benchmark = True
model_fname = 'data/deeplab_{0}_{1}_v3_{2}_epoch%d.pth'.format(args.backbone, args.dataset, args.exp)
if args.dataset == 'pascal':
raise NotImplementedError
elif args.dataset == 'cityscapes':
kwargs = {'num_workers': args.workers, 'pin_memory': True, 'drop_last': True}
dataset_loader, num_classes = dataloaders.make_data_loader(args, **kwargs)
args.num_classes = num_classes
elif args.dataset == 'marsh' :
kwargs = {'num_workers': args.workers, 'pin_memory': True, 'drop_last': True}
dataset_loader,val_loader, test_loader, num_classes = dataloaders.make_data_loader(args, **kwargs)
args.num_classes = num_classes
else:
raise ValueError('Unknown dataset: {}'.format(args.dataset))
if args.backbone == 'autodeeplab':
model = Retrain_Autodeeplab(args)
model.load_state_dict(torch.load(r"./run/marsh/deeplab-autodeeplab/model_best.pth.tar")['state_dict'], strict=False)
else:
raise ValueError('Unknown backbone: {}'.format(args.backbone))
def __init__(self, args):
self.args = args
# Define Saver
self.saver = Saver(args)
self.saver.save_experiment_config()
# Define Tensorboard Summary
self.summary = TensorboardSummary(self.saver.experiment_dir)
self.writer = self.summary.create_summary()
# Define Dataloader
kwargs = {'num_workers': args.workers, 'pin_memory': True}
self.train_loader, self.val_loader, self.test_loader, self.nclass = make_data_loader(
args, **kwargs)
# Define network
self.model = DeepLab(num_classes=self.nclass,
backbone=args.backbone,
output_stride=args.out_stride,
sync_bn=args.sync_bn,
freeze_bn=args.freeze_bn)
# Using cuda
if args.cuda:
self.model = torch.nn.DataParallel(self.model,
device_ids=self.args.gpu_ids)
patch_replication_callback(self.model)
self.model = self.model.cuda()
# Resuming checkpoint
self.best_pred = 0.0
if args.resume is not None:
if not os.path.isfile(args.resume):
raise RuntimeError("=> no checkpoint found at '{}'".format(
args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
if args.cuda:
self.model.module.load_state_dict(checkpoint['state_dict'])
else:
self.model.load_state_dict(checkpoint['state_dict'])
if not args.ft:
self.optimizer.load_state_dict(checkpoint['optimizer'])
self.best_pred = checkpoint['best_pred']
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
# Clear start epoch if fine-tuning
if args.ft:
args.start_epoch = 0
def __init__(self, args):
self.args = args
# Define Dataloader
kwargs = {'num_workers': args.workers, 'pin_memory': True}
self.train_loader, self.val_loader, self.test_loader, self.nclass = make_data_loader(args, **kwargs)
# # Define network
model = DeepLab(num_classes=self.nclass,
backbone=args.backbone)
# model = DeepLab(num_classes=self.nclass,
# backbone=args.backbone,
# output_stride=args.out_stride,
# sync_bn=args.sync_bn,
# freeze_bn=args.freeze_bn)
self.model = model
# Define Evaluator
self.evaluator = Evaluator(self.nclass)
# Using cuda
if args.cuda:
self.model = torch.nn.DataParallel(self.model, device_ids=self.args.gpu_ids)
patch_replication_callback(self.model)
self.model = self.model.cuda()
# Resuming checkpoint
self.best_pred = 0.0
if args.resume is not None:
if not os.path.isfile(args.resume):
raise RuntimeError("=> no checkpoint found at '{}'" .format(args.resume))
if args.cuda:
checkpoint = torch.load(args.resume)
else:
checkpoint = torch.load(args.resume, map_location='cpu')
args.start_epoch = checkpoint['epoch']
if args.cuda:
self.model.module.load_state_dict(checkpoint['state_dict'])
else:
self.model.load_state_dict(checkpoint['state_dict'])
# if not args.ft:
# self.optimizer.load_state_dict(checkpoint['optimizer'])
self.best_pred = checkpoint['best_pred']
print("=> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
def __init__(self, args):
if not os.path.isfile(args.model):
raise RuntimeError("no checkpoint found at '{}'".fromat(args.model))
self.args = args
self.color_map = get_pascal_labels()
self.test_loader, self.ids, self.nclass = make_data_loader(args)
#Define model
model = DeepLab(num_classes=self.nclass,
backbone=args.backbone,
output_stride=args.out_stride,
sync_bn=False,
freeze_bn=False)
self.model = model
device = torch.device('cpu')
checkpoint = torch.load(args.model, map_location=device)
self.model.load_state_dict(checkpoint['state_dict'])
self.evaluator = Evaluator(self.nclass)
def __init__(self, args):
self.args = args
path = Path()
# image to patch
n_patch = int(16*12) #192
eval_per = int(n_patch/args.batch_size) #
# path
self.event_dir = path.event
self.model_dir = os.path.join(self.event_dir, 'run', 'checkpoint.pth.tar')
test_list = args.test_list
with open(test_list) as f:
self.lines = f.readlines()
# range
self.ids = [i.split(' ')[0] for i in self.lines]
self.mins = [float(i.split(' ')[1]) for i in self.lines]
self.maxs = [float(i.split(' ')[2]) for i in self.lines]
# Define Dataloader
kwargs = {'num_workers': args.workers, 'pin_memory': True}
self.test_loader = make_data_loader(args, **kwargs)
# Define network
self.model = mymodels.resnet152()
# Binary classification
num_ftrs = self.model.fc.in_features
self.model.fc = nn.Linear(num_ftrs, 2) # len(class_names) = 2
del self.model.maxpool
# Resuming checkpoint
state_dict = torch.load(self.model_dir)
print('=>load pre-trained model')
best_acc = state_dict['best_acc'] # accuracy
print('=>model accuracy: %0.3f' % best_acc)
self.model.load_state_dict(state_dict['state_dict'])
# Using cuda
if args.cuda:
self.model = self.model.cuda()
def test(args):
kwargs = {'num_workers': 1, 'pin_memory': True}
train_loader, val_loader, test_loader, nclass = make_data_loader(args, **kwargs)
model = DeepLab(num_classes=nclass,
backbone=args.backbone,
output_stride=args.out_stride,
sync_bn=False)
model.load_state_dict(torch.load(args.pretrained, map_location=device)['state_dict'])
model.eval()
tbar = tqdm(test_loader) ## train test dev
for i, sample in enumerate(tbar):
image, target = sample['image'], sample['label']
# original_image = image
if args.use_mixup:
image, targets_a, targets_b, lam = mixup_data(image, target,
args.mixup_alpha, use_cuda=False)
# mixed_image = image
# image = norm(image.permute(0,2,3,1)).permute(0,3,1,2)
output = model(image)
def __init__(self, cfg):
self.cfg = cfg
# Define Dataloader
kwargs = {
'num_workers': self.cfg.SYSTEM.NUM_WORKERS,
'pin_memory': True
}
# Define Model and Load from File
self.model = load_model(cfg)
# Define Criterion
# whether to use class balanced weights
if self.cfg.TRAIN.USE_BALANCED_WEIGHTS:
classes_weights_path = os.path.join(
cfg.DATASET.ROOT, cfg.DATASET.NAME + '_classes_weights.npy')
if os.path.isfile(classes_weights_path):
weight = np.load(classes_weights_path)
else:
train_loader = make_data_loader(cfg, **kwargs)[0]
weight = calculate_weights_labels(cfg.DATASET.ROOT,
cfg.DATASET.NAME,
train_loader,
cfg.DATASET.N_CLASSES)
weight = torch.from_numpy(weight.astype(np.float32))
else:
weight = None
self.criterion = SegmentationLosses(
weight=weight, cuda=self.cfg.SYSTEM.CUDA).build_loss(
mode=self.cfg.MODEL.LOSS_TYPE)
# Using cuda
if self.cfg.SYSTEM.CUDA:
print("Using CUDA")
self.model = torch.nn.DataParallel(
self.model, device_ids=self.cfg.SYSTEM.GPU_IDS)
patch_replication_callback(self.model)
self.model = self.model.cuda()
self.evaluator = SegmentationEvaluator(cfg.DATASET.N_CLASSES)
self.img_evaluator = ImageSegmentationEvaluator(cfg.DATASET.N_CLASSES)
def test(args):
kwargs = {'num_workers': 1, 'pin_memory': True}
_, val_loader, _, nclass = make_data_loader(args, **kwargs)
checkpoint = torch.load(args.ckpt)
if checkpoint is None:
raise ValueError
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
model = DeepLab(num_classes=nclass,
backbone='resnet',
output_stride=16,
sync_bn=True,
freeze_bn=False)
model.load_state_dict(checkpoint['state_dict'])
model.eval()
model.to(device)
torch.set_grad_enabled(False)
tbar = tqdm(val_loader)
num_img_tr = len(val_loader)
for i, sample in enumerate(tbar):
x1, x2, y1, y2 = [
int(item) for item in sample['img_meta']['bbox_coord']
] # bbox coord
w, h = x2 - x1, y2 - y1
img = sample['img_meta']['image'].squeeze().cpu().numpy()
img_w, img_h = img.shape[:2]
inputs = sample['image'].cuda()
output = model(inputs).squeeze().cpu().numpy()
pred = np.argmax(output, axis=0)
result = decode_segmap(pred, dataset=args.dataset, plot=False)
result = imresize(result, (w, h))
result_padding = np.zeros(img.shape, dtype=np.uint8)
result_padding[y1:y2, x1:x2] = result
result = img // 2 + result_padding * 127
result[result > 255] = 255
plt.imsave(
os.path.join('run', args.dataset, 'deeplab-resnet', 'output',
str(i)), result)
def main(cfg):
datasets = make_data_loader(cfg)
for dataset in datasets[:3]:
img_list = []
if dataset is not None:
for ii, sample in enumerate(tqdm(dataset)):
for jj in range(len(sample["id"])):
if cfg.DATASET.NAME == 'cityscapes':
filepath = sample['id'][jj].replace(
'leftImg8bit',
'normalized_depth').replace('png', 'txt')
img_list.append(sample['id'][jj])
elif cfg.DATASET.NAME in ['sunrgbd', 'coco']:
id = dataset.dataset.coco_id_index[sample['id']
[jj].item()]
img_path, depth_path, img_id = dataset.dataset.get_path(
id)
assert img_id == sample['id'][jj].item()
filepath = 'normalized_depth'.join(
img_path.rsplit('image', 1))
filepath = os.path.splitext(filepath)[0] + '.jpg'
img_list.append(
dataset.dataset.coco.loadImgs(img_id)[0]
['file_name'])
dir = os.path.dirname(filepath)
if not os.path.exists(dir):
os.makedirs(dir)
#if not os.path.exists(filepath):
depth = ((sample['depth'][jj].numpy() + 1) * 125)
depth[depth < 0] = 0
depth[depth > 255] = 255
depth_img = Image.fromarray(depth.astype(np.uint8))
with open(filepath, 'wb') as fp:
depth_img.save(fp)
f = '{}/image_list_{}.txt'.format(cfg.DATASET.ROOT,
dataset.dataset.split)
with open(f, 'w') as fp:
fp.write('\n'.join(img_list))
def test(model_path):
args = makeargs()
kwargs = {'num_workers': args.workers, 'pin_memory': True}
train_loader, val_loader, test_loader, nclass = make_data_loader(args, **kwargs)
print('Loading model...')
model = DeepLab(num_classes=8, backbone='drn', output_stride=args.output_stride,
sync_bn=args.sync_bn, freeze_bn=args.freeze_bn)
model.eval()
checkpoint = torch.load(model_path)
model = model.cuda()
model.load_state_dict(checkpoint['state_dict'])
print('Done')
criterion = SegmentationLosses(weight=None, cuda=args.cuda).build_loss(mode=args.loss_type)
evaluator = Evaluator(nclass)
evaluator.reset()
print('Model infering')
test_dir = 'test_example1'
test_loss = 0.0
tbar = tqdm(test_loader, desc='\r')
for i, sample in enumerate(tbar):
image, target = sample['image'], sample['label']
image, target = image.cuda(), target.cuda()
with torch.no_grad(): #
output = model(image)
loss = criterion(output, target)
test_loss += loss.item()
tbar.set_description('Test loss: %.3f' % (test_loss / (i + 1)))
pred = output.data.cpu().numpy()
target = target.cpu().numpy()
pred = np.argmax(pred, axis=1)
evaluator.add_batch(target, pred)
print(image.shape)
Acc = evaluator.Pixel_Accuracy()
mIoU = evaluator.Mean_Intersection_over_Union()
print('testing:')
print("Acc:{}, mIoU:{},".format(Acc, mIoU))
print('Loss: %.3f' % test_loss)
def __init__(self):
self.backbone = 'resnet34'
self.lr = 1e-4
self.batch = 64
self.crop_size = 384
logger = logging.getLogger('train')
# print settings
logger.info('\nTRAINING SETTINGS')
logger.info('###########################')
logger.info(datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
logger.info('backbone:{}, lr:{}, batch:{}, crop size:{}'.format(self.backbone, self.lr, self.batch, self.crop_size))
logger.info('###########################\n')
# model define
self.train_loader, self.test_loader = make_data_loader(batch=self.batch, crop_size=self.crop_size)
model = smp.PAN(encoder_name=self.backbone, encoder_weights='imagenet', in_channels=3, classes=2)
self.model = nn.DataParallel(model.cuda())
self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.lr)
self.criterion = nn.CrossEntropyLoss()
self.epoch = 0
def initialize_model(self, args):
self.args = args
# Define Saver
self.saver = Saver(self.args)
self.saver.save_experiment_config()
# Define Tensorboard Summary
self.summary = TensorboardSummary(self.saver.experiment_dir)
self.writer = self.summary.create_summary()
# Define Dataloader
kwargs = {'num_worker': self.args.worker, 'pin_memory': True}
self.train_loader, self.val_loader, self.test_loader, self.nclass = make_data_loader(
self.args, **kwargs)
# Define network
model = DeepLab(num_classes=self.nclass,
backbone=self.args.backbone,
output_stride=self.args.out_stride,
sync_bn=self.args.sync_bn,
freeze_bn=self.args.freeze_bn)
# Define Evaluator
self.evaluator = Evaluator(self.nclass)
# Using cuda
if self.args.cuda:
self.model = torch.nn.DataParallel(self.model,
device_ids=self.args.gpu_ids)
patch_replication_callback(self.model)
self.model = self.model.cuda()
if not os.path.isfile(self.args.resume):
raise RuntimeError("=> no checkpoint found at '{}'".format(
self.args.resume))
checkpoint = torch.load(self.args.resume)
self.args.start_epoch = checkpoint['epoch']
if self.args.cuda:
self.model.module.load_state_dict(checkpoint['state_dict'])
else:
self.model.load_state_dict(checkpoint['state_dict'])
self.model.eval()
self.evaluator.reset()
def test():
# ---- create model ---------- ---------- ---------- ---------- ----------#
net = make_model(args.model, num_classes=12).cuda()
net = torch.nn.DataParallel(net) # Multi-GPU
# ---- load pretrained model --------- ---------- ----------#
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
cp_states = torch.load(args.resume)
net.load_state_dict(cp_states['state_dict'], strict=True)
else:
raise Exception("=> NO checkpoint found at '{}'".format(args.resume))
# ---- Data loader
train_loader, val_loader = make_data_loader(args)
torch.cuda.empty_cache()
# ---- Evaluation
v_prec, v_recall, v_iou, v_acc, v_ssc_iou, v_mean_iou = validate_on_dataset_stsdf(net, val_loader)
print('Validate with TSDF:, p {:.1f}, r {:.1f}, IoU {:.1f}'.format(v_prec*100.0, v_recall*100.0, v_iou*100.0))
print('pixel-acc {:.4f}, mean IoU {:.1f}, SSC IoU:{}'.format(v_acc*100.0, v_mean_iou*100.0, v_ssc_iou*100.0))
def main(cfg):
datasets = make_data_loader(cfg)
for dataset in datasets[:3]:
img_list = []
if dataset is not None:
for ii, sample in enumerate(tqdm(dataset)):
for jj in range(len(sample["id"])):
if cfg.DATASET.NAME == 'cityscapes':
filepath = sample['id'][jj].replace(
'leftImg8bit', 'bbox').replace('png', 'txt')
img_list.append(sample['id'][jj])
elif cfg.DATASET.NAME in ['sunrgbd', 'coco']:
id = dataset.dataset.coco_id_index[sample['id']
[jj].item()]
img_path, depth_path, img_id = dataset.dataset.get_path(
id)
assert img_id == sample['id'][jj].item()
filepath = 'bbox'.join(img_path.rsplit('image', 1))
filepath = os.path.splitext(filepath)[0] + '.txt'
img_list.append(
dataset.dataset.coco.loadImgs(img_id)[0]
['file_name'])
dir = os.path.dirname(filepath)
if not os.path.exists(dir):
os.makedirs(dir)
#if not os.path.exists(filepath):
np.savetxt(
filepath,
sample['label'][jj],
delimiter=",",
fmt=['%d', '%10.8f', '%10.8f', '%10.8f', '%10.8f'])
f = '{}/image_list_{}.txt'.format(cfg.DATASET.ROOT,
dataset.dataset.split)
with open(f, 'w') as fp:
fp.write('\n'.join(img_list))
def __init__(self, args):
self.args = args
# Define network
model = DeepLab(num_classes=args.num_classes,
backbone=args.backbone,
output_stride=args.out_stride,
sync_bn=args.sync_bn,
freeze_bn=args.freeze_bn)
self.model = model
kwargs = {'num_workers': args.workers, 'pin_memory': True}
_, self.valid_loader = make_data_loader(args, **kwargs)
self.pred_remap = args.pred_remap
self.gt_remap = args.gt_remap
# Define Evaluator
self.evaluator = Evaluator(args.eval_num_classes)
# Using cuda
if args.cuda:
self.model = torch.nn.DataParallel(self.model, device_ids=self.args.gpu_ids)
patch_replication_callback(self.model)
self.model = self.model.cuda()
# Resuming checkpoint
if args.resume is not None:
if not os.path.isfile(args.resume):
raise RuntimeError("=> no checkpoint found at '{}'" .format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
if args.cuda:
self.model.module.load_state_dict(checkpoint['state_dict'])
else:
self.model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
def __init__(self, hparams):
super().__init__()
self.hparams = hparams
kwargs = {'num_workers': hparams.workers, 'pin_memory': True}
self.train_loader, self.val_loader, self.test_loader, self.nclass = make_data_loader(
hparams, **kwargs)
self.num_img_tr = len(self.train_loader)
self.pretrained_net = get_efficientunet_b4(out_channels=self.nclass,
concat_input=True,
pretrained=True)
if hparams.use_balanced_weights:
parameters_dir = "/work/scratch/lei/MyProject/t_chucai/models_and_parameters/parameters/classes_weights"
classes_weights_path = os.path.join(
parameters_dir, hparams.dataset + '_classes_weights.npy')
if os.path.isfile(classes_weights_path):
weight = np.load(classes_weights_path)
else:
weight = calculate_weigths_labels(hparams.dataset,
self.train_loader,
self.nclass)
self.weight = torch.from_numpy(weight.astype(np.float32))
else:
self.weight = None
self.evaluator = Evaluator(self.nclass)
def __init__(self, args):
self.args = args
# Define Saver
self.saver = Saver(args)
self.saver.save_experiment_config()
# Define Tensorboard Summary
self.summary = TensorboardSummary(self.saver.experiment_dir)
self.writer = self.summary.create_summary()
# Define Dataloader
kwargs = {'num_workers': args.workers, 'pin_memory': True}
self.train_loader, self.val_loader, self.test_loader, self.nclass = make_data_loader(args, **kwargs)
# Define network
model = DeepLab(num_classes=self.nclass,
backbone=args.backbone,
output_stride=args.out_stride,
sync_bn=args.sync_bn,
freeze_bn=args.freeze_bn)
train_params = [{'params': model.get_1x_lr_params(), 'lr': args.lr},
{'params': model.get_10x_lr_params(), 'lr': args.lr * 10}]
# Define Optimizer
optimizer = torch.optim.SGD(train_params, momentum=args.momentum,
weight_decay=args.weight_decay, nesterov=args.nesterov)
# Define Criterion
# whether to use class balanced weights
if args.use_balanced_weights:
classes_weights_path = os.path.join(Path.db_root_dir(args.dataset), args.dataset+'_classes_weights.npy')
if os.path.isfile(classes_weights_path):
weight = np.load(classes_weights_path)
else:
weight = calculate_weigths_labels(args.dataset, self.train_loader, self.nclass)
weight = torch.from_numpy(weight.astype(np.float32))
else:
weight = None
self.criterion = SegmentationLosses(weight=weight, cuda=args.cuda).build_loss(mode=args.loss_type)
self.model, self.optimizer = model, optimizer
# Define Evaluator
self.evaluator = Evaluator(self.nclass)
# Define lr scheduler
self.scheduler = LR_Scheduler(args.lr_scheduler, args.lr,
args.epochs, len(self.train_loader))
# Using cuda
if args.cuda:
self.model = torch.nn.DataParallel(self.model, device_ids=self.args.gpu_ids)
patch_replication_callback(self.model)
self.model = self.model.cuda()
# Resuming checkpoint
self.best_pred = 0.0
if args.resume is not None:
if not os.path.isfile(args.resume):
raise RuntimeError("=> no checkpoint found at '{}'" .format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
if args.cuda:
self.model.module.load_state_dict(checkpoint['state_dict'])
else:
self.model.load_state_dict(checkpoint['state_dict'])
if not args.ft:
self.optimizer.load_state_dict(checkpoint['optimizer'])
self.best_pred = checkpoint['best_pred']
print("=> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
# Clear start epoch if fine-tuning
if args.ft:
args.start_epoch = 0
