def main(_):
parser = argparse.ArgumentParser(
description='Classification model training')
parser.add_argument('--config_file', type=str, default=None,
help='Optional config file for params')
parser.add_argument('opts', help='see config.py for all options',
default=None, nargs=argparse.REMAINDER)
args = parser.parse_args()
if args.config_file is not None:
cfg_from_file(args.config_file)
if args.opts is not None:
cfg_from_list(args.opts)
assert_and_infer_cfg()
print_cfg()
os.environ["CUDA_VISIBLE_DEVICES"] = str(cfg.GPU_ID)
logger = utils.setup_custom_logger('root')
tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)
tf_config = tf.ConfigProto(device_count=dict(
GPU=1), gpu_options=tf.GPUOptions(allow_growth=True))
tf.enable_resource_variables()
train(tf_config, logger)
test(tf_config, logger)
def main():
global args
args = parser.parse_args()
if args.cfg_file is not None:
cfg_from_file(args.cfg_file)
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
files = os.listdir(args.model_dir)
cp_files = [f for f in files if f.endswith('.pth.tar')]
if args.file_ptn is not None:
ptn = re.compile(args.file_ptn)
cp_files = [f for f in files if ptn.search(f)]
model_info = []
for cp_file in cp_files:
file_name = cp_file.rsplit('.', 2)[0]
model_group_name, model_name, _ = file_name.split('-')
cp_path = os.path.join(args.model_dir, cp_file)
model_info.append((model_group_name, model_name, cp_path))
att_query = AttQuery(model_info, args.split, args.model_dir)
visualizer = Visualizer()
while True:
att_query.print_query()
command = input('input command: ')
if ' ' in command:
opt, arg = command.split(' ', 1)
else:
opt, arg = command, None
if opt in ('q', 'question'):
att_query.set_question(arg)
elif opt in ('a', 'answer'):
att_query.set_answer(arg)
elif opt in ('c', 'condition'):
att_query.set_condition(arg)
elif opt in ('x', 'clean'):
att_query.set_question(None)
att_query.set_answer(None)
att_query.set_condition(None)
elif opt in ('s', 'save'):
if arg is None:
inds = range(att_query.get_res_cnt())
else:
inds = map(int, arg.split(','))
att_query.save(inds)
elif opt in ('r', 'run'):
if arg is None:
arg = 1
result = att_query.run(int(arg))
visualizer.visualize(result, att_query.model_info)
elif opt in ('e', 'exit'):
break
else:
print('wrong command !')
def main():
global args
args = parser.parse_args()
args_str = json.dumps(vars(args), indent=2)
print('[Info] called with: ' + args_str)
if args.cfg_file is not None:
cfg_from_file(args.cfg_file)
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
# checkpoint directory
cfg.LOG_DIR = os.path.join(cfg.LOG_DIR, args.checkpoint)
# select device
torch.cuda.set_device(args.gpu_id)
print('[Info] use gpu: {}'.format(torch.cuda.current_device()))
# data
print('[Info] init dataset')
model_group_name, model_name = args.model.split('/')
val_set = VQADataset('test', model_group_name)
val_loader = torch.utils.data.DataLoader(val_set,
batch_size=args.bs,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
print('sample count: {}'.format(len(val_set)))
# model
print('[Info] construct model')
model_group = import_module('models.' + model_group_name)
model = getattr(model_group, model_name)(num_words=val_set.num_words,
num_ans=val_set.num_ans,
emb_size=get_emb_size())
model.cuda()
cudnn.benchmark = True
print('[Info] model name: ' + args.model)
# predict
fnames = [(i, 'checkpoint-{:03}.pth.tar'.format(i))
for i in range(args.start_epoch, args.end_epoch, args.epoch_freq)
]
cp_files = [(i, os.path.join(cfg.LOG_DIR, fname)) for i, fname in fnames]
for epoch, cp_file in cp_files:
if os.path.isfile(cp_file):
print("[Info] loading checkpoint '{}'".format(cp_file))
checkpoint = torch.load(cp_file)
model.load_state_dict(checkpoint['state_dict'])
else:
print("[Info] no checkpoint found at '{}'".format(cp_file))
continue
results = predict(val_loader, model)
result_file = os.path.join(cfg.LOG_DIR,
'result-{:03}.json'.format(epoch))
json.dump(results, open(result_file, 'w'))
net.load(DEFAULT_WEIGHTS)
solver = Solver(net)
toc = time.clock()
print('Time to load model: ' + str(toc - tic))
tic = time.clock()
path = './test/'
dirs = sorted(os.listdir(path))
time_ims = []
for i in dirs:
print(i)
time_ims.append(load_demo_images(path + i + '/'))
# Run the network
voxel_prediction, _ = solver.test_output(np.array(time_ims))
pred_file_name = str(i) + '.obj'
# Save the prediction to an OBJ file (mesh file).
voxel2obj(pred_file_name, voxel_prediction[0, :, 1, :, :] > 0.4)
toc = time.clock()
print('Time for each frame: ' + str(float((toc - tic) / len(dirs))))
if __name__ == '__main__':
# Set the batch size to 1
cfg_from_list(['CONST.BATCH_SIZE', 1])
main()
dest='cfg_file',
help='optional cfg.OPOSE file',
default='./cfgs/opose/vgg19s8_cpm6s.yml',
type=str)
parser.add_argument('--set',
dest='set_cfgs',
help='set cfg.OPOSE keys',
default=None,
nargs=argparse.REMAINDER)
args = parser.parse_args()
print('==> Called with args:')
print(args)
if args.cfg_file is not None:
cfg_from_file(args.cfg_file)
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
print('==> Using config:')
print(cfg.OPOSE)
# Use CUDA
gpu = []
os.environ['CUDA_VISIBLE_DEVICES'] = cfg.gpu_ids
for i in cfg.gpu_ids.split(','):
gpu.append(int(i))
USE_CUDA = torch.cuda.is_available()
# Random seed
if cfg.rng_seed is None:
cfg.rng_seed = random.randint(1, 10000)
random.seed(cfg.rng_seed)
torch.manual_seed(cfg.rng_seed)
# Global param
NUM_GPUS = len(cfg.gpu_ids.split(','))
def main():
global args
args = parser.parse_args()
args_str = json.dumps(vars(args), indent=2)
if args.cfg_file is not None:
cfg_from_file(args.cfg_file)
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
# use timestamp as log subdirectory
timestamp = args.timestamp
cfg.LOG_DIR = os.path.join(cfg.LOG_DIR, timestamp)
model_group_name, model_name = args.model.split('/')
# setting log handlers
sh = logging.StreamHandler(sys.stdout)
sh.setLevel(logging.DEBUG)
logger.addHandler(sh)
logger.debug('[Info] called with: ' + args_str)
logger.debug('[Info] timestamp: ' + timestamp)
# select device
torch.cuda.set_device(args.gpu_id)
logger.debug('[Info] use gpu: {}'.format(torch.cuda.current_device()))
# data
assert (len(cfg.TEST.SPLITS) == 1 and cfg.TEST.SPLITS[0] in ('val2014'))
logger.debug('[Info] init dataset')
val_set = VQADataset('test', model_group_name)
RES_DIR = '/home/lyt/code/bert-as-service-test/result'
queIds, queFea, _ = load_data(split_name='val2014', RES_DIR=RES_DIR)
assert queIds.tolist() == val_set.que_id.tolist()
logger.debug('[Info] Clustering using {}, {} clusters'.format(
args.cluster_alg, args.n_clusters))
clusfilename = '{}/{}/{}_{}_n{}.pkl'.format(RES_DIR, 'v2', 'train2014',
args.cluster_alg,
args.n_clusters)
logger.debug('[Info] cluster file: {}'.format(clusfilename))
val_qTypeLabels = clustering(queFea,
clu_num=args.n_clusters,
clu_alg=args.cluster_alg,
savefname=clusfilename)
# model
logger.debug('[Info] construct model')
model_group = import_module('models.' + model_group_name)
model = getattr(model_group, model_name)(num_words=val_set.num_words,
num_ans=val_set.num_ans,
emb_size=get_emb_size())
logger.debug('[Info] model name: ' + args.model)
total_param = 0
for param in model.parameters():
total_param += param.nelement()
logger.debug('[Info] total parameters: {}M'.format(
math.ceil(total_param / 2**20)))
model.cuda()
cudnn.benchmark = True
# load best model, predict
logger.debug('[Info] load model ...')
best_path = os.path.join(cfg.LOG_DIR, 'model-best.pth.tar')
#if os.path.isfile(best_path):
assert os.path.isfile(best_path)
logger.debug("[Info] loading checkpoint '{}'".format(best_path))
cp_state = torch.load(best_path)
best_acc = cp_state['best_acc']
logger.debug('[Info] best model with best acc {}'.format(best_acc))
model.load_state_dict(cp_state['state_dict'])
#else:
# logger.debug("[Info] no checkpoint found at '{}'".format(best_path))
for i in range(args.n_clusters):
logger.debug('[Info] choose cluster ID: {}'.format(i))
#sel = val_qTypeLabels == args.clus_id
sel = val_qTypeLabels == i
val_quesIds = queIds[sel].tolist()
logger.debug(
'[Info] #Val set before/after clustering and choosing {}/{}'.
format(queIds.shape[0], len(val_quesIds)))
val_set_sub = select_subset(val_set, sel)
val_loader = torch.utils.data.DataLoader(val_set_sub,
batch_size=args.bs,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
logger.debug('sample count: {}'.format(len(val_set_sub)))
acc = validate(val_loader, model, None, None, quesIds=val_quesIds)
logger.debug('Evaluate Result:\tAcc {0}'.format(acc))
if __name__ == '__main__':
import matplotlib.pyplot as plt
# _, axes = plt.subplots(2,2,figsize=(10,15))
# axes = axes.flatten()
# from datasets.nyud import nyud
# imdb = nyud('train', '2012')
# with open('datalayer_test.pt', 'w') as f:
# layerStr = '{}'.format(datalayer_test(imdb))
# print layerStr
# f.write(layerStr)
cfg_from_list(['TRAIN.BATCH_SIZE', '1'])
caffe.set_mode_gpu()
caffe.set_device(0)
# net = caffe.Net('datalayer_test.pt', caffe.TRAIN)
solver = caffe.SGDSolver('solver.pt')
# layer_ind = list(solver.net._layer_names).index('data')
# solver.net.layers[layer_ind].set_imdb(imdb)
# conv_filters = solver.net.layers[1].blobs[0].data
# print conv_filters
print 'Start training..'
# plt.ion()
def main():
args = parser.parse_args()
if args.cfg_file is not None:
cfg_from_file(args.cfg_file)
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
# select device
torch.cuda.set_device(args.gpu_id)
print('[Info] use gpu: {}'.format(torch.cuda.current_device()))
# get parameters
sys.path.insert(0, args.model_dir)
from params import params
assert len(params) > 1
last_cfg = params[0][-1]
last_cfg()
get_data.main()
dataset = VQADataset('test', params[0][1])
itoa = dataset.codebook['itoa']
vote_buff = [{} for i in range(len(dataset))]
conf_buff = np.zeros((len(dataset), len(itoa)))
sm_conf_buff = np.zeros((len(dataset), len(itoa)))
l2_conf_buff = np.zeros((len(dataset), len(itoa)))
que_ids = dataset.que_id
for fpath, mgrp, mname, acc, cfg_func, in params:
# data
if cfg_func != last_cfg:
cfg_func()
get_data.main()
last_cfg = cfg_func
dataset = VQADataset('test', mgrp)
itoa = dataset.codebook['itoa']
dataset.reload_obj(mgrp)
dataloader = torch.utils.data.DataLoader(
dataset, batch_size=args.bs, shuffle=False,
num_workers=2, pin_memory=True)
# model
model_group = import_module('models.' + mgrp)
model = getattr(model_group, mname)
num_words=dataset.num_words,
num_ans=dataset.num_ans,
emb_size=get_emb_size())
cp_file = os.path.join(args.model_dir, fpath)
checkpoint = torch.load(cp_file, map_location=lambda s, l: s.cuda(0))
model.load_state_dict(checkpoint['state_dict'])
model.cuda()
model.eval()
# predict
bar = progressbar.ProgressBar()
start = 0
# sample: (que_id, img, que, [obj])
for sample in bar(dataloader):
sample_var = [Variable(d).cuda() for d in list(sample)[1:]]
score = model(*sample_var)
sm_score = torch.nn.functional.softmax(score)
l2_score = torch.nn.functional.normalize(score)
bs = score.size(0)
conf_buff[start:start+bs] += score.data.cpu().numpy()
sm_conf_buff[start:start+bs] += sm_score.data.cpu().numpy()
l2_conf_buff[start:start+bs] += l2_score.data.cpu().numpy()
_, ans_ids = torch.max(score.data, dim=1)
for i, ans_id in enumerate(ans_ids):
ans = itoa[ans_id]
ans_score = acc + vote_buff[start + i].get(ans, 0)
vote_buff[start + i][ans] = ans_score
start += bs
args = parser.parse_args()
return args
if __name__ == '__main__':
args = parse_args()
print('Called with args:')
pprint.pprint(args)
# set the global cfg variable from the file
if args.cfg_file is not None:
for cfg_file in args.cfg_file:
cfg_from_file(cfg_file)
if args.batch_size is not None:
cfg_from_list(['BATCH_SIZE', args.batch_size])
if args.no_prefetch:
cfg_from_list(['USE_PREFETCH', False])
print('Using config:')
pprint.pprint(cfg)
if not args.randomize:
# fix the random seeds (numpy and caffe) for reproducibility
np.random.seed(cfg.RNG_SEED)
caffe.set_random_seed(cfg.RNG_SEED)
# set up caffe
caffe.set_mode_gpu()
if args.gpu_id is not None:
caffe.set_device(args.gpu_id)
def main():
global args
args = parser.parse_args()
args_str = json.dumps(vars(args), indent=2)
if args.cfg_file is not None:
cfg_from_file(args.cfg_file)
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
# use timestamp as log subdirectory
timestamp = datetime.datetime.now().strftime('%Y%m%d%H%M%S')
cfg.LOG_DIR = os.path.join(cfg.LOG_DIR, timestamp)
os.mkdir(cfg.LOG_DIR)
json.dump(cfg, open(cfg.LOG_DIR + '/config.json', 'w'), indent=2)
model_group_name, model_name = args.model.split('/')
shutil.copy('models/' + model_group_name + '.py', cfg.LOG_DIR)
# init ploter
ploter = Ploter(timestamp)
# setting log handlers
fh = logging.FileHandler(os.path.join(cfg.LOG_DIR, 'log'))
fh.setLevel(logging.DEBUG)
fhc = logging.FileHandler('current.log')
fhc.setLevel(logging.DEBUG)
sh = logging.StreamHandler(sys.stdout)
sh.setLevel(logging.DEBUG)
fmt = '[%(asctime)-15s] %(message)s'
datefmt = '%Y-%m-%d %H:%M:%S'
formatter = logging.Formatter(fmt, datefmt)
fh.setFormatter(formatter)
fhc.setFormatter(formatter)
logger.addHandler(fh)
logger.addHandler(fhc)
logger.addHandler(sh)
logger.debug('[Info] called with: ' + args_str)
logger.debug('[Info] timestamp: ' + timestamp)
logger.debug('[Info] CPU random seed: {}'.format(torch.initial_seed()))
logger.debug('[Info] GPU random seed: {}'.format(
torch.cuda.initial_seed()))
# select device
torch.cuda.set_device(args.gpu_id)
logger.debug('[Info] use gpu: {}'.format(torch.cuda.current_device()))
# data
logger.debug('[Info] init dataset')
do_test = (len(cfg.TEST.SPLITS) == 1
and cfg.TEST.SPLITS[0] in ('train2014', 'val2014'))
trn_set = VQADataset('train', model_group_name)
train_loader = torch.utils.data.DataLoader(trn_set,
batch_size=args.bs,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
if do_test:
val_set = VQADataset('test', model_group_name)
val_loader = torch.utils.data.DataLoader(val_set,
batch_size=args.bs,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
# model
emb_size = 300
if cfg.WORD_EMBEDDINGS:
word_vec = merge_embeddings(cfg.WORD_EMBEDDINGS)
aword = next(iter(word_vec))
emb_size = len(word_vec[aword])
logger.debug('[Info] embedding size: {}'.format(emb_size))
logger.debug('[Info] construct model, criterion and optimizer')
model_group = import_module('models.' + model_group_name)
model = getattr(model_group, model_name)(num_words=trn_set.num_words,
num_ans=trn_set.num_ans,
emb_size=emb_size)
logger.debug('[Info] model name: ' + args.model)
total_param = 0
for param in model.parameters():
total_param += param.nelement()
logger.debug('[Info] total parameters: {}M'.format(
math.ceil(total_param / 2**20)))
# initialize word embedding with pretrained
if cfg.WORD_EMBEDDINGS:
emb = model.we.weight.data.numpy()
words = trn_set.codebook['itow']
assert '<PAD>' not in word_vec
fill_cnt = 0
for i, w in enumerate(words):
if w in word_vec:
emb[i] = word_vec[w]
fill_cnt += 1
logger.debug('[debug] word embedding filling count: {}/{}'.format(
fill_cnt, len(words)))
model.we.weight = nn.Parameter(torch.from_numpy(emb))
if model_group_name in ('onehot_label', 'prob_label'):
# initialize object embedding with pretrained
obj_emb = model.obj_net[0].weight.data.numpy()
if model_group_name == 'prob_label':
obj_emb = obj_emb.T
fill_cnt = 0
for i, line in enumerate(trn_set.objects_vocab):
avail, vec = get_class_embedding(line, word_vec, emb_size)
if avail:
obj_emb[i] = vec
fill_cnt += 1
logger.debug('[debug] class embedding filling count: {}/{}'.format(
fill_cnt, len(trn_set.objects_vocab)))
if model_group_name == 'prob_label':
obj_emb = obj_emb.T
model.obj_net[0].weight = nn.Parameter(torch.from_numpy(obj_emb))
model.cuda()
if cfg.SOFT_LOSS:
criterion = nn.BCEWithLogitsLoss().cuda()
else:
criterion = nn.CrossEntropyLoss().cuda()
logger.debug('[Info] criterion name: ' + criterion.__class__.__name__)
optimizer = torch.optim.Adam(model.parameters(),
args.lr,
weight_decay=args.wd)
cudnn.benchmark = True
# train
logger.debug('[Info] start training...')
is_best = False
best_acc = 0
best_epoch = -1
for epoch in range(args.start_epoch, args.epochs):
lr = adjust_learning_rate(optimizer, epoch)
ploter.append(epoch, lr, 'lr')
loss = train(train_loader, model, criterion, optimizer, epoch)
ploter.append(epoch, loss, 'train-loss')
if do_test:
acc = validate(val_loader, model, criterion, epoch)
ploter.append(epoch, acc, 'val-acc')
if acc > best_acc:
is_best = True
best_acc = acc
best_epoch = epoch
logger.debug('Evaluate Result:\t'
'Acc {0}\t'
'Best {1} ({2})'.format(acc, best_acc, best_epoch))
# save checkpoint
cp_fname = 'checkpoint-{:03}.pth.tar'.format(epoch)
cp_path = os.path.join(cfg.LOG_DIR, cp_fname)
state = {
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'best_acc': best_acc,
'optimizer': optimizer.state_dict()
}
if epoch % args.save_freq == 0:
torch.save(state, cp_path)
if is_best:
best_path = os.path.join(cfg.LOG_DIR, 'model-best.pth.tar')
torch.save(state, best_path)
def main():
args = parse_args()
#print('Called with args:')
#print(args)
# Set main gpu
theano.sandbox.cuda.use(args.gpu_id)
if args.cfg_files is not None:
for cfg_file in args.cfg_files:
cfg_from_file(cfg_file)
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
if not args.randomize:
np.random.seed(cfg.CONST.RNG_SEED)
if args.batch_size is not None:
cfg_from_list(['CONST.BATCH_SIZE', args.batch_size])
if args.iter is not None:
cfg_from_list(['TRAIN.NUM_ITERATION', args.iter])
if args.net_name is not None:
cfg_from_list(['NET_NAME', args.net_name])
if args.model_name is not None:
cfg_from_list(['CONST.NETWORK_CLASS', args.model_name])
if args.dataset is not None:
cfg_from_list(['DATASET', args.dataset])
if args.exp is not None:
cfg_from_list(['TEST.EXP_NAME', args.exp])
if args.out_path is not None:
cfg_from_list(['DIR.OUT_PATH', args.out_path])
if args.weights is not None:
cfg_from_list(['CONST.WEIGHTS', args.weights, 'TRAIN.RESUME_TRAIN', True,
'TRAIN.INITIAL_ITERATION', int(args.init_iter)])
print('Using config:')
pprint.pprint(cfg)
if not args.test:
train()
