def __init__(self, args, root=Path.db_root_dir('cityscapes'), split="train"):
self.root = root
self.split = split
self.args = args
self.files = {}
self.images_base = os.path.join(self.root, 'leftImg8bit', self.split)
self.annotations_base = os.path.join(self.root, 'gtFine_trainvaltest', 'gtFine', self.split)
self.files[split] = self.recursive_glob(rootdir=self.images_base, suffix='.png')
self.void_classes = [0, 1, 2, 3, 4, 5, 6, 9, 10, 14, 15, 16, 18, 29, 30, -1]
self.valid_classes = [7, 8, 11, 12, 13, 17, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 31, 32, 33]
self.class_names = ['unlabelled', 'road', 'sidewalk', 'building', 'wall', 'fence', \
'pole', 'traffic_light', 'traffic_sign', 'vegetation', 'terrain', \
'sky', 'person', 'rider', 'car', 'truck', 'bus', 'train', \
'motorcycle', 'bicycle']
self.ignore_index = 255
self.class_map = dict(zip(self.valid_classes, range(self.NUM_CLASSES)))
if not self.files[split]:
raise Exception("No files for split=[%s] found in %s" % (split, self.images_base))
print("Found %d %s images" % (len(self.files[split]), split))
def __init__(self,
base_dir=Path.db_root_dir('sbd'),
split='train',
transform=None
):
"""
:param base_dir: path to VOC dataset directory
:param split: train/val
:param transform: transform to apply
"""
super().__init__()
self._base_dir = base_dir
self._dataset_dir = os.path.join(self._base_dir, 'dataset')
self._image_dir = os.path.join(self._dataset_dir, 'img')
self._cat_dir = os.path.join(self._dataset_dir, 'cls')
if isinstance(split, str):
self.split = [split]
else:
split.sort()
self.split = split
self.transform = transform
# Get list of all images from the split and check that the files exist
self.im_ids = []
self.images = []
self.categories = []
for splt in self.split:
with open(os.path.join(self._dataset_dir, splt + '.txt'), "r") as f:
lines = f.read().splitlines()
for line in lines:
_image = os.path.join(self._image_dir, line + ".jpg")
_categ= os.path.join(self._cat_dir, line + ".mat")
assert os.path.isfile(_image)
assert os.path.isfile(_categ)
self.im_ids.append(line)
self.images.append(_image)
self.categories.append(_categ)
assert (len(self.images) == len(self.categories))
# Display stats
print('Number of images: {:d}'.format(len(self.images)))
def __init__(self, dataset='ucf101', split='train', clip_len=16, transforms=None):
self.root_dir, split_dir, self.bbox_dir = Path.db_dir(dataset)
# self.root_dir, self.output_dir, self.bbox_output_dir = root_dir, output_dir, \
# bbox_output_dir
self.fnames, self.labels = self.make_dataset_sth(split_dir, split)
self.transforms = transforms
#folder = os.path.join(self.output_dir, split)
#bbox_folder = self.bbox_output_dir
self.clip_len = clip_len
self.split = split
# The following three parameters are chosen as described in the paper section 4.1
self.resize_height = 256
self.resize_width = 256
self.crop_size = 256
self.graph = _graphFront()
def __init__(self,
base_dir=Path.db_root_dir('pascal'),
split='train',
transform=None
):
"""
:param base_dir: path to VOC dataset directory
:param split: train/val
:param transform: transform to apply
"""
super().__init__()
self._base_dir = base_dir
self._image_dir = os.path.join(self._base_dir, 'JPEGImages')
self._cat_dir = os.path.join(self._base_dir, 'SegmentationClass')
if isinstance(split, str):
self.split = [split]
else:
split.sort()
self.split = split
self.transform = transform
_splits_dir = os.path.join(self._base_dir, 'ImageSets', 'Segmentation')
self.im_ids = []
self.images = []
self.categories = []
for splt in self.split:
with open(os.path.join(os.path.join(_splits_dir, splt + '.txt')), "r") as f:
lines = f.read().splitlines()
for ii, line in enumerate(lines):
_image = os.path.join(self._image_dir, line + ".jpg")
_cat = os.path.join(self._cat_dir, line + ".png")
assert os.path.isfile(_image)
assert os.path.isfile(_cat)
self.im_ids.append(line)
self.images.append(_image)
self.categories.append(_cat)
assert (len(self.images) == len(self.categories))
# Display stats
print('Number of images in {}: {:d}'.format(split, len(self.images)))
def __init__(self,
args,
base_dir=Path.db_root_dir('coco'),
split='train',
year='2017'):
super().__init__()
ann_file = os.path.join(base_dir, 'annotations/instances_{}{}.json'.format(split, year))
ids_file = os.path.join(base_dir, 'annotations/{}_ids_{}.pth'.format(split, year))
self.img_dir = os.path.join(base_dir, 'images/{}{}'.format(split, year))
self.split = split
self.coco = COCO(ann_file)
self.coco_mask = mask
if os.path.exists(ids_file):
self.ids = torch.load(ids_file)
else:
ids = list(self.coco.imgs.keys())
self.ids = self._preprocess(ids, ids_file)
self.args = args
def __load_pretrained_weights(self):
"""Initialiaze network."""
corresp_name = {
# Conv1
"features.0.weight": "conv1.weight",
"features.0.bias": "conv1.bias",
# Conv2
"features.3.weight": "conv2.weight",
"features.3.bias": "conv2.bias",
# Conv3a
"features.6.weight": "conv3a.weight",
"features.6.bias": "conv3a.bias",
# Conv3b
"features.8.weight": "conv3b.weight",
"features.8.bias": "conv3b.bias",
# Conv4a
"features.11.weight": "conv4a.weight",
"features.11.bias": "conv4a.bias",
# Conv4b
"features.13.weight": "conv4b.weight",
"features.13.bias": "conv4b.bias",
# Conv5a
"features.16.weight": "conv5a.weight",
"features.16.bias": "conv5a.bias",
# Conv5b
"features.18.weight": "conv5b.weight",
"features.18.bias": "conv5b.bias",
# fc6
"classifier.0.weight": "fc6.weight",
"classifier.0.bias": "fc6.bias",
# fc7
"classifier.3.weight": "fc7.weight",
"classifier.3.bias": "fc7.bias",
}
p_dict = torch.load(Path.model_dir())
s_dict = self.state_dict()
for name in p_dict:
if name not in corresp_name:
continue
s_dict[corresp_name[name]] = p_dict[name]
self.load_state_dict(s_dict)
def __init__(self, dataset='volleyball', split='train', clip_len=16, preprocess=False):
# self.root_dir, self.output_dir, self.bbox_output_dir = root_dir, output_dir, bbox_output_dir
self.root_dir, self.bbox_output_dir = Path.db_dir(dataset)
# dic ={'train': '1 3 6 7 10 13 15 16 18 22 23 31 32 36 38 39 40 41 42 48 50 52 53 54', \
dic ={'train': '38 39 40 41 42 48 50 52 53 54', \
'val': '0 2 8 12 17 19 24 26 27 28 30 33 46 49 51', \
'test': '4 5 9 11 14 20 21 25 29 34 35 37 43 44 45 47'}
label_index = {'r_set': 0, 'r_spike': 1, 'r-pass': 2, 'r_winpoint': 3, 'l_winpoint': 4, \
'l-pass': 5, 'l-spike': 6, 'l_set': 7}
video_index = dic[split].split(' ')
self.clip_len = clip_len
self.split = split
# The following three parameters are chosen as described in the paper section 4.1
self.resize_height = 128#256#112#780
self.resize_width = 192#384#112#1280
self.fnames, self.labels, self.bboxes = self.make_dataset_sth(video_index, label_index)
self.graph = _graphFront()
def calculate_weigths_labels(dataset, dataloader, num_classes):
# Create an instance from the data loader
z = np.zeros((num_classes,))
# Initialize tqdm
tqdm_batch = tqdm(dataloader)
print('Calculating classes weights')
for sample in tqdm_batch:
y = sample['label']
y = y.detach().cpu().numpy()
mask = (y >= 0) & (y < num_classes)
labels = y[mask].astype(np.uint8)
count_l = np.bincount(labels, minlength=num_classes)
z += count_l
tqdm_batch.close()
total_frequency = np.sum(z)
class_weights = []
for frequency in z:
class_weight = 1 / (np.log(1.02 + (frequency / total_frequency)))
class_weights.append(class_weight)
ret = np.array(class_weights)
classes_weights_path = os.path.join(Path.db_root_dir(dataset), dataset+'_classes_weights.npy')
np.save(classes_weights_path, ret)
return ret
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
def __init__(self,
root=Path.db_root_dir('pascal'),
split='val',
transform=None,
download=False,
preprocess=False,
area_thres=500,
retname=True,
suppress_void_pixels=True,
default=False,
which_part='whole'):
self.root = root
_voc_root = os.path.join(self.root, self.BASE_DIR)
_mask_dir = os.path.join(_voc_root, 'SegmentationObject')
_cat_dir = os.path.join(_voc_root, 'SegmentationClass')
_image_dir = os.path.join(_voc_root, 'JPEGImages')
self.transform = transform
if isinstance(split, str):
self.split = [split]
else:
split.sort()
self.split = split
self.area_thres = area_thres
self.retname = retname
self.suppress_void_pixels = suppress_void_pixels
self.default = default
# Build the ids file
self.area_th_str = ""
if self.area_thres != 0:
self.area_th_str = '_area_thres-' + str(area_thres)
self.obj_list_file = os.path.join(
self.root, self.BASE_DIR, 'ImageSets', 'Segmentation',
'_'.join(self.split) + '_instances' + self.area_th_str + '.txt')
if download:
self._download()
# if not self._check_integrity():
# raise RuntimeError('Dataset not found or corrupted.' +
# ' You can use download=True to download it')
# train/val/test splits are pre-cut
_splits_dir = os.path.join(_voc_root, 'ImageSets', 'Segmentation')
self.im_ids = []
self.images = []
self.categories = []
self.masks = []
for splt in self.split:
with open(os.path.join(os.path.join(_splits_dir, splt + '.txt')),
"r") as f:
lines = f.read().splitlines()
for ii, line in enumerate(lines):
_image = os.path.join(_image_dir, line + ".jpg")
_cat = os.path.join(_cat_dir, line + ".png")
_mask = os.path.join(_mask_dir, line + ".png")
assert os.path.isfile(_image)
assert os.path.isfile(_cat)
assert os.path.isfile(_mask)
self.im_ids.append(line.rstrip('\n'))
self.images.append(_image)
self.categories.append(_cat)
self.masks.append(_mask)
assert (len(self.images) == len(self.masks))
assert (len(self.images) == len(self.categories))
# Precompute the list of objects and their categories for each image
if (not self._check_preprocess()) or preprocess:
print(
'Preprocessing of PASCAL VOC dataset, this will take long, but it will be done only once.'
)
self._preprocess()
# Build the list of objects
self.obj_list = []
num_images = 0
for ii in range(len(self.im_ids)):
flag = False
for jj in range(len(self.obj_dict[self.im_ids[ii]])):
if self.obj_dict[self.im_ids[ii]][jj] != -1:
self.obj_list.append([ii, jj])
flag = True
if flag:
num_images += 1
self.sbox_train = self.obj_list[::2]
self.click_train = self.obj_list[1::2]
if split == 'train':
if which_part == 'sbox':
self.target_list = self.sbox_train
elif which_part == 'click':
self.target_list = self.click_train
elif which_part == 'whole':
self.target_list = self.obj_list
else:
raise NotImplementedError
else:
self.target_list = self.obj_list
# Display stats
print('Number of images: {:d}\nNumber of objects: {:d}'.format(
num_images, len(self.target_list)))
import networks.deeplab_resnet as resnet
from mypath import Path
from dataloaders import helpers as helpers
modelName = 'dextr_pascal-sbd'
pad = 50
thres = 0.8
gpu_id = 0
device = torch.device("cuda:" +
str(gpu_id) if torch.cuda.is_available() else "cpu")
# Create the network and load the weights
net = resnet.resnet101(1, nInputChannels=4, classifier='psp')
print("Initializing weights from: {}".format(
os.path.join(Path.models_dir(), modelName + '.pth')))
state_dict_checkpoint = torch.load(os.path.join(Path.models_dir(),
modelName + '.pth'),
map_location=lambda storage, loc: storage)
# Remove the prefix .module from the model when it is trained using DataParallel
if 'module.' in list(state_dict_checkpoint.keys())[0]:
new_state_dict = OrderedDict()
for k, v in state_dict_checkpoint.items():
name = k[7:] # remove `module.` from multi-gpu training
new_state_dict[name] = v
else:
new_state_dict = state_dict_checkpoint
net.load_state_dict(new_state_dict)
net.eval()
net.to(device)
def __init__(
self,
split='val',
root=Path.db_root_dir('thinobject5k'),
transform=None,
area_thres=0,
retname=True,
use_thin=False):
# setup
self.split = split
self.root = root
self.transform = transform
self.area_thres = area_thres
self.retname = retname
self.use_thin = use_thin
self.imgs_dir = os.path.join(self.root, 'images')
self.gts_dir = os.path.join(self.root, 'masks')
if self.use_thin:
self.thins_dir = os.path.join(Path.db_root_dir('thin_regions'),
'thinobject5k_' + self.split, 'gt_thin')
if self.area_thres != 0:
self.obj_list_file = os.path.join(self.root, self.split +
'_instances_area_thres-' + str(area_thres) + '.pkl')
else:
self.obj_list_file = os.path.join(self.root, self.split +
'_instances.pkl')
with open(os.path.join(self.root, 'list', split + '.txt'), 'r') as f:
lines = f.read().splitlines()
# Get the list of all images
self.im_ids, self.imgs, self.gts, self.thins = [], [], [], []
for _line in lines:
_img = os.path.join(self.imgs_dir, _line[:-4]+'.jpg')
_gt = os.path.join(self.gts_dir, _line)
assert os.path.isfile(_img)
assert os.path.isfile(_gt)
self.im_ids.append(_line)
self.imgs.append(_img)
self.gts.append(_gt)
if self.use_thin:
_thin = os.path.join(self.thins_dir, _line+'-0.png')
assert os.path.isfile(_thin)
self.thins.append(_thin)
assert len(self.imgs) == len(self.gts)
if self.use_thin:
assert len(self.imgs) == len(self.thins)
# Pre-compute the list of objects for each image
if (not self._check_preprocess()):
print('Pre-processing ThinObject-5K dataset, this will take long, but it '
'will be done only once.')
self._preprocess()
# Build the list of objects
self.obj_list = []
num_images = 0
for ii in range(len(self.im_ids)):
if self.im_ids[ii] in self.obj_dict.keys():
for jj in self.obj_dict[self.im_ids[ii]].keys():
if self.obj_dict[self.im_ids[ii]][jj] != -1:
self.obj_list.append([ii, jj])
num_images += 1
# Display dataset statistics
print('ThinObject-5K dataset\n'
'---------------------\n'
'#Images: {:d}\n'
'#Objects: {:d}'.format(num_images, len(self.obj_list)))
if torch.cuda.is_available():
print('Using GPU: {} '.format(gpu_id))
# Network definition
nEpochs = 100 # Number of epochs
resume_epoch = 0 # Default is 0, change if want to resume
# # Setting other parameters
ucf = True
hollywood = False
dhf1k = False
snapshot = 1 # Store a model every snapshot epochs
nAveGrad = 10
save_dir = Path.save_root_dir()
if not os.path.exists(save_dir):
os.makedirs(os.path.join(save_dir))
if ucf:
db_root_dir = './dataloaders/ucf'
inputRes = (180, 320, 3)
elif hollywood:
db_root_dir = './dataloaders/hollywood'
inputRes = (180, 320, 3)
elif dhf1k:
db_root_dir = './dataloaders/dhf1k'
inputRes = (180, 320, 3)
modelName = 'ucf_salar'
resumeModelName = 'ucf_salar'
def __load_pretrained_weights(self):
"""Initialiaze network."""
corresp_name = {
# Conv1
"module.features.0.weight": "res2d.base_model.features.0.weight",
"module.features.0.bias": "res2d.base_model.features.0.bias",
# Conv2
"module.features.2.weight": "res2d.base_model.features.2.weight",
"module.features.2.bias": "res2d.base_model.features.2.bias",
# Conv3a
"module.features.5.weight": "res2d.base_model.features.5.weight",
"module.features.5.bias": "res2d.base_model.features.5.bias",
# Conv3b
"module.features.7.weight": "res2d.base_model.features.7.weight",
"module.features.7.bias": "res2d.base_model.features.7.bias",
# Conv4a
"module.features.10.weight": "res2d.base_model.features.10.weight",
"module.features.10.bias": "res2d.base_model.features.10.bias",
# Conv4b
"module.features.12.weight": "res2d.base_model.features.12.weight",
"module.features.12.bias": "res2d.base_model.features.12.bias",
# Conv5a
"module.features.14.weight": "res2d.base_model.features.14.weight",
"module.features.14.bias": "res2d.base_model.features.14.bias",
# Conv5b
"module.features.16.weight": "res2d.base_model.features.16.weight",
"module.features.16.bias": "res2d.base_model.features.16.bias",
"module.features.19.weight": "res2d.base_model.features.19.weight",
"module.features.19.bias": "res2d.base_model.features.19.bias",
"module.features.21.weight": "res2d.base_model.features.21.weight",
"module.features.21.bias": "res2d.base_model.features.21.bias",
"module.features.23.weight": "res2d.base_model.features.23.weight",
"module.features.23.bias": "res2d.base_model.features.23.bias",
"module.features.25.weight": "res2d.base_model.features.25.weight",
"module.features.25.bias": "res2d.base_model.features.25.bias",
"module.features.28.weight": "res2d.base_model.features.28.weight",
"module.features.28.bias": "res2d.base_model.features.28.bias",
"module.features.30.weight": "res2d.base_model.features.30.weight",
"module.features.30.bias": "res2d.base_model.features.30.bias",
"module.features.32.weight": "res2d.base_model.features.32.weight",
"module.features.32.bias": "res2d.base_model.features.32.bias",
"module.features.34.weight": "res2d.base_model.features.34.weight",
"module.features.34.bias": "res2d.base_model.features.34.bias",
# fc6
"module.fc6.weight": "res2d.base_model.fc6.weight",
"module.fc6.bias": "res2d.base_model.fc6.bias",
# fc7
"module.fc7.weight": "res2d.base_model.fc7.weight",
"module.fc7.bias": "res2d.base_model.fc7.bias",
}
p_dict = torch.load(Path.model_dir())
print("p_dict", [item for item in p_dict["state_dict"]])
# print("p_dict", p_dict["state_dict"])
s_dict = self.state_dict()
# for item in s_dict:
# print("sdict", item)
for name in p_dict['state_dict']:
if name not in corresp_name:
print("not", name)
continue
s_dict[corresp_name[name]] = p_dict["state_dict"][name]
self.load_state_dict(s_dict)
class Config:
# data
min_size = 600
max_size = 1000
input_size = (1000, 800)
num_workers = 8
test_num_workes = 8
batch_size = 1
# sigma for l1_smooth_loss
rpn_sigma = 3.
roi_sigma = 1.
# param for optimizer
# 0.0005 in origin paper but 0.0001 in tf-faster-rcnn
weight_decay = 0.0005
lr_decay = 0.1
lr = 1e-3
# visualization
env = "faster-rcnn" # visdom env
port = 8097
plot_every = 40 # vis every N iter
# preset
dataset = "voc"
data_dir = Path.db_root_dir(dataset)
pretrained_model = "vgg16"
# training
epoch = 14
use_mgpu = True
use_adam = False # Use Adam optimizer
use_chainer = False # try match everything as chairs
use_drop = False # use dropout in RoIHead
# debug
debug_file = "tmp/debug"
test_num = 10000
# model
load_path = None
caffe_pretrain = False
caffe_pretrain_path = ""
def _parse(self, kwargs):
state_dict = self._state_dict()
for k, v in kwargs.items():
if k not in state_dict:
raise ValueError("UnKnown Option: --{}".format(k))
setattr(self, k, v)
print('======user config========')
pprint(self._state_dict())
print('==========end============')
def _state_dict(self):
return {
k: getattr(self, k)
for k, _ in Config.__dict__.items() if not k.startswith('_')
}
def main(start_epoch, epochs):
assert torch.cuda.is_available(), NotImplementedError('No cuda available ')
if not osp.exists('data/'):
os.mkdir('data/')
if not osp.exists('log/'):
os.mkdir('log/')
args = obtain_evaluate_args()
torch.backends.cudnn.benchmark = True
model_fname = 'data/deeplab_{0}_{1}_v3_{2}_epoch%d.pth'.format(
'autodeeplab', 'cityscapes', 'bnlr7e-3')
if args.dataset == 'cityscapes':
dataset = CityscapesSegmentation(args=args,
root=Path.db_root_dir(args.dataset),
split='reval')
print(dataset)
else:
return NotImplementedError
if args.backbone == 'autodeeplab':
model = Retrain_Autodeeplab(args)
else:
raise ValueError('Unknown backbone: {}'.format(args.backbone))
if not args.train:
val_dataloader = DataLoader(dataset, batch_size=16, shuffle=False)
model = torch.nn.DataParallel(model).cuda()
print("======================start evaluate=======================")
for epoch in range(0, args.epochs):
print("evaluate epoch {:}".format(epoch + start_epoch))
checkpoint_name = model_fname % (epoch + start_epoch)
print(checkpoint_name)
checkpoint = torch.load(checkpoint_name)
##TODO: capire perchè non fanno i due commenti sotto
#state_dict = {k[1:]: v for k, v in checkpoint['state_dict'].items() if 'tracked' not in k}
#model.module.load_state_dict(state_dict)
inter_meter = AverageMeter()
union_meter = AverageMeter()
for i, sample in enumerate(val_dataloader):
inputs, target = sample['image'], sample['label']
#i have to add this line because of CUDA OUT OF MEMORY
target = target[:, :200, :400]
N, H, W = target.shape
total_outputs = torch.zeros(
(N, dataset.NUM_CLASSES, H, W)).cuda()
with torch.no_grad():
for j, scale in enumerate(args.eval_scales):
new_scale = [int(H * scale), int(W * scale)]
inputs = F.upsample(inputs,
new_scale,
mode='bilinear',
align_corners=True)
inputs = inputs.cuda()
outputs = model(inputs)
outputs = F.upsample(outputs, (H, W),
mode='bilinear',
align_corners=True)
total_outputs += outputs
_, pred = torch.max(total_outputs, 1)
pred = pred.detach().cpu().numpy().squeeze().astype(
np.uint8)
mask = target.numpy().astype(np.uint8)
print('eval: {0}/{1}'.format(i + 1, len(val_dataloader)))
inter, union = inter_and_union(pred, mask,
len(dataset.CLASSES))
inter_meter.update(inter)
union_meter.update(union)
iou = inter_meter.sum / (union_meter.sum + 1e-10)
miou = 'epoch: {0} Mean IoU: {1:.2f}'.format(
epoch,
iou.mean() * 100)
f = open('log/result.txt', 'a')
for i, val in enumerate(iou):
class_iou = 'IoU {0}: {1:.2f}\n'.format(
dataset.CLASSES[i], val * 100)
f.write(class_iou)
f.write('\n')
f.write(miou)
f.write('\n')
f.close()
def __init__(
self,
args,
base_dir=Path.db_root_dir('pascal'),
split='train',
):
"""
:param base_dir: path to VOC dataset directory
:param split: train/val
:param transform: transform to apply
"""
super().__init__()
self._base_dir = base_dir
self._image_dir = os.path.join(self._base_dir, 'JPEGImages')
self._cat_dir = os.path.join(self._base_dir, 'SegmentationClass')
self._test_image_dir = "/data/weishizheng/QiuYiqiao/pascal/test/VOCdevkit/VOC2012/JPEGImages/"
self._test_label_dir = "/data/weishizheng/QiuYiqiao/pascal/test/VOCdevkit/result_pascal_test/"
#self._test_label_dir = "/data/weishizheng/QiuYiqiao/Segmentation-codes/result_pascal_test_confidence/"
if isinstance(split, str):
self.split = [split]
else:
split.sort()
self.split = split
self.args = args
_splits_dir = os.path.join(self._base_dir, 'ImageSets', 'Segmentation')
self.im_ids = []
self.images = []
self.categories = []
for splt in self.split:
with open(os.path.join(os.path.join(_splits_dir, splt + '.txt')),
"r") as f:
lines = f.read().splitlines()
for ii, line in enumerate(lines):
_image = os.path.join(self._image_dir, line + ".jpg")
_cat = os.path.join(self._cat_dir, line + ".png")
assert os.path.isfile(_image)
assert os.path.isfile(_cat)
self.im_ids.append(line)
self.images.append(_image)
self.categories.append(_cat)
self.pseudo_ids = []
self.test_images = []
self.pseudo_labels = []
self.train_images = []
self.train_labels = []
self.val_images = []
self.val_labels = []
random.shuffle(list(zip(self.images, self.categories)))
self.num_train = int(len(self.images) * 0.8)
self.num_val = len(self.images) - self.num_train
self.train_images = self.images[0:self.num_train]
self.train_labels = self.categories[0:self.num_train]
self.val_images = self.images[self.num_train + 1:]
self.val_labels = self.categories[self.num_train + 1:]
with open(
'/data/weishizheng/QiuYiqiao/pascal/test/VOCdevkit/VOC2012/ImageSets/Segmentation/test.txt',
"r") as f:
lines = f.read().splitlines()
for ii, line in enumerate(lines):
_image = os.path.join(self._test_image_dir, line + ".jpg")
_cat = os.path.join(self._test_label_dir,
line + "_segmentation.png")
assert os.path.isfile(_image)
assert os.path.isfile(_cat)
self.test_images.append(_image)
self.pseudo_labels.append(_cat)
assert (len(self.images) == len(self.categories))
assert (len(self.test_images) == len(self.pseudo_labels))
# Display stats
if self.split[0] == 'train':
print('Number of images in {}: {:d}'.format(
split, len(self.train_images)))
print('Number of pseudo images {:d}'.format(len(self.test_images)))
elif self.split[0] == 'val':
print('Number of images in {}: {:d}'.format(
split, len(self.val_images)))
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()
self.use_amp = True if (APEX_AVAILABLE and args.use_amp) else False
self.opt_level = args.opt_level
# 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)
cell_path_d = os.path.join(args.saved_arch_path, 'genotype_device.npy')
cell_path_c = os.path.join(args.saved_arch_path, 'genotype_cloud.npy')
network_path_space = os.path.join(args.saved_arch_path, 'network_path_space.npy')
new_cell_arch_d = np.load(cell_path_d)
new_cell_arch_c = np.load(cell_path_c)
new_network_arch = np.load(network_path_space)
new_network_arch = [1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2]
# Define network
model = new_cloud_Model(network_arch= new_network_arch,
cell_arch_d = new_cell_arch_d,
cell_arch_c = new_cell_arch_c,
num_classes=self.nclass,
device_num_layers=6)
# TODO: look into these
# TODO: ALSO look into different param groups as done int deeplab below
# train_params = [{'params': model.get_1x_lr_params(), 'lr': args.lr},
# {'params': model.get_10x_lr_params(), 'lr': args.lr * 10}]
#
train_params = [{'params': model.parameters(), 'lr': args.lr}]
# 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_device = Evaluator(self.nclass)
self.evaluator_cloud = Evaluator(self.nclass)
# Define lr scheduler
self.scheduler = LR_Scheduler(args.lr_scheduler, args.lr,
args.epochs, len(self.train_loader)) #TODO: use min_lr ?
# Using cuda
if self.use_amp and args.cuda:
keep_batchnorm_fp32 = True if (self.opt_level == 'O2' or self.opt_level == 'O3') else None
# fix for current pytorch version with opt_level 'O1'
if self.opt_level == 'O1' and torch.__version__ < '1.3':
for module in self.model.modules():
if isinstance(module, torch.nn.modules.batchnorm._BatchNorm):
# Hack to fix BN fprop without affine transformation
if module.weight is None:
module.weight = torch.nn.Parameter(
torch.ones(module.running_var.shape, dtype=module.running_var.dtype,
device=module.running_var.device), requires_grad=False)
if module.bias is None:
module.bias = torch.nn.Parameter(
torch.zeros(module.running_var.shape, dtype=module.running_var.dtype,
device=module.running_var.device), requires_grad=False)
# print(keep_batchnorm_fp32)
self.model, [self.optimizer, self.architect_optimizer] = amp.initialize(
self.model, [self.optimizer, self.architect_optimizer], opt_level=self.opt_level,
keep_batchnorm_fp32=keep_batchnorm_fp32, loss_scale="dynamic")
print('cuda finished')
# Using data parallel
if args.cuda and len(self.args.gpu_ids) >1:
if self.opt_level == 'O2' or self.opt_level == 'O3':
print('currently cannot run with nn.DataParallel and optimization level', self.opt_level)
self.model = torch.nn.DataParallel(self.model, device_ids=self.args.gpu_ids)
patch_replication_callback(self.model)
print('training on multiple-GPUs')
# 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 the weights are wrapped in module object we have to clean it
if args.clean_module:
self.model.load_state_dict(checkpoint['state_dict'])
state_dict = checkpoint['state_dict']
new_state_dict = OrderedDict()
for k, v in state_dict.items():
name = k[7:] # remove 'module.' of dataparallel
new_state_dict[name] = v
self.model.load_state_dict(new_state_dict)
else:
if (torch.cuda.device_count() > 1 or args.load_parallel):
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,
phase="train",
data_dir=Path.db_root_dir('SUNRGBD')):
self.phase = phase
self.args = args
self.data_dir = data_dir
# self.transform = transform
try:
with open(img_dir_train_file, 'r') as f:
self.img_dir_train = f.read().splitlines()
with open(depth_dir_train_file, 'r') as f:
self.depth_dir_train = f.read().splitlines()
with open(label_dir_train_file, 'r') as f:
self.label_dir_train = f.read().splitlines()
with open(img_dir_test_file, 'r') as f:
self.img_dir_test = f.read().splitlines()
with open(depth_dir_test_file, 'r') as f:
self.depth_dir_test = f.read().splitlines()
with open(label_dir_test_file, 'r') as f:
self.label_dir_test = f.read().splitlines()
except:
SUNRGBDMeta_dir = os.path.join(
self.data_dir, 'SUNRGBDtoolbox/Metadata/SUNRGBDMeta.mat')
allsplit_dir = os.path.join(
self.data_dir, 'SUNRGBDtoolbox/traintestSUNRGBD/allsplit.mat')
SUNRGBD2Dseg_dir = os.path.join(
self.data_dir, 'SUNRGBDtoolbox/Metadata/SUNRGBD2Dseg.mat')
self.img_dir_train = []
self.depth_dir_train = []
self.label_dir_train = []
self.img_dir_test = []
self.depth_dir_test = []
self.label_dir_test = []
self.SUNRGBD2Dseg = h5py.File(SUNRGBD2Dseg_dir,
mode='r',
libver='latest')
SUNRGBDMeta = scipy.io.loadmat(
SUNRGBDMeta_dir, squeeze_me=True,
struct_as_record=False)['SUNRGBDMeta']
split = scipy.io.loadmat(allsplit_dir,
squeeze_me=True,
struct_as_record=False)
split_train = split['alltrain']
seglabel = self.SUNRGBD2Dseg['SUNRGBD2Dseg']['seglabel']
for i, meta in enumerate(SUNRGBDMeta):
meta_dir = '/'.join(meta.rgbpath.split('/')[:-2])
real_dir = meta_dir.replace('/n/fs/sun3d/data', self.data_dir)
depth_bfx_path = os.path.join(real_dir,
'depth_bfx/' + meta.depthname)
rgb_path = os.path.join(real_dir, 'image/' + meta.rgbname)
label_path = os.path.join(real_dir, 'label/label.npy')
if not os.path.exists(label_path):
os.makedirs(os.path.join(real_dir, 'label'), exist_ok=True)
label = np.array(self.SUNRGBD2Dseg[
seglabel.value[i][0]].value.transpose(1, 0))
np.save(label_path, label)
if meta_dir in split_train:
self.img_dir_train = np.append(self.img_dir_train,
rgb_path)
self.depth_dir_train = np.append(self.depth_dir_train,
depth_bfx_path)
self.label_dir_train = np.append(self.label_dir_train,
label_path)
else:
self.img_dir_test = np.append(self.img_dir_test, rgb_path)
self.depth_dir_test = np.append(self.depth_dir_test,
depth_bfx_path)
self.label_dir_test = np.append(self.label_dir_test,
label_path)
local_file_dir = '/'.join(img_dir_train_file.split('/')[:-1])
if not os.path.exists(local_file_dir):
os.mkdir(local_file_dir)
with open(img_dir_train_file, 'w') as f:
f.write('\n'.join(self.img_dir_train))
with open(depth_dir_train_file, 'w') as f:
f.write('\n'.join(self.depth_dir_train))
with open(label_dir_train_file, 'w') as f:
f.write('\n'.join(self.label_dir_train))
with open(img_dir_test_file, 'w') as f:
f.write('\n'.join(self.img_dir_test))
with open(depth_dir_test_file, 'w') as f:
f.write('\n'.join(self.depth_dir_test))
with open(label_dir_test_file, 'w') as f:
f.write('\n'.join(self.label_dir_test))
def __init__(self, split='val',
root=Path.db_root_dir(),
num_frames=None,
custom_frames=None,
transform=None,
retname=False,
seq_name=None,
obj_id=None,
gt_only_first_frame=False,
no_gt=False,
batch_gt=False,
rgb=False,
effective_batch=None):
"""Loads image to label pairs for tool pose estimation
split: Split or list of splits of the dataset
root: dataset directory with subfolders "JPEGImages" and "Annotations"
num_frames: Select number of frames of the sequence (None for all frames)
custom_frames: List or Tuple with the number of the frames to include
transform: Data transformations
retname: Retrieve meta data in the sample key 'meta'
seq_name: Use a specific sequence
obj_id: Use a specific object of a sequence (If None and sequence is specified, the batch_gt is True)
gt_only_first_frame: Provide the GT only in the first frame
no_gt: No GT is provided
batch_gt: For every frame sequence batch all the different objects gt
rgb: Use RGB channel order in the image
"""
if isinstance(split, str):
self.split = [split]
else:
split.sort()
self.split = split
self.db_root_dir = root
self.transform = transform
self.seq_name = seq_name
self.obj_id = obj_id
self.num_frames = num_frames
self.custom_frames = custom_frames
self.retname = retname
self.rgb = rgb
if seq_name is not None and obj_id is None:
batch_gt = True
self.batch_gt = batch_gt
self.all_seqs_list = []
self.seqs = []
for splt in self.split:
with open(os.path.join(self.db_root_dir, 'ImageSets', '2017', splt + '.txt')) as f:
seqs_tmp = f.readlines()
seqs_tmp = list(map(lambda elem: elem.strip(), seqs_tmp))
self.seqs.extend(seqs_tmp)
self.seq_list_file = os.path.join(self.db_root_dir, 'ImageSets', '2017',
'_'.join(self.split) + '_instances.txt')
# Precompute the dictionary with the objects per sequence
if not self._check_preprocess():
self._preprocess()
if self.seq_name is None:
img_list = []
labels = []
for seq in self.seqs:
images = np.sort(os.listdir(os.path.join(self.db_root_dir, 'JPEGImages/480p/', seq.strip())))
images_path = list(map(lambda x: os.path.join('JPEGImages/480p/', seq.strip(), x), images))
lab = np.sort(os.listdir(os.path.join(self.db_root_dir, 'Annotations/480p/', seq.strip())))
lab_path = list(map(lambda x: os.path.join('Annotations/480p/', seq.strip(), x), lab))
if num_frames is not None:
seq_len = len(images_path)
num_frames = min(num_frames, seq_len)
frame_vector = np.arange(num_frames)
frames_ids = list(np.round(frame_vector*seq_len/float(num_frames)).astype(np.int))
frames_ids[-1] = min(frames_ids[-1], seq_len)
images_path = [images_path[x] for x in frames_ids]
if no_gt:
lab_path = [None] * len(images_path)
else:
lab_path = [lab_path[x] for x in frames_ids]
elif isinstance(custom_frames, tuple) or isinstance(custom_frames, list):
assert min(custom_frames) >= 0 and max(custom_frames) <= len(images_path)
images_path = [images_path[x] for x in custom_frames]
if no_gt:
lab_path = [None] * len(images_path)
else:
lab_path = [lab_path[x] for x in custom_frames]
if gt_only_first_frame:
lab_path = [lab_path[0]]
lab_path.extend([None] * (len(images_path) - 1))
elif no_gt:
lab_path = [None] * len(images_path)
if self.batch_gt:
obj = self.seq_dict[seq]
if -1 in obj:
obj.remove(-1)
for ii in range(len(img_list), len(images_path)+len(img_list)):
self.all_seqs_list.append([obj, ii])
else:
for obj in self.seq_dict[seq]:
if obj != -1:
for ii in range(len(img_list), len(images_path)+len(img_list)):
self.all_seqs_list.append([obj, ii])
img_list.extend(images_path)
labels.extend(lab_path)
else:
# Initialize the per sequence images for online training
assert self.seq_name in self.seq_dict.keys(), '{} not in {} set.'.format(self.seq_name, '_'.join(self.split))
names_img = np.sort(os.listdir(os.path.join(self.db_root_dir, 'JPEGImages/480p/', str(seq_name))))
img_list = list(map(lambda x: os.path.join('JPEGImages/480p/', str(seq_name), x), names_img))
name_label = np.sort(os.listdir(os.path.join(self.db_root_dir, 'Annotations/480p/', str(seq_name))))
labels = list(map(lambda x: os.path.join('Annotations/480p/', str(seq_name), x), name_label))
if num_frames is not None:
seq_len = len(img_list)
num_frames = min(num_frames, seq_len)
frame_vector = np.arange(num_frames)
frames_ids = list(np.round(frame_vector * seq_len / float(num_frames)).astype(np.int))
frames_ids[-1] = min(frames_ids[-1], seq_len)
img_list = [img_list[x] for x in frames_ids]
if no_gt:
labels = [None] * len(img_list)
else:
labels = [labels[x] for x in frames_ids]
elif isinstance(custom_frames, tuple) or isinstance(custom_frames, list):
assert min(custom_frames) >= 0 and max(custom_frames) <= len(img_list)
img_list = [img_list[x] for x in custom_frames]
if no_gt:
labels = [None] * len(img_list)
else:
labels = [labels[x] for x in custom_frames]
if gt_only_first_frame:
labels = [labels[0]]
labels.extend([None]*(len(img_list)-1))
elif no_gt:
labels = [None] * len(img_list)
if obj_id is not None:
assert obj_id in self.seq_dict[self.seq_name], \
"{} doesn't have this object id {}.".format(self.seq_name, str(obj_id))
if self.batch_gt:
self.obj_id = self.seq_dict[self.seq_name]
if -1 in self.obj_id:
self.obj_id.remove(-1)
assert (len(labels) == len(img_list))
if effective_batch:
self.img_list = img_list * effective_batch
self.labels = labels * effective_batch
else:
self.img_list = img_list
self.labels = labels
def parse_args():
parser = argparse.ArgumentParser(description='command for the first train')
parser.add_argument('--lr', type=float, default=0.1, help='learning rate')
parser.add_argument('--batch_size',
type=int,
default=100,
help='#images in each mini-batch')
parser.add_argument('--test_batch_size',
type=int,
default=100,
help='#images in each mini-batch')
parser.add_argument('--epoch',
type=int,
default=150,
help='training epoches')
parser.add_argument('--wd', type=float, default=1e-4, help='weight decay')
parser.add_argument('--momentum', default=0.9, type=float, help='momentum')
parser.add_argument('--dataset_type',
default='semiSup',
help='noise type of the dataset')
parser.add_argument('--epoch_begin',
default=0,
type=int,
help='the epoch to begin update labels')
parser.add_argument('--epoch_update',
default=1,
type=int,
help='#epoch to average to update soft labels')
parser.add_argument('--out',
type=str,
default='./data/model_data',
help='Directory of the output')
parser.add_argument('--alpha',
type=float,
default=0.8,
help='Hyper param for loss')
parser.add_argument('--beta',
type=float,
default=0.4,
help='Hyper param for loss')
parser.add_argument('--download',
action='store_true',
default=False,
help='download dataset')
parser.add_argument('--network',
type=str,
default='MT_Net',
help='the backbone of the network')
parser.add_argument('--seed',
type=int,
default=1,
help='random seed (default: 1)')
parser.add_argument('--seed_val',
type=int,
default=1,
help='seed for the validation split')
parser.add_argument('--M',
action='append',
type=int,
default=[],
help="Milestones for the LR sheduler")
parser.add_argument('--experiment_name',
type=str,
default='Proof',
help='name of the experiment (for the output files)')
parser.add_argument('--label_noise',
type=float,
default=0.0,
help='ratio of labeles to relabel randomly')
parser.add_argument(
'--loss_term',
type=str,
default='MixUp_ep',
help='the loss to use: "Reg_ep" for CE, or "MixUp_ep" for M')
parser.add_argument(
'--relab',
type=str,
default='unifRelab',
help='choose how to relabel the random samples from the unlabeled set')
parser.add_argument('--gausTF',
type=bool,
default=False,
help='apply gaussian noise')
parser.add_argument('--dropout',
type=float,
default=0.0,
help='cnn dropout')
parser.add_argument('--initial_epoch',
type=int,
default=0,
help='#images in each mini-batch')
parser.add_argument('--Mixup_Alpha',
type=float,
default=1,
help='alpha value for the beta dist from mixup')
parser.add_argument('--cuda_dev',
type=int,
default=0,
help='set to 1 to choose the second gpu')
parser.add_argument('--save_checkpoint',
type=str,
default="False",
help='save checkpoints for ensembles')
parser.add_argument('--swa', type=str, default='True', help='Apply SWA')
parser.add_argument('--swa_start', type=int, default=350, help='Start SWA')
parser.add_argument('--swa_freq', type=float, default=5, help='Frequency')
parser.add_argument('--swa_lr', type=float, default=-0.01, help='LR')
parser.add_argument(
'--labeled_batch_size',
default=8,
type=int,
metavar='N',
help="labeled examples per minibatch (default: no constrain)")
parser.add_argument(
'--validation_exp',
type=str,
default='False',
help=
'Ignore the testing set during training and evaluation (it gets 5k samples from the training data to do the validation step)'
)
parser.add_argument(
'--drop_extra_forward',
type=str,
default='True',
help='Do an extra forward pass to compute the labels without dropout.')
parser.add_argument(
'--val_samples',
type=int,
default=5000,
help=
'Number of samples to be kept for validation (from the training set))')
parser.add_argument(
'--DApseudolab',
type=str,
default="False",
help='Apply data augmentation when computing pseudolabels')
parser.add_argument('--DA',
type=str,
default='standard',
help='Chose the type of DA')
parser.add_argument('--dataset',
type=str,
default='cifar10',
help='Dataset to train on, default: cifar10')
parser.add_argument('--labels', type=str, default=None)
parser.add_argument('--labeled_samples', type=str, default=None)
parser.add_argument('--load', type=str, default=None)
parser.add_argument('--freeze', action='store_true', default=False)
args = parser.parse_args()
from mypath import Path
args.train_root = Path.db_root_dir(args.dataset)
return args
def data_config(args, transform_train, transform_test, dst_folder):
if args.validation_exp == "False":
args.val_samples = 0
####################################### Train ##########################################################
trainset, clean_labels, noisy_labels, train_noisy_indexes, train_clean_indexes, valset = get_dataset(
args,
transform_train,
transform_test,
dst_folder,
dataset=args.dataset)
labels = np.argmax(np.load(args.labels)['arr_0'], axis=1)
labeled_ids = np.load(args.labeled_samples)['arr_0']
if args.labeled_batch_size > 0 and not args.dataset_type == 'sym_noise_warmUp':
print("Training with two samplers. {0} clean samples per batch".format(
args.labeled_batch_size))
batch_sampler = TwoStreamBatchSampler(train_noisy_indexes,
train_clean_indexes,
args.batch_size,
args.labeled_batch_size)
train_loader = torch.utils.data.DataLoader(trainset,
batch_sampler=batch_sampler,
num_workers=12,
pin_memory=True)
else:
train_loader = torch.utils.data.DataLoader(trainset,
batch_size=args.batch_size,
shuffle=True,
num_workers=12,
pin_memory=True)
if args.validation_exp == "True":
print("Training to choose hyperparameters --- VALIDATON MODE ---.")
testset = valset
else:
print("Training to compare to the SOTA --- TESTING MODE ---.")
if args.dataset == "cifar10":
testset = datasets.CIFAR10(root=Path.db_root_dir(args.dataset),
train=False,
download=False,
transform=transform_test)
else:
testset = datasets.CIFAR100(root=Path.db_root_dir(args.dataset),
train=False,
download=False,
transform=transform_test)
test_loader = torch.utils.data.DataLoader(testset,
batch_size=args.test_batch_size,
shuffle=False,
num_workers=12,
pin_memory=True)
# train and val
print('-------> Data loading')
print("Training with {0} labeled samples ({1} unlabeled samples)".format(
len(clean_labels) - len(train_noisy_indexes),
len(train_noisy_indexes)))
return train_loader, test_loader, train_noisy_indexes
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)
self.classNames = ['Background','Aeroplane', 'Bicycle', 'Bird', 'Boat', 'Bottle', 'Bus',\
'Car', 'Cat', 'Chair', 'Cow', 'Dinning Table', 'Dog', 'Horse',\
'Motorbike', 'Person', 'Pottled Plant', 'Sheep', 'Sofa', 'Train', 'TV monitor']
colorMap = [( 0, 0, 0),(0.50, 0, 0),( 0, 0.50, 0),(0.50, 0.50, 0),( 0, 0, 0.5),(0.50, 0, 0.5),( 0, 0.50, 0.5),\
(0.50, 0.5, 0.5),(0.25, 0, 0),(0.75, 0, 0),(0.25, 0.50, 0),(0.75, 0.50, 0),(0.25, 0, 0.5),(0.75, 0, 0.5),\
(0.25, 0.5, 0.5),(0.25, 0.5, 0.5),( 0, 0.25, 0),(0.50, 0.25, 0),( 0, 0.75, 0),(0.50, 0.75, 0),( 0, 0.25, 0.5)]
self.colorMap = color_map(256, normalized=True)
self.cmap = colors.ListedColormap(colorMap)
bounds = [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19, 20, 21
]
self.norm = colors.BoundaryNorm(bounds, self.cmap.N)
model = waspnet(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)
self.evaluatorCRF = 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))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
p = checkpoint['state_dict']
if args.cuda:
prefix = 'invalid'
state_dict = self.model.module.state_dict()
model_dict = {}
for k, v in p.items():
if k in state_dict:
if not k.startswith(prefix):
model_dict[k] = v
state_dict.update(model_dict)
self.model.module.load_state_dict(state_dict)
else:
self.model.load_state_dict(checkpoint['state_dict'])
if not args.ft:
if not self.args.dataset == 'cityscapes':
self.optimizer.load_state_dict(checkpoint['optimizer'])
self.best_pred = checkpoint['best_pred']
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
print("Best mIOU = " + str(self.best_pred))
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
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()
kwargs = {'num_workers': args.workers, 'pin_memory': True}
self.train_loader1, self.train_loader2, self.val_loader, self.test_loader, self.nclass = make_data_loader(
args, **kwargs)
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:
#if so, which trainloader to use?
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)
# Define network
model = AutoDeeplab(num_classes=self.nclass,
num_layers=12,
criterion=self.criterion)
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
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_loader1))
self.architect = Architect(self.model, args)
# Using cuda
if args.cuda:
self.model = torch.nn.DataParallel(self.model.cuda())
#patch_replication_callback(self.model)
self.model = self.model.cuda()
print('cuda finished')
# 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
self.saver = Saver(args)
self.saver.save_experiment_config()
self.summary = TensorboardSummary(self.saver.experiment_dir)
self.writer = self.summary.create_summary()
# Define Dataloader
kwargs = {'num_workers': args.workers, 'pin_memory': True, 'drop_last': True}
_, self.val_loader, self.test_loader, self.nclass = make_data_loader(args, **kwargs)
if args.network == 'searched-dense':
cell_path = os.path.join(args.saved_arch_path, 'autodeeplab', 'genotype.npy')
cell_arch = np.load(cell_path)
if self.args.C == 2:
C_index = [5]
#4_15_80e_40a_03-lr_5e-4wd_6e-4alr_1e-3awd 513x513 batch 4
network_arch = [1, 2, 2, 2, 3, 2, 2, 1, 1, 1, 1, 2]
low_level_layer = 0
elif self.args.C == 3:
C_index = [3, 7]
network_arch = [1, 2, 3, 2, 2, 3, 2, 3, 2, 3, 2, 3]
low_level_layer = 0
elif self.args.C == 4:
C_index = [2, 5, 8]
network_arch = [1, 2, 3, 3, 2, 3, 3, 3, 3, 3, 2, 2]
low_level_layer = 0
model = ADD(network_arch,
C_index,
cell_arch,
self.nclass,
args,
low_level_layer)
elif args.network.startswith('autodeeplab'):
network_arch = [0, 0, 0, 1, 2, 1, 2, 2, 3, 3, 2, 1]
cell_path = os.path.join(args.saved_arch_path, 'autodeeplab', 'genotype.npy')
cell_arch = np.load(cell_path)
low_level_layer = 2
if self.args.C == 2:
C_index = [5]
elif self.args.C == 3:
C_index = [3, 7]
elif self.args.C == 4:
C_index = [2, 5, 8]
if args.network == 'autodeeplab-dense':
model = ADD(network_arch,
C_index,
cell_arch,
self.nclass,
args,
low_level_layer)
elif args.network == 'autodeeplab-baseline':
model = Baselin_Model(network_arch,
C_index,
cell_arch,
self.nclass,
args,
low_level_layer)
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 = nn.CrossEntropyLoss(weight=weight, ignore_index=255).cuda()
self.model = model
# Define Evaluator
self.evaluator = []
for num in range(self.args.C):
self.evaluator.append(Evaluator(self.nclass))
# Using cuda
if args.cuda:
self.model = self.model.cuda()
if args.confidence == 'edm':
self.edm = EDM()
self.edm = self.edm.cuda()
else:
self.edm = False
# 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 the weights are wrapped in module object we have to clean it
if args.clean_module:
self.model.load_state_dict(checkpoint['state_dict'])
state_dict = checkpoint['state_dict']
new_state_dict = OrderedDict()
for k, v in state_dict.items():
name = k[7:] # remove 'module.' of dataparallel
new_state_dict[name] = v
self.model.load_state_dict(new_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']))
if args.resume_edm is not None:
if not os.path.isfile(args.resume_edm):
raise RuntimeError("=> no checkpoint found at '{}'".format(args.resume_edm))
checkpoint = torch.load(args.resume_edm)
# if the weights are wrapped in module object we have to clean it
if args.clean_module:
self.edm.load_state_dict(checkpoint['state_dict'])
state_dict = checkpoint['state_dict']
new_state_dict = OrderedDict()
for k, v in state_dict.items():
name = k[7:] # remove 'module.' of dataparallel
new_state_dict[name] = v
self.edm.load_state_dict(new_state_dict)
else:
self.edm.load_state_dict(checkpoint['state_dict'])
def _load_pretrained_weights(self):
"""Initialiaze network."""
corresp_name = {
# Conv1
"module.features.0.weight": "features.0.weight",
"module.features.0.bias": "features.0.bias",
# Conv2
"module.features.2.weight": "features.2.weight",
"module.features.2.bias": "features.2.bias",
# Conv3a
"module.features.5.weight": "features.5.weight",
"module.features.5.bias": "features.5.bias",
# Conv3b
"module.features.7.weight": "features.7.weight",
"module.features.7.bias": "features.7.bias",
# Conv4a
"module.features.10.weight": "features.10.weight",
"module.features.10.bias": "features.10.bias",
# Conv4b
"module.features.12.weight": "features.12.weight",
"module.features.12.bias": "features.12.bias",
# Conv5a
"module.features.14.weight": "features.14.weight",
"module.features.14.bias": "features.14.bias",
# Conv5b
"module.features.16.weight": "features.16.weight",
"module.features.16.bias": "features.16.bias",
"module.features.19.weight": "features.19.weight",
"module.features.19.bias": "features.19.bias",
"module.features.21.weight": "features.21.weight",
"module.features.21.bias": "features.21.bias",
"module.features.23.weight": "features.23.weight",
"module.features.23.bias": "features.23.bias",
"module.features.25.weight": "features.25.weight",
"module.features.25.bias": "features.25.bias",
"module.features.28.weight": "features.28.weight",
"module.features.28.bias": "features.28.bias",
"module.features.30.weight": "features.30.weight",
"module.features.30.bias": "features.30.bias",
"module.features.32.weight": "features.32.weight",
"module.features.32.bias": "features.32.bias",
"module.features.34.weight": "features.34.weight",
"module.features.34.bias": "features.34.bias",
# fc6
"module.fc6.weight": "fc6.weight",
"module.fc6.bias": "fc6.bias",
# fc7
"module.fc7.weight": "fc7.weight",
"module.fc7.bias": "fc7.bias",
}
p_dict = torch.load(Path.model_dir())
# print("p_dict", [item for item in p_dict["state_dict"]])
s_dict = self.state_dict()
# for item in s_dict:
# print("sdict", item)
for name in p_dict['state_dict']:
if name not in corresp_name:
print("not", name)
continue
s_dict[corresp_name[name]] = p_dict["state_dict"][name]
self.load_state_dict(s_dict)
raise ValueError
filt = upsample_filt(h)
for i in range(m):
lay.weight[i, i, :, :].data.copy_(torch.from_numpy(filt))
return lay.weight.data
if __name__ == '__main__':
import os
from mypath import Path
# Output
output = Image.open(
os.path.join(Path.db_root_dir(),
'Annotations/480p/blackswan/anno0.png'))
output = np.asarray(output, dtype=np.float32) / 255.0
output = logit(output)
output = Variable(torch.from_numpy(output)).cuda()
# GroundTruth
label = Image.open(
os.path.join(Path.db_root_dir(),
'Annotations/480p/blackswan/00001.png'))
label = Variable(
torch.from_numpy(np.asarray(label, dtype=np.float32)) / 255.0).cuda()
loss = class_balanced_cross_entropy_loss(output, label)
print(loss)
def __init__(self, args):
self.args = args
self.vs = Vs(args.dataset)
# 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)
if self.args.norm == "gn":
norm = gn
elif self.args.norm == "bn":
if self.args.sync_bn:
norm = syncbn
else:
norm = bn
elif self.args.norm == "abn":
if self.args.sync_bn:
norm = syncabn(self.args.gpu_ids)
else:
norm = abn
else:
print("Please check the norm.")
exit()
# Define network
if self.args.model == "deeplabv3+":
model = DeepLab(args=self.args,
num_classes=self.nclass,
freeze_bn=args.freeze_bn)
elif self.args.model == "deeplabv3":
model = DeepLabv3(
Norm=args.norm,
backbone=args.backbone,
output_stride=args.out_stride,
num_classes=self.nclass,
freeze_bn=args.freeze_bn,
)
elif self.args.model == "fpn":
model = FPN(args=args, num_classes=self.nclass)
# 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 = 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))
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"]))
# Clear start epoch if fine-tuning
if args.ft:
args.start_epoch = 0
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-i',
'--image',
type=str,
default='ims/dog-cat.jpg',
help='path to image')
parser.add_argument('--model-name', type=str, default='dextr_pascal-sbd')
parser.add_argument('-o',
'--output',
type=str,
default='results',
help='path where results will be saved')
parser.add_argument('--pad', type=int, default=50, help='padding size')
parser.add_argument('--thres', type=float, default=.9)
parser.add_argument('--gpu-id', type=int, default=0)
parser.add_argument('--anchors',
type=int,
default=5,
help='amount of points to set')
parser.add_argument(
'--anchor-points',
type=str,
default=None,
help='path to folder of anchor points (tracking points)')
parser.add_argument(
'--use-frame-info',
type=bool,
default=True,
help='wheter to use the frame number from the csv file or not')
parser.add_argument('--corrections',
action='store_true',
help='toggle popup message wheater to correct or not')
parser.add_argument(
'--cut',
action='store_true',
help='if used, will save the cutted image instead of the mask as png')
opt = parser.parse_args()
modelName = opt.model_name
pad = opt.pad
thres = opt.thres
gpu_id = opt.gpu_id
device = torch.device("cuda:" +
str(gpu_id) if torch.cuda.is_available() else "cpu")
# Create the network and load the weights
net = resnet.resnet101(1, nInputChannels=4, classifier='psp')
print("Initializing weights from: {}".format(
os.path.join(Path.models_dir(), modelName + '.pth')))
state_dict_checkpoint = torch.load(
os.path.join(Path.models_dir(), modelName + '.pth'),
map_location=lambda storage, loc: storage)
# Remove the prefix .module from the model when it is trained using DataParallel
if 'module.' in list(state_dict_checkpoint.keys())[0]:
new_state_dict = OrderedDict()
for k, v in state_dict_checkpoint.items():
name = k[7:] # remove `module.` from multi-gpu training
new_state_dict[name] = v
else:
new_state_dict = state_dict_checkpoint
net.load_state_dict(new_state_dict)
net.eval()
net.to(device)
# Read image and click the points
if os.path.isfile(opt.image):
images = [opt.image]
else:
images = sorted(glob.glob(opt.image + '/*.*'))
if opt.anchor_points:
tracks = sorted(glob.glob(opt.anchor_points + '/*.csv'))
frames, X, Y = [], [], []
for i in range(len(tracks)):
f, x, y = np.loadtxt(tracks[i], delimiter=',', unpack=True)
frames.append(f.tolist())
X.append(x.tolist())
Y.append(y.tolist())
anchorPoints = []
uframes = np.unique(np.hstack([np.array(a) for a in frames])).tolist()
# print(uframes)
for i in range(len(uframes)):
extreme_points = []
for j in range(len(frames)):
try:
ind = frames[j].index(uframes[i])
extreme_points.append([X[j][ind], Y[j][ind]])
except ValueError:
continue
anchorPoints.append(np.array(extreme_points))
for i, img in enumerate(images):
if opt.use_frame_info and opt.anchor_points is not None:
file_number = int(re.sub(r'\D', '', img))
if not file_number in uframes:
print(img, 'skipped')
continue
if opt.anchor_points is None:
plt.figure()
while True:
image = np.array(Image.open(img))
mask_path = os.path.join(opt.output, os.path.split(img)[1])
if opt.anchor_points is None:
plt.ion()
plt.axis('off')
plt.imshow(image)
plt.title(
'Click the four extreme points of the objects\nHit enter/middle mouse button when done (do not close the window)'
)
results = []
with torch.no_grad():
# while 1:
if opt.anchor_points:
if opt.use_frame_info:
try:
index = uframes.index(file_number)
except ValueError:
print(
'Could not find data for frame %i. Use frame %i instead.'
% (file_number, i))
index = i
else:
index = i
extreme_points_ori = anchorPoints[index].astype(np.int)
else:
extreme_points_ori = np.array(
plt.ginput(opt.anchors, timeout=0)).astype(np.int)
# print(extreme_points_ori,extreme_points_ori.shape)
# Crop image to the bounding box from the extreme points and resize
bbox = helpers.get_bbox(image,
points=extreme_points_ori,
pad=pad,
zero_pad=False)
crop_image = helpers.crop_from_bbox(image, bbox, zero_pad=True)
resize_image = helpers.fixed_resize(
crop_image, (512, 512)).astype(np.float32)
# Generate extreme point heat map normalized to image values
extreme_points = extreme_points_ori - [
np.min(extreme_points_ori[:, 0]),
np.min(extreme_points_ori[:, 1])
] + [pad, pad]
extreme_points = (
512 * extreme_points *
[1 / crop_image.shape[1], 1 / crop_image.shape[0]]).astype(
np.int)
extreme_heatmap = helpers.make_gt(resize_image,
extreme_points,
sigma=10)
extreme_heatmap = helpers.cstm_normalize(extreme_heatmap, 255)
# Concatenate inputs and convert to tensor
input_dextr = np.concatenate(
(resize_image, extreme_heatmap[:, :, np.newaxis]), axis=2)
inputs = torch.from_numpy(
input_dextr.transpose((2, 0, 1))[np.newaxis, ...])
# Run a forward pass
inputs = inputs.to(device)
outputs = net.forward(inputs)
outputs = interpolate(outputs,
size=(512, 512),
mode='bilinear',
align_corners=True)
outputs = outputs.to(torch.device('cpu'))
pred = np.transpose(outputs.data.numpy()[0, ...], (1, 2, 0))
pred = 1 / (1 + np.exp(-pred))
pred = np.squeeze(pred)
result = helpers.crop2fullmask(pred,
bbox,
im_size=image.shape[:2],
zero_pad=True,
relax=pad) > thres
results.append(result)
# Plot the results
plt.imshow(helpers.overlay_masks(image / 255, results))
plt.plot(extreme_points_ori[:, 0], extreme_points_ori[:, 1],
'gx')
if not opt.cut:
helpers.save_mask(results, mask_path)
else:
Image.fromarray(
np.concatenate(
(image, 255 * result[..., None].astype(np.int)),
2).astype(np.uint8)).save(mask_path, 'png')
'''if len(extreme_points_ori) < 4:
if len(results) > 0:
helpers.save_mask(results, 'demo.png')
print('Saving mask annotation in demo.png and exiting...')
else:
print('Exiting...')
sys.exit()'''
if opt.anchor_points is None:
plt.close()
if opt.corrections:
if easygui.ynbox(image=mask_path):
break
else:
break
print(img, 'done')
def main():
# General parameters
gpu_id = 0
# Configuration used in the challenges
max_nb_interactions = 8 # Maximum number of interactions
max_time_per_interaction = 30 # Maximum time per interaction per object
# Total time available to interact with a sequence and an initial set of scribbles
max_time = max_nb_interactions * max_time_per_interaction # Maximum time per object
# Interactive parameters
subset = 'val'
host = 'localhost' # 'localhost' for subsets train and val.
# ScribbleNet parameters
time_budget_per_object = 20
parent_model = 'scribblenet_parent.pth'
prev_mask = True # Use previous mask as no-care area when fine-tuning
save_model_dir = Path.models_dir()
report_save_dir = Path.save_root_dir()
save_result_dir = report_save_dir
model = ScribbleNetMain(parent_model,
save_model_dir,
gpu_id,
time_budget_per_object,
save_result_dir=save_result_dir)
seen_seq = {}
with DavisInteractiveSession(host=host,
davis_root=Path.db_root_dir(),
subset=subset,
report_save_dir=report_save_dir,
max_nb_interactions=max_nb_interactions,
max_time=max_time) as sess:
while sess.next():
t_total = timeit.default_timer()
# Get the current iteration scribbles
sequence, scribbles, first_scribble = sess.get_scribbles()
if first_scribble:
n_interaction = 1
n_objects = Davis.dataset[sequence]['num_objects']
first_frame = interactive_utils.scribbles.annotated_frames(
scribbles)[0]
seen_seq[sequence] = 1 if sequence not in seen_seq.keys(
) else seen_seq[sequence] + 1
else:
n_interaction += 1
pred_masks = []
print(
'\nRunning sequence {} in interaction {} and scribble iteration {}'
.format(sequence, n_interaction, seen_seq[sequence]))
for obj_id in range(1, n_objects + 1):
model.train(first_frame,
n_interaction,
obj_id,
scribbles,
seen_seq[sequence],
subset=subset,
use_previous_mask=prev_mask)
pred_masks.append(
model.test(sequence,
n_interaction,
obj_id,
subset=subset,
scribble_iter=seen_seq[sequence]))
final_masks = interactive_utils.mask.combine_masks(pred_masks)
# Submit your prediction
sess.submit_masks(final_masks)
t_end = timeit.default_timer()
print(
'Total time (training and testing) for single interaction: ' +
str(t_end - t_total))
# Get the DataFrame report
report = sess.get_report()
# Get the global summary
summary = sess.get_global_summary(
save_file=os.path.join(report_save_dir, 'summary.json'))
def __init__(self,
db_csv,
base_dir=Path.db_root_dir('pascal'),
transform=None,
area_thres=0,
preprocess=False,
default=False,
retname=True):
"""
:param base_dir: path to VOC dataset directory
:param split: train/val
:param transform: transform to apply
"""
super().__init__()
self._base_dir = base_dir
self._image_dir = os.path.join(self._base_dir, 'JPEGImages')
self._mask_dir = os.path.join(self._base_dir, 'SegmentationObject')
self._cat_dir = os.path.join(self._base_dir, 'SegmentationClass')
self.area_thres = area_thres
self.default = default
self.retname = retname
if isinstance(split, str):
self.split = [split]
else:
split.sort()
self.split = split
# Build the ids file
area_th_str = ""
if self.area_thres != 0:
area_th_str = '_area_thres-' + str(area_thres)
self.obj_list_file = os.path.join(
self._base_dir, 'ImageSets', 'Segmentation',
'_'.join(self.split) + '_instances' + area_th_str + '.txt')
self.transform = transform
_splits_dir = os.path.join(self._base_dir, 'ImageSets', 'Segmentation')
self.im_ids = []
self.images = []
self.categories = []
self.masks = []
for splt in self.split:
with open(os.path.join(os.path.join(_splits_dir, splt + '.txt')),
"r") as f:
lines = f.read().splitlines()
for ii, line in enumerate(lines):
_image = os.path.join(self._image_dir, line + ".jpg")
_cat = os.path.join(self._cat_dir, line + ".png")
_mask = os.path.join(self._mask_dir, line + ".png")
assert os.path.isfile(_image)
assert os.path.isfile(_cat)
assert os.path.isfile(_mask)
self.im_ids.append(line.rstrip('\n'))
self.images.append(_image)
self.categories.append(_cat)
self.masks.append(_mask)
assert (len(self.images) == len(self.masks))
assert (len(self.images) == len(self.categories))
# Precompute the list of objects and their categories for each image
if (not self._check_preprocess()) or preprocess:
print(
'Preprocessing of PASCAL VOC dataset, this will take long, but it will be done only once.'
)
self._preprocess()
# Build the list of objects
self.obj_list = []
num_images = 0
for ii in range(len(self.im_ids)):
flag = False
for jj in range(len(self.obj_dict[self.im_ids[ii]])):
if self.obj_dict[self.im_ids[ii]][jj] != -1:
self.obj_list.append([ii, jj])
flag = True
if flag:
num_images += 1
# Display stats
print('Number of images: {:d}\nNumber of objects: {:d}'.format(
num_images, len(self.obj_list)))
import numpy as np
import matplotlib.pyplot as plt
import os
use_cuda = 0
device = torch.device("cuda" if use_cuda else "cpu")
parent_epoch = 1
n_Epoch = 0
print_every = 500
train_batch = 1
db_root_dir = Path.db_root_dir()
save_dir = Path.save_root_dir()
parentModelName = 'parent'
if 'SEQ_NAME' not in os.environ.keys():
seq_name = 'blackswan'
else:
seq_name = str(os.environ['SEQ_NAME'])
db_root_dir = Path.db_root_dir()
save_dir = Path.save_root_dir()
if not os.path.exists(save_dir):
os.makedirs(os.path.join(save_dir))
def __init__(self,
dataset='ucf101',
split='train',
clip_len=16,
preprocess=False):
self.root_dir, self.output_dir = Path.db_dir(dataset)
folder = os.path.join(self.output_dir, split)
self.clip_len = clip_len
self.split = split
# The following three parameters are chosen as described in the paper section 4.1
self.resize_height = 128
self.resize_width = 171
self.crop_size = 112
if not self.check_integrity():
raise RuntimeError(
'Dataset not found or corrupted.' +
' You need to download it from official website.')
if (not self.check_preprocess()) or preprocess:
print(
'Preprocessing of {} dataset, this will take long, but it will be done only once.'
.format(dataset))
self.preprocess()
# Obtain all the filenames of files inside all the class folders
# Going through each class folder one at a time
self.fnames, labels = [], []
for label in sorted(os.listdir(folder)):
for fname in os.listdir(os.path.join(folder, label)):
self.fnames.append(os.path.join(folder, label, fname))
labels.append(label)
assert len(labels) == len(self.fnames)
print('Number of {} videos: {:d}'.format(split, len(self.fnames)))
# Prepare a mapping between the label names (strings) and indices (ints)
self.label2index = {
label: index
for index, label in enumerate(sorted(set(labels)))
}
# Convert the list of label names into an array of label indices
self.label_array = np.array(
[self.label2index[label] for label in labels], dtype=int)
if dataset == "ucf101":
if not os.path.exists(
'/home/hadi/Documents/ai/action_recognition/pytorch-video-recognition/dataloaders/ucf_labels.txt'
):
with open(
'/home/hadi/Documents/ai/action_recognition/pytorch-video-recognition/dataloaders/ucf_labels.txt',
'w') as f:
for id, label in enumerate(sorted(self.label2index)):
f.writelines(str(id + 1) + ' ' + label + '\n')
elif dataset == 'hmdb51':
if not os.path.exists('dataloaders/hmdb_labels.txt'):
with open('dataloaders/hmdb_labels.txt', 'w') as f:
for id, label in enumerate(sorted(self.label2index)):
f.writelines(str(id + 1) + ' ' + label + '\n')
def __init__(
self,
args,
base_dir=Path.db_root_dir('vocdetection'),
split='train',
):
"""
:param base_dir: path to VOC dataset directory
:param split: train/val
:param transform: transform to apply
"""
super().__init__()
self._base_dir = base_dir
self._image_dir = os.path.join(self._base_dir, 'train')
self._cat_dir = os.path.join(self._base_dir, 'label')
self._image_dir_val = os.path.join('/home/xupeihan/deeplab/test/',
'val')
self._cat_dir_val = os.path.join('/home/xupeihan/deeplab/test/',
'label')
if isinstance(split, str):
self.split = [split]
else:
split.sort()
self.split = split
self.args = args
_splits_dir = os.path.join(self._base_dir, 'Segmentation')
self.im_ids = []
self.images = []
self.categories = []
# for splt in self.split:
# with open(os.path.join(os.path.join(_splits_dir, splt + '.txt')), "r") as f:
# lines = f.read().splitlines()
# for ii, line in enumerate(lines):
# _image = os.path.join(self._image_dir, line + ".jpg")
# _cat = os.path.join(self._cat_dir, line + ".png")
# assert os.path.isfile(_image)
# assert os.path.isfile(_cat)
# self.im_ids.append(line)
# self.images.append(_image)
# self.categories.append(_cat)
if self.split[0] == 'train':
with open(os.path.join(os.path.join(_splits_dir, split + '.txt')),
'r') as f:
lines = f.read().splitlines()
for ii, line in enumerate(lines):
_image = os.path.join(self._image_dir, line + ".jpg")
_cat = os.path.join(self._cat_dir, line + ".png")
assert os.path.isfile(_image)
assert os.path.isfile(_cat)
self.im_ids.append(line)
self.images.append(_image)
self.categories.append(_cat)
else:
#print(os.path.join(os.path.join(_splits_dir ,'val' + '.txt')))
with open(os.path.join(os.path.join(_splits_dir, split + '.txt')),
'r') as f:
lines = f.read().splitlines()
for ii, line in enumerate(lines):
_image = os.path.join(self._image_dir_val, line + ".jpg")
_cat = os.path.join(self._cat_dir_val, line + ".png")
assert os.path.isfile(_image)
assert os.path.isfile(_cat)
self.im_ids.append(line)
self.images.append(_image)
self.categories.append(_cat)
assert (len(self.images) == len(self.categories))
# Display stats
print('Number of images in {}: {:d}'.format(split, len(self.images)))
img[img != 0] = 1
return img.reshape(600, 400).astype(np.uint8)
if __name__ == "__main__":
from dataloaders.utils import decode_segmap
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
import argparse
parser = argparse.ArgumentParser()
args = parser.parse_args()
args.base_size = 513
args.crop_size = 513
dataset = FashionDataset(args, Path.db_root_dir('fashion_clothes'),
'train', 'clothes')
dataloader = DataLoader(dataset,
batch_size=1,
shuffle=False,
num_workers=0)
for ii, sample in enumerate(dataloader):
for jj in range(sample["image"].size()[0]):
img = sample['image'].numpy()
gt = sample['label'].numpy()
tmp = np.array(gt[jj]).astype(np.uint8)
segmap = decode_segmap(tmp, dataset='fashion_clothes')
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)
if args.loss_type == 'depth_loss_two_distributions':
self.nclass = args.num_class + args.num_class2 + 1
if args.loss_type == 'depth_avg_sigmoid_class':
self.nclass = args.num_class + args.num_class2
# 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)
print("\nDefine models...\n")
self.model_aprox_depth = DeepLab(num_classes=1,
backbone=args.backbone,
output_stride=args.out_stride,
sync_bn=args.sync_bn,
freeze_bn=args.freeze_bn)
self.input_conv = nn.Conv2d(4, 3, 3, padding=1)
# Using cuda
if args.cuda:
self.model_aprox_depth = torch.nn.DataParallel(self.model_aprox_depth, device_ids=self.args.gpu_ids)
patch_replication_callback(self.model_aprox_depth)
self.model_aprox_depth = self.model_aprox_depth.cuda()
self.input_conv = self.input_conv.cuda()
print("\nLoad checkpoints...\n")
if not args.cuda:
ckpt_aprox_depth = torch.load(args.ckpt, map_location='cpu')
self.model_aprox_depth.load_state_dict(ckpt_aprox_depth['state_dict'])
else:
ckpt_aprox_depth = torch.load(args.ckpt)
self.model_aprox_depth.module.load_state_dict(ckpt_aprox_depth['state_dict'])
train_params = [{'params': model.get_1x_lr_params(), 'lr': args.lr},
{'params': model.get_10x_lr_params(), 'lr': args.lr * 10}]
# Define Optimizer
# set optimizer
optimizer = torch.optim.Adam(train_params, args.lr)
# 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
if 'depth' in args.loss_type:
self.criterion = DepthLosses(weight=weight,
cuda=args.cuda,
min_depth=args.min_depth,
max_depth=args.max_depth,
num_class=args.num_class,
cut_point=args.cut_point,
num_class2=args.num_class2).build_loss(mode=args.loss_type)
self.infer = DepthLosses(weight=weight,
cuda=args.cuda,
min_depth=args.min_depth,
max_depth=args.max_depth,
num_class=args.num_class,
cut_point=args.cut_point,
num_class2=args.num_class2)
self.evaluator_depth = EvaluatorDepth(args.batch_size)
else:
self.criterion = SegmentationLosses(cuda=args.cuda, weight=weight).build_loss(mode=args.loss_type)
self.evaluator = Evaluator(self.nclass)
self.model, self.optimizer = model, optimizer
# 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
if 'depth' in args.loss_type:
self.best_pred = 1e6
if args.resume is not None:
if not os.path.isfile(args.resume):
raise RuntimeError("=> no checkpoint found at '{}'".format(args.resume))
if not args.cuda:
checkpoint = torch.load(args.resume, map_location='cpu')
else:
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
if args.cuda:
state_dict = checkpoint['state_dict']
state_dict.popitem(last=True)
state_dict.popitem(last=True)
self.model.module.load_state_dict(state_dict, strict=False)
else:
state_dict = checkpoint['state_dict']
state_dict.popitem(last=True)
state_dict.popitem(last=True)
self.model.load_state_dict(state_dict, strict=False)
if not args.ft:
self.optimizer.load_state_dict(checkpoint['optimizer'])
self.best_pred = checkpoint['best_pred']
if 'depth' in args.loss_type:
self.best_pred = 1e6
print("=> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
# Clear start epoch if fine-tuning
if args.ft:
args.start_epoch = 0
# add input layer to the model
self.model = nn.Sequential(
self.input_conv,
self.model
)
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()
def __init__(self,
args,
base_dir=Path.db_root_dir('isic'),
split='train',
percent=1,
label_percent=0.6):
"""
:param base_dir: path to VOC dataset directory
:param split: train/val
:param transform: transform to apply
"""
super().__init__()
self._base_dir = base_dir
self._image_dir = os.path.join(self._base_dir,
'ISIC2018_Task1-2_Training_Input')
self._label_dir = os.path.join(self._base_dir,
'ISIC2018_Task1_Training_GroundTruth')
self._test_image_dir = os.path.join(self._base_dir,
"ISIC2018_Task1-2_Test_Input")
#self._test_label_dir = os.path.join(self._base_dir, "pseudo_label_unet2")
#self._test_label_dir = os.path.join(self._base_dir, "results-high-confidence")
self._test_label_dir = "/data/weishizheng/QiuYiqiao/Segmentation-codes/pseudo_label_unet4/"
self.args = args
self.split = split
self.percent = percent
self.label_percent = label_percent
"""
print("***************************************************")
print( args.percent )
print( percent)
print( args.label_percent )
print( label_percent )
print("###################################################")
"""
"""
if isinstance(split, str):
self.split = [split]
else:
split.sort()
self.split = split
"""
iddataset_path = Path.iddataset_path()
with open(iddataset_path, "rb") as f:
iddataset = pickle.load(f)
if split == 'train':
im_ids = iddataset["train"]
elif split == "val":
im_ids = iddataset["val"]
self.im_ids = []
self.images = []
self.labels = []
for image_id in im_ids:
_image = os.path.join(self._image_dir, image_id[0] + ".jpg")
_label = os.path.join(self._label_dir,
image_id[0] + "_segmentation.png")
#print(_image)
#print(_label)
assert os.path.isfile(_image)
assert os.path.isfile(_label)
self.im_ids.append(image_id[0])
self.images.append(_image)
self.labels.append(_label)
# use for pseudo_label
test_image_name = self.get_file_name(self._test_image_dir)
self.test_images = []
self.pseudo_labels = []
#self.pseudo_labels = get_file(self._test_label_dir)
for image_name in test_image_name:
_image = os.path.join(self._test_image_dir, image_name + ".jpg")
_label = os.path.join(self._test_label_dir,
image_name + "_segmentation.jpg")
assert os.path.isfile(_image)
#set_trace()
assert os.path.isfile(_label)
self.test_images.append(_image)
self.pseudo_labels.append(_label)
if percent < 1:
print("geting ", self.percent)
print("geting ", self.label_percent)
print("using ", percent, " pseudo_labels")
random.shuffle(list(zip(self.test_images, self.pseudo_labels)))
num_of_test = int(len(self.test_images) * percent)
self.test_images = self.test_images[0:num_of_test]
self.pseudo_labels = self.pseudo_labels[0:num_of_test]
print("{} {}".format(len(self.images), len(self.test_images)))
self.num_of_train = len(self.images)
self.num_of_test = len(self.test_images)
assert (len(self.images) == len(self.labels))
# Display stats
print('Number of images in {}: {:d}'.format(split, len(self.images)))
def make_data_loader(args, **kwargs):
if args.dataset == 'pascal':
train_set = pascal.VOCSegmentation(args, split='train')
val_set = pascal.VOCSegmentation(args, split='val')
if args.use_sbd:
sbd_train = sbd.SBDSegmentation(args, split=['train', 'val'])
train_set = combine_dbs.CombineDBs([train_set, sbd_train],
excluded=[val_set])
num_class = train_set.NUM_CLASSES
train_loader = DataLoader(train_set,
batch_size=args.batch_size,
shuffle=True,
**kwargs)
val_loader = DataLoader(val_set,
batch_size=args.batch_size,
shuffle=False,
**kwargs)
test_loader = None
return train_loader, val_loader, test_loader, num_class
elif args.dataset == 'cityscapes':
train_set = cityscapes.CityscapesSegmentation(args, split='train')
val_set = cityscapes.CityscapesSegmentation(args, split='val')
test_set = cityscapes.CityscapesSegmentation(args, split='test')
num_class = train_set.NUM_CLASSES
train_loader = DataLoader(train_set,
batch_size=args.batch_size,
shuffle=True,
**kwargs)
val_loader = DataLoader(val_set,
batch_size=args.batch_size,
shuffle=False,
**kwargs)
test_loader = DataLoader(test_set,
batch_size=args.batch_size,
shuffle=False,
**kwargs)
return train_loader, val_loader, test_loader, num_class
elif args.dataset == 'coco':
train_set = coco.COCOSegmentation(args, split='train')
val_set = coco.COCOSegmentation(args, split='val')
num_class = train_set.NUM_CLASSES
train_loader = DataLoader(train_set,
batch_size=args.batch_size,
shuffle=True,
**kwargs)
val_loader = DataLoader(val_set,
batch_size=args.batch_size,
shuffle=False,
**kwargs)
test_loader = None
return train_loader, val_loader, test_loader, num_class
elif args.dataset == 'flood':
workpath = Path.db_root_dir('flood')
train_data = flood.load_flood_train_data(workpath)
train_dataset = flood.InMemoryDataset(train_data,
flood.processAndAugment)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=16,
shuffle=True,
sampler=None,
batch_sampler=None,
num_workers=0,
collate_fn=None,
pin_memory=True,
drop_last=False,
timeout=0,
worker_init_fn=None)
valid_data = flood.load_flood_valid_data(workpath)
valid_dataset = flood.InMemoryDataset(valid_data, flood.processTestIm)
valid_loader = torch.utils.data.DataLoader(
valid_dataset,
batch_size=4,
shuffle=True,
sampler=None,
batch_sampler=None,
num_workers=0,
collate_fn=lambda x:
(torch.cat([a[0] for a in x], 0), torch.cat([a[1] for a in x], 0)),
pin_memory=True,
drop_last=False,
timeout=0,
worker_init_fn=None)
test_data = flood.load_flood_valid_data(workpath)
test_dataset = flood.InMemoryDataset(test_data, flood.processTestIm)
test_loader = torch.utils.data.DataLoader(
test_dataset,
batch_size=4,
shuffle=True,
sampler=None,
batch_sampler=None,
num_workers=0,
collate_fn=lambda x:
(torch.cat([a[0] for a in x], 0), torch.cat([a[1] for a in x], 0)),
pin_memory=True,
drop_last=False,
timeout=0,
worker_init_fn=None)
num_class = 2
return train_loader, valid_loader, test_loader, num_class
else:
raise NotImplementedError
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.printer = args.printer
# Define Dataloader
kwargs = {'num_workers': args.workers, 'pin_memory': True}
self.train_loader, self.val_loader, self.test_loader, self.nclass, self.class_names = make_data_loader(
args, **kwargs)
# Define network
self.model = self.get_net()
if args.net in {
'deeplabv3p', 'wdeeplabv3p', 'wsegnet', 'segnet', 'unet'
}:
train_params = [{
'params': self.model.get_1x_lr_params(),
'lr': args.lr
}, {
'params': self.model.get_10x_lr_params(),
'lr': args.lr * 10
}]
elif args.net in {'segnet', 'waveunet', 'unet', 'waveunet_v2'}:
weight_p, bias_p = [], []
for name, p in self.model.named_parameters():
if 'bias' in name:
bias_p.append(p)
else:
weight_p.append(p)
train_params = [{
'params': weight_p,
'weight_decay': args.weight_decay,
'lr': args.lr
}, {
'params': bias_p,
'weight_decay': 0,
'lr': args.lr
}]
else:
train_params = None
assert args.net in {
'deeplabv3p', 'wdeeplabv3p', 'wsegnet', 'segnet', 'unet'
}
optimizer = torch.optim.SGD(train_params,
momentum=args.momentum,
nesterov=args.nesterov)
self.optimizer = optimizer
# Define Optimizer
# 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.criterion = SegmentationLosses(
weight=weight,
cuda=args.cuda,
batch_average=self.args.batch_average).build_loss(
mode=args.loss_type)
# Define Evaluator
self.evaluator = Evaluator(self.nclass)
# Define lr scheduler
self.args.printer.pprint(
'Using {} LR Scheduler!, initialization lr = {}'.format(
args.lr_scheduler, args.lr))
if self.args.net.startswith('deeplab'):
self.scheduler = LR_Scheduler(args.lr_scheduler, args.lr,
args.epochs, len(self.train_loader))
else:
self.scheduler = LR_Scheduler(args.lr_scheduler,
args.lr,
args.epochs,
len(self.train_loader),
net=self.args.net)
for key, value in self.args.__dict__.items():
if not key.startswith('_'):
self.printer.pprint('{} ==> {}'.format(key.rjust(24), value))
# Using cuda
if args.cuda:
self.model = torch.nn.DataParallel(self.model,
device_ids=self.args.gpu,
output_device=args.out_gpu)
patch_replication_callback(self.model)
self.model = self.model.cuda()
# Resuming checkpoint
self.best_pred = 0.0
if args.resume is not None:
if args.dataset in ['pascal', 'cityscapes']:
#self.load_pretrained_model()
#elif args.dataset == 'cityscapes':
self.load_pretrained_model_cityscape()
# Clear start epoch if fine-tuning
if args.ft:
args.start_epoch = 0
