def main():
# parse options
parser = TestOptions()
opts = parser.parse()
# data loader
train_loader, input_data_par = get_loader(1)
# model
print('\n--- load model ---')
model = DRIT(opts)
model.setgpu(opts.gpu)
model.resume(opts.resume, train=False)
model.eval()
# directory
result_dir = os.path.join(opts.result_dir, opts.name)
if not os.path.exists(result_dir):
os.mkdir(result_dir)
# test
print('\n--- testing ---')
for it, (images_a, images_b, labels) in enumerate(train_loader['test']):
images_a = images_a.cuda(opts.gpu).detach()
images_b = images_b.cuda(opts.gpu).detach()
with torch.no_grad():
loss = model.test_model(images_a, images_b)
print('it:{}, loss:{}'.format(it, loss))
return
def main(args):
parser = argparse.ArgumentParser(
description=("Run deep models for visual semantic role segmentation "
"(or detection)"))
parser.add_argument("mode", help="Mode to run model in (e.g. 'train')")
parser.add_argument("-s",
"--save_dir",
help="directory for saving the model",
default="saved_models/%s" %
dt.datetime.now().strftime("%Y_%m_%d_%H_%M_%S"))
parser.add_argument("-e",
"--epochs",
help="number of epochs for training",
type=int,
default=50)
parser.add_argument("-p",
"--save_per",
help="epochs to wait before saving",
type=int,
default=5)
parser.add_argument("-l",
"--learn_rate",
help="learning rate",
type=float,
default=0.001)
parser.add_argument("-c",
"--cuda",
type=int,
nargs="+",
help="ids of gpus to use during training",
default=[])
parser.add_argument("-f",
"--fake",
action="store_true",
help=("flag to use fake data that loads quickly (for"
"development purposes)"))
parser.add_argument(
"--net",
help="file in which model is stored. Used in test mode.",
default=None)
cfg = parser.parse_args(args)
if cfg.mode == 'train':
model = md.CtxBB()
if cfg.fake:
dataloader = get_fake_loader()
else:
dataloader = ld.get_loader("vcoco_train", ld.COCO_IMGDIR)
trainer = md.BasicTrainer(model, dataloader, **vars(cfg))
logging.getLogger(__name__).info("Beginning Training...")
trainer.train(cfg.epochs)
elif cfg.mode == 'test':
checkpoint = torch.load(cfg.net)
model = checkpoint["model"]
evaluator = ev.Evaluator(**vars(cfg))
ev.do_eval(evaluator, model, "vcoco_val", cfg.save_dir)
else:
logging.getLogger(__name__).error("Invalid mode '%s'" % str(cfg.mode))
sys.exit(1)
if embedding == 'glove':
inp = loadmat('embedding/' + dataset + '-inp-glove6B.mat')['inp']
inp = torch.FloatTensor(inp)
elif embedding == 'googlenews':
inp = loadmat('embedding/' + dataset + '-inp-googlenews.mat')['inp']
inp = torch.FloatTensor(inp)
elif embedding == 'fasttext':
inp = loadmat('embedding/' + dataset + '-inp-fasttext.mat')['inp']
inp = torch.FloatTensor(inp)
else:
inp = None
print('...Data loading is beginning...')
data_loader, input_data_par = get_loader(DATA_DIR, batch_size)
print('...Data loading is completed...')
model_ft = ALGCN(img_input_dim=input_data_par['img_dim'],
text_input_dim=input_data_par['text_dim'],
num_classes=input_data_par['num_class'],
t=t,
adj_file='data/' + dataset + '/adj.mat',
inp=inp,
gamma=gamma).cuda()
# params_to_update = list(model_ft.parameters())
params_to_update = model_ft.get_config_optim(lr)
# Observe that all parameters are being optimized
optimizer = optim.Adam(params_to_update, lr=lr, betas=betas)
if __name__ == '__main__':
# environmental setting: setting the following parameters based on your experimental environment.
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# data parameters
MAX_EPOCH = 100
batch_size = 45
lr = 1e-4
betas = (0.5, 0.999)
weight_decay = 0
hyper_parameters = {'cm_tri': 1, 'margin': 50, 'num_per_cls': 3}
print('...Data loading is beginning...')
# the first dataloader is for training, while the next two are for validating
dataloader, cartoon_dataloader, portrait_dataloader, input_data_par = get_loader(
dataset_path='/media/ckq/datasets/cartoon/train',
batch_size=batch_size,
num_per_cls=hyper_parameters['num_per_cls'])
#dataloader, cartoon_dataloader, portrait_dataloader, input_data_par = get_loader_split_label(dataset_path='/media/ckq/datasets/cartoon/train', batch_size=batch_size, num_per_cls=hyper_parameters['num_per_cls'])
#dataloader, cartoon_dataloader, portrait_dataloader = get_loader_feature(cartoon_feature_path='/home/sxfd91307/cartoon_retrieval/features/cartoon_resnet34_adam.hdf5', portrait_feature_path='/home/sxfd91307/cartoon_retrieval/features/portrait_resnet152.hdf5', batch_size=batch_size, num_per_cls=hyper_parameters['num_per_cls'])
print('...Data loading is completed...')
model = C2R_single(input_data_par['num_class']).to(device)
#model.load_state_dict(torch.load('weights/best_2771.pt'))
#model = IDCM_NN().to(device)
params_to_update = add_weight_decay(model, weight_decay)
# params_to_update = list(model.parameters())
# Observe that all parameters are being optimized
results_txt = 'results.txt'
with open(results_txt, 'w') as f:
for result in results:
#print(result)
f.write(result)
f.write('\n')
print('...Testing is completed...')
if valid_compute:
print('...Data loading is beginning...')
dataloader, cartoon_dataloader, portrait_dataloader, _ = get_loader(
dataset_path='/media/ckq/datasets/cartoon/train',
batch_size=batch_size,
num_per_cls=1)
print('...Data loading is completed...')
t_cartoon_features, t_cartoon_names, t_portrait_features, t_portrait_names = [], [], [], []
with torch.no_grad():
for cartoons, cartoon_names in cartoon_dataloader['valid']:
cartoons = cartoons.to(device)
cartoon_names = cartoon_names.to(device)
#cartoon_names = np.asarray(cartoon_names)
cartoons_feature, _ = model(cartoons=cartoons)
t_cartoon_features.append(cartoons_feature.cpu().numpy())
t_cartoon_names.append(cartoon_names.cpu().squeeze(-1).numpy())
for portraits, portrait_names in portrait_dataloader['valid']:
# preds, sorted capts, dec lens, attention wieghts
return predictions, encoded_captions, dec_len, alphas
# vocab indices
PAD = 0
START = 1
END = 2
UNK = 3
# Load vocabulary
with open('data/vocab.pkl', 'rb') as f:
vocab = pickle.load(f)
# load data
train_loader = get_loader('train', vocab, batch_size)
val_loader = get_loader('val', vocab, batch_size)
#############
# Init model
#############
criterion = nn.CrossEntropyLoss().to(device)
if from_checkpoint:
encoder = Encoder().to(device)
decoder = Decoder(vocab_size=len(vocab),
use_glove=glove_model,
use_bert=bert_model).to(device)
# data parameters
DATA_DIR = 'data/' + dataset + '/'
alpha = 1e-3
beta = 1e-1
MAX_EPOCH = 500 #500
batch_size = 100
# batch_size = 512
lr = 1e-4
betas = (0.5, 0.999)
weight_decay = 0
#load data
print('...Data loading is beginning...')
data_loader, input_data_par = get_loader(
DATA_DIR, batch_size
) # load the datasets .mat files pretrained by the CNN networks which contain the image, text, label information
print('...Data loading is completed...')
# set train model
model_ft = IDCM_NN(img_input_dim=input_data_par['img_dim'],
text_input_dim=input_data_par['text_dim'],
output_dim=input_data_par['num_class']).to(device)
params_to_update = list(model_ft.parameters())
# Observe that all parameters are being optimized
optimizer = optim.Adam(params_to_update, lr=lr, betas=betas)
print('...Training is beginning...')
# Train and evaluate
