def testDefaultConfigFileParser_Basic(self): p = configargparse.DefaultConfigFileParser() self.assertTrue(len(p.get_syntax_description()) > 0) # test the simplest case input_config_str = StringIO("""a: 3\n""") parsed_obj = p.parse(input_config_str) output_config_str = p.serialize(parsed_obj) self.assertEqual(input_config_str.getvalue().replace(": ", " = "), output_config_str) self.assertDictEqual(parsed_obj, dict([('a', '3')]))
def load_env(env_file: str = '.env', sh_exp: bool = True): """ load .env file, and set as environment variables :param env_file: env filename (default ".env") :param sh_exp: apply sh expansion (default True) """ env_conf = configargparse.DefaultConfigFileParser() if sh_exp: sh_result = subprocess.run(["bash", "-x", env_file], stdout=subprocess.PIPE, stderr=subprocess.PIPE, encoding='ascii') env_str = sh_result.stderr.replace("+ ", "") sio = io.StringIO("\n".join(shlex.split(env_str))) envs = env_conf.parse(sio) else: with open(env_file) as conf_file: envs = env_conf.parse(conf_file) envs.update(os.environ) # don't overwrite original environment os.environ.update(envs)
def testDefaultConfigFileParser_All(self): p = configargparse.DefaultConfigFileParser() # test the all syntax case config_lines = [ "# comment1 ", "[ some section ]", "----", "---------", "_a: 3", "; comment2 ", "_b = c", "_list_arg1 = [a, b, c]", "_str_arg = true", "_list_arg2 = [1, 2, 3]", ] # test parse input_config_str = StringIO("\n".join(config_lines) + "\n") parsed_obj = p.parse(input_config_str) # test serialize output_config_str = p.serialize(parsed_obj) self.assertEqual( "\n".join( l.replace(': ', ' = ') for l in config_lines if l.startswith('_')) + "\n", output_config_str) self.assertDictEqual( parsed_obj, dict([ ('_a', '3'), ('_b', 'c'), ('_list_arg1', ['a', 'b', 'c']), ('_str_arg', 'true'), ('_list_arg2', ['1', '2', '3']), ])) self.assertListEqual(parsed_obj['_list_arg1'], ['a', 'b', 'c']) self.assertListEqual(parsed_obj['_list_arg2'], ['1', '2', '3'])
def render_model(): # get model paths path, epoch = opt.render_model epoch = int(epoch) assert (os.path.isdir(path)) assert (os.path.isfile(path + '/config.ini')) p = configargparse.DefaultConfigFileParser() with open(path + '/config.ini') as f: args = p.parse(f) opt.hidden_layers = int(args['hidden_layers']) opt.hidden_features = int(args['hidden_features']) opt.use_piecewise_model = args['use_piecewise_model'] == 'true' opt.use_grad = args['use_grad'] == 'true' opt.activation = args['activation'] opt.normalize_pe = args['normalize_pe'] == 'true' opt.img_size = int(args['img_size']) opt.num_cuts = int(args['num_cuts']) opt.use_sampler = args['use_sampler'] == 'true' opt.dataset = args['dataset'] if opt.dataset == 'deepvoxels': dataset = dataio.DeepVoxelDataset(opt.dv_dataset_path, mode='test', resize_to=2 * (opt.img_size, )) use_ndc = False elif opt.dataset == 'llff': dataset = dataio.LLFFDataset(opt.llff_dataset_path, mode='test', final_render=False) use_ndc = True elif opt.dataset == 'blender': dataset = dataio.NerfBlenderDataset(opt.nerf_dataset_path, splits=['test'], mode='test', select_idx=opt.render_select_idx, resize_to=2 * (opt.img_size, )) use_ndc = False else: raise NotImplementedError('dataset not implemented') if opt.use_sampler: cam_params = dataset.get_camera_params() sampler = modules.SamplingNet(Nt=opt.samples_per_ray, ncuts=opt.num_cuts, sampling_interval=(cam_params['near'], cam_params['far'])) else: sampler = None add_pe_ray_samples = 10 # 10 cos + sin add_pe_orientations = 4 # 4 cos + sin model_sigma = modules.RadianceNet( out_features=1, hidden_layers=opt.hidden_layers, hidden_features=opt.hidden_features, nl=opt.activation, use_grad=opt.use_grad, input_name=['ray_samples', 'ray_orientations'], input_processing_fn=modules.input_processing_fn, input_pe_params={ 'ray_samples': add_pe_ray_samples, 'ray_orientations': add_pe_orientations }, sampler=sampler, normalize_pe=opt.normalize_pe) ckpt_dict = torch.load(path + '/checkpoints/' + f'model_sigma_epoch_{epoch:04d}.pth') state_dict = translate_saved_weights(ckpt_dict, model_sigma) model_sigma.load_state_dict(state_dict, strict=True) model_sigma.eval() model_sigma.cuda() model_rgb = modules.RadianceNet( out_features=3, hidden_layers=opt.hidden_layers, hidden_features=opt.hidden_features, nl=opt.activation, use_grad=opt.use_grad, input_name=['ray_samples', 'ray_orientations'], input_processing_fn=modules.input_processing_fn, input_pe_params={ 'ray_samples': add_pe_ray_samples, 'ray_orientations': add_pe_orientations }, sampler=sampler, normalize_pe=opt.normalize_pe) ckpt_dict = torch.load(path + '/checkpoints/' + f'model_rgb_epoch_{epoch:04d}.pth') state_dict = translate_saved_weights(ckpt_dict, model_rgb) model_rgb.load_state_dict(state_dict, strict=True) model_rgb.eval() model_rgb.cuda() models = {'sigma': model_sigma, 'rgb': model_rgb} # set up dataset coords_dataset = dataio.Implicit6DMultiviewDataWrapper( dataset, dataset.get_img_shape(), dataset.get_camera_params(), samples_per_ray=opt.samples_per_ray, samples_per_view=np.prod(dataset.get_img_shape()[:2]), use_ndc=use_ndc) coords_dataset.toggle_logging_sampling() if opt.render_output is None: output_path = path + '/render' else: output_path = opt.render_output utils.render_views(output_path, models, coords_dataset, use_piecewise_model=opt.use_piecewise_model, num_cuts=opt.num_cuts, use_sampler=opt.use_sampler, integral_render=True, chunk_size=opt.chunk_size_train, video=False) sys.exit()
def read_config_file(file_path): config_file = configargparse.DefaultConfigFileParser() with open(file_path, 'r') as f: args = config_file.parse(f) print(args) return args
args = parser.parse_args() # Display all of values - and where they are coming from print(parser.format_values()) WINDOW_SIZE = args.window_size EMBEDDING_SIZE = args.embedding_size DENSE_SIZE = args.dense_size if args.create_config: options = {} for attr, value in args.__dict__.items(): if attr != "config" and attr != "create_config" and value is not None: options[attr] = value file_name = args.create_config content = configargparse.DefaultConfigFileParser().serialize(options) Path(file_name).write_text(content) print("configuration saved to file: %s" % file_name) sys.exit(0) import tensorflow as tf import tensorflow.keras as K import tensorflow_datasets as tfds # Implement simple SpaceTokenizer - built-in tokenizer in tf filter-out # non alphanumeric tokens # see https://www.tensorflow.org/datasets/api_docs/python/tfds/features/text/TokenTextEncoder class SpaceTokenizer(object): def tokenize(self, s): toks = []