def __init__(self):
parser = argparse.ArgumentParser()
parser.add_argument('-d', '--sys_device_ids', type=eval, default=(0, ))
parser.add_argument('-r', '--run', type=int, default=1)
parser.add_argument('--set_seed', type=str2bool, default=False)
parser.add_argument(
'--dataset',
type=str,
default='market1501',
choices=['market1501', 'cuhk03', 'duke', 'combined'])
parser.add_argument('--trainset_part',
type=str,
default='trainval',
choices=['trainval', 'train'])
parser.add_argument('--resize_h_w', type=eval, default=(256, 128))
# These several only for training set
parser.add_argument('--crop_prob', type=float, default=0)
parser.add_argument('--crop_ratio', type=float, default=1)
parser.add_argument('--mirror', type=str2bool, default=True)
parser.add_argument('--ids_per_batch', type=int, default=16)
parser.add_argument('--ims_per_id', type=int, default=4)
parser.add_argument('--log_to_file', type=str2bool, default=True)
parser.add_argument('--steps_per_log', type=int, default=20)
parser.add_argument('--epochs_per_val', type=int, default=1e10)
parser.add_argument('--last_conv_stride',
type=int,
default=1,
choices=[1, 2])
parser.add_argument('--normalize_feature',
type=str2bool,
default=False)
parser.add_argument('--margin', type=float, default=0.3)
parser.add_argument('--only_test', type=str2bool, default=False)
parser.add_argument('--resume', type=str2bool, default=False)
parser.add_argument('--exp_dir', type=str, default='')
parser.add_argument('--model_weight_file', type=str, default='')
parser.add_argument('--base_lr', type=float, default=2e-4)
parser.add_argument('--lr_decay_type',
type=str,
default='exp',
choices=['exp', 'staircase'])
parser.add_argument('--exp_decay_at_epoch', type=int, default=151)
parser.add_argument('--staircase_decay_at_epochs',
type=eval,
default=(
101,
201,
))
parser.add_argument('--staircase_decay_multiply_factor',
type=float,
default=0.1)
parser.add_argument('--total_epochs', type=int, default=300)
args = parser.parse_args()
# gpu ids
self.sys_device_ids = args.sys_device_ids
# If you want to make your results exactly reproducible, you have
# to fix a random seed.
if args.set_seed:
self.seed = 1
else:
self.seed = None
# The experiments can be run for several times and performances be averaged.
# `run` starts from `1`, not `0`.
self.run = args.run
###########
# Dataset #
###########
# If you want to make your results exactly reproducible, you have
# to also set num of threads to 1 during training.
if self.seed is not None:
self.prefetch_threads = 1
else:
self.prefetch_threads = 2
self.dataset = args.dataset
self.trainset_part = args.trainset_part
# Image Processing
# Just for training set
self.crop_prob = args.crop_prob
self.crop_ratio = args.crop_ratio
self.resize_h_w = args.resize_h_w
# Whether to scale by 1/255
self.scale_im = True
self.im_mean = [0.486, 0.459, 0.408]
self.im_std = [0.229, 0.224, 0.225]
self.train_mirror_type = 'random' if args.mirror else None
self.ids_per_batch = args.ids_per_batch
self.ims_per_id = args.ims_per_id
self.train_final_batch = False
self.train_shuffle = True
self.test_batch_size = 32
self.test_final_batch = True
self.test_mirror_type = None
self.test_shuffle = False
dataset_kwargs = dict(name=self.dataset,
resize_h_w=self.resize_h_w,
scale=self.scale_im,
im_mean=self.im_mean,
im_std=self.im_std,
batch_dims='NCHW',
num_prefetch_threads=self.prefetch_threads)
prng = np.random
if self.seed is not None:
prng = np.random.RandomState(self.seed)
self.train_set_kwargs = dict(part=self.trainset_part,
ids_per_batch=self.ids_per_batch,
ims_per_id=self.ims_per_id,
final_batch=self.train_final_batch,
shuffle=self.train_shuffle,
crop_prob=self.crop_prob,
crop_ratio=self.crop_ratio,
mirror_type=self.train_mirror_type,
prng=prng)
self.train_set_kwargs.update(dataset_kwargs)
prng = np.random
if self.seed is not None:
prng = np.random.RandomState(self.seed)
self.val_set_kwargs = dict(part='val',
batch_size=self.test_batch_size,
final_batch=self.test_final_batch,
shuffle=self.test_shuffle,
mirror_type=self.test_mirror_type,
prng=prng)
self.val_set_kwargs.update(dataset_kwargs)
prng = np.random
if self.seed is not None:
prng = np.random.RandomState(self.seed)
self.test_set_kwargs = dict(part='test',
batch_size=self.test_batch_size,
final_batch=self.test_final_batch,
shuffle=self.test_shuffle,
mirror_type=self.test_mirror_type,
prng=prng)
self.test_set_kwargs.update(dataset_kwargs)
###############
# ReID Model #
###############
# The last block of ResNet has stride 2. We can set the stride to 1 so that
# the spatial resolution before global pooling is doubled.
self.last_conv_stride = args.last_conv_stride
# Whether to normalize feature to unit length along the Channel dimension,
# before computing distance
self.normalize_feature = args.normalize_feature
# Margin of triplet loss
self.margin = args.margin
#############
# Training #
#############
self.weight_decay = 0.0005
# Initial learning rate
self.base_lr = args.base_lr
self.lr_decay_type = args.lr_decay_type
self.exp_decay_at_epoch = args.exp_decay_at_epoch
self.staircase_decay_at_epochs = args.staircase_decay_at_epochs
self.staircase_decay_multiply_factor = args.staircase_decay_multiply_factor
# Number of epochs to train
self.total_epochs = args.total_epochs
# How often (in epochs) to test on val set.
self.epochs_per_val = args.epochs_per_val
# How often (in batches) to log. If only need to log the average
# information for each epoch, set this to a large value, e.g. 1e10.
self.steps_per_log = args.steps_per_log
# Only test and without training.
self.only_test = args.only_test
self.resume = args.resume
#######
# Log #
#######
# If True,
# 1) stdout and stderr will be redirected to file,
# 2) training loss etc will be written to tensorboard,
# 3) checkpoint will be saved
self.log_to_file = args.log_to_file
# The root dir of logs.
if args.exp_dir == '':
self.exp_dir = osp.join(
'exp/train',
'{}'.format(self.dataset),
#
'lcs_{}_'.format(self.last_conv_stride) +
('nf_' if self.normalize_feature else 'not_nf_') +
'margin_{}_'.format(tfs(self.margin)) +
'lr_{}_'.format(tfs(self.base_lr)) +
'{}_'.format(self.lr_decay_type) +
('decay_at_{}_'.format(self.exp_decay_at_epoch) if self.
lr_decay_type == 'exp' else 'decay_at_{}_factor_{}_'.format(
'_'.join([str(e)
for e in args.staircase_decay_at_epochs]),
tfs(self.staircase_decay_multiply_factor))) +
'total_{}'.format(self.total_epochs),
#
'run{}'.format(self.run),
)
else:
self.exp_dir = args.exp_dir
self.stdout_file = osp.join(self.exp_dir,
'stdout_{}.txt'.format(time_str()))
self.stderr_file = osp.join(self.exp_dir,
'stderr_{}.txt'.format(time_str()))
# Saving model weights and optimizer states, for resuming.
self.ckpt_file = osp.join(self.exp_dir, '{}_ckpt.pth')
# Just for loading a pretrained model; no optimizer states is needed.
self.model_weight_file = args.model_weight_file
def __init__(self):
parser = argparse.ArgumentParser()
parser.add_argument('-d', '--sys_device_ids', type=eval, default=(0,))
parser.add_argument('--dataset', type=str, default='market1501',
choices=['market1501', 'cuhk03', 'duke'])
parser.add_argument('--num_queries', type=int, default=16)
parser.add_argument('--rank_list_size', type=int, default=10)
parser.add_argument('--resize_h_w', type=eval, default=(256, 128))
parser.add_argument('--last_conv_stride', type=int, default=1,
choices=[1, 2])
parser.add_argument('--normalize_feature', type=str2bool, default=False)
parser.add_argument('--log_to_file', type=str2bool, default=True)
parser.add_argument('--exp_dir', type=str, default='')
parser.add_argument('--ckpt_file', type=str, default='')
parser.add_argument('--model_weight_file', type=str, default='')
args = parser.parse_args()
# gpu ids
self.sys_device_ids = args.sys_device_ids
self.num_queries = args.num_queries
self.rank_list_size = args.rank_list_size
###########
# Dataset #
###########
self.dataset = args.dataset
self.prefetch_threads = 2
# Image Processing
self.resize_h_w = args.resize_h_w
# Whether to scale by 1/255
self.scale_im = True
self.im_mean = [0.486, 0.459, 0.408]
self.im_std = [0.229, 0.224, 0.225]
self.test_mirror_type = None
self.test_batch_size = 32
self.test_final_batch = True
self.test_shuffle = False
dataset_kwargs = dict(
name=self.dataset,
resize_h_w=self.resize_h_w,
scale=self.scale_im,
im_mean=self.im_mean,
im_std=self.im_std,
batch_dims='NCHW',
num_prefetch_threads=self.prefetch_threads)
prng = np.random
self.test_set_kwargs = dict(
part='test',
batch_size=self.test_batch_size,
final_batch=self.test_final_batch,
shuffle=self.test_shuffle,
mirror_type=self.test_mirror_type,
prng=prng)
self.test_set_kwargs.update(dataset_kwargs)
###############
# ReID Model #
###############
# The last block of ResNet has stride 2. We can set the stride to 1 so that
# the spatial resolution before global pooling is doubled.
self.last_conv_stride = args.last_conv_stride
# Whether to normalize feature to unit length along the Channel dimension,
# before computing distance
self.normalize_feature = args.normalize_feature
#######
# Log #
#######
# If True, stdout and stderr will be redirected to file
self.log_to_file = args.log_to_file
# The root dir of logs.
if args.exp_dir == '':
self.exp_dir = osp.join(
'exp/visualize_rank_list',
'{}'.format(self.dataset),
)
else:
self.exp_dir = args.exp_dir
self.stdout_file = osp.join(
self.exp_dir, 'stdout_{}.txt'.format(time_str()))
self.stderr_file = osp.join(
self.exp_dir, 'stderr_{}.txt'.format(time_str()))
# Model weights and optimizer states, for resuming.
self.ckpt_file = args.ckpt_file
# Just for loading a pretrained model; no optimizer states is needed.
self.model_weight_file = args.model_weight_file
