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', 'customized']) parser.add_argument('--trainset_part', type=str, default='trainval', choices=['trainval', 'train']) parser.add_argument('--customized_folder_path', type=str, default='customized') 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('--batch_size', type=int, default=64) 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=1) parser.add_argument('--last_conv_stride', type=int, default=1, choices=[1, 2]) # When the stride is changed to 1, we can compensate for the receptive field # using dilated convolution. However, experiments show dilated convolution is useless. parser.add_argument('--last_conv_dilation', type=int, default=1, choices=[1, 2]) parser.add_argument('--num_stripes', type=int, default=6) parser.add_argument('--local_conv_out_channels', type=int, default=256) 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('--new_params_lr', type=float, default=0.1) parser.add_argument('--finetuned_params_lr', type=float, default=0.01) parser.add_argument('--staircase_decay_at_epochs', type=eval, default=(41, )) parser.add_argument('--staircase_decay_multiply_factor', type=float, default=0.1) parser.add_argument('--total_epochs', type=int, default=60) 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.train_batch_size = args.batch_size self.train_final_batch = False self.train_shuffle = True self.test_mirror_type = None self.test_batch_size = 32 self.test_final_batch = True self.test_shuffle = False self.customized_folder_path = args.customized_folder_path 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', customized_folder_path=self.customized_folder_path, 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, batch_size=self.train_batch_size, 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 # When the stride is changed to 1, we can compensate for the receptive field # using dilated convolution. However, experiments show dilated convolution is useless. self.last_conv_dilation = args.last_conv_dilation # Number of stripes (parts) self.num_stripes = args.num_stripes # Output channel of 1x1 conv self.local_conv_out_channels = args.local_conv_out_channels ############# # Training # ############# self.momentum = 0.9 self.weight_decay = 0.0005 # Initial learning rate self.new_params_lr = args.new_params_lr self.finetuned_params_lr = args.finetuned_params_lr 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), '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('-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=(384, 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('--batch_size', type=int, default=64) 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=1) parser.add_argument('--last_conv_stride', type=int, default=1, choices=[1, 2]) # When the stride is changed to 1, we can compensate for the receptive field # using dilated convolution. However, experiments show dilated convolution is useless. parser.add_argument('--last_conv_dilation', type=int, default=1, choices=[1, 2]) parser.add_argument('--num_stripes', type=int, default=6) parser.add_argument('--local_conv_out_channels', type=int, default=256) 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('--new_params_lr', type=float, default=0.1) parser.add_argument('--finetuned_params_lr', type=float, default=0.01) parser.add_argument('--staircase_decay_at_epochs', type=eval, default=(41,)) parser.add_argument('--staircase_decay_multiply_factor', type=float, default=0.1) parser.add_argument('--total_epochs', type=int, default=60) 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.train_batch_size = args.batch_size self.train_final_batch = False self.train_shuffle = True 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 if self.seed is not None: prng = np.random.RandomState(self.seed) self.train_set_kwargs = dict( part=self.trainset_part, batch_size=self.train_batch_size, 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 # When the stride is changed to 1, we can compensate for the receptive field # using dilated convolution. However, experiments show dilated convolution is useless. self.last_conv_dilation = args.last_conv_dilation # Number of stripes (parts) self.num_stripes = args.num_stripes # Output channel of 1x1 conv self.local_conv_out_channels = args.local_conv_out_channels ############# # Training # ############# self.momentum = 0.9 self.weight_decay = 0.0005 # Initial learning rate self.new_params_lr = args.new_params_lr self.finetuned_params_lr = args.finetuned_params_lr 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), '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=(384, 128)) parser.add_argument('--last_conv_stride', type=int, default=1, choices=[1, 2]) parser.add_argument('--num_stripes', type=int, default=6) parser.add_argument('--local_conv_out_channels', type=int, default=256) 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 # Number of stripes (parts) self.num_stripes = args.num_stripes # Output channel of 1x1 conv self.local_conv_out_channels = args.local_conv_out_channels ####### # 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
def __init__(self, gpus, dataset, feat_dims_per_part, \ only_test, loop, save_dir): self.run = loop self.seed = None if self.seed is not None: self.prefetch_threads = 1 else: self.prefetch_threads = 2 self.trainset_part = 'trainval' # gpu ids self.sys_device_ids = gpus # dataset name self.dataset = dataset # Just for training set self.crop_prob = 0 self.crop_ratio = 1 self.resize_h_w = (384, 128) 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' self.train_batch_size = 64 self.train_final_batch = False self.train_shuffle = True self.test_mirror_type = None self.test_batch_size = 32 self.test_final_batch = True self.test_shuffle = False ## Dataset 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) # Training dataset prng = np.random if self.seed is not None: prng = np.random.RandomState(self.seed) self.train_set_kwargs = dict( part=self.trainset_part, batch_size=self.train_batch_size, 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) # Valid dataset 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) self.val_set = None # Test dataset 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 self.last_conv_stride = 1 self.last_conv_dilation = 1 self.num_stripes = 6 self.local_conv_out_channels = feat_dims_per_part ## Training self.momentum = 0.9 self.weight_decay = 0.0005 # Initial learning rate self.new_params_lr = 0.1 self.finetuned_params_lr = 0.01 self.staircase_decay_at_epochs = (41,) self.staircase_decay_multiply_factor = 0.1 # Number of epochs to train self.total_epochs = 60 # How often (in epochs) to test on val set. self.epochs_per_val = 1 # 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 = 20 # Only test and without training. self.only_test = only_test self.resume = False self.log_to_file = True # The root dir of logs. assert loop > 0 if save_dir == '': self.exp_dir = osp.join( 'exp/train', '{}'.format(self.dataset), 'run{}'.format(self.run), ) else: self.exp_dir = save_dir + '/' + str(loop) 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())) #ckpt_fname = 'ckpt' + str(loop) + '.pth' self.ckpt_file = osp.join(self.exp_dir, 'ckpt.pth')
def __init__(self): parser = argparse.ArgumentParser() parser.add_argument('-d', '--sys_device_ids', type=eval, default=(0, 1, 2, 3)) parser.add_argument('-r', '--run', type=int, default=1) parser.add_argument('--set_seed', type=str2bool, default=False) parser.add_argument('--pcb_dataset', type=str, default='market1501', choices=['market_png_4_1','market_png','market30_retain_pixel1','market30_retain_pixel2','market30_retain_pixel4',\ 'market30_retain_pixel5','market30_retain_pixel6',\ 'market30_retain_pixel7','market30_retain_pixel8','market30_retain_pixel9','market30_retain_pixel10',\ 'market30_retain_pixel3','cuhk33_retain_3','market30_retain_pixel0_3_1','mars30_retain_pixel7','mars32_retain_pixel7','mars33_retain_pixel7','market30_retain_2','market30_retain_3','market30_retain_pixel0_2','market30_retain_pixel0_3',\ 'market30_retain_pixel0','mars_oldmask_retain','mars','mars20','mars22','mars23','mars30','mars32','mars33','market',\ 'cuhk20','cuhk22','cuhk23','cuhk20_retain','cuhk22_retain','cuhk23_retain','cuhk30','cuhk32','cuhk33',\ 'cuhk30_retain','cuhk32_retain','cuhk33_retain','cuhk40','cuhk42','cuhk43','cuhk40_retain','cuhk42_retain',\ 'cuhk43_retain','market1501','market_combined','market23','market22', 'market20','market20_retain','market22_retain',\ 'market23_retain', 'market30','market32','market33','market30_retain','market32_retain','market33_retain',\ 'market40','market42','market43','market40_retain','market42_retain','market43_retain','market_oldmask',\ 'market_oldmask_retain','market_trans','market_png']) parser.add_argument('--triplet_dataset', type=str, default='market1501', choices=['market_png_4_1','market_png','market30_retain_pixel3_rand_1','market30_retain_pixel1_4_1',\ 'market30_retain_pixel2_4_1','market30_retain_pixel4_4_1','market30_retain_pixel5_4_1',\ 'market30_retain_pixel6_4_1','market30_retain_pixel7_4_1','market30_retain_pixel8_4_1','market30_retain_pixel9_4_1',\ 'market30_retain_pixel10_4_1','market30_retain_rand_1','market30_retain_pixel3_3_1','market30_retain_pixel3_4_1',\ 'market30_retain_pixel3_5_3','market30_retain_pixel3_rand_1',\ 'cuhk33_retain_3_1','cuhk33_retain_4','cuhk33_retain_4_1','cuhk33_retain_5','cuhk33_retain_5_3','cuhk33_retain_5_6',\ 'market30_retain_3_1','market30_retain_4','market30_retain_4_1','market30_retain_5',\ 'market30_retain_5_3','market30_retain_5_6','market33_retain_5','market33_retain_5_3','market33_retain_5_6',\ 'market33_retain_3','market33_retain_3_1','market33_retain_4','market33_retain_4_1',\ 'market30_retain_pixel0_4_1','market30_retain_pixel0_5_6','market30_retain_pixel0_5_3','market30_retain_pixel0_5',\ 'market30_retain_pixel0_4_5','cuhk33_retain_3','market30_retain_pixel0_3_1','mars30_retain_pixel7','mars32_retain_pixel7',\ 'mars33_retain_pixel7','market30_retain_2','market30_retain_3','market30_retain_pixel0_2','market30_retain_pixel0_3',\ 'market30_retain_pixel0','mars_oldmask_retain','mars','mars20','mars22','mars23','mars30','mars32','mars33','market',\ 'cuhk20','cuhk22','cuhk23','cuhk20_retain','cuhk22_retain','cuhk23_retain','cuhk30','cuhk32','cuhk33',\ 'cuhk30_retain','cuhk32_retain','cuhk33_retain','cuhk40','cuhk42','cuhk43','cuhk40_retain','cuhk42_retain',\ 'cuhk43_retain','market1501','market_combined','market23','market22', 'market20','market20_retain','market22_retain',\ 'market23_retain', 'market30','market32','market33','market30_retain','market32_retain','market33_retain',\ 'market40','market42','market43','market40_retain','market42_retain','market43_retain','market_oldmask',\ 'market_oldmask_retain','market_trans','market_png']) parser.add_argument('--trainset_part', type=str, default='trainval', choices=['trainval', 'train']) parser.add_argument('--resize_h_w', type=eval, default=(384, 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('--batch_size', type=int, default=64) parser.add_argument('--triplet_batch_size', type=int, default=192) 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=1) parser.add_argument('--last_conv_stride', type=int, default=1, choices=[1, 2]) # When the stride is changed to 1, we can compensate for the receptive field # using dilated convolution. However, experiments show dilated convolution is useless. parser.add_argument('--last_conv_dilation', type=int, default=1, choices=[1, 2]) parser.add_argument('--num_stripes', type=int, default=6) parser.add_argument('--num_cols', type=int, default=1) parser.add_argument('--local_conv_out_channels', type=int, default=256) parser.add_argument('--only_test', type=str2bool, default=False) parser.add_argument('--only_triplet', type=str2bool, default=False) parser.add_argument('--only_all', 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('--new_params_lr', type=float, default=0.1) parser.add_argument('--finetuned_params_lr', type=float, default=0.01) parser.add_argument('--triplet_finetuned_params_lr', type=float, default=0.001) parser.add_argument('--all_base_finetuned_params_lr', type=float, default=0.001) parser.add_argument('--all_new_finetuned_params_lr', type=float, default=0.01) parser.add_argument('--staircase_decay_at_epochs', type=eval, default=(41, )) parser.add_argument('--all_staircase_decay_at_epochs', type=eval, default=(25, )) parser.add_argument('--staircase_decay_multiply_factor', type=float, default=0.1) parser.add_argument('--triplet_staircase_decay_multiply_factor', type=float, default=1) parser.add_argument('--total_epochs', type=int, default=5) parser.add_argument('--triplet_epochs', type=int, default=5) parser.add_argument('--pcb_epochs', type=int, default=60) parser.add_argument('--margin', type=float, default=0.5, metavar='MARGIN') parser.add_argument('--momentum', type=float, default=0.9, metavar='MOMENTTUM') parser.add_argument('--weight_decay', type=float, default=0.0005) args = parser.parse_args() #lr self.triplet_finetuned_params_lr = args.triplet_finetuned_params_lr self.all_base_finetuned_params_lr = args.all_base_finetuned_params_lr self.all_new_finetuned_params_lr = args.all_new_finetuned_params_lr # gpu ids self.sys_device_ids = args.sys_device_ids #parts number self.parts_num = args.num_cols * args.num_stripes # margin self.margin = args.margin # 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.pcb_dataset = args.pcb_dataset self.triplet_dataset = args.triplet_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,0.5] # self.im_std = [0.229, 0.224, 0.225,0.5] self.im_mean = None self.im_std = None self.train_mirror_type = 'random' if args.mirror else None self.pcb_train_batch_size = args.batch_size self.train_batch_size = args.triplet_batch_size self.train_final_batch = False #modify the train_shuffle and keep the corresponding relation self.train_shuffle = False self.pcb_train_shuffle = True self.test_mirror_type = None self.test_batch_size = 32 self.test_final_batch = True self.test_shuffle = False self.pcb_test_shuffle = True triplet_dataset_kwargs = dict( name=self.triplet_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) pcb_dataset_kwargs = dict(name=self.pcb_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) """ pcb dataset """ prng = np.random if self.seed is not None: prng = np.random.RandomState(self.seed) self.pcb_train_set_kwargs = dict(part=self.trainset_part, batch_size=self.pcb_train_batch_size, final_batch=self.train_final_batch, shuffle=self.pcb_train_shuffle, crop_prob=self.crop_prob, crop_ratio=self.crop_ratio, mirror_type=self.train_mirror_type, prng=prng) self.pcb_train_set_kwargs.update(pcb_dataset_kwargs) """ all dataset """ prng = np.random if self.seed is not None: prng = np.random.RandomState(self.seed) self.all_train_set_kwargs = dict(part=self.trainset_part, batch_size=self.train_batch_size, final_batch=self.train_final_batch, shuffle=self.pcb_train_shuffle, crop_prob=self.crop_prob, crop_ratio=self.crop_ratio, mirror_type=self.train_mirror_type, prng=prng) self.all_train_set_kwargs.update(pcb_dataset_kwargs) """ triplet dataset """ prng = np.random if self.seed is not None: prng = np.random.RandomState(self.seed) self.train_set_anchor_kwargs = dict(flag='anchor', part=self.trainset_part, batch_size=self.train_batch_size, 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_anchor_kwargs.update(triplet_dataset_kwargs) prng = np.random if self.seed is not None: prng = np.random.RandomState(self.seed) self.train_set_positive_kwargs = dict( flag='positive', part=self.trainset_part, batch_size=self.train_batch_size, 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_positive_kwargs.update(triplet_dataset_kwargs) prng = np.random if self.seed is not None: prng = np.random.RandomState(self.seed) self.train_set_negative_kwargs = dict( flag='negative', part=self.trainset_part, batch_size=self.train_batch_size, 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_negative_kwargs.update(triplet_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(triplet_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(triplet_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 # When the stride is changed to 1, we can compensate for the receptive field # using dilated convolution. However, experiments show dilated convolution is useless. self.last_conv_dilation = args.last_conv_dilation # Number of stripes (parts) self.num_stripes = args.num_stripes self.num_cols = args.num_cols # Output channel of 1x1 conv self.local_conv_out_channels = args.local_conv_out_channels ############# # Training # ############# self.momentum = args.momentum self.weight_decay = args.weight_decay # Initial learning rate self.new_params_lr = args.new_params_lr self.finetuned_params_lr = args.finetuned_params_lr self.staircase_decay_at_epochs = args.staircase_decay_at_epochs self.staircase_decay_multiply_factor = args.staircase_decay_multiply_factor self.triplet_staircase_decay_multiply_factor = args.triplet_staircase_decay_multiply_factor self.all_staircase_decay_at_epochs = args.all_staircase_decay_at_epochs # Number of epochs to train self.total_epochs = args.total_epochs self.triplet_epochs = args.triplet_epochs self.pcb_epochs = args.pcb_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 #Only triplet without pcb training ,load pcb_ckpt file self.only_triplet = args.only_triplet self.only_all = args.only_all 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.pcb_dataset), '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.pcb_ckpt_file = osp.join(self.exp_dir, 'pcb_ckpt.pth') self.triplet_ckpt_file = osp.join(self.exp_dir, 'triplet_ckpt.pth') 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=(384, 128)) parser.add_argument('--last_conv_stride', type=int, default=1, choices=[1, 2]) parser.add_argument('--num_stripes', type=int, default=6) parser.add_argument('--local_conv_out_channels', type=int, default=256) 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 # Number of stripes (parts) self.num_stripes = args.num_stripes # Output channel of 1x1 conv self.local_conv_out_channels = args.local_conv_out_channels ####### # 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