def get_cifar10_datasets(args, train_portion=1.0): kwargs = {'num_workers': 4, 'pin_memory': True} if args.cuda else {'num_workers': 4} dataset_root = dir_utils.get_dir(os.path.join(os.path.expanduser('~'), 'datasets', 'RRSVM_datasets')) train_set = datasets.CIFAR10(root=dataset_root, train=True, download=True, transform=transform_train) if train_portion < 1.0: np.random.seed(args.seed or 0) n_samples = len(train_set) categorical_labels = list(set(train_set.train_labels)) n_categories = len(categorical_labels) # evenly sample: selected_indices = [] for idx in range(n_categories): categorical_idx = [i for i in range(n_samples) if train_set.train_labels[i] == categorical_labels[idx]] n_categorical_samples = len(categorical_idx) indices = np.random.permutation(n_categorical_samples) relative_indices = indices[:][: int(n_categorical_samples * train_portion)] s_selected_indices = [categorical_idx[i] for i in relative_indices] selected_indices.extend(s_selected_indices) train_loader = torch.utils.data.DataLoader(train_set, batch_size=args.train_batch_size, sampler=SubsetRandomSampler(selected_indices), **kwargs) else: train_loader = torch.utils.data.DataLoader(train_set, batch_size=args.train_batch_size, shuffle=True, **kwargs) testset = datasets.CIFAR10(root=dataset_root, train=False, download=True, transform=transform_test) test_loader = torch.utils.data.DataLoader(testset, batch_size=args.test_batch_size, shuffle=False, **kwargs) return train_loader, test_loader
def test(epoch): global best_acc net.eval() test_loss = 0 correct = 0 total = 0 total_n = 0 pbar = progressbar.ProgressBar(max_value=n_testdata // test_batch_size) for batch_idx, (inputs, targets) in enumerate(testloader): if use_cuda: inputs, targets = inputs.cuda(), targets.cuda() inputs, targets = Variable(inputs, volatile=True), Variable(targets) outputs = net(inputs) loss = criterion(outputs, targets) test_loss += loss.data[0] _, predicted = torch.max(outputs.data, 1) total += targets.size(0) correct += predicted.eq(targets.data).cpu().sum() pbar.update(batch_idx) total_n = batch_idx + 1 # Save checkpoint. t_acc = 100. * correct / total t_loss = test_loss / (total_n) w_line = '\nVal:\t{:d}\t{:.04f}\t{:.04f}\n'.format(epoch, t_loss, t_acc) print(w_line) save_dir = dir_utils.get_dir('./snapshots/cifar10_letnet_{:s}'.format( args.model)) log_file = os.path.join(save_dir, 'log.txt') if not os.path.isfile(log_file): with open(log_file, 'w') as f: f.write(w_line) else: with open(log_file, 'a') as f: f.write(w_line) sys.stdout.flush() if t_acc > best_acc: print('Saving..') state = { 'net': net.state_dict(), 'optimizer': optimizer.state_dict(), 'acc': t_acc, 'loss': t_loss, 'epoch': epoch, } torch.save(state, os.path.join(save_dir, 'ckpt.t7')) best_acc = t_acc
def main(): global args, best_mAP args = parser.parse_args() if args.finetune: print("=> using pre-trained model") pretrained = True else: print("=> creating model from new") pretrained = False if args.model.lower() == 'orig': print("Using Original Model") useRRSVM = False elif args.model.lower() == 'rrsvm': print("Using RRSVM Model") useRRSVM = True else: raise NotImplemented model = inception_v3.inception_v3(pretrained, useRRSVM=useRRSVM) print("Number of Params in InceptionV3-{:s}\t{:d}".format(args.model, sum([p.data.nelement() for p in model.parameters()]))) criterion = nn.CrossEntropyLoss() optimizer = torch.optim.SGD(filter(lambda p:p.requires_grad, model.parameters()), args.lr, momentum=args.momentum, weight_decay=args.weight_decay) p_constraint = False if args.positive_constraint: p_constraint = True use_cuda = torch.cuda.is_available() and (args.gpu_id is not None or args.multiGpu) if use_cuda: if args.multiGpu: if args.gpu_id is None: # using all the GPUs device_count = torch.cuda.device_count() print("Using ALL {:d} GPUs".format(device_count)) model = nn.DataParallel(model, device_ids=[i for i in range(device_count)]).cuda() else: print("Using GPUs: {:s}".format(args.gpu_id)) device_ids = [int(x) for x in args.gpu_id] model = nn.DataParallel(model, device_ids=device_ids).cuda() else: torch.cuda.set_device(int(args.gpu_id)) model.cuda() criterion.cuda() cudnn.benchmark = True global save_dir save_dir = './snapshots/ImageNet_Inceptionv3_{:s}'.format(args.model.upper()) if args.positive_constraint: save_dir = save_dir + '_p' if args.finetune: save_dir = save_dir + '_finetune' save_dir = dir_utils.get_dir(save_dir) # optionally resume from a checkpoint if args.resume: # if os.path.isfile(args.resume): ckpt_filename = 'model_best.ckpt.t7' assert os.path.isfile(os.path.join(save_dir, ckpt_filename)), 'Error: no checkpoint directory found!' checkpoint = torch.load(os.path.join(save_dir, ckpt_filename), map_location=lambda storage, loc: storage) args.start_epoch = checkpoint['epoch'] best_prec1 = checkpoint['prec1'] model.load_state_dict(checkpoint['state_dict']) # TODO: check how to load optimizer correctly optimizer.load_state_dict(checkpoint['optimizer']) print("=> loading checkpoint '{}', epoch: {:d}".format(ckpt_filename, args.start_epoch)) else: print('==> Training with NO History..') if os.path.isfile(os.path.join(save_dir, 'log.txt')): os.remove(os.path.join(save_dir, 'log.txt')) user_root = os.path.expanduser('~') dataset_path = os.path.join(user_root, 'datasets/imagenet12') traindir = os.path.join(dataset_path, 'train') valdir = os.path.join(dataset_path, 'val') normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_dataset = datasets.ImageFolder( traindir, transforms.Compose([ transforms.RandomSizedCrop(299), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize, ])) train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True) val_loader = torch.utils.data.DataLoader( datasets.ImageFolder(valdir, transforms.Compose([ transforms.Scale(341), transforms.CenterCrop(299), transforms.ToTensor(), normalize, ])), batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) if args.evaluate: validate(val_loader, model, criterion, use_cuda) return for epoch in range(args.start_epoch, args.n_epochs): # if args.distributed: # train_sampler.set_epoch(epoch) adjust_learning_rate(optimizer, epoch, args.finetune) # train for one epoch train(train_loader, model, criterion, optimizer, epoch, p_constraint, use_cuda) # evaluate on validation set prec1, prec5 = validate(val_loader, model, criterion, use_cuda) # remember best prec@1 and save checkpoint is_best = prec1 > best_prec1 best_prec1 = max(prec1, best_prec1) save_checkpoint({ 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'prec1': prec1, 'prec5': prec5, 'optimizer': optimizer.state_dict(), }, is_best, filename=os.path.join(save_dir, '{:04d}_checkpoint.pth.tar'.format(epoch)))
def main(): global args, best_mAP args = parser.parse_args() useRRSVM = True use_cuda = cuda_model.ifUseCuda(args.gpu_id, args.multiGpu) model = Network.getRes101Model(eval=False, gpu_id=args.gpu_id, multiGpu=args.multiGpu, useRRSVM=useRRSVM) print("Number of Params in ResNet101\t{:d}".format( sum([p.data.nelement() for p in model.parameters()]))) #TODO: add weight # criterion = nn.CrossEntropyLoss() # criterion = nn.MultiLabelSoftMarginLoss(weight=torch.FloatTensor([10,1]).cuda()) # you need to modify this to satisfy the papers w_p =10 and w_n = 1 criterion = Network.WeightedBCEWithLogitsLoss( weight=torch.FloatTensor([1, 10])) # criterion = nn.BCEWithLogitsLoss() if use_cuda: criterion.cuda() cudnn.benchmark = True optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad, model.parameters()), args.lr, momentum=args.momentum, weight_decay=args.weight_decay) # optimizer = torch.optim.(filter(lambda p:p.requires_grad, model.parameters()), args.lr) lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[20, 40]) global save_dir save_dir = './snapshots/HICO_ResNet101_wBCE' save_dir = dir_utils.get_dir(save_dir) # optionally resume from a checkpoint if args.resume: # if os.path.isfile(args.resume): ckpt_filename = 'model_best.pth.tar' assert os.path.isfile(os.path.join( save_dir, ckpt_filename)), 'Error: no checkpoint directory found!' checkpoint = torch.load(os.path.join(save_dir, ckpt_filename), map_location=lambda storage, loc: storage) # args.start_epoch = checkpoint['epoch'] best_mAP = checkpoint['mAP'] args.start_epoch = 0 model.load_state_dict(checkpoint['state_dict'], strict=False) # TODO: check how to load optimizer correctly # optimizer.load_state_dict(checkpoint['optimizer']) print( "=> loading checkpoint '{}', epoch: {:d}, current Precision: {:.04f}" .format(ckpt_filename, args.start_epoch, best_mAP)) train_loader = torch.utils.data.DataLoader(HICODataLoader.HICODataset( split='train', transform=HICODataLoader.HICO_train_transform()), batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True) test_loader = torch.utils.data.DataLoader(HICODataLoader.HICODataset( split='test', transform=HICODataLoader.HICO_val_transform()), batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) if args.evaluate: print("Evaluation Only") mAP, loss = validate(test_loader, model, criterion, use_cuda) return avg_train_losses = [] avg_test_losses = [] for epoch in range(args.start_epoch, args.epochs): lr_scheduler.step(epoch) print('Epoch\t{:d}\t LR lr {:.5f}'.format( epoch, optimizer.param_groups[0]['lr'])) # train for one epoch _, avg_train_loss = train(train_loader, model, criterion, optimizer, epoch, use_cuda) # evaluate on validation set mAP, avg_test_loss = validate(test_loader, model, criterion, use_cuda) # remember best prec@1 and save checkpoint is_best = mAP > best_mAP best_mAP = max(mAP, best_mAP) save_checkpoint( { 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'mAP': mAP, 'optimizer': optimizer.state_dict(), }, is_best, filename=os.path.join(save_dir, '{:04d}_checkpoint.pth.tar'.format(epoch))) avg_train_losses.append(avg_train_loss) avg_test_losses.append(avg_test_loss) loss_record = {'train': avg_train_losses, 'test': avg_test_losses} with open(os.path.join(save_dir, 'loss.pkl'), 'wb') as handle: pkl.dump(loss_record, handle, protocol=pkl.HIGHEST_PROTOCOL)
model.cuda() criterion.cuda() cudnn.benchmark = True # Model save_dir = './snapshots/{:s}_{:s}'.format(args.dataset.lower(), identifier) if args.positive_constraint: save_dir = './snapshots/{:s}_{:s}_p'.format(args.dataset.lower(), identifier) if args.id is not None: save_dir = save_dir+args.id save_dir = dir_utils.get_dir(save_dir) if not args.verbose: log_file = os.path.join(save_dir, 'log.txt') sys.stdout = open(log_file, "w") if args.resume: # Load checkpoint. print('==> Resuming from checkpoint..') assert os.path.isfile(os.path.join(save_dir, 'ckpt.t7')), 'Error: no checkpoint directory found!' checkpoint = torch.load(os.path.join(save_dir, 'ckpt.t7'), map_location=lambda storage, loc: storage) state_dict = checkpoint['net'] model.load_state_dict(state_dict) best_acc = checkpoint['acc'] start_epoch = checkpoint['epoch'] else: print('==> Training from scratch..')
default=10, metavar='N', help='how many batches to wait before logging training status') parser.add_argument( '--pool-method', default='RRSVM', help='pooling method (max|RRSVM|SoftRRSVM) (default: RRSVM)') args = parser.parse_args() args.cuda = not args.no_cuda and torch.cuda.is_available() torch.manual_seed(args.seed) if args.cuda: torch.cuda.manual_seed(args.seed) dataset_root = dir_utils.get_dir( os.path.join(os.path.expanduser('~'), 'datasets', 'RRSVM_datasets')) kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {} train_size = 6000 # use a subset of training data train_set = datasets.MNIST(dataset_root, train=True, download=True, transform=transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, )) ])) indices = torch.randperm(len(train_set)) train_indices = indices[:][:train_size or None] train_loader = torch.utils.data.DataLoader( train_set, batch_size=args.batch_size,
parser.add_argument( '--resume', '-r', default= 'snapshots/MTweak3-FullVGG-1024x512/params/best-5000-0.55-0.77.pth.tar', type=str, help='resume from checkpoint') if __name__ == '__main__': args = parser.parse_args() identifier = 'MTweak3-FullVGG' running_name = '{:s}-{:d}x{:d}'.format(identifier, args.l1, args.l2) save_dir = dir_utils.get_dir('./snapshots/{:s}'.format(running_name)) save_file = os.path.join(save_dir, '{:s}.txt'.format(running_name)) param_save_dir = dir_utils.get_dir(os.path.join(save_dir, 'params')) ckpt_file = args.resume if ckpt_file is not None: if not os.path.isfile(ckpt_file): print("CKPT {:s} NOT EXIST".format(ckpt_file)) sys.exit(-1) print("load from {:s}".format(ckpt_file)) single_pass_net = CompositionNet(pretrained=False, LinearSize1=args.l1, LinearSize2=args.l2) siamese_net = SiameseNet(single_pass_net)
return TopNp if __name__ == '__main__': # Test save_ckpt_topN_state: import numpy as np import py_utils.dir_utils as dir_utils np.random.seed(0) n_iter = 100 x_len = 20 TopN = 10 for t in range(100): x = np.random.rand(10) TopNp = [] dir_name = dir_utils.get_dir('Test') for x_i in x: epoch_state = { 'performance': x_i } TopNp = save_ckpt_topN_state(epoch_state, x_i, dir_name, TopNp, TopN) # Check correctness: save_name_pattern = '{:04d}.pth.tar' saved_x = [] for idx in range(TopN): ckpt = torch.load(os.path.join(dir_name, save_name_pattern.format(idx+1)), map_location=lambda storage, loc: storage) saved_x.append(ckpt['performance']) x_sorted = - np.sort(-x) Flag = True
import os import sys import py_utils.dir_utils as dir_utils user_root = os.path.expanduser('~') dataset_root = os.path.join(user_root, 'datasets', 'RRSVM_dataset') dataset_root = dir_utils.get_dir(dataset_root) print "DEBUG"
download=True, transform=transform_test) testloader = torch.utils.data.DataLoader(testset, batch_size=test_batch_size, shuffle=False, num_workers=2) n_testdata = len(testset) print('# testing: {:d}\t batch size: {:d}, # batch: {:d}'.format( n_testdata, test_batch_size, n_testdata // test_batch_size)) classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck') # Model save_dir = dir_utils.get_dir('./snapshots/cifar10_letnet_{:s}'.format( args.model)) if args.resume: # Load checkpoint. print('==> Resuming from checkpoint..') assert os.path.isfile(os.path.join( save_dir, 'ckpt.t7')), 'Error: no checkpoint directory found!' checkpoint = torch.load(os.path.join(save_dir, 'ckpt.t7'), map_location=lambda storage, loc: storage) net_struct = model[args.model.upper()] net = net_struct() state_dict = checkpoint['net'] net.load_state_dict(state_dict) best_acc = checkpoint['acc'] start_epoch = checkpoint['epoch']
def get_minst_datasets(args, train_portion=1.0): kwargs = { 'num_workers': 1, 'pin_memory': True } if args.cuda else { 'num_workers': 1 } dataset_root = dir_utils.get_dir( os.path.join(os.path.expanduser('~'), 'datasets', 'RRSVM_datasets')) # train_size = 6000 # use a subset of training data train_set = datasets.MNIST(dataset_root, train=True, download=True, transform=transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, )) ])) if train_portion < 1.0: np.random.seed(args.seed or 0) n_samples = len(train_set) categories_labels = list(set(train_set.train_labels.numpy())) n_categories = len(categories_labels) # evenly sample: selected_indices = [] for idx in range(n_categories): categorical_idx = [ i for i in range(n_samples) if train_set.train_labels[i] == categories_labels[idx] ] n_categorical_samples = len(categorical_idx) indices = np.random.permutation(n_categorical_samples) relative_indices = indices[:][:int(n_categorical_samples * train_portion)] s_selected_indices = [categorical_idx[i] for i in relative_indices] selected_indices.extend(s_selected_indices) train_loader = torch.utils.data.DataLoader( train_set, batch_size=args.train_batch_size, sampler=SubsetRandomSampler(selected_indices), **kwargs) else: train_loader = torch.utils.data.DataLoader( train_set, batch_size=args.train_batch_size, **kwargs) test_loader = torch.utils.data.DataLoader(datasets.MNIST( dataset_root, train=False, transform=transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, )) ])), batch_size=args.test_batch_size, shuffle=False, **kwargs) return train_loader, test_loader