def main():
parser = argparse.ArgumentParser()
parser.add_argument('dataset',
help='dataset ('
'shapenet'
', '
'primitives'
')')
parser.add_argument('embeddings_path',
help='path to text embeddings pickle file')
parser.add_argument('--metric',
help='path to text embeddings pickle file',
default='minkowski',
type=str)
parser.add_argument('--cfg',
dest='cfg_files',
action='append',
help='optional config file',
default=None,
type=str)
args = parser.parse_args()
# modify default config if requested
if args.cfg_files is not None:
for cfg_file in args.cfg_files:
cfg_from_file(cfg_file)
cfg_from_list(['CONST.DATASET', args.dataset])
with open(args.embeddings_path, 'rb') as f:
embeddings_dict = pickle.load(f)
if os.path.basename(args.embeddings_path) == 'text_embeddings.p':
subdir = 'text'
elif ((os.path.basename(args.embeddings_path) == 'shape_embeddings.p')
or (os.path.basename(args.embeddings_path)
== 'modified_shape_embeddings.p')):
subdir = 'shape'
else:
subdir = 'unspecified'
render_dir = os.path.join(os.path.dirname(args.embeddings_path),
'nearest_neighbor_renderings', subdir)
np.random.seed(1234)
compute_metrics(args.dataset,
embeddings_dict,
metric=args.metric,
concise=render_dir)
test_loader = DataLoader(test_set,
batch_size=args.batch_size,
shuffle=False,
pin_memory=True,
num_workers=args.workers,
collate_fn=test_set.collate_batch)
return test_loader
if __name__ == "__main__":
# merge config and log to file
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)
cfg.TAG = os.path.splitext(os.path.basename(args.cfg_file))[0]
if args.eval_mode == 'rpn':
cfg.RPN.ENABLED = True
cfg.RCNN.ENABLED = False
root_result_dir = os.path.join('../', 'output', 'rpn', cfg.TAG)
ckpt_dir = os.path.join('../', 'output', 'rpn', cfg.TAG, 'ckpt')
elif args.eval_mode == 'rcnn':
cfg.RCNN.ENABLED = True
cfg.RPN.ENABLED = cfg.RPN.FIXED = True
root_result_dir = os.path.join('../', 'output', 'rcnn', cfg.TAG)
ckpt_dir = os.path.join('../', 'output', 'rcnn', cfg.TAG, 'ckpt')
elif args.eval_mode == 'rcnn_offline':
cfg.RCNN.ENABLED = True
cfg.RPN.ENABLED = False
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_net()
else:
test_net()
ax.set_zlim(0, 32) # c = 16
plt.tight_layout()
plt.savefig('gen.png')
faces = faces.copy()
verts = (verts.copy() - 16) / 16
# fit_mesh({'pos_idx': faces, 'vtx_pos': verts, 'col_idx': faces, 'vtx_col': torch.ones(verts.shape)}, paths, display_interval=50)
fit_mesh_col(
{
'pos_idx': faces,
'vtx_pos': verts,
'col_idx': faces,
'vtx_col': torch.ones(verts.shape)
},
paths,
display_interval=None)
if __name__ == '__main__':
# Set the batch size to 1
# run: python estimate_shape.py
# change the path to images and pretrained weights
cfg_from_list(['CONST.BATCH_SIZE', 1])
# weight: https://drive.google.com/open?id=1LtNhuUQdAeAyIUiuCavofBpjw26Ag6DP
DEFAULT_WEIGHTS = 'checkpoint.pth'
#paths = ['images/bottle1.jpg', 'images/bottle2.jpg', 'images/bottle3.jpg', 'images/bottle4.jpg']
path = 'images/bottle'
main(path)
def main():
### set divice
if not args.cuda:
cfg.TRAIN.DEVICE = torch.device('cpu')
else :
assert torch.cuda.is_available(), "Not enough GPU"
#assert d < torch.cuda.device_count(), "Not enough GPU"
os.environ["CUDA_VISIBLE_DEVICES"] = ",".join([str(ids) for ids in args.device_ids])
torch.backends.cudnn.benchmark=True
cfg.CUDA = True
cfg.TRAIN.DEVICE = torch.device('cuda:0')
print("Let's use", torch.cuda.device_count(), "GPUs!")
### set config
cfg_from_file(args.cfg_file)
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
cfg_from_args(args)
print_cfg(cfg)
# assert_and_infer_cfg()
if not cfg.TRAIN.NO_SAVE:
run_folder = create_folder_for_run(cfg.TRAIN.RUNS_FOLDER)
logging.basicConfig(level=logging.INFO,
format='%(message)s',
handlers=[
logging.FileHandler(os.path.join(run_folder, f'{cfg.TRAIN.NAME}.log')),
logging.StreamHandler(sys.stdout)
])
with open(os.path.join(run_folder, 'config_and_args.pkl'), 'wb') as f:
blob = {'cfg': yaml.dump(cfg), 'args': args}
pickle.dump(blob, f, pickle.HIGHEST_PROTOCOL)
with open(os.path.join(run_folder, 'args.txt'), 'w') as f:
for item in vars(args):
f.write(item+":"+str(getattr(args,item))+'\n')
logging.info('×' * 40)
shutil.copy(args.cfg_file, os.path.join(run_folder, cfg.TRAIN.NAME) + '_cfg')
logging.info('save config and args in runs folder:\n %s' % run_folder)
# if args.use_tfboard:
# tblogger = SummaryWriter(run_folder)
else:
logging.basicConfig(level=logging.INFO)
# logger = logging.getLogger(__name__)
# print('args:')
# logging.info(pprint.pformat(vars(args)))
# print('cfg:')
# logging.info(yaml.dump(cfg.TRAIN))
loader = Random_DataLoader()
model = get_Model()
model = nn.DataParallel(model)
model.to(cfg.TRAIN.DEVICE)
logging.info(model)
Trainer(loader, model)
def modify_args(args):
"""Modify the default config based on the command line arguments.
"""
# modify default config if requested
if args.cfg_files is not None:
for cfg_file in args.cfg_files:
cfg_from_file(cfg_file)
randomize = args.randomize
if args.test: # Always randomize in test phase
randomize = True
if not randomize:
np.random.seed(cfg.CONST.RNG_SEED)
# NOTE: Unfortunately order matters here
if args.lba_only is True:
cfg_from_list(['LBA.COSINE_DIST', False])
if args.metric_learning_only is True:
cfg_from_list(['LBA.NO_LBA', True])
if args.non_inverted_loss is True:
cfg_from_list(['LBA.INVERTED_LOSS', False])
if args.dataset is not None:
cfg_from_list(['CONST.DATASET', args.dataset])
if args.lba_mode is not None:
cfg_from_list(['LBA.MODEL_TYPE', args.lba_mode])
if args.lba_test_mode is not None:
cfg_from_list(['LBA.TEST_MODE', args.lba_test_mode])
# cfg_from_list(['LBA.N_CAPTIONS_PER_MODEL', 1]) # NOTE: Important!
if args.shapenet_ct_classifier is True:
cfg_from_list(
['CONST.SHAPENET_CT_CLASSIFIER', args.shapenet_ct_classifier])
if args.visit_weight is not None:
cfg_from_list(['LBA.VISIT_WEIGHT', args.visit_weight])
if args.lba_unnormalize is True:
cfg_from_list(['LBA.NORMALIZE', False])
if args.improved_wgan is True:
cfg_from_list(['CONST.IMPROVED_WGAN', args.improved_wgan])
if args.synth_embedding is True:
cfg_from_list(['CONST.SYNTH_EMBEDDING', args.synth_embedding])
if args.all_tuples is True:
cfg_from_list(['CONST.TEST_ALL_TUPLES', args.all_tuples])
if args.reed_classifier is True:
cfg_from_list(['CONST.REED_CLASSIFIER', args.reed_classifier])
if args.noise_dist is not None:
cfg_from_list(['GAN.NOISE_DIST', args.noise_dist])
if args.uniform_max is not None:
cfg_from_list(['GAN.NOISE_UNIF_ABS_MAX', args.uniform_max])
if args.num_critic_steps is not None:
cfg_from_list(['WGAN.NUM_CRITIC_STEPS', args.num_critic_steps])
if args.intense_training_freq is not None:
cfg_from_list(
['WGAN.INTENSE_TRAINING_FREQ', args.intense_training_freq])
if args.match_loss_coeff is not None:
cfg_from_list(['WGAN.MATCH_LOSS_COEFF', args.match_loss_coeff])
if args.fake_match_loss_coeff is not None:
cfg_from_list(
['WGAN.FAKE_MATCH_LOSS_COEFF', args.fake_match_loss_coeff])
if args.fake_mismatch_loss_coeff is not None:
cfg_from_list(
['WGAN.FAKE_MISMATCH_LOSS_COEFF', args.fake_mismatch_loss_coeff])
if args.gp_weight is not None:
cfg_from_list(['WGAN.GP_COEFF', args.gp_weight])
if args.text2text_weight is not None:
cfg_from_list(['WGAN.TEXT2TEXT_WEIGHT', args.text2text_weight])
if args.shape2shape_weight is not None:
cfg_from_list(['WGAN.SHAPE2SHAPE_WEIGHT', args.shape2shape_weight])
if args.learning_rate is not None:
cfg_from_list(['TRAIN.LEARNING_RATE', args.learning_rate])
if args.critic_lr_multiplier is not None:
cfg_from_list(
['GAN.D_LEARNING_RATE_MULTIPLIER', args.critic_lr_multiplier])
if args.decay_steps is not None:
cfg_from_list(['TRAIN.DECAY_STEPS', args.decay_steps])
if args.queue_capacity is not None:
cfg_from_list(['CONST.QUEUE_CAPACITY', args.queue_capacity])
if args.n_minibatch_test is not None:
cfg_from_list(['CONST.N_MINIBATCH_TEST', args.n_minibatch_test])
if args.noise_size is not None:
cfg_from_list(['GAN.NOISE_SIZE', args.noise_size])
if args.batch_size is not None:
cfg_from_list(['CONST.BATCH_SIZE', args.batch_size])
if args.summary_freq is not None:
cfg_from_list(['TRAIN.SUMMARY_FREQ', args.summary_freq])
if args.num_epochs is not None:
cfg_from_list(['TRAIN.NUM_EPOCHS', args.num_epochs])
if args.model is not None:
cfg_from_list(['NETWORK', args.model])
if args.optimizer is not None:
cfg_from_list(['TRAIN.OPTIMIZER', args.optimizer])
if args.critic_optimizer is not None:
cfg_from_list(['GAN.D_OPTIMIZER', args.critic_optimizer])
if args.ckpt_path is not None:
cfg_from_list(['DIR.CKPT_PATH', args.ckpt_path])
if args.lba_ckpt_path is not None:
cfg_from_list(['END2END.LBA_CKPT_PATH', args.lba_ckpt_path])
if args.val_ckpt_path is not None:
cfg_from_list(['DIR.VAL_CKPT_PATH', args.val_ckpt_path])
if args.log_path is not None:
cfg_from_list(['DIR.LOG_PATH', args.log_path])
if args.augment_max is not None:
cfg_from_list(['TRAIN.AUGMENT_MAX', args.augment_max])
if args.test:
cfg_from_list(['TRAIN.AUGMENT_MAX', 0])
cfg_from_list(['CONST.BATCH_SIZE', 1])
cfg_from_list(['LBA.N_CAPTIONS_PER_MODEL', 1]) # NOTE: Important!
cfg_from_list(['LBA.N_PRIMITIVE_SHAPES_PER_CATEGORY',
1]) # NOTE: Important!
if args.test_npy:
cfg_from_list(['CONST.BATCH_SIZE', 1])
# To overwrite default variables, put the set_cfgs after all argument initializations
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
def main():
args = parse_args()
cfg.DATA_DIR = args.data_dir
cfg.CONTEXT_FUSION = args.context_fusion
# c_time = time.strftime('%m%d_%H%M', time.localtime())
# if not os.path.exists(cfg.LOG_DIR):
# os.makedirs(cfg.LOG_DIR)
# file_handler = logging.FileHandler(pjoin(cfg.LOG_DIR,
# args.network_name + '_%s.txt' % c_time))
# logging.getLogger().addHandler(file_handler)
print('------ called with args: -------')
pprint.pprint(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)
if cfg.INIT_BY_GLOVE and cfg.KEEP_AS_GLOVE_DIM:
cfg.EMBED_DIM = cfg.GLOVE_DIM
else:
cfg.EMBED_DIM = args.embed_dim
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)
tf.set_random_seed(cfg.RNG_SEED)
imdb, roidb = GetRoidb(args.imdb_name)
output_dir = get_output_dir(imdb, args.tag)
print("output will be saved to `{:s}`".format(output_dir))
# tensorboard directory where the summaries are saved during training
tb_dir = get_output_tb_dir(imdb, args.tag)
print('TensorFlow summaries will be saved to `{:s}`'.format(tb_dir))
# also add validation set, but with no flipping image
orgflip = cfg.TRAIN.USE_FLIPPED
cfg.TRAIN.USE_FLIPPED = False
_, valroidb = GetRoidb(args.imdbval_name)
cfg.TRAIN.USE_FLIPPED = orgflip
# load network
if args.net == 'vgg16':
net = vgg16()
elif args.net == 'res50':
net = resnetv1(num_layers=50)
elif args.net == 'res101':
net = resnetv1(num_layers=101)
elif args.net == 'res152':
net = resnetv1(num_layers=152)
else:
raise NotImplementedError
if args.weights and not args.weights.endswith('.ckpt'):
try:
ckpt = tf.train.get_checkpoint_state(args.weights)
pretrained_model = ckpt.model_checkpoint_path
except:
raise ValueError("NO checkpoint found in {}".format(args.weights))
else:
pretrained_model = args.weights
# TODO: "imdb" may not be useful during training
train_net(net, imdb, roidb, valroidb, output_dir, tb_dir,
pretrained_model=pretrained_model,
max_iters=args.max_iters)
def main():
args = parse_args()
# c_time = time.strftime('%m%d_%H%M', time.localtime())
# if not os.path.exists(cfg.LOG_DIR):
# os.makedirs(cfg.LOG_DIR)
# file_handler = logging.FileHandler(pjoin(cfg.LOG_DIR,
# args.network_name + '_%s.txt' % c_time))
# logging.getLogger().addHandler(file_handler)
print('------ called with args: -------')
pprint.pprint(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("runing with LIMIT_RAM: {}".format(cfg.LIMIT_RAM))
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)
tf.set_random_seed(cfg.RNG_SEED)
if not cfg.LIMIT_RAM:
imdb, roidb = combined_roidb(args.imdb_name)
else:
imdb, roidb = get_roidb_limit_ram(args.imdb_name)
output_dir = get_output_dir(imdb, args.tag)
print("output will be saved to `{:s}`".format(output_dir))
# tensorboard directory where the summaries are saved during training
tb_dir = get_output_tb_dir(imdb, args.tag)
print('TensorFlow summaries will be saved to `{:s}`'.format(tb_dir))
# also add validation set, but with no flipping image
orgflip = cfg.TRAIN.USE_FLIPPED
cfg.TRAIN.USE_FLIPPED = False
if not cfg.LIMIT_RAM:
_, valroidb = combined_roidb(args.imdbval_name)
else:
_, valroidb = get_roidb_limit_ram(args.imdbval_name)
cfg.TRAIN.USE_FLIPPED = orgflip
# load network
if args.net == 'vgg16':
net = vgg16()
elif args.net == 'res50':
net = resnetv1(num_layers=50)
elif args.net == 'res101':
net = resnetv1(num_layers=101)
elif args.net == 'res152':
net = resnetv1(num_layers=152)
else:
raise NotImplementedError
# TODO: "imdb" may not be useful during training
train_net(net, imdb, roidb, valroidb, output_dir, tb_dir,
pretrained_model=args.pretrained_model,
max_iters=args.max_iters)