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))
