def main(): exp_name = f'baseline_{now()}' device, log, result_dir = setup(exp_name, conf) train_df = load_csv(conf.train_csv) if conf.npy: train_images = np.load(conf.train_images) else: train_images = pd.read_parquet(conf.train_images) test_df = load_csv(conf.test_csv) if conf.npy: test_images = np.load(conf.test_images) else: test_images = pd.read_parquet(conf.test_images) log.info('done') for i in range(5): if i != conf.fold: continue if "resnet" in conf.arch or "resnext" in conf.arch: model_ft = ResNet(conf, arch_name=conf.arch, input_size=conf.image_size) model_ft.load_state_dict( torch.load("result/baseline_2020_03_21_13_01_08/model_0.pkl")) elif "densenet" in conf.arch: model_ft = DenseNet(conf, arch_name=conf.arch, input_size=conf.image_size) elif "efficientnet" in conf.arch: model_ft = EfficientNet(conf, arch_name=conf.arch) criterion = [ nn.CrossEntropyLoss(reduction="none"), nn.CrossEntropyLoss(reduction="none"), nn.CrossEntropyLoss(reduction="none") ] criterion = [c.to(device) for c in criterion] model_ft, val_preds = train_model(train_df, train_images, test_df, test_images, model_ft, criterion, log, device, result_dir, fold=i, num_epoch=conf.num_epoch) torch.save(model_ft.state_dict(), result_dir / f'model_{i}.pkl') np.save(result_dir / f'val_preds_{i}.npy', val_preds)
class ResNetLift(nn.Module): def __init__(self, network, num_joints, num_layers, num_features, mode, model_2d_path, model_lift_path): super(ResNetLift, self).__init__() # 2d pose estimation module self.model_2d = ResNetInt(network, num_joints) if model_2d_path is not None: if os.path.isfile(model_2d_path): print('Load pretrained 2D pose estimation model..') state = torch.load(model_2d_path) pretrained_dict = state['model'] model_dict = self.model_2d.state_dict() new_pretrained_dict = { k[7:]: v for k, v in pretrained_dict.items() if k[7:] in model_dict } model_dict.update(new_pretrained_dict) self.model_2d.load_state_dict(model_dict) else: raise ValueError('model does not exist: %s' % model_2d_path) # 2d-to-3d pose lifting module self.model_lift = ResNet(mode, num_joints, num_layers, num_features) if model_lift_path is not None: if os.path.isfile(model_lift_path): print('Load pretrained 2D pose estimation model..') state = torch.load(model_lift_path) pretrained_dict = state['model'] model_dict = self.model_lift.state_dict() new_pretrained_dict = { k[7:]: v for k, v in pretrained_dict.items() if k[7:] in model_dict } model_dict.update(new_pretrained_dict) self.model_lift.load_state_dict(model_dict) else: raise ValueError('model does not exist: %s' % model_lift_path) def forward(self, inp): [img, bbox, cam_c] = inp # 2d prediction [H, pred2d] = self.model_2d(img) # 3d prediction pose2d = pred2d.clone() [pose_local, depth_root] = self.model_lift([pose2d, bbox, cam_c]) return [H, pred2d, pose_local, depth_root] def set_fliptest(self, val): self.model_2d.set_fliptest(val) self.model_lift.set_fliptest(val)
def resnest18(pretrained=False, root='~/.encoding/models', **kwargs): model = ResNet(Bottleneck, [2, 2, 2, 2], radix=2, groups=1, bottleneck_width=64, deep_stem=True, stem_width=32, avg_down=True, avd=True, avd_first=False, **kwargs) if pretrained: # 官方没有提供resnest18的预训练模型,我这里用resnest50的预训练模型加载 weight = torch.hub.load_state_dict_from_url( resnest_model_urls['resnest50'], progress=True, check_hash=True) model_dict = model.state_dict() for k,v in weight.items(): if k in model_dict.keys(): model_dict[k] = v model.load_state_dict(model_dict) return model
def resnet18(pretrained=False): """Constructs a ResNet-34 model. Args: pretrained (bool): If True, returns a model pre-trained on ImageNet """ model = ResNet(BasicBlock, [2, 2, 2, 2]) if pretrained: model_dict = model.state_dict() pretrained_dict = model_zoo.load_url(model_urls['resnet18']) pretrained_dict = { k: v for k, v in pretrained_dict.items() if not k.startswith("fc") } model_dict.update(pretrained_dict) model.load_state_dict(model_dict) # model.load_state_dict(model_zoo.load_url(model_urls['resnet34'])) return model
def main(): global best_acc start_epoch = args.start_epoch # start from epoch 0 or last checkpoint epoch if not os.path.isdir(args.checkpoint): mkdir_p(args.checkpoint) # Data print('==> Preparing dataset %s' % args.dataset) transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) if args.dataset == 'cifar10': dataloader = datasets.CIFAR10 num_classes = 10 else: dataloader = datasets.CIFAR100 num_classes = 100 trainset = dataloader(root='./data', train=True, download=True, transform=transform_train) trainloader = data.DataLoader(trainset, batch_size=args.train_batch, shuffle=True, num_workers=args.workers) testset = dataloader(root='./data', train=False, download=False, transform=transform_test) testloader = data.DataLoader(testset, batch_size=args.test_batch, shuffle=False, num_workers=args.workers) # Model print("==> creating model") model = ResNet( num_classes=num_classes, depth=args.depth, norm_type=args.norm, basicblock=args.basicblock, ) model = torch.nn.DataParallel(model).cuda() cudnn.benchmark = True print(model) print(' Total params: %.4fM' % (sum(p.numel() for p in model.parameters())/1000000.0)) criterion = nn.CrossEntropyLoss() optimizer = set_optimizer(model, args) # Resume title = '{}-ResNet-{}-{}'.format(args.dataset, args.depth, args.norm) if args.resume: # Load checkpoint. print('==> Resuming from checkpoint..') assert os.path.isfile(args.resume), 'Error: no checkpoint directory found!' args.checkpoint = os.path.dirname(args.resume) checkpoint = torch.load(args.resume) best_acc = checkpoint['best_acc'] start_epoch = checkpoint['epoch'] model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title, resume=True) else: logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title) logger.set_names(['Learning Rate', 'Train Loss', 'Valid Loss', 'Train Acc.', 'Valid Acc.', 'Train Acc.5', 'Valid Acc.5']) if args.evaluate: print('\nEvaluation only') test_loss, test_acc = test(testloader, model, criterion, start_epoch, use_cuda) print(' Test Loss: %.8f, Test Acc: %.2f' % (test_loss, test_acc)) return # Train and val for epoch in range(start_epoch, args.epochs): adjust_learning_rate(optimizer, epoch) print('\nEpoch: [%d | %d] LR: %f' % (epoch + 1, args.epochs, state['lr'])) train_loss, train_acc, train_acc5 = train(trainloader, model, criterion, optimizer, epoch, use_cuda) test_loss, test_acc, test_acc5 = test(testloader, model, criterion, epoch, use_cuda) # append logger file logger.append([state['lr'], train_loss, test_loss, train_acc, test_acc, train_acc5, test_acc5]) # save model is_best = test_acc > best_acc best_acc = max(test_acc, best_acc) save_checkpoint({ 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'acc': test_acc, 'best_acc': best_acc, 'optimizer' : optimizer.state_dict(), }, is_best, checkpoint=args.checkpoint) logger.close() print('Best acc:') print(best_acc)
unlabeled_eval_loader_test = SVHNLoader(root=args.dataset_root, batch_size=args.batch_size, split='test', aug=None, shuffle=False, target_list = range(args.num_labeled_classes, num_classes)) labeled_eval_loader = SVHNLoader(root=args.dataset_root, batch_size=args.batch_size, split='test', aug=None, shuffle=False, target_list = range(args.num_labeled_classes)) all_eval_loader = SVHNLoader(root=args.dataset_root, batch_size=args.batch_size, split='test', aug=None, shuffle=False, target_list = range(num_classes)) if args.mode == 'train': if args.IL: save_weight = model.head1.weight.data.clone() save_bias = model.head1.bias.data.clone() model.head1 = nn.Linear(512, num_classes).to(device) model.head1.weight.data[:args.num_labeled_classes] = save_weight model.head1.bias.data[:] = torch.min(save_bias) - 1. model.head1.bias.data[:args.num_labeled_classes] = save_bias train_IL(model, mix_train_loader, labeled_eval_loader, unlabeled_eval_loader, args) else: train(model, mix_train_loader, labeled_eval_loader, unlabeled_eval_loader, args) torch.save(model.state_dict(), args.model_dir) print("model saved to {}.".format(args.model_dir)) else: print("model loaded from {}.".format(args.model_dir)) if args.IL: model.head1 = nn.Linear(512, num_classes).to(device) model.load_state_dict(torch.load(args.model_dir)) print('Evaluating on Head1') args.head = 'head1' print('test on labeled classes (test split)') test(model, labeled_eval_loader, args) if args.IL: print('test on unlabeled classes (test split)') test(model, unlabeled_eval_loader_test, args) print('test on all classes (test split)')
def main(args): transform = getTransforms() data_path = os.path.join('data', args.data) if not os.path.exists(data_path): print('ERROR: No dataset named {}'.format(args.data)) exit(1) trainset = BaseDataset(list_path=os.path.join(data_path, 'train.lst'), transform=transform) trainloader = torch.utils.data.DataLoader(trainset, batch_size=args.train_batch, shuffle=True, num_workers=1) testset = BaseDataset(list_path=os.path.join(data_path, 'val.lst'), transform=transform) testloader = torch.utils.data.DataLoader(testset, batch_size=args.val_batch, shuffle=True, num_workers=1) model = ResNet(num_layers=18, num_classes=args.num_classes, pretrained=True).to(DEVICE) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=0.9) summary(model, input_size=(3, 32, 32)) max_epoch = args.max_epoch last_epoch = 0 best_val_loss = None best_accuracy = None train_losses = [] val_losses = [] accuracies = [] output_dir = os.path.join('outputs', args.data) model_state_file = os.path.join(output_dir, 'checkpoint.pth.tar') os.makedirs(output_dir, exist_ok=True) if os.path.exists(model_state_file): checkpoint = torch.load(model_state_file) last_epoch = checkpoint['epoch'] best_val_loss = checkpoint['best_val_loss'] best_accuracy = checkpoint['best_accuracy'] train_losses = checkpoint['train_losses'] val_losses = checkpoint['val_losses'] accuracies = checkpoint['accuracies'] model.load_state_dict(checkpoint['state_dict'], strict=False) optimizer.load_state_dict(checkpoint['optimizer']) print('=> loaded checkpoint (epoch {})'.format(last_epoch)) for epoch in range(last_epoch, max_epoch): print('Epoch {}'.format(epoch)) train_loss = train(model=model, dataloader=trainloader, criterion=criterion, optimizer=optimizer, device=DEVICE) val_loss = val(model=model, dataloader=testloader, criterion=criterion, device=DEVICE) accuracy = test(model=model, dataloader=testloader, device=DEVICE) train_losses.append(train_loss) val_losses.append(val_loss) accuracies.append(accuracy) print('Loss: train = {}, val = {}, acc. = {}'.format( train_loss, val_loss, accuracy)) # if best_val_loss is None or val_loss < best_val_loss: # best_val_loss = val_loss # torch.save( # model.state_dict(), # os.path.join(output_dir, 'best.pth') # ) if best_accuracy is None or accuracy > best_accuracy: best_accuracy = accuracy torch.save(model.state_dict(), os.path.join(output_dir, 'best.pth')) print('=> saving checkpoint to {}'.format(model_state_file)) torch.save( { 'epoch': epoch + 1, 'best_val_loss': best_val_loss, 'best_accuracy': best_accuracy, 'train_losses': train_losses, 'val_losses': val_losses, 'accuracies': accuracies, 'state_dict': model.state_dict(), 'optimizer': optimizer.state_dict() }, model_state_file) if (epoch + 1) % 100 == 0: # plt.plot(range(epoch+1), train_losses, label="train") # plt.plot(range(epoch+1), val_losses, label="val") # plt.yscale('log') # plt.legend() # plt.savefig(os.path.join(output_dir, 'losses.png')) # plt.clf() fig, ax1 = plt.subplots() ax2 = ax1.twinx() ax1.plot(range(epoch + 1), train_losses, label='train') ax1.plot(range(epoch + 1), val_losses, label='val') ax1.set_xscale('log') ax1.set_yscale('log') ax2.plot(range(epoch + 1), accuracies, color='red', label='accuracy') ax2.set_xscale('log') handler1, label1 = ax1.get_legend_handles_labels() handler2, label2 = ax2.get_legend_handles_labels() ax1.legend(handler1 + handler2, label1 + label2, loc=3, borderaxespad=0.) plt.savefig(os.path.join(output_dir, 'losses.png')) plt.clf()
def main(): # for repeatable experiments cudnn.benchmark = False cudnn.deterministic = True np.random.seed(0) torch.manual_seed(0) torch.cuda.manual_seed(0) # options opt = Opts().parse() # dataset loader (train) if opt.dataset_train == 'h36m': train_loader = torch.utils.data.DataLoader( H36M17(opt.protocol, 'train', True, opt.scale, opt.noise, opt.std_train, opt.std_test, opt.noise_path), batch_size=opt.batch_size, shuffle=True, num_workers=int(conf.num_threads)) elif opt.dataset_train == 'inf': train_loader = torch.utils.data.DataLoader( MPIINF('train', opt.noise, opt.std_train, opt.std_test, opt.noise_path), batch_size=opt.batch_size, shuffle=True, num_workers=int(conf.num_threads)) elif opt.dataset_train == 'h36m_inf': train_loader = torch.utils.data.DataLoader(H36M17_MPIINF('train', opt), batch_size=opt.batch_size, shuffle=True, num_workers=int( conf.num_threads)) else: raise ValueError('unsupported dataset %s' % opt.dataset_train) # dataset loader (valid) if opt.dataset_test == 'h36m': val_loader = torch.utils.data.DataLoader( H36M17(opt.protocol, 'val', False, False, opt.noise, opt.std_train, opt.std_test), batch_size=opt.batch_size, shuffle=False, num_workers=int(conf.num_threads)) elif opt.dataset_test == 'inf': val_loader = torch.utils.data.DataLoader( MPIINF('val', opt.noise, opt.std_train, opt.std_test), batch_size=opt.batch_size, shuffle=False, num_workers=int(conf.num_threads)) else: raise ValueError('unsupported dataset %s' % opt.dataset_test) # model if opt.network == 'resnet': model = ResNet(opt.mode, conf.num_joints, opt.num_layers, opt.num_features).cuda() else: raise ValueError('unsupported model %s' % opt.network) # multi-gpu if opt.multi_gpu == True: model = torch.nn.DataParallel(model, device_ids=[0, 1, 2]) else: model = torch.nn.DataParallel(model, device_ids=[0]) # optimizer if opt.opt_method == 'rmsprop': optimizer = torch.optim.RMSprop(model.parameters(), lr=opt.lr) elif opt.opt_method == 'adam': optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr) else: raise ValueError('unsupported optimizer %s' % opt.opt_method) # scheduler scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[200, 300], gamma=0.1) # log log = [] log.append([]) # epoch log.append([]) # cost (train) log.append([]) # error3d1 (train) log.append([]) # error3d2 (train) log.append([]) # cost (val) log.append([]) # error3d1 (val) log.append([]) # error3d2 (val) # load model idx_start = opt.num_epochs while idx_start > 0: file_name = os.path.join(opt.save_dir, 'model_{}.pth'.format(idx_start)) if os.path.exists(file_name): state = torch.load(file_name) model.load_state_dict(state['model']) optimizer.load_state_dict(state['optimizer']) scheduler.load_state_dict(state['scheduler']) log_name = os.path.join(opt.save_dir, 'log_{}.pkl'.format(idx_start)) if os.path.exists(log_name): with open(log_name, 'rb') as fin: log = pickle.load(fin) break idx_start -= 1 # logger if idx_start == 0: logger = Logger(opt.save_dir + '/logs') else: logger = Logger(opt.save_dir + '/logs', reset=False) # train epoch = idx_start + 1 for epoch in range(idx_start + 1, opt.num_epochs + 1): # for repeatable experiments np.random.seed(epoch) torch.manual_seed(epoch) torch.cuda.manual_seed(epoch) # do scheduler scheduler.step() # perform one epoch of training cost_train, error3d1_train, error3d2_train = train( epoch, opt, train_loader, model, optimizer) logger.scalar_summary('cost_train', cost_train, epoch) logger.scalar_summary('error3d1_train', error3d1_train, epoch) logger.scalar_summary('error3d2_train', error3d2_train, epoch) # perform one epoch of validation with torch.no_grad(): cost_val, error3d1_val, error3d2_val = val(epoch, opt, val_loader, model) logger.scalar_summary('cost_val', cost_val, epoch) logger.scalar_summary('error3d1_val', error3d1_val, epoch) logger.scalar_summary('error3d2_val', error3d2_val, epoch) # print message to log file logger.write('%d %1.1e | %.4f %.4f %.4f | %.4f %.4f %.4f\n' % (epoch, optimizer.param_groups[0]['lr'], cost_train, error3d1_train, error3d2_train, cost_val, error3d1_val, error3d2_val)) # log[0].append(epoch) log[1].append(cost_train) log[2].append(error3d1_train) log[3].append(error3d2_train) log[4].append(cost_val) log[5].append(error3d1_val) log[6].append(error3d2_val) # save model state = { 'epoch': epoch, 'model': model.state_dict(), 'optimizer': optimizer.state_dict(), 'scheduler': scheduler.state_dict() } if epoch % opt.save_intervals == 0: torch.save( state, os.path.join(opt.save_dir, 'model_{}.pth'.format(epoch))) log_name = os.path.join(opt.save_dir, 'log_{}.pkl'.format(epoch)) with open(log_name, 'wb') as fout: pickle.dump(log, fout) logger.close() # save final model file_name = os.path.join(opt.save_dir, 'final_model.pth') torch.save(state, file_name) # save final log log_name = os.path.join(opt.save_dir, 'final_log.pkl') with open(log_name, 'wb') as fout: pickle.dump(log, fout) # plotting x = range(1, opt.num_epochs + 1) cost_train = np.array(log[1]) error3d1_train = np.array(log[2]) error3d2_train = np.array(log[3]) cost_val = np.array(log[4]) error3d1_val = np.array(log[5]) error3d2_val = np.array(log[6]) fig, ax = plt.subplots() ax.plot(x, cost_train, 'r') ax.plot(x, cost_val, 'b') ax.set(xlabel='epoch', ylabel='cost', title='cost') plt.legend(('cost_train', 'cost_val')) ax.grid() fig.savefig(os.path.join(opt.save_dir, 'cost.png')) fig, ax = plt.subplots() ax.plot(x, error3d1_train, 'r') ax.plot(x, error3d2_train, 'm') ax.plot(x, error3d1_val, 'b') ax.plot(x, error3d2_val, 'c') ax.set(xlabel='epoch', ylabel='error3d', title='3D error (mm)') plt.legend( ('error3d1_train', 'error3d2_train', 'error3d1_val', 'error3d2_val')) ax.grid() fig.savefig(os.path.join(opt.save_dir, 'error3d.png')) #--------------------------------------------------------------------------- # dataset loader (test) if opt.dataset_test == 'h36m': test_loader = torch.utils.data.DataLoader( H36M17(opt.protocol, 'test', True, False, opt.noise, opt.std_train, opt.std_test), batch_size=opt.batch_size, shuffle=False, num_workers=int(conf.num_threads)) elif opt.dataset_test == 'inf': test_loader = torch.utils.data.DataLoader( MPIINF('val', opt.noise, opt.std_train, opt.std_test), batch_size=opt.batch_size, shuffle=False, num_workers=int(conf.num_threads)) else: raise ValueError('unsupported dataset %s' % opt.dataset_test) # final evaluation with torch.no_grad(): cost_final, error3d1_final, error3d2_final = test( epoch, opt, test_loader, model)
accuracy = 0 with torch.no_grad(): for batch_idx, (data, label) in enumerate(test_loader): data = data.to(device) label = label.to(device) pred = model(data) loss = criterion(pred, label.long()) eval_loss += loss.item() pred, label = pred.cpu().squeeze(), label.cpu().squeeze() # print(batch_idx, pred, label) if torch.argmax(pred) == label: accuracy += 1 eval_loss /= len(test_loader) accuracy /= len(test_loader) print('====> Avg validation loss: %.4f, accuracy: %.2f%%' % (eval_loss, accuracy*100)) return accuracy # Complete training if train_mode: accuracy = [] for epoch in range(1, epochs + 1): train(epoch) accuracy.append(validate()) if epoch % 10 == 0: # Save optimized model parameters torch.save(model.state_dict(), os.path.join(weight_path, "resnet2_lr4_ep%d" % epoch)) print(accuracy) else: validate()