def extract_image_feature(args): try: model = nets[args.net]() model.to(args.device) except Exception as e: logger.error("Initialize {} error: {}".format(args.net, e)) return logger.info("Extracting {} feature.".format(args.net)) query_dataloader = get_loader(args.query_data, args.batch_size) gallery_dataloader = get_loader(args.gallery_data, args.batch_size) checkpointer = Checkpointer(model, save_dir=args.out_dir) _ = checkpointer.load(args.checkpoint_path, use_latest=args.checkpoint_path is None) model.eval() with torch.no_grad(): for dataloader in [query_dataloader, gallery_dataloader]: for batch_imgs, batch_filenames in tqdm(dataloader): batch_imgs = batch_imgs.to(args.device) batch_features, batch_predicts = model(batch_imgs) batch_features = batch_features.cpu().detach().numpy() if args.pcaw is not None: batch_features = args.pcaw(batch_features.T, transpose=True) batch_predicts = np.argmax(batch_predicts.cpu().detach().numpy(), axis=1) for feature_per_image, predict_per_image, name_per_image in zip(batch_features, batch_predicts, batch_filenames): try: out_dir = os.path.join(args.out_dir, 'feat') if not os.path.exists(out_dir): os.makedirs(out_dir) np.save(os.path.join(out_dir, name_per_image + '.npy'), feature_per_image) np.save(os.path.join(out_dir, name_per_image + '.prd.npy'), predict_per_image) except OSError: logger.info("can not write feature with {}.".format(name_per_image))
def main(config): if config.checkpoint_dir is None: config.checkpoint_dir = 'checkpoints' os.makedirs(config.checkpoint_dir, exist_ok=True) os.makedirs(config.sample_dir, exist_ok=True) # config.manual_seed = random.randint(1, 10000) # print("Random Seed: ", config.manual_seed) # random.seed(config.manual_seed) # torch.manual_seed(config.manual_seed) # if torch.cuda.is_available(): # torch.cuda.manual_seed_all(config.manual_seed) # cudnn.benchmark = True data_loader = get_loader(config.data_path, config.batch_size, config.image_size, shuffle=True, num_workers=int(config.workers)) trainer = Trainer(config, data_loader) trainer.train() test_loader = data.test_loader.get_loader(config.test_data_path, config.test_batch_size, config.image_size, shuffle=None, num_workers=int(config.workers)) tester = Tester(config, test_loader) tester.test()
def main(): dicts = {} print('share the vocabulary between source and target') dicts = initVocabulary('source and target', opt.q_file, opt.vocab, opt.vocab_size) # print(dicts.labelToIdx) print(dicts.labelToIdx) print('Preparing training ...') trainset = makeData(opt.q_file, opt.r_file, dicts) print(trainset[0][0].size(), trainset[0][1].size()) trainloader = dataloader.get_loader(trainset, batch_size=4, shuffle=True, num_workers=2) for i, a in enumerate(trainloader): x, y = a[0], a[1] print(x.size(), i) # print(y,i,dicts.convertToLabel(y)) if opt.save_vocab is None: saveVocabulary('source', dicts, opt.save_data + '.txt') print('Saving data to \'' + opt.save_data + '.train.pt\'...') save_data = {'dicts': dicts, 'train': trainset} # print(dicts.labelToIdx) torch.save(save_data, opt.save_data)
torch.cuda.manual_seed(opt.seed) print(use_cuda) # data print('loading data...\n') start_time = time.time() datas = torch.load(config.data) print('loading time cost: %.3f' % (time.time() - start_time)) trainset, validset = datas['train'], datas['valid'] src_vocab, tgt_vocab = datas['dicts']['src'], datas['dicts']['tgt'] config.src_vocab = src_vocab.size() config.tgt_vocab = tgt_vocab.size() trainloader = dataloader.get_loader(trainset, batch_size=config.batch_size, shuffle=True, num_workers=2) validloader = dataloader.get_loader(validset, batch_size=config.batch_size, shuffle=False, num_workers=2) if opt.pretrain: pretrain_embed = torch.load(config.emb_file) else: pretrain_embed = None # model print('building model...\n') # 这个用法有意思,实际是 调了model.seq2seq 并且运行了最后这个括号里的五个参数的方法。(初始化了一个对象也就是) model = getattr(models, opt.model)(config,
#torch.cuda.set_device(opt.gpus[0]) torch.cuda.manual_seed(opt.seed) #data print('loading data...\n') start_time = time.time() datas = torch.load(config.data) print('loading time cost: %.3f' % (time.time() - start_time)) testset = datas['valid'] src_vocab, tgt_vocab = datas['dicts']['src'], datas['dicts']['tgt'] config.src_vocab = src_vocab.size() config.tgt_vocab = tgt_vocab.size() testloader = dataloader.get_loader(testset, batch_size=config.batch_size, shuffle=False, num_workers=2) if opt.pretrain: pretrain_embed = torch.load(config.emb_file) else: pretrain_embed = None # model print('building model...\n') model = getattr(models, opt.model)(config, src_vocab.size(), tgt_vocab.size(), use_cuda, pretrain=pretrain_embed, score_fn=opt.score)
torch.cuda.set_device(opt.gpus[0]) torch.cuda.manual_seed(opt.seed) print(use_cuda) # data print('loading data...\n') start_time = time.time() datas = torch.load(config.data) print('loading time cost: %.3f' % (time.time()-start_time)) trainset, validset = datas['train'], datas['valid'] src_vocab, tgt_vocab = datas['dicts']['src'], datas['dicts']['tgt'] config.src_vocab = src_vocab.size() config.tgt_vocab = tgt_vocab.size() trainloader = dataloader.get_loader(trainset, batch_size=config.batch_size, shuffle=True) validloader = dataloader.get_loader(validset, batch_size=config.batch_size, shuffle=False) if opt.pretrain: pretrain_embed = torch.load(config.emb_file) else: pretrain_embed = None # model print('building model...\n') model = getattr(models, opt.model)(config, src_vocab.size(), tgt_vocab.size(), use_cuda, pretrain=pretrain_embed, score_fn=opt.score) if opt.restore: model.load_state_dict(checkpoints['model']) if use_cuda:
# cuda use_cuda = torch.cuda.is_available() and len(opt.gpus) > 0 #use_cuda = True if use_cuda: torch.cuda.set_device(opt.gpus[0]) torch.cuda.manual_seed(config.net_seed) # data print('loading data...\n') start_time = time.time() item_train, label_train, item_test, label_test = dataset.get_data(config) trainloader = dataloader.get_loader(item_train, label_train, config.train_batch_size, config, shuffle=True, balance=True) validloader = dataloader.get_loader(item_test, label_test, config.test_batch_size, config, shuffle=False, balance=False) testloader = dataloader.get_loader(item_test, label_test, config.test_batch_size, config, shuffle=False, balance=False)
if use_cuda: torch.cuda.set_device(opt.gpus[0]) torch.cuda.manual_seed(opt.seed) # data print('loading data...\n') start_time = time.time() datas = torch.load(config.data) print('loading time cost: %.3f' % (time.time() - start_time)) testset = datas['test'] src_vocab, tgt_vocab = datas['dicts']['src'], datas['dicts']['tgt'] config.src_vocab = src_vocab.size() config.tgt_vocab = tgt_vocab.size() testloader = dataloader.get_loader(testset, batch_size=config.batch_size, shuffle=False) if opt.pretrain: pretrain_embed = torch.load(config.emb_file) else: pretrain_embed = None # model print('building model...\n') model = getattr(models, opt.model)(config, src_vocab.size(), tgt_vocab.size(), use_cuda, pretrain=pretrain_embed, score_fn=opt.score)
print('loading time cost: %.3f' % (time.time() - start_time)) trainset, validset, testset = datas['train'], datas['valid'], datas['test'] src_vocab, tgt_vocab = datas['dicts']['src'], datas['dicts']['tgt'] config.src_vocab = src_vocab.size() config.tgt_vocab = tgt_vocab.size() ## For EOS and SOS trainset.tgt_vocab_size = tgt_vocab.size() + 2 validset.tgt_vocab_size = tgt_vocab.size() + 2 testset.tgt_vocab_size = tgt_vocab.size() + 2 trainloader = dataloader.get_loader(trainset, batch_size=config.train_batch_size, shuffle=True, num_workers=2, max_len=config.max_tgt_len, sos_id=tgt_vocab.size(), eos_id=tgt_vocab.size() + 1) validloader = dataloader.get_loader(validset, batch_size=config.test_batch_size, shuffle=False, num_workers=2, max_len=config.max_tgt_len, sos_id=tgt_vocab.size(), eos_id=tgt_vocab.size() + 1) testloader = dataloader.get_loader(testset, batch_size=config.test_batch_size, shuffle=False, num_workers=2, max_len=config.max_tgt_len,
root = Path(__file__).parent.resolve() opt_file = "shared/defaults.yml" opt = load_opts(path=root / opt_file) # Set up comet experiment: # comet_exp = Experiment(workspace=opt.comet.workspace, project_name=opt.comet.project_name) if comet_exp is not None: comet_exp.log_asset(file_data=str(root / opt_file), file_name=root / opt_file) comet_exp.log_parameters(opt) opt.comet.exp = comet_exp opt = set_mode("train", opt) val_loader = get_loader(opt) test_display_images = [ iter(val_loader).next() for i in range(opt.comet.display_size) ] opt = set_mode("train", opt) loader = get_loader(opt) train_display_images = [ iter(loader).next() for i in range(opt.comet.display_size) ] model = SonderFlowEstimator() model.initialize(opt) model.setup() total_steps = 0
def main(args): print("Process %s, running on %s: starting (%s)" % (os.getpid(), os.name, time.asctime())) process_num = round(time.time()) dir_name = args.name + '_' + str(process_num) tb_path = "bleeds_experiments/logs/%s/" % (dir_name) writer = SummaryWriter(tb_path) use_gpu = args.gpu if not torch.cuda.is_available(): use_gpu = False transform = transforms.Compose([ # transforms.RandomCrop(32, padding=4), transforms.CenterCrop(900), transforms.Resize((224, 224)), # transforms.RandomHorizontalFlip(), # transforms.RandomRotation(30), # transforms.RandomPerspective(), # transforms.ColorJitter(), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) val_transform = transforms.Compose([ transforms.CenterCrop(500), transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) train_dataset = BleedsDataset(transform=transform, mode="train", dataset_path=_DATASET_PATH, batch_size=args.batch_size, upsample=args.upsample) val_dataset = BleedsDataset(transform=val_transform, mode="val", dataset_path=_DATASET_PATH) test_dataset = BleedsDataset(transform=val_transform, mode="test", dataset_path=_DATASET_PATH) train_loader = get_loader(train_dataset, batch_size=args.batch_size, shuffle=True) val_loader = get_loader(val_dataset, batch_size=args.batch_size, shuffle=True) test_loader = get_loader(test_dataset, batch_size=args.batch_size, shuffle=True) print("Loaded datasets now loading models") encoder = EncoderCNN(pretrained=args.pretrained, base_model=args.base_model) if args.seq_model: decoder = DecoderLSTM() else: decoder = Aggregator(max_aggregate=args.max_aggregate) if use_gpu: cudnn.benchmark = True encoder = encoder.cuda() decoder = decoder.cuda() encoder_trainables = [p for p in encoder.parameters() if p.requires_grad] decoder_trainables = [p for p in decoder.parameters() if p.requires_grad] params = encoder_trainables + decoder_trainables optimizer = torch.optim.SGD(params=params, lr=args.lr, momentum=0.9) # optimizer = torch.optim.Adam(params=params, lr=args.lr, betas=(0.9, 0.999), eps=1e-08) if args.cyclic_lr: scheduler = cyclicLR.CyclicCosAnnealingLR(optimizer, milestones=[10, 20], eta_min=1e-7) loss_fn = torch.nn.BCELoss() metrics_fn = utils.find_metrics start_epoch, best_loss = utils.load_checkpoint(encoder, decoder, args.resume) epoch = start_epoch while epoch <= int(args.n_epochs): print("=" * 50) if args.cyclic_lr: scheduler.step() else: utils.adjust_learning_rate(args.lr, optimizer, epoch, args.lr_decay) print("Epoch %d Training Starting" % epoch) print("Learning Rate : ", utils.get_lr(optimizer)) print("\n", "-" * 10, "Training", "-" * 10, "\n") train_loss = train.train(train_loader, encoder, decoder, optimizer, loss_fn, metrics_fn, epoch, writer, use_gpu) print("\n", "-" * 10, "Validation", "-" * 10, "\n") val_loss = train.validate(val_loader, encoder, decoder, loss_fn, metrics_fn, epoch, writer, use_gpu, ver="validation") print("-" * 50) print("Training Loss: ", float(train_loss)) print("Validation Loss: ", float(val_loss)) if epoch % args.test_epoch == 0: test_loss = train.validate(test_loader, encoder, decoder, loss_fn, metrics_fn, epoch, writer, use_gpu, ver="val") print("Test Set Loss Loss: ", float(test_loss)) print("=" * 50) curr_state = state = { "epoch": epoch, "best_loss": min(best_loss, val_loss), "encoder": encoder.state_dict(), "decoder": decoder.state_dict() } # filename = 'epoch_' + str(epoch) + '_checkpoint.pth.tar' utils.save_checkpoint( state=curr_state, is_best=bool(val_loss < best_loss), dir_name=dir_name, # filename=filename ) if val_loss < best_loss: best_loss = val_loss epoch += 1 writer.add_scalar('data/learning_rate', utils.get_lr(optimizer), epoch) print(utils.get_lr(optimizer))