config_loader.py

def config_parser():

    import configargparse
    parser = configargparse.ArgumentParser()
    parser.add_argument('--config',
                        is_config_file=True,
                        default='./configs/train_DTU.txt',
                        help='config file path')
    parser.add_argument("--expname", type=str, help='experiment name')
    parser.add_argument("--basedir",
                        type=str,
                        default='./logs/',
                        help='where to store ckpts and logs')
    parser.add_argument("--datadir",
                        type=str,
                        default='./data/DTU_MVS/',
                        help='input data directory')
    parser.add_argument(
        "--num_workers",
        type=int,
        default=8,
        help='Number of worker processes preparing input data for SRF.'
        'The larger the better, but should not exceed the number of available CPUs.'
    )

    # architecture options
    parser.add_argument("--reduce_features",
                        action='store_true',
                        help='Reduce feature sizes and number of features. No compression by default.')
    parser.add_argument("--no_compression",
                        action='store_true',
                        help='Disable compression')
    parser.add_argument("--intermediate_feature_size",
                        type=int,
                        default=256,
                        help="Intermediate compression size")
    parser.add_argument("--compressed_feature_size",
                        type=int,
                        default=128,
                        help="Final compression size")
    parser.add_argument("--num_attn_heads",
                        type=int,
                        default=8,
                        help="Number of attention heads")
    parser.add_argument("--num_transformer_layers",
                        type=int,
                        default=2,
                        help="Number of transformer layers")
    parser.add_argument("--disable_pos_encoding",
                        action='store_true',
                        help="Disable positional encoding")

    # pretraining and freezing options
    parser.add_argument("--pretrained_path",
                        type=str,
                        default=None,
                        help='path to pretrained model weights')
    parser.add_argument(
        "--cnn_weight_path",
        type=str,
        default=None,
        help=
        'path to pretrained cnn weights. setting this will override pretrained model weights.'
    )
    parser.add_argument("--freeze_cnn",
                        action='store_true',
                        help='whether to freeze cnn weights')

    # training options
    parser.add_argument(
        "--shuffle_combis",
        action='store_true',
        help=
        'Do we want to randomly sample similarity combinations in SRF? True, if set, False else.'
    )
    parser.add_argument("--fine_tune",
                        type=str,
                        default=None,
                        help='scan to fine tune to')
    parser.add_argument("--lrate_decay_off",
                        action='store_true',
                        help='turn off lrate decay')
    parser.add_argument("--split",
                        type=str,
                        default='split.pkl',
                        help='name of split file')
    parser.add_argument("--model",
                        type=str,
                        default='model1',
                        help='the neural model to use')
    parser.add_argument(
        "--fine_model_duplicate",
        action='store_true',
        help=
        'if true use the same model for fine and coarse hierarchical sampling')
    parser.add_argument(
        "--N_rand",
        type=int,
        default=32 * 32 * 4,
        help='batch size (number of random rays per gradient step)')
    parser.add_argument("--lrate",
                        type=float,
                        default=5e-4,
                        help='learning rate')
    parser.add_argument("--lrate_decay",
                        type=int,
                        default=250,
                        help='exponential learning rate decay (in 1000 steps)')
    parser.add_argument("--no_reload",
                        action='store_true',
                        help='do not reload weights from saved ckpt')
    parser.add_argument(
        "--ckpt_path",
        type=str,
        default=None,
        help='Specific NN parameter file (npy) to reload for the network.'
        'Given string is appended to the experiments folder path.')
    parser.add_argument(
        "--ckpt_expname",
        type=str,
        default=None,
        help=
        'Experiment name to load checkpoint and render from. If not given, the experiment from the config file is used.'
    )
    parser.add_argument("--batch_size",
                        type=int,
                        default=1,
                        help='number of training scenes used per batch')
    parser.add_argument("--precrop_iters",
                        type=int,
                        default=0,
                        help='number of steps to train on central crops')
    parser.add_argument("--precrop_frac",
                        type=float,
                        default=.5,
                        help='fraction of img taken for central crops')
    parser.add_argument(
        "--sigmoid",
        action='store_true',
        help=
        'if true, use sigmoid to activate raw predicion with sigmoid, relu else'
    )
    parser.add_argument(
        "--num_reference_views",
        type=int,
        default=10,
        help=
        'number of reference views given to the network as input to predict a novel view'
    )

    # rendering options
    parser.add_argument('--video', dest='video', action='store_true')
    parser.set_defaults(video=False)

    parser.add_argument(
        "--N_rays_test",
        type=int,
        default=128,
        help='number of rays considered par batch in test mode')
    parser.add_argument("--N_samples",
                        type=int,
                        default=64,
                        help='number of coarse samples per ray')
    parser.add_argument("--N_importance",
                        type=int,
                        default=0,
                        help='number of additional fine samples per ray')
    parser.add_argument("--perturb",
                        type=float,
                        default=1.,
                        help='set to 0. for no jitter, 1. for jitter')
    parser.add_argument(
        "--raw_noise_std",
        type=float,
        default=0.,
        help=
        'std dev of noise added to regularize sigma_a output, 1e0 recommended')

    parser.add_argument(
        "--render_factor",
        type=int,
        default=4,
        help='Downsampling factor to speed up test time rendering of images. '
        '1 is full size, set to 4 or 8 for faster preview.')

    parser.add_argument(
        "--vis_render_factor",
        type=int,
        default=16,
        help=
        'Downsampling factor to speed up training visualization rendering of images. '
        '1 is full size, set to 16 and above to avoid memory problems.')

    # dataset options
    parser.add_argument("--dataset_type",
                        type=str,
                        default='DTU',
                        help='options: DTU')

    parser.add_argument("--near",
                        type=int,
                        default=None,
                        help='near clipping plane location')
    parser.add_argument("--far",
                        type=int,
                        default=None,
                        help='far clipping plane location')

    ## generation options
    parser.add_argument(
        "--eval",
        action='store_true',
        help='turn on eval mode - render images from eval poses')
    parser.add_argument(
        "--generate_specific_samples",
        nargs='+',
        type=str,
        default=None,
        help=
        'Visualize specific samples during generation and for visualizing training progress.'
    )
    parser.add_argument(
        "--gen_pose",
        nargs='+',
        type=int,
        default=None,
        help=
        'List index of pose to generate. Where the list of poses is provided by the dataset '
        'specific class and represents a camera path.')
    parser.add_argument(
        "--fixed_batch",
        type=int,
        default=0,
        help=
        'A fixed batch of input reference images is loaded. Inputs are divided into batches'
        'of size num_reference_views keeping their ordering in the split file.'
    )

    parser.add_argument(
        "--white_bkgd",
        action='store_true',
        help=
        'set to render synthetic data on a white bkgd (always use for dvoxels)'
    )
    parser.add_argument(
        "--half_res",
        action='store_true',
        help='load blender synthetic data at 400x400 instead of 800x800')
    parser.add_argument(
        "--no_ndc",
        action='store_true',
        help=
        'use normalized device coordinates (set for non-forward facing scenes)'
    )
    # this is set false in all cases in the paper
    parser.add_argument(
        "--lindisp",
        action='store_true',
        help='sampling linearly in disparity rather than depth')

    # logging/saving options
    parser.add_argument("--i_print",
                        type=int,
                        default=100,
                        help='frequency of console printout and metric loggin')
    parser.add_argument(
        "--i_val_fine_tune",
        type=int,
        default=200,
        help='frequency of val loss computation in fine tuning mode')
    parser.add_argument("--i_saveckpt",
                        type=int,
                        default=1000,
                        help='frequency of weight ckpt saving')
    parser.add_argument("--i_no_val",
                        action='store_true',
                        help='turn off validation computation')
    parser.add_argument("--i_testset",
                        type=int,
                        default=1000,
                        help='frequency of testset saving')
    parser.add_argument("--i_validation_loss",
                        type=int,
                        default=500,
                        help='frequency of val loss computation')

    # gpu options
    from torch.cuda import device_count
    parser.add_argument("--n_gpus",
                        type=int,
                        default=device_count(),
                        help='number of gpus to use')
    parser.add_argument(
        "--no_parallel",
        action='store_true',
        help='do not use GPU parallelization, overrides n_gpus')

    return parser


def get_config():

    parser = config_parser()
    cfg = parser.parse_args()
    if cfg.gen_pose is None:
        cfg.gen_pose = [0]
    return cfg