def main(args): np.random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed_all(args.seed) cudnn.benchmark = True use_gpu = torch.cuda.is_available() if args.use_cpu: use_gpu = False # Create data loaders if args.height is None or args.width is None: args.height, args.width = (144, 56) if args.arch == 'inception' else \ (256, 128) query_img = args.query gallery_path = args.gallery transform = Compose([ RectScale(args.height, args.width), ToTensor(), Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) query_loader = DataLoader(RawDatasetPath(glob.glob(query_img + '/*.jpg'), transform=transform), batch_size=1, shuffle=False, num_workers=args.workers, pin_memory=use_gpu, drop_last=False) gallery_loader = DataLoader(RawDatasetPath(glob.glob(gallery_path + '/*.jpg'), transform=transform), batch_size=16, shuffle=False, num_workers=args.workers, pin_memory=use_gpu, drop_last=False) # Create model model = models.create(args.arch, num_features=args.features, dropout=args.dropout, num_classes=751, cut_at_pooling=False, FCN=True) # Load from checkpoint print('Loading model ...') if args.load_weights and check_isfile(args.load_weights): load_checkpoint(model, args.load_weights) model = nn.DataParallel(model).cuda() if use_gpu else model distmat = inference(model, query_loader, gallery_loader, use_gpu) if args.visualize_ranks: # Do some visualize ranks pass
def main(args): os.environ["CUDA_VISIBLE_DEVICES"] = "0" #device_ids = [0, 1, 2, 3] np.random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed_all(args.seed) cudnn.benchmark = True # Redirect print to both console and log file if not args.evaluate: sys.stdout = Logger(osp.join(args.logs_dir, 'log.txt')) # Create data loaders if args.height is None or args.width is None: args.height, args.width = (144, 56) if args.arch == 'inception' else \ (256, 128) dataset, num_classes, train_loader, query_loader, gallery_loader = \ get_data(args.dataset, args.data_dir, args.height, args.width, args.batch_size, args.workers, ) # Create model model = models.create(args.arch, num_features=args.features, dropout=args.dropout, num_classes=num_classes, cut_at_pooling=False, FCN=True) # Load from checkpoint start_epoch = best_top1 = 0 if args.resume: checkpoint = load_checkpoint(args.resume) model_dict = model.state_dict() checkpoint_load = { k: v for k, v in (checkpoint['state_dict']).items() if k in model_dict } model_dict.update(checkpoint_load) model.load_state_dict(model_dict) # model.load_state_dict(checkpoint['state_dict']) start_epoch = checkpoint['epoch'] best_top1 = checkpoint['best_top1'] print("=> Start epoch {} best top1 {:.1%}".format( start_epoch, best_top1)) #model = nn.DataParallel(model) model = nn.DataParallel(model).cuda() # Evaluator evaluator = Evaluator(model) # Final test print('Test with best model:') checkpoint = load_checkpoint('checkpoint.pth.tar') model.module.load_state_dict(checkpoint['state_dict']) evaluator.evaluate(query_loader, gallery_loader, dataset.query, dataset.gallery)
def main(args): np.random.seed(args.seed) torch.manual_seed(args.seed) cudnn.benchmark = True # Redirect print to both console and log file if not args.evaluate: sys.stdout = Logger(osp.join(args.logs_dir, 'log.txt')) # Create data loaders #if args.height is None or args.width is None: # args.height, args.width = (224, 224) #dataset, num_classes, train_loader, test_loader = \ # get_data(args.dataset, args.split, args.data_dir, args.height, # args.width, args.batch_size, args.num_instances, args.workers, # args.combine_trainval) query_loader, gallery_loader = get_real_test_data(args.query_dir, args.gallery_dir, args.height, args.width, args.batch_size, args.workers) #query_loader, _ = get_real_test_data(args.query_dir, args.gallery_dir, args.height, args.width, args.batch_size, args.workers) # Create model model = models.create(args.arch, num_classes=args.num_classes, num_features=args.features, test_attribute=True) # Load from checkpoint start_epoch = best_top1 = 0 if args.weights: checkpoint = load_checkpoint(args.weights) model.load_state_dict(checkpoint['state_dict']) if args.resume and not args.weights: checkpoint = load_checkpoint(args.resume) model.load_state_dict(checkpoint['state_dict']) start_epoch = checkpoint['epoch'] print("=> Start epoch {} best top1 {:.1%}".format( start_epoch, best_top1)) model = nn.DataParallel(model).cuda() # Evaluator evaluator = Evaluator(model) if args.evaluate: print("Test:") evaluator.evaluate(test_loader, dataset.query, dataset.gallery) return # Test evaluator.evaluate(query_loader, gallery_loader)
def main_worker(args): cudnn.benchmark = True log_dir = osp.dirname(args.resume) sys.stdout = Logger(osp.join(log_dir, 'log_test.txt')) # Create data loaders dataset_target, test_loader_target = \ get_data(args.dataset, args.data_dir, args.height, args.width, args.batch_size, args.workers) # Create model model = models.create(args.arch, num_features=args.features, num_classes=0) model.cuda() model = nn.DataParallel(model) # Load from checkpoint checkpoint = load_checkpoint(args.resume) copy_state_dict(checkpoint, model) # Evaluator evaluator = Evaluator(model) print("Testing...") evaluator.evaluate(test_loader_target, dataset_target.query, dataset_target.gallery, cmc_flag=True, args=args, rerank=args.rerank) return
def main(args): print('running...') np.random.seed(args.seed) torch.manual_seed(args.seed) cudnn.benchmark = True print(args) # Create data loaders if args.target_height is None or args.target_width is None: args.target_height, args.target_width = (288, 384) # Create model model = Combine_Net(arch=args.arch, num_classes=args.num_classes, num_features=args.num_features) # Load from checkpoint checkpoint = load_checkpoint(args.resume) model.net.load_state_dict(checkpoint['state_dict']) #model = nn.DataParallel(model, [0,1]).cuda() model = nn.DataParallel(model, [0, 1, 2, 3]).cuda() query_loader, gallery_loader = get_real_test_data( args.query_dir, args.gallery_dir, args.target_height, args.target_width, args.batch_size, args.workers) #query_features = extract_features(model, query_loader, is_flip=True) gallery_features = extract_features(model, gallery_loader, is_flip=True) #q_file = open('query_se_res152.pkl', 'wb') g_file = open('your_gallery_feature_name.pkl', 'wb') #pickle.dump(query_features, q_file) pickle.dump(gallery_features, g_file) #q_file.close() g_file.close() print('Done')
def main(args): dataset, num_classes, train_loader, query_loader, gallery_loader = \ get_data(args.dataset, args.data_dir, args.height, args.width, args.batch_size, args.re, args.workers) model = models.create('resnet50', num_features=1024, dropout=0.5, num_classes=13164) model = model.cuda() checkpoint = load_checkpoint('./checkpointres50.pth.tar') model.load_state_dict(checkpoint['state_dict']) for batch_idx, (imgs, _, pids) in enumerate(train_loader): imgs = imgs.cuda() featurelist, _ = model(imgs) all = featurelist[6].data.cpu() all= F.normalize(all) break for batch_idx, (imgs, _, pids) in enumerate(train_loader): imgs = imgs.cuda() featurelist, _ = model(imgs) features = featurelist[6].data.cpu() features=F.normalize(features) all = torch.cat((all, features), 0) print(batch_idx) if batch_idx == 100: torch.save(all, './renet50vidlayer6.pkl') break torch.save(all, './renet50vidlayer6.pkl') print('done!')
def main(args): np.random.seed(args.seed) torch.manual_seed(args.seed) cudnn.benchmark = True # Not sure about this one metric = DistanceMetric(algorithm='euclidean') for test_set in args.test_sets: dataset, _, loader = load_dataset(args.architecture, dataset=test_set) cmcs = {} for batch_id in args.batch_ids: benchmark_dir = os.path.join(working_dir, 'benchmarks', batch_id, args.loss, args.architecture) _, num_classes, _ = load_dataset(args.architecture, dataset='synthetic', batch_id=batch_id) model = setup_model(args.loss, args.architecture, num_classes) model = nn.DataParallel(model).cuda() checkpoint = load_checkpoint( os.path.join(benchmark_dir, 'model_best.pth.tar')) model.module.load_state_dict(checkpoint['state_dict']) evaluator = Evaluator(model) cmcs[batch_id] = evaluator.test(loader, dataset.query, dataset.gallery, metric) plot(args, os.path.join(working_dir, 'plots'), cmcs, test_set)
def checkpoint_loader(model, path): checkpoint = load_checkpoint(path) pretrained_dict = checkpoint['state_dict'] if isinstance(model, nn.DataParallel): Parallel = 1 model = model.module.cpu() else: Parallel = 0 model_dict = model.state_dict() # 1. filter out unnecessary keys pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict} # if eval_only: # keys_to_del = [] # for key in pretrained_dict.keys(): # if 'classifier' in key: # keys_to_del.append(key) # for key in keys_to_del: # del pretrained_dict[key] # pass # 2. overwrite entries in the existing state dict model_dict.update(pretrained_dict) # 3. load the new state dict model.load_state_dict(model_dict) start_epoch = checkpoint['epoch'] best_top1 = checkpoint['best_top1'] if Parallel: model = nn.DataParallel(model).cuda() return model, start_epoch, best_top1
def loadDataset(): torch.cuda.set_device(0) logs_dir = 'market-1501-Exper33/RPP/' num_features = 256 num_classes = 751 T = 1 dim = 256 dropout = 0.5 model = models.create('resnet50_rpp', num_features=num_features, dropout=dropout, num_classes=num_classes, cut_at_pooling=False, FCN=True, T=T, dim=dim) model = model.cuda() checkpoint = load_checkpoint( osp.join(logs_dir, 'cvs_checkpoint_0107.pth.tar')) model.load_state_dict(checkpoint['state_dict']) res = [] frame_number = 0 # --datasets shujuku = {} rentidir = '/data/reid/renti/queries' return model
def main(args): cudnn.benchmark = True # Redirect print to both console and log file if not args.evaluate: sys.stdout = Logger(osp.join(args.logs_dir, 'log.txt')) detectmodel, ic = getdetection() dataset, num_classes, train_loader, query_loader, gallery_loader = \ get_data(detectmodel, ic, args.dataset, args.data_dir, args.height, args.width, args.batch_size, args.re, args.workers) model = models.create(args.arch, num_features=512, dropout=args.dropout, num_classes=13164) model = model.cuda() checkpoint = load_checkpoint( '/home/l603a/REID/wyf/DLMB-PB/resnet18_hd_nodropout_FC_three_branch.pth.tar' ) model.load_state_dict(checkpoint['state_dict']) top1, map = test_vehicleid(model, query_loader, gallery_loader, query_loader, gallery_loader, 32, 'xent', euclidean_distance_loss='xent', epoch=0, use_metric_cuhk03=False, ranks=[1, 5, 10, 20], return_distmat=False)
def resume(self, ckpt_file): print("continued from", ckpt_file) model = models.create(self.model_name, dropout=self.dropout, num_classes=self.num_classes) self.model = nn.DataParallel(model).cuda() self.model.load_state_dict(load_checkpoint(ckpt_file))
def main(args): print('running...') np.random.seed(args.seed) torch.manual_seed(args.seed) cudnn.benchmark = True print(args) # Create data loaders if args.target_height is None or args.target_width is None: args.target_height, args.target_width = (288, 384) # Create model model = Combine_Net(arch=args.arch, num_classes=args.num_classes, num_features=args.num_features) # Load from checkpoint checkpoint = load_checkpoint(args.resume) model.net.load_state_dict(checkpoint['state_dict']) device_ids = [0, 1, 2, 3] model = nn.DataParallel(model, device_ids) model = model.cuda(device_ids[0]) root_path = args.data_dir sub_folders = os.listdir(root_path) for folder in sub_folders: print(folder) data_dir = root_path + folder data_loader = get_real_test_data(data_dir, args.target_height, args.target_width, args.batch_size, args.workers) direct_features = extract_features(model, data_loader, is_flip=False) p_file = open(folder + '_direction.pkl', 'wb') pickle.dump(direct_features, p_file) p_file.close() print('Done')
def main_worker(args): cudnn.benchmark = True log_dir = osp.dirname(args.resume) sys.stdout = Logger(osp.join(log_dir, 'log_test.txt')) print("==========\nArgs:{}\n==========".format(args)) # Create data loaders dataset_target, test_loader_target = \ get_data(args.dataset_target, args.data_dir, args.height, args.width, args.batch_size, args.workers) # Create model model = models.create(args.arch, pretrained=False, cut_at_pooling=args.cut_at_pooling, num_features=args.features, dropout=args.dropout, num_classes=0) model.cuda() model = nn.DataParallel(model) # Load from checkpoint checkpoint = load_checkpoint(args.resume) copy_state_dict(checkpoint['state_dict'], model) # start_epoch = checkpoint['epoch'] # best_mAP = checkpoint['best_mAP'] # print("=> Checkpoint of epoch {} best mAP {:.1%}".format(start_epoch, best_mAP)) # Evaluator evaluator = Evaluator(model) print("Test on the target domain of {}:".format(args.dataset_target)) evaluator.evaluate(test_loader_target, dataset_target.query, dataset_target.gallery, cmc_flag=True, rerank=args.rerank) return
def test_with_open_reid(args): # Create data loaders assert args.num_instances > 1, "num_instances should be greater than 1" assert args.batch_size % args.num_instances == 0, \ 'num_instances should divide batch_size' if args.height is None or args.width is None: args.height, args.width = (144, 56) if args.arch == 'inception' else \ (256, 128) dataset, num_classes, train_loader, val_loader, test_loader = \ get_data(args.dataset, args.split, args.data_dir, args.height, args.width, args.batch_size, args.num_instances, args.workers, args.combine_trainval) # Create model model = models.create(args.arch, num_features=1024, dropout=args.dropout, num_classes=args.features) model = nn.DataParallel(model).cuda() print('Test with best model:') # checkpoint = load_checkpoint(osp.join(args.logs_dir, 'checkpoint.pth.tar')) checkpoint = load_checkpoint(osp.join(args.logs_dir, 'model_best.pth.tar')) model.module.load_state_dict(checkpoint['state_dict']) # Distance metric metric = DistanceMetric(algorithm=args.dist_metric) # Evaluator evaluator = Evaluator(model) metric.train(model, train_loader) print("Validation:") evaluator.evaluate(val_loader, dataset.val, dataset.val, metric) print("Test:") evaluator.evaluate(test_loader, dataset.query, dataset.gallery, metric)
def loadDataset(): logs_dir = 'market-1501-Exper33/RPP/' num_features = 256 num_classes = 751 T = 1 dim = 256 dropout = 0.5 ### model = models.create('resnet50_rpp', num_features=num_features, dropout=dropout, num_classes=num_classes, cut_at_pooling=False, FCN=True, T=T, dim=dim) model = model.cuda() checkpoint = load_checkpoint(osp.join(logs_dir, 'checkpoint.pth.tar')) model.load_state_dict(checkpoint['state_dict']) res = [] frame_number = 0 return model
def resume(self, ckpt_file, step): print("continued from step", step) model = models.create(self.model_name, dropout=self.dropout, embeding_fea_size=self.embeding_fea_size, fixed_layer=self.fixed_layer) self.model = nn.DataParallel(model).cuda() self.model.load_state_dict(load_checkpoint(ckpt_file))
def resume(self, ckpt_file, step): print("continued from step", step) model = models.create(self.model_name, dropout=self.dropout, num_classes=self.num_classes, is_output_feature=True) self.model = nn.DataParallel(model).cuda() self.model.load_state_dict(load_checkpoint(ckpt_file))
def init_model(model_path): model = models.create('resnet50', num_features=128, num_classes=216, dropout=0) checkpoint = load_checkpoint(model_path) model.load_state_dict(checkpoint['state_dict']) model = torch.nn.DataParallel(model).cuda() return model
def create_model(args, classes): model = models.create(args.arch, num_features=args.features, norm=False, dropout=args.dropout, num_classes=classes) model.cuda() model = nn.DataParallel(model) initial_weights = load_checkpoint(args.init) copy_state_dict(initial_weights['state_dict'], model) return model
def main(args): os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu np.random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed_all(args.seed) cudnn.benchmark = True # Redirect print to both console and log file sys.stdout = Logger( osp.join(args.logs_dir, 'log-partial-reid-group-test.txt')) # Create data loaders if args.height is None or args.width is None: args.height, args.width = (144, 56) if args.arch == 'inception' else \ (256, 128) dataset_set, num_classes, query_loader_set, gallery_loader_set = \ get_data(args.dataset, args.data_dir, args.height, args.width, args.ratio, args.batch_size, args.workers ) # Create model model = models.create(args.arch, num_features=args.features, dropout=args.dropout, num_classes=num_classes, cut_at_pooling=False, FCN=True, num_parts=args.num_parts) # Load from checkpoint start_epoch = best_top1 = 0 if args.resume: checkpoint = load_checkpoint(args.resume) model_dict = model.state_dict() checkpoint_load = { k: v for k, v in (checkpoint['state_dict']).items() if k in model_dict } model_dict.update(checkpoint_load) model.load_state_dict(model_dict) # model.load_state_dict(checkpoint['state_dict']) start_epoch = checkpoint['epoch'] best_top1 = checkpoint['best_top1'] print("=> Start epoch {} best top1 {:.1%}".format( start_epoch, best_top1)) model = nn.DataParallel(model).cuda() # Evaluator evaluator = Evaluator(model) print("Test:") with torch.no_grad(): evaluator.evaluate(query_loader_set, gallery_loader_set, dataset_set) return
def resume(self, ckpt_file, step): print("continued from step", step) model = models.create(self.model_name, dropout=self.dropout, num_classes=self.num_classes, mode=self.mode) # self.model = nn.DataParallel(model).cuda() model.load_state_dict(load_checkpoint(ckpt_file), strict=False) model_distill = deepcopy(model) # model.load_state_dict(load_checkpoint_new(ckpt_file), strict=False) self.model = nn.DataParallel(model).cuda() self.model_distill = nn.DataParallel(model_distill).cuda()
def create_model(args): model = models.create(args.arch, num_features=args.features, norm=True, dropout=args.dropout, num_classes=0) # use CUDA model = model.cuda() if args.resume: checkpoint = load_checkpoint(args.resume) model.copy_weight(checkpoint['state_dict']) model = nn.DataParallel(model) return model
def getdetection(): model = models.create('resnet50', num_features=1024, dropout=0.5, num_classes=13164) model = model.cuda() model.eval() checkpoint = load_checkpoint('./checkpointres50.pth.tar') model.load_state_dict(checkpoint['state_dict']) label = torch.load('./renet50layer6label10class15000.pkl') Ic = np.zeros(1024) for i in range(0, 1024): if label[i] == 4: Ic[i] = 1 Ic = torch.from_numpy(Ic) return model ,Ic
def _init_models(self): #self.net_G = CustomPoseGenerator(self.opt.pose_feature_size, 2048, self.opt.noise_feature_size, self.net_G = CustomPoseGenerator(self.opt.pose_feature_size, 2048, 0, pose_nc=self.pose_size, dropout=self.opt.drop, norm_layer=self.norm_layer, fuse_mode=self.opt.fuse_mode, connect_layers=self.opt.connect_layers) if (self.opt.emb_type == 'Single'): self.net_E = SingleNet(self.opt.arch, self.emb_size, pretraind=True, use_bn=True, test_bn=False, last_stride=self.opt.last_stride) elif (self.opt.emb_type == 'Siamese'): self.net_E = SiameseNet(self.opt.arch, self.emb_size, pretraind=True, use_bn=True, test_bn=False, last_stride=self.opt.last_stride) else: raise ValueError('unrecognized model') self.net_Di = SingleNet('resnet18', 1, pretraind=True, use_bn=True, test_bn=False, last_stride=2) self.net_Dp = NLayerDiscriminator(3+self.pose_size, norm_layer=self.norm_layer) if self.opt.stage==0: # This is for training end-to-end init_weights(self.net_G) init_weights(self.net_Dp) elif self.opt.stage==1: # This is for training fixing a baseline model init_weights(self.net_G) init_weights(self.net_Dp) checkpoint = load_checkpoint(self.opt.netE_pretrain) if 'state_dict' in checkpoint.keys(): checkpoint = checkpoint['state_dict'] state_dict = remove_module_key(checkpoint) self.net_E.load_state_dict(state_dict) #state_dict['classifier.weight'] = state_dict['classifier.weight'][1:2] #state_dict['classifier.bias'] = torch.FloatTensor([state_dict['classifier.bias'][1]]) #self.net_Di.load_state_dict(state_dict) elif self.opt.stage==2: # This is for training with a provided model self._load_state_dict(self.net_E, self.opt.netE_pretrain) self._load_state_dict(self.net_G, self.opt.netG_pretrain) self._load_state_dict(self.net_Di, self.opt.netDi_pretrain) self._load_state_dict(self.net_Dp, self.opt.netDp_pretrain) else: raise ValueError('unrecognized mode') self.net_E = torch.nn.DataParallel(self.net_E).cuda() self.net_G = torch.nn.DataParallel(self.net_G).cuda() self.net_Di = torch.nn.DataParallel(self.net_Di).cuda() self.net_Dp = torch.nn.DataParallel(self.net_Dp).cuda()
def main(argv): #parser parser = argparse.ArgumentParser(description='test part bilinear network') parser.add_argument('--exp-dir', type=str, default='logs/market1501/exp1') parser.add_argument('--target-epoch', type=int, default=750) parser.add_argument('--gpus', type=str, default='0') args = parser.parse_args(argv) # Settings exp_dir = args.exp_dir target_epoch = args.target_epoch batch_size = 50 gpu_ids = args.gpus set_paths('paths') os.environ['CUDA_VISIBLE_DEVICES'] = gpu_ids args = json.load(open(osp.join(exp_dir, "args.json"), "r")) # Load data t = T.Compose([ T.RectScale(args['height'], args['width']), T.CenterCrop((args['crop_height'], args['crop_width'])), T.ToTensor(), T.RGB_to_BGR(), T.NormalizeBy(255), ]) dataset = datasets.create(args['dataset'], 'data/{}'.format(args['dataset'])) dataset_ = Preprocessor(list(set(dataset.query) | set(dataset.gallery)), root=dataset.images_dir, transform=t) dataloader = DataLoader(dataset_, batch_size=batch_size, shuffle=False) # Load model model = models.create(args['arch'], dilation=args['dilation'], use_relu=args['use_relu'], initialize=False).cuda() weight_file = osp.join(exp_dir, 'epoch_{}.pth.tar'.format(target_epoch)) model.load(load_checkpoint(weight_file)) model.eval() # Evaluate evaluator = Evaluator(model) evaluator.evaluate(dataloader, dataset.query, dataset.gallery)
def main(args): np.random.seed(args.seed) torch.manual_seed(args.seed) np.random.seed(args.seed) cudnn.benchmark = True # Redirect print to both console and log file name = f'{args.dataset}-{args.arch}' logs_dir = f'logs/softmax-loss/{name}' # Create data loaders if args.height is None or args.width is None: args.height, args.width = (144, 56) if args.arch == 'inception' else \ (256, 128) dataset, num_classes, train_loader, val_loader, test_loader = \ get_data(args.dataset, args.split, args.data_dir, args.height, args.width, args.batch_size, args.workers, args.combine_trainval) # Create model model = models.create(args.arch, num_features=args.features, dropout=args.dropout, cos_output=args.cos_output) # Load from checkpoint start_epoch = best_top1 = 0 checkpoint = load_checkpoint(args.resume) model.load_state_dict(checkpoint['state_dict'], strict=False) start_epoch = checkpoint['epoch'] best_top1 = checkpoint['best_top1'] print("=> Start epoch {} best top1 {:.1%}".format(start_epoch, best_top1)) model = model.cuda() # Distance metric metric = DistanceMetric(algorithm=args.dist_metric) # Evaluator evaluator = Evaluator(model, normalize_features=True) # args.cos_output) metric.train(model, train_loader) print("Validation:") evaluator.evaluate(val_loader, dataset.val, dataset.val, metric) print("Test:") evaluator.evaluate(test_loader, dataset.query, dataset.gallery, metric)
def __init__(self, depth, checkpoint=None, pretrained=True, num_features=2048, dropout=0.1, num_classes=0, numCams=0): super(ResNet, self).__init__() self.depth = depth self.checkpoint = checkpoint self.pretrained = pretrained self.num_features = num_features self.dropout = dropout self.num_classes = num_classes if self.dropout > 0: self.drop = nn.Dropout(self.dropout) # Construct base (pretrained) resnet if depth not in ResNet.__factory: raise KeyError("Unsupported depth:", depth) self.base = ResNet.__factory[depth](pretrained=pretrained) out_planes = self.base.fc.in_features # resume from pre-iteration training if self.checkpoint: state_dict = load_checkpoint(checkpoint) self.load_state_dict(state_dict['state_dict'], strict=False) self.feat = nn.Linear(out_planes, self.num_features, bias=False) self.feat_bn = nn.BatchNorm1d(self.num_features) self.relu = nn.ReLU(inplace=True) init.normal(self.feat.weight, std=0.001) init.constant(self.feat_bn.weight, 1) init.constant(self.feat_bn.bias, 0) # x2 classifier self.classifier_x2 = nn.Linear(self.num_features, self.num_classes) init.normal(self.classifier_x2.weight, std=0.001) init.constant(self.classifier_x2.bias, 0) if not self.pretrained: self.reset_params()
def loadDataset(): torch.cuda.set_device(0) logs_dir = 'market-1501-Exper33/RPP/' num_features = 256 num_classes = 751 T = 1 dim = 256 dropout = 0.5 ### model = models.create('resnet50_rpp', num_features=num_features, dropout=dropout, num_classes=num_classes, cut_at_pooling=False, FCN=True, T=T, dim=dim) model = model.cuda() checkpoint = load_checkpoint(osp.join(logs_dir, 'checkpoint.pth.tar')) model.load_state_dict(checkpoint['state_dict']) res = [] frame_number = 0 # --datasets shujuku = {} rentidir = '/data/reid/renti/queries' for query in os.listdir(rentidir): query_dir = osp.join(rentidir, query) shujuku[query] = [] for img in os.listdir(query_dir): _img = cv2.imread(osp.join(query_dir, img)) _img = np.transpose(_img, (2, 0, 1)).astype(np.float32) _img = torch.from_numpy(_img) _img = torch.unsqueeze(_img, 0) _feature = extract_cnn_feature(model, _img.cuda()) shujuku[query].append(_feature) # -- return model, shujuku
def load_params(new_model, pretrained_model): new_model_dict = new_model.module.state_dict() pretrained_checkpoint = load_checkpoint(pretrained_model) #for name, param in pretrained_checkpoint.items(): for name, param in pretrained_checkpoint.items(): print('pretrained_model params name and size: ', name, param.size()) if name in new_model_dict and 'classifier' not in name: if isinstance(param, Parameter): param = param.data try: new_model_dict[name].copy_(param) print('############# new_model load params name: ',name) except: raise RuntimeError('While copying the parameter named {}, ' + 'whose dimensions in the model are {} and ' + 'whose dimensions in the checkpoint are {}.' .format(name, new_model_dict[name].size(), param.size())) else: continue
def eval(save_dir): mAP = [] Acc = [] features = [] for idx, config in enumerate(configs): model = models.create( config.model_name, num_features=config.num_features, dropout=config.dropout, num_classes=config.num_classes) model = torch.nn.DataParallel(model).cuda() model_name = MODEL[idx] feature = [] for epoch in range(5): save_pth = os.path.join(save_dir, '%s.epoch%s' % (model_name, epoch)) if os.path.exists(save_pth) is not True: raise ValueError('wrong model pth %s' % save_pth) checkpoint = load_checkpoint(save_pth) state_dict = { k: v for k, v in checkpoint['state_dict'].items() if k in model.state_dict().keys() } model.load_state_dict(state_dict) result = checkpoint['performance'] mAP += [str(result[0])] Acc += [str(result[1])] feature += [mu.get_feature(model, query_gallery, data.images_dir, config)] features += [feature] for idx in range(5): feas = [features[j][idx] for j in range(3)] result = mu.combine_evaluate(feas, data) mAP += [str(result[0])] Acc += [str(result[1])] return mAP, Acc
def main(args): np.random.seed(args.seed) torch.manual_seed(args.seed) cudnn.benchmark = True logger = TensorLogger(osp.join(args.log_root, 'Tensorboard_logs', args.logs_dir)) # Redirect print to both console and log file logs_dir = osp.join(args.log_root, args.logs_dir) if not args.evaluate: sys.stdout = Logger(osp.join(logs_dir, 'log.txt')) # Create data loaders assert args.num_instances > 1, "num_instances should be greater than 1" assert args.source_batch_size % args.num_instances == 0, \ 'num_instances should divide batch_size' if args.height is None or args.width is None: args.height, args.width = (144, 56) if args.arch == 'inception' else \ (256, 128) # Create source data_loader source_dataset, source_num_classes, source_train_loader\ , source_val_loader, source_test_loader = \ get_source_data(args.source_dataset, args.split, args.data_dir, args.height, args.width, args.source_batch_size, args.num_instances, args.workers, args.combine_trainval) # Create target data_loader target_dataset, target_num_classes, target_train_loader\ , target_val_loader, target_test_loader = \ get_target_data(args.target_dataset, args.split, args.data_dir, args.height, args.width, args.target_batch_size, args.workers, args.combine_trainval) print("lr:", args.lr) print("max_epoch:", args.epochs) # Create model # Hacking here to let the classifier be the last feature embedding layer # Net structure: avgpool -> FC(1024) -> FC(args.features) model = ResNet_recon(num_features=1024, dropout=args.dropout) if args.evaluate: model_evalu = nn.DataParallel(model).cuda() model = model.cuda(0) # For source triplet-loss trip_embedding = Trip_embedding(num_features=1024, num_diff_features=128, dropout=args.dropout).cuda(1) # For target reconstruction-loss recon_module = Reconstruct(num_features=1024).cuda(1) # Criterion criterion = ReconTripLoss().cuda(1) # Load from checkpoint start_epoch = best_top1 = 0 if args.resume: model_path = load_checkpoint(args.resume) model.load_state_dict(model_path['state_dict']) # trip_embedding.load_state_dict(model_path['trip_em']) recon_module.load_state_dict(model_path['recon_dict']) start_epoch = model_path['epoch'] best_top1 = model_path['best_top1'] is_best = False top1 = best_top1 print("=> Start epoch {} best top1 {:.1%}" .format(start_epoch, best_top1)) # model = nn.DataParallel(model, device_ids=[0,1]).cuda(1) # model.cuda(0) # trip_embedding.cuda(1) # recon_module.cuda(1) # criterion.cuda(1) # Distance metric metric = DistanceMetric(algorithm=args.dist_metric) # Evaluator if args.evaluate: evaluator = Evaluator(model_evalu) metric.train(model_evalu, source_train_loader) # print("Validation:") # evaluator.evaluate(val_loader, dataset.val, dataset.val, metric) print("Test:") if len(args.source_dataset) > 1: for dataset_name in args.source_dataset: print("{} source_test result:".format(dataset_name)) evaluator.evaluate(source_test_loader[dataset_name], source_dataset.query[dataset_name], source_dataset.gallery[dataset_name], metric) return else: print("source test result") evaluator.evaluate(source_test_loader, source_dataset.query, source_dataset.gallery, metric) print("target test result") evaluator.evaluate(target_test_loader, target_dataset.query, target_dataset.gallery, metric) return evaluator = Evaluator(model) # Optimizer optimizer = torch.optim.Adam([{'params': model.parameters()}, # {'params': trip_embedding.parameters()}, {'params': recon_module.parameters()}], lr=args.lr, weight_decay=args.weight_decay) # Trainer trainer = Transfer_Trainer(model, recon_module, trip_embedding, criterion) # Schedule learning rate def adjust_lr(epoch): lr = args.lr if epoch <= args.lr_change_epochs else \ args.lr * (0.001 ** ((epoch - args.lr_change_epochs)/ float(args.epochs-args.lr_change_epochs))) for g in optimizer.param_groups: g['lr'] = lr * g.get('lr_mult', 1) # epoch_num = args.maxstep//(750//18) + 1 # Start training top1 = 0 is_best = True for epoch in range(start_epoch, args.epochs): adjust_lr(epoch) trainer.train(epoch, source_train_loader, target_train_loader, optimizer, logger) #######Tensorboard-logs########## # for tag, value in model.named_parameters(): # tag = tag.replace('.', '/') # try: # logger.histo_summary(tag, to_np(value), epoch * len(source_train_loader) + 1) # logger.histo_summary(tag + '/grad', to_np(value.grad), epoch * len(source_train_loader) + 1) # except AttributeError, e: # pass if epoch % 25 == 0 and epoch != 0: top1 = evaluator.evaluate(source_test_loader, source_dataset.query, source_dataset.query) target_top1 = evaluator.evaluate(target_test_loader, target_dataset.query, target_dataset.query) print('target_top1 = {:5.1%}'.format(target_top1)) # top1 = evaluator.evaluate(test_loader, dataset.query, dataset.gallery) is_best = top1 > best_top1 best_top1 = max(top1, best_top1) save_checkpoint({ 'state_dict': model.state_dict(), 'recon_dict': recon_module.state_dict(), # 'trip_em': trip_embedding.state_dict(), 'epoch': epoch + 1, 'best_top1': best_top1, }, is_best, fpath=osp.join(logs_dir, 'checkpoint.pth.tar')) print('\n * Finished epoch {:3d} top1: {:5.1%} best: {:5.1%}{}\n'. format(epoch, top1, best_top1, ' *' if is_best else '')) # Final test print('Test with best model:') checkpoint = load_checkpoint(osp.join(logs_dir, 'checkpoint.pth.tar')) model.module.load_state_dict(checkpoint['state_dict']) metric.train(model, source_train_loader) print("Test:") if len(args.dataset) > 1: for dataset_name in args.dataset: print("{} test result:".format(dataset_name)) evaluator.evaluate(source_test_loader[dataset_name], source_dataset.query[dataset_name], source_dataset.gallery[dataset_name], metric) else: evaluator.evaluate(source_test_loader, source_dataset.query, source_dataset.gallery, metric)
def main(args): np.random.seed(args.seed) torch.manual_seed(args.seed) cudnn.benchmark = True logger = TensorLogger(osp.join(args.log_root, 'Tensorboard_logs', args.logs_dir)) # Redirect print to both console and log file logs_dir = osp.join(args.log_root, args.logs_dir) if not args.evaluate: sys.stdout = Logger(osp.join(logs_dir, 'log.txt')) # Create data loaders # assert args.num_instances > 1, "num_instances should be greater than 1" assert args.batch_size % args.num_instances == 0, \ 'num_instances should divide batch_size' if args.height is None or args.width is None: args.height, args.width = (144, 56) if args.arch == 'inception' else \ (256, 128) dataset, num_classes, train_loader, val_loader, test_loader = \ get_data(args.dataset, args.split, args.data_dir, args.height, args.width, args.batch_size, args.num_instances, args.workers, args.combine_trainval) print("lr:", args.lr) print("max_epoch:", args.epochs) # Create model # Hacking here to let the classifier be the last feature embedding layer # Net structure: avgpool -> FC(1024) -> FC(args.features) model = models.create(args.arch, num_features=1024, num_diff_features=128, dropout=args.dropout, cut_at_pooling=False) print(model) # Load from checkpoint start_epoch = best_top1 = 0 if args.resume: checkpoint = load_checkpoint(args.resume) pretrained_dict = {k: v for k, v in checkpoint['state_dict'].items() if k in model.state_dict()} model_dict = model.state_dict() model_dict.update(pretrained_dict) model.load_state_dict(model_dict) start_epoch = checkpoint['epoch'] best_top1 = checkpoint['best_top1'] print("=> Start epoch {} best top1 {:.1%}" .format(start_epoch, best_top1)) model = nn.DataParallel(model).cuda() # Distance metric metric = DistanceMetric(algorithm=args.dist_metric) # Evaluator evaluator = Evaluator(model) if args.evaluate: metric.train(model, train_loader) # print("Validation:") # evaluator.evaluate(val_loader, dataset.val, dataset.val, metric) print("Test:") if len(args.dataset)>1: for dataset_name in args.dataset: print("{} test result:".format(dataset_name)) evaluator.evaluate(test_loader[dataset_name], dataset.query[dataset_name], dataset.gallery[dataset_name], metric) return else: evaluator.evaluate(test_loader, dataset.query, dataset.gallery, metric) return # Criterion criterion = TripletLoss(margin=args.margin).cuda() # Optimizer optimizer = torch.optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay) # Trainer trainer = Trainer(model, criterion) # Schedule learning rate def adjust_lr(epoch): # lr = args.lr if epoch <= 270 else \ # args.lr * (0.001 ** ((epoch - 270) / 135)) # lr = args.lr if epoch <= 100 else \ # args.lr * (0.001 ** ((epoch - 100) / 50.0)) lr = args.lr if epoch <= args.lr_change_epochs else \ args.lr * (0.001 ** ((epoch - args.lr_change_epochs)/float(args.epochs-args.lr_change_epochs))) for g in optimizer.param_groups: g['lr'] = lr * g.get('lr_mult', 1) # epoch_num = args.maxstep//(750//18) + 1 # Start training for epoch in range(start_epoch, args.epochs): adjust_lr(epoch) trainer.train(epoch, train_loader, optimizer, logger) #######Tensorboard-logs########## for tag, value in model.named_parameters(): tag = tag.replace('.', '/') try: logger.histo_summary(tag, to_np(value), epoch*len(train_loader) + 1) logger.histo_summary(tag + '/grad', to_np(value.grad), epoch*len(train_loader) + 1) except AttributeError: pass # top1 = evaluator.evaluate(val_loader, dataset.val, dataset.val) # top1 = evaluator.evaluate(test_loader, dataset.query, dataset.gallery) top1 = 1 # is_best = top1 > best_top1 # best_top1 = max(top1, best_top1) # save_checkpoint({ # 'state_dict': model.module.state_dict(), # 'epoch': epoch + 1, # 'best_top1': best_top1, # }, is_best, fpath=osp.join(args.logs_dir, 'checkpoint.pth.tar')) is_best = False best_top1 = 1 save_checkpoint({ 'state_dict': model.module.state_dict(), 'epoch': epoch + 1, 'best_top1': best_top1, }, is_best, fpath=osp.join(logs_dir, 'checkpoint.pth.tar')) print('\n * Finished epoch {:3d} top1: {:5.1%} best: {:5.1%}{}\n'. format(epoch, top1, best_top1, ' *' if is_best else '')) # Final test print('Test with best model:') checkpoint = load_checkpoint(osp.join(logs_dir, 'checkpoint.pth.tar')) model.module.load_state_dict(checkpoint['state_dict']) metric.train(model, train_loader) print("Test:") if len(args.dataset) > 1: for dataset_name in args.dataset: print("{} test result:".format(dataset_name)) evaluator.evaluate(test_loader[dataset_name], dataset.query[dataset_name], dataset.gallery[dataset_name], metric) else: evaluator.evaluate(test_loader, dataset.query, dataset.gallery, metric)
def main(args): np.random.seed(args.seed) torch.manual_seed(args.seed) cudnn.benchmark = True # Redirect print to both console and log file if not args.evaluate: sys.stdout = Logger(osp.join(args.logs_dir, 'log.txt')) # Create data loaders if args.height is None or args.width is None: args.height, args.width = (144, 56) if args.arch == 'inception' else \ (256, 128) dataset, num_classes, train_loader, val_loader, test_loader = \ get_data(args.dataset, args.split, args.data_dir, args.height, args.width, args.batch_size, args.workers, args.combine_trainval) # Create model model = models.create(args.arch, num_features=args.features, norm=True, dropout=args.dropout) # Load from checkpoint start_epoch = best_top1 = 0 if args.resume: checkpoint = load_checkpoint(args.resume) model.load_state_dict(checkpoint['state_dict']) start_epoch = checkpoint['epoch'] best_top1 = checkpoint['best_top1'] print("=> Start epoch {} best top1 {:.1%}" .format(start_epoch, best_top1)) model = nn.DataParallel(model).cuda() # Distance metric metric = DistanceMetric(algorithm=args.dist_metric) # Evaluator evaluator = Evaluator(model) if args.evaluate: metric.train(model, train_loader) print("Validation:") evaluator.evaluate(val_loader, dataset.val, dataset.val, metric) print("Test:") evaluator.evaluate(test_loader, dataset.query, dataset.gallery, metric) return # Criterion criterion = OIMLoss(model.module.num_features, num_classes, scalar=args.oim_scalar, momentum=args.oim_momentum).cuda() # Optimizer if hasattr(model.module, 'base'): base_param_ids = set(map(id, model.module.base.parameters())) new_params = [p for p in model.parameters() if id(p) not in base_param_ids] param_groups = [ {'params': model.module.base.parameters(), 'lr_mult': 0.1}, {'params': new_params, 'lr_mult': 1.0}] else: param_groups = model.parameters() optimizer = torch.optim.SGD(param_groups, lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay, nesterov=True) # Trainer trainer = Trainer(model, criterion) # Schedule learning rate def adjust_lr(epoch): step_size = 60 if args.arch == 'inception' else 40 lr = args.lr * (0.1 ** (epoch // step_size)) for g in optimizer.param_groups: g['lr'] = lr * g.get('lr_mult', 1) # Start training for epoch in range(start_epoch, args.epochs): adjust_lr(epoch) trainer.train(epoch, train_loader, optimizer) if epoch < args.start_save: continue top1 = evaluator.evaluate(val_loader, dataset.val, dataset.val) is_best = top1 > best_top1 best_top1 = max(top1, best_top1) save_checkpoint({ 'state_dict': model.module.state_dict(), 'epoch': epoch + 1, 'best_top1': best_top1, }, is_best, fpath=osp.join(args.logs_dir, 'checkpoint.pth.tar')) print('\n * Finished epoch {:3d} top1: {:5.1%} best: {:5.1%}{}\n'. format(epoch, top1, best_top1, ' *' if is_best else '')) # Final test print('Test with best model:') checkpoint = load_checkpoint(osp.join(args.logs_dir, 'model_best.pth.tar')) model.module.load_state_dict(checkpoint['state_dict']) metric.train(model, train_loader) evaluator.evaluate(test_loader, dataset.query, dataset.gallery, metric)
def main(args): np.random.seed(args.seed) torch.manual_seed(args.seed) cudnn.benchmark = True # Redirect print to both console and log file if not args.evaluate: sys.stdout = Logger(osp.join(args.logs_dir, 'log.txt')) # Create data loaders assert args.num_instances > 1, "num_instances should be greater than 1" assert args.batch_size % args.num_instances == 0, \ 'num_instances should divide batch_size' if args.height is None or args.width is None: args.height, args.width = (144, 56) if args.arch == 'inception' else \ (256, 128) dataset, num_classes, train_loader, val_loader, test_loader = \ get_data(args.dataset, args.split, args.data_dir, args.height, args.width, args.batch_size, args.num_instances, args.workers, args.combine_trainval) # Create model # Hacking here to let the classifier be the last feature embedding layer # Net structure: avgpool -> FC(1024) -> FC(args.features) model = models.create(args.arch, num_features=1024, dropout=args.dropout, num_classes=args.features) # Load from checkpoint start_epoch = best_top1 = 0 if args.resume: checkpoint = load_checkpoint(args.resume) model.load_state_dict(checkpoint['state_dict']) start_epoch = checkpoint['epoch'] best_top1 = checkpoint['best_top1'] print("=> Start epoch {} best top1 {:.1%}" .format(start_epoch, best_top1)) model = nn.DataParallel(model).cuda() # Distance metric metric = DistanceMetric(algorithm=args.dist_metric) # Evaluator evaluator = Evaluator(model) if args.evaluate: metric.train(model, train_loader) print("Validation:") evaluator.evaluate(val_loader, dataset.val, dataset.val, metric) print("Test:") evaluator.evaluate(test_loader, dataset.query, dataset.gallery, metric) return # Criterion criterion = TripletLoss(margin=args.margin).cuda() # Optimizer optimizer = torch.optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay) # Trainer trainer = Trainer(model, criterion) # Schedule learning rate def adjust_lr(epoch): lr = args.lr if epoch <= 100 else \ args.lr * (0.001 ** ((epoch - 100) / 50.0)) for g in optimizer.param_groups: g['lr'] = lr * g.get('lr_mult', 1) # Start training for epoch in range(start_epoch, args.epochs): adjust_lr(epoch) trainer.train(epoch, train_loader, optimizer) if epoch < args.start_save: continue top1 = evaluator.evaluate(val_loader, dataset.val, dataset.val) is_best = top1 > best_top1 best_top1 = max(top1, best_top1) save_checkpoint({ 'state_dict': model.module.state_dict(), 'epoch': epoch + 1, 'best_top1': best_top1, }, is_best, fpath=osp.join(args.logs_dir, 'checkpoint.pth.tar')) print('\n * Finished epoch {:3d} top1: {:5.1%} best: {:5.1%}{}\n'. format(epoch, top1, best_top1, ' *' if is_best else '')) # Final test print('Test with best model:') checkpoint = load_checkpoint(osp.join(args.logs_dir, 'model_best.pth.tar')) model.module.load_state_dict(checkpoint['state_dict']) metric.train(model, train_loader) evaluator.evaluate(test_loader, dataset.query, dataset.gallery, metric)
def main(args): # os.environ["CUDA_VISIBLE_DEVICES"] = "0,1" np.random.seed(args.seed) torch.manual_seed(args.seed) cudnn.benchmark = True #######Tensorboard-logs########## logger = TensorLogger(args.Tensorlogs_dir) # Redirect print to both console and log file if not args.evaluate: sys.stdout = Logger(osp.join(args.logs_dir, 'log5.txt')) # sys.stdout = Logger(osp.join(args.logs_dir, 'log.txt')) # Create data loaders assert args.num_instances > 1, "num_instances should be greater than 1" assert args.batch_size % args.num_instances == 0, \ 'num_instances should divide batch_size' if args.height is None or args.width is None: args.height, args.width = (144, 56) if args.arch == 'inception' else \ (256, 128) dataset, num_classes, train_loader, val_loader, test_loader = \ get_data(args.dataset, args.split, args.data_dir, args.height, args.width, args.batch_size, args.num_instances, args.workers, args.combine_trainval) now = datetime.datetime.now() print(now.strftime('%Y-%m-%d %H:%M:%S')) # Create model # Hacking here to let the classifier be the last feature embedding layer # Net structure: avgpool -> FC(1024) -> FC(args.features) model = models.create(args.arch, num_features=1024, dropout=args.dropout, num_diff_features=args.features, \ pretrained=True) # model_path = load_checkpoint(args.model_path) # model.load_state_dict(model_path['state_dict']) # Criterion criterion = AdaptTripletLoss(margin=args.margin, num_feature=args.features).cuda() # criterion = TripletLoss(margin=args.margin,\ # metric_embedding=args.metric_embedding).cuda() start_epoch = best_top1 = top1 = 0 is_best = False if args.resume_from_trip: model_path = load_checkpoint(args.resume_from_trip) model.load_state_dict(model_path['state_dict']) start_epoch = model_path['epoch'] best_top1 = model_path['best_top1'] is_best = False top1 = best_top1 print("=> Start epoch {} best top1 {:.1%}" .format(start_epoch, best_top1)) if args.resume: model_path = load_checkpoint(args.resume) model.load_state_dict(model_path['state_dict']) criterion.load_state_dict(model_path['adapt_metric']) start_epoch = model_path['epoch'] best_top1 = model_path['best_top1'] is_best = False top1 = best_top1 print("=> Start epoch {} best top1 {:.1%}" .format(start_epoch, best_top1)) # Load from checkpoint # if args.resume: # checkpoint = load_checkpoint(args.resume) # model.load_state_dict(checkpoint['state_dict']) # start_epoch = checkpoint['epoch'] # best_top1 = checkpoint['best_top1'] # print("=> Start epoch {} best top1 {:.1%}" # .format(start_epoch, best_top1)) model = nn.DataParallel(model).cuda() # Distance metric metric = DistanceMetric(algorithm=args.dist_metric) # Evaluator evaluator = ADP_Evaluator(model, criterion) # evaluator = Evaluator(model) if args.evaluate: # metric.train(model, train_loader) # print("Validation:") # evaluator.evaluate(val_loader, dataset.val, dataset.val, metric) print("Test:") if len(args.dataset) > 1: for dataset_name in args.dataset: print("{} test result:".format(dataset_name)) evaluator.evaluate(test_loader[dataset_name], dataset.query[dataset_name], dataset.gallery[dataset_name]) return else: evaluator.evaluate(test_loader, dataset.query, dataset.gallery) return # Optimizer # optimizer = torch.optim.Adam(model.parameters(), lr=args.lr, # weight_decay=args.weight_decay) if args.only_train_metric: optimizer = torch.optim.Adam(criterion.parameters(), lr=args.lr, weight_decay = args.weight_decay) for param in model.parameters(): param.requires_grad = False only_metric_train = True else: optimizer = torch.optim.Adam([{'params': model.parameters(), 'lr': 0.1*args.lr}, {'params': criterion.parameters()}], lr=args.lr, weight_decay = args.weight_decay) only_metric_train = False # def part_param(model,str): # for name,param in model.named_parameters(): # if str not in name: # yield param # # new_param = part_param(model,'base') # optimizer = torch.optim.Adam([ # {'params': model.module.base.parameters()}, # {'params':new_param, 'weight_decay':1.5*args.weight_decay} # ] # ,lr=args.lr, weight_decay=args.weight_decay,) # Trainer trainer = Trainer(model, criterion) # Schedule learning rate def adjust_lr(epoch): # lr = args.lr if epoch <= 270 else \ # args.lr * (0.001 ** ((epoch - 270) / 135)) # lr = args.lr if epoch <= 100 else \ # args.lr * (0.001 ** ((epoch - 100) / 50.0)) lr = args.lr if epoch <= args.lr_change_epochs else \ args.lr * (0.01 ** ((epoch - args.lr_change_epochs)/float(args.epochs-args.lr_change_epochs))) for g in optimizer.param_groups: g['lr'] = lr * g.get('lr_mult', 1) def adjust_lambda(epochs): w_lambda = 0.001 if epoch <=30 else 0.001*(0.01**((epoch - 30)/70)) return w_lambda # Start training for epoch in range(start_epoch, args.epochs): adjust_lr(epoch) weight_constraint_lambda = 0.0001 trainer.train(epoch, train_loader, optimizer, logger, weight_constraint_lambda) #######Tensorboard-logs########## if not only_metric_train: for tag, value in model.named_parameters(): tag = tag.replace('.', '/') try: logger.histo_summary(tag, to_np(value), epoch*len(train_loader) + 1) logger.histo_summary(tag + '/grad', to_np(value.grad), epoch*len(train_loader) + 1) except AttributeError,e: pass for tag, value in criterion.named_parameters(): tag = tag.replace('.', '/') try: logger.histo_summary(tag, to_np(value), epoch*len(train_loader) + 1) logger.histo_summary(tag + '/grad', to_np(value.grad), epoch*len(train_loader) + 1) except AttributeError, e: pass
'state_dict': model.module.state_dict(), 'adapt_metric':criterion.state_dict(), 'epoch': epoch + 1, 'best_top1': best_top1, }, is_best, fpath=osp.join(args.logs_dir, 'checkpoint.pth.tar')) if (epoch+1) % 50 ==0: checkpoint_file =osp.join(args.logs_dir, 'checkpoint.pth.tar') stepcheckpoint_file = osp.join(args.logs_dir, 'checkpoint{}.pth.tar'.format(epoch+1)) shutil.copy(checkpoint_file,stepcheckpoint_file) print('\n * Finished epoch {:3d} top1: {:5.1%} best: {:5.1%}{}\n'. format(epoch, top1, best_top1, ' *' if is_best else '')) now = datetime.datetime.now() print(now.strftime('%Y-%m-%d %H:%M:%S')) # Final test print('Test with best model:') checkpoint = load_checkpoint(osp.join(args.logs_dir, 'checkpoint.pth.tar')) model.module.load_state_dict(checkpoint['state_dict']) criterion.load_state_dict(checkpoint['adapt_metric']) # metric.train(model, train_loader) # evaluator.evaluate(test_loader, dataset.query, dataset.gallery, metric) if len(args.dataset) > 1: for dataset_name in args.dataset: print("{} test result:".format(dataset_name)) evaluator.evaluate(test_loader[dataset_name], dataset.query[dataset_name], dataset.gallery[dataset_name]) else: evaluator.evaluate(test_loader, dataset.query, dataset.gallery) if __name__ == '__main__': parser = argparse.ArgumentParser(description="Softmax loss classification") # data
def main(args): np.random.seed(args.seed) torch.manual_seed(args.seed) cudnn.benchmark = True #######Tensorboard-logs########## logger = TensorLogger(args.Tensorlogs_dir) # Redirect print to both console and log file if not args.evaluate: sys.stdout = Logger(osp.join(args.logs_dir, 'log.txt')) # Create data loaders if args.height is None or args.width is None: args.height, args.width = (144, 56) if args.arch == 'inception' else \ (256, 128) dataset, _, _, val_loader, test_loader = \ get_data(args.dataset, args.split, args.data_dir, args.height, args.width, args.batch_size, args.workers, args.combine_trainval) trans_train_loader, num_classes = get_fake_data(args.trans_name, args.trans_data_txt, args.height, args.width, args.batch_size, args.workers) # Create model model = models.create(args.arch, dropout=0, num_classes=num_classes) # model = models.create(args.arch, num_features=1024, num_diff_features=args.features, # dropout=args.dropout, num_classes=num_classes, iden_pretrain=True) # Load from checkpoint start_epoch = best_top1 = 0 if args.resume: checkpoint = load_checkpoint(args.resume) model.load_state_dict(checkpoint['state_dict']) start_epoch = checkpoint['epoch'] best_top1 = checkpoint['best_top1'] print("=> Start epoch {} best top1 {:.1%}" .format(start_epoch, best_top1)) model = nn.DataParallel(model).cuda() # Distance metric metric = DistanceMetric(algorithm=args.dist_metric) # Evaluator evaluator = Evaluator(model) if args.evaluate: metric.train(model, trans_train_loader) # print("Validation:") # evaluator.evaluate(val_loader, dataset.val, dataset.val, metric) print("Test:") evaluator.evaluate(test_loader, dataset.query, dataset.gallery, metric) return # Criterion criterion = nn.CrossEntropyLoss().cuda() # Optimizer if hasattr(model.module, 'base'): base_param_ids = set(map(id, model.module.base.parameters())) new_params = [p for p in model.parameters() if id(p) not in base_param_ids] param_groups = [ {'params': model.module.base.parameters(), 'lr_mult': 0.1}, {'params': new_params, 'lr_mult': 1.0}] else: param_groups = model.parameters() optimizer = torch.optim.SGD(param_groups, lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay, nesterov=True) # Trainer trainer = Trainer(model, criterion) # Schedule learning rate def adjust_lr(epoch): # lr = args.lr if epoch <= 270 else \ # args.lr * (0.001 ** ((epoch - 270) / 135)) # lr = args.lr if epoch <= 100 else \ # args.lr * (0.001 ** ((epoch - 100) / 50.0)) lr = args.lr * 0.1**(epoch//args.lr_change_epochs) for g in optimizer.param_groups: g['lr'] = lr * g.get('lr_mult', 1) # Start training for epoch in range(start_epoch, args.epochs): adjust_lr(epoch) trainer.train(epoch, trans_train_loader, optimizer, logger) #######Tensorboard-logs########## # for tag, value in model.named_parameters(): # tag = tag.replace('.', '/') # try: # logger.histo_summary(tag, to_np(value), epoch * len(train_loader) + 1) # logger.histo_summary(tag + '/grad', to_np(value.grad), epoch * len(train_loader) + 1) # except AttributeError, e: # pass # for tag, value in criterion.named_parameters(): # tag = tag.replace('.', '/') # try: # logger.histo_summary(tag, to_np(value), epoch * len(train_loader) + 1) # logger.histo_summary(tag + '/grad', to_np(value.grad), epoch * len(train_loader) + 1) # except AttributeError, e: # pass ################################# top1 = evaluator.evaluate(val_loader, dataset.val, dataset.val) is_best = top1 > best_top1 best_top1 = max(top1, best_top1) save_checkpoint({ 'state_dict': model.module.state_dict(), 'epoch': epoch + 1, 'best_top1': best_top1, }, is_best, fpath=osp.join(args.logs_dir, 'checkpoint.pth.tar')) print('\n * Finished epoch {:3d} top1: {:5.1%} best: {:5.1%}{}\n'. format(epoch, top1, best_top1, ' *' if is_best else '')) # Final test print('Test with best model:') checkpoint = load_checkpoint(osp.join(args.logs_dir, 'model_best.pth.tar')) model.module.load_state_dict(checkpoint['state_dict']) metric.train(model, trans_train_loader) evaluator.evaluate(test_loader, dataset.query, dataset.gallery, metric)