def argParser(): """ This function creates a parser object which parses all the flags from the command line We can access the parsed command line values using the args object returned by this function Usage: First field is the flag name. dest=NAME is the name to reference when using the parameter (args.NAME) default is the default value of the parameter Example: > python run.py --batch-size 100 args.batch_size <-- 100 """ # parser = argparse.ArgumentParser() parser = HyperOptArgumentParser(strategy='random_search') # trainer arguments parser.add_argument("--gpu", dest="gpu", default='0', help="GPU number") parser.add_argument("--mode", dest="mode", default='train', help="Mode is one of 'train', 'test'") parser.add_argument("--encode", dest="encode", default=0, type=int, help="encode is 0 or 1, default 0") parser.add_argument("--ntrials", dest="ntrials", default=20, type=int, help="Number of trials to run for hyperparameter tuning") # model-specific arguments # (non-tunable) parser.add_argument("--model", dest="model", default="baseline_lstm", help="Name of model to use") parser.add_argument("--epochs", dest="epochs", type=int, default=10, help="Number of epochs to train for") parser.add_argument("--patience", dest="patience", type=int, default=10, help="Learning rate decay scheduler patience, number of epochs") # (tunable arguments) parser.opt_list("--batch-size", dest="batch_size", type=int, default=100, help="Size of the minibatch", tunable=False, options=[32, 64, 128, 256]) parser.opt_range("--learning-rate", dest="learning_rate", type=float, default=1e-3, help="Learning rate for training", tunable=True, low=1e-3, high=1e-1, nb_samples=4) parser.opt_list("--hidden-size", dest="hidden_size", type=int, default=100, help="Dimension of hidden layers", tunable=False, options=[32, 64, 128, 256]) parser.opt_list('--optimizer', dest="optimizer", type=str, default='SGD', help='Optimizer to use (default: SGD)', tunable=False, options=['SGD', 'Adam']) parser.opt_range('--weight-decay', dest="weight_decay", type=float, default=1e-5, help='Weight decay for L2 regularization.', tunable=True, low=1e-6, high=1e-1, nb_samples=10) parser.opt_list('--frame-freq', dest="frame_freq", type=int, default=5, help='Frequency for sub-sampling frames from a video', tunable=True, options=[10, 30, 60, 75, 100]) # (tcn-only arguments) parser.opt_list('--dropout', dest="dropout", type=float, default=0.05, help='Dropout applied to layers (default: 0.05)', tunable=True, options=[0.05, 0.1, 0.3, 0.5, 0.7]) parser.opt_list('--levels', dest="levels", type=int, default=8, help='# of levels for TCN (default: 8)', tunable=True, options=[6, 8, 10, 12]) # LSTM only arguments parser.opt_list('--num_layers', dest="num_layers", type=int, default=1, help='# of layers in LSTM (default:1', tunable=True, options=[1, 2, 3, 4, 5]) # program arguments (dataset and logger paths) parser.add_argument("--raw_data_path", dest="raw_data_path", default="/mnt/disks/disk1/raw", help="Path to raw dataset") parser.add_argument('--proc_data_path', dest="proc_data_path", default="/mnt/disks/disk1/processed", help="Path to processed dataset") parser.add_argument("--log", dest="log", default='', help="Unique log directory name under log/. If the name is empty, do not store logs") parser.add_argument("--checkpoint", dest="checkpoint", type=str, default="", help="Path to the .pth checkpoint file. Used to continue training from checkpoint") # create argparser args = parser.parse_args() return args
def get_args(): parser = HyperOptArgumentParser() parser.add_argument('--work_dir', metavar='DIR', default="./work_dir", type=str, help='path to save output') parser.add_argument('--proj_name', type=str) parser.add_argument('--name', type=str) parser.add_argument('--gpus', type=str, default='7', help='how many gpus') parser.add_argument('--dist_bd', type=str, default='dp', choices=('dp', 'ddp', 'ddp2'), help='supports three options dp, ddp, ddp2') parser.add_argument('--use_16bit', dest='use_16bit', action='store_true', help='if true uses 16 bit precision') parser.add_argument('--eval', '--evaluate', dest='evaluate', action='store_true', help='evaluate model on validation set') parser.add_argument('--seed', default=1, type=int) parser.add_argument('--load_mem', action='store_true') parser.add_argument('--track_grad_norm', action='store_true') parser = CGCNModel.add_model_specific_args(parser) return parser.parse_args()
def get_args(): parser = argparse.ArgumentParser() parser.add_argument('-s', '--sweep', action='store_true', help='Run a hyperparameter sweep over all options') # DataModule args parser = MNISTDataModule.add_argparse_args(parser) # Trainer args (https://pytorch-lightning.readthedocs.io/en/latest/common/trainer.html#trainer-flags) parser = Trainer.add_argparse_args(parser) # Set some sane defaults for x in parser._actions: if x.dest == 'gpus': x.default = 1 if x.dest == 'max_epochs': x.default = 100 # TestTube args - hyperparam parser & slurm info parser = HyperOptArgumentParser(strategy='grid_search', add_help=False, parents=[parser]) parser.add_argument('--test_tube_exp_name', default='sweep_test') parser.add_argument('--log_path', default='./pytorch-slurm') # LightningModule args (hyperparameters) parser = MNISTClassifier.add_model_specific_args(parser) args = parser.parse_args() return args
def parse_args(): def path(str): return os.path.abspath((os.path.expanduser(str))) parser = HyperOptArgumentParser() parser.add_argument("--dataset", type=str, default="trec_web.1-200.asrc") parser.add_argument("--asrc-path", type=path, default=None) parser.add_argument("--log-path", type=path, default="robustness_log") parser.add_argument("--test", action='store_true') parser.add_argument("--fp16", action='store_true') parser.add_argument("--gpu-num", type=int, default=1) parser.add_argument("--model", type=str, choices=["bert", "mp", "conv_knrm", "all"], default="all") parser.add_argument("--exp", type=str, default="weight_decay", choices=["dropout", "weight_decay"]) parser.add_argument("--saved-preprocessor", type=path, default="preprocessor") parser.opt_list("--weight-decay", type=float, tunable=True, options=[ 0.0001, 0.001, 0.01, 0.02, 0.04, 0.06, 0.08, 0.1, 0.12, 0.14, 0.16, 0.18, 0.20 ]) args = parser.parse_args() return args
def main(): parser = HyperOptArgumentParser( description='Train a PyTorch Lightning model on Yest dataset', strategy='random_search' ) parser.opt_list('--nb_layers', default=2, type=int, tunable=False, options=[2, 4, 8]) parser.opt_range('--layer_size', default=20, type=int, tunable=False, low=10, high=200, nb_samples=10, help="size of the hidden layer") parser.add_argument('--model', default="model.ptl", help="path to save the model") parser.add_argument('--train', default="yeast_train.svm", help="path to the training data") parser.add_argument('--val', default="yeast_test.svm", help="path to the training data") hparams = parser.parse_args() hparams.optimize_parallel_cpu(train_main, nb_trials=20, nb_workers=8)
def test_preprocessing_noise(self): dataset = MaestroDataset('/Volumes/Elements/Datasets/maestro-v2.0.0', item_length=176400, sampling_rate=44100, mode='validation', max_file_count=20, shuffle_with_seed=123) parser = HyperOptArgumentParser(strategy='random_search', add_help=False) #parser = ArgumentParser() parser = ContrastivePredictiveSystem.add_model_specific_args( parser, root_dir='../') hparams = parser.parse_args() preprocessing = PreprocessingModule(hparams) pass
def load_yaml_args(parser: HyperOptArgumentParser, log): """ Function that load the args defined in a YAML file and replaces the values parsed by the HyperOptArgumentParser """ old_args = vars(parser.parse_args()) configs = old_args.get("config") if configs: yaml_file = yaml.load(open(configs).read(), Loader=yaml.FullLoader) for key, value in yaml_file.items(): if key in old_args: old_args[key] = value else: raise Exception( "{} argument defined in {} is not valid!".format( key, configs)) else: log.warning("We recommend the usage of YAML files to keep track \ of the hyperparameter during testing and training.") return TTNamespace(**old_args)
def get_all_params(search_type='grid_search', args=None): # Raise error if user has other command line arguments specified (as could override configs in # confusing ways) if args is not None and len(args) != 8: raise ValueError( 'No command line arguments allowed other than config file names') elif args is None and len(sys.argv[1:]) != 8: raise ValueError( 'No command line arguments allowed other than config file names') # Create parser parser = HyperOptArgumentParser(strategy=search_type) parser.add_argument('--data_config', type=str) parser.add_argument('--model_config', type=str) parser.add_argument('--training_config', type=str) parser.add_argument('--compute_config', type=str) namespace, extra = parser.parse_known_args(args) # Add arguments from all configs configs = [ namespace.data_config, namespace.model_config, namespace.training_config, namespace.compute_config ] for config in configs: config_json = commentjson.load(open(config, 'r')) for (key, value) in config_json.items(): add_to_parser(parser, key, value) # Add save/user dirs parser.add_argument('--save_dir', default=get_user_dir('save'), type=str) parser.add_argument('--data_dir', default=get_user_dir('data'), type=str) # Add parameters dependent on previous inputs namespace, extra = parser.parse_known_args(args) add_dependent_params(parser, namespace) return parser.parse_args(args)
def get_all_params(): # raise error if user has other command line arguments specified if len(sys.argv[1:]) != 6: raise ValueError( 'No command line arguments allowed other than config file names') def add_to_parser(parser, arg_name, value): if arg_name == 'expt_ids' or arg_name == 'expt_ids_to_keep': # treat expt_ids differently, want to parse full lists as one if isinstance(value, list): value = ';'.join(value) parser.add_argument('--' + arg_name, default=value) elif isinstance(value, list): parser.opt_list('--' + arg_name, options=value, tunable=True) else: parser.add_argument('--' + arg_name, default=value) # create parser parser = HyperOptArgumentParser(strategy='grid_search') parser.add_argument('--data_config', type=str) parser.add_argument('--model_config', type=str) parser.add_argument('--train_config', type=str) namespace, extra = parser.parse_known_args() # add arguments from all configs configs = [ namespace.data_config, namespace.model_config, namespace.train_config ] for config in configs: config_dict = yaml.safe_load(open(config)) for (key, value) in config_dict.items(): add_to_parser(parser, key, value) return parser.parse_args()
# define tensorflow graph x = tf.placeholder(dtype=tf.int32, name='x') y = tf.placeholder(dtype=tf.int32, name='y') out = x * y sess = tf.Session() # Run the tf op for train_step in range(0, 100): output = sess.run(out, feed_dict={x: hparams.x_val, y: hparams.y_val}) exp.log({'fake_err': output}) # save exp when we're done exp.save() # set up our argparser and make the y_val tunable parser = HyperOptArgumentParser(strategy='random_search') parser.add_argument('--test_tube_exp_name', default='my_test') parser.add_argument('--log_path', default='/Users/waf/Desktop/test') parser.opt_list('--y_val', default=12, options=[1, 2, 3, 4], tunable=True) parser.opt_list('--x_val', default=12, options=[20, 12, 30, 45], tunable=True) hyperparams = parser.parse_args() # optimize on 4 gpus at the same time # each gpu will get 1 experiment with a set of hyperparams hyperparams.optimize_parallel_gpu(train, gpu_ids=['1', '0', '3', '2'], nb_trials=4, nb_workers=4)
# module purge # module load icc/2018.1.163-GCC-6.4.0-2.28 # module load OpenMPI/2.1.2 # module load goolfc/2017b # module load TensorFlow/1.7.0-Python-3.6.3 # MPIRUNFILE=/share/apps/software/Compiler/intel/2018.1.163-GCC-6.4.0-2.28/OpenMPI/2.1.2/bin/mpirun if __name__ == '__main__': # Set up our argparser and make the y_val tunable. hyper_parser = HyperOptArgumentParser(strategy='random_search') hyper_parser.add_argument('--test_tube_exp_name', default='my_test') hyper_parser.add_argument('--log_path', default='.') hyper_parser.add_argument('--seed', default=42, type=int) hyper_parser = esnnparms(hyper_parser) hyperparams = hyper_parser.parse_args() print(hyperparams) # Enable cluster training. cluster = SlurmCluster( hyperparam_optimizer=hyperparams, log_path=hyperparams.log_path, python_cmd='python3', enable_log_err=True, enable_log_out=True #test_tube_exp_name=hyperparams.test_tube_exp_name ) # Email results if your hpc supports it. cluster.notify_job_status( email='*****@*****.**', on_done=False, on_fail=True)
def get_args(command=None): # parser = argparse.ArgumentParser() parser = HyperOptArgumentParser(strategy="random_search", add_help=False) # Analysis args # parser.add_argument("--bert_model", default='bert-base-uncased', type=str, help="bert model name") parser.add_argument( "--bert_model", default="distilbert-base-uncased", type=str, help="bert model name", ) parser.add_argument( "--emb_file", default="~/checkpoint/bert_vectors/", type=str, help="location of embedding file", ) parser.add_argument( "--data_loc", default="~/checkpoint/dialog_metric/convai2_data/", type=str, help="location of data dump", ) parser.add_argument("--data_name", default="convai2", type=str, help="convai2/cornell_movie") parser.add_argument("--tok_file", default="na", type=str, help="tokens and word dict file") parser.add_argument("--pca_file", default="na", type=str, help="pca saved weights file") parser.opt_list( "--learn_down", default=False, action="store_true", options=[True, False], tunable=False, ) parser.opt_list( "--fix_down", default=False, action="store_true", options=[True, False], tunable=False, ) parser.add_argument( "--trained_bert_suffix", default="ep_10_lm", type=str, help="folder to look for trained bert", ) parser.add_argument("--tc", default=False, action="store_true") parser.opt_list( "--downsample", default=True, action="store_true", options=[True, False], tunable=False, ) parser.opt_list("--down_dim", type=int, default=300, options=[100, 300, 400], tunable=False) parser.add_argument("--load_fine_tuned", default=True, action="store_true") # parser.add_argument("--fine_tune_model", default="~/checkpoint/dialog_metric/cleaned/bert_lm",type=str) parser.add_argument( "--fine_tune_model", default="~/checkpoint/dialog_metric/cleaned/distilbert_lm", type=str, ) # Experiment ID parser.add_argument("--id", default="ruber_bs", type=str) # Model training args parser.add_argument("--device", default="cuda", type=str, help="cuda/cpu") parser.add_argument( "--model", default="models.TransitionPredictorMaxPoolLearnedDownsample", type=str, help="full model name path", ) parser.opt_list( "--optim", default="adam,lr=0.0001", type=str, help="optimizer", options=["adam,lr=0.001", "adam,lr=0.01", "adam,lr=0.0001"], tunable=False, ) parser.add_argument("--epochs", default=10, type=int, help="number of epochs") parser.add_argument("--margin", default=0.5, type=float, help="margin") parser.add_argument( "--train_mode", default="ref_score", type=str, help="ref_score/cont_score/all/nce", ) parser.add_argument("--num_nce", type=int, default=5, help="number of nce samples per scheme") parser.add_argument( "--model_save_dir", default="~/checkpoint/dialog_metric/", type=str, help="model save dir", ) parser.add_argument( "--model_load_path", default="~/checkpoint/dialog_metric/", type=str, help="if there is a need of different load path", ) parser.add_argument("--batch_size", default=64, type=int, help="batch size") parser.add_argument( "--load_model", default=False, action="store_true", help="load model from previous checkpoint", ) parser.add_argument( "--logger_dir", default="./", type=str, help="log directory (must be created)", ) parser.add_argument("--log_interval", default=100, type=int, help="log interval") parser.add_argument("--watch_model", default=False, action="store_true", help="wandb watch model") parser.add_argument( "--vector_mode", default=True, action="store_true", help="if false, train with word representations", ) parser.add_argument( "--remote_logging", default=False, action="store_true", help="wandb remote loggin on or off", ) parser.add_argument("--wandb_project", default="dialog-metric", type=str) parser.add_argument("--bidirectional", default=False, action="store_true") parser.add_argument("--dataloader_threads", default=8, type=int) parser.add_argument("--exp_data_folder", default="na", help="exp data folder") parser.add_argument("--num_workers", default=4, type=int, help="dataloader num workers") parser.opt_list( "--clip", default=0.5, type=float, help="gradient clipping", options=[0.0, 0.5, 1.0], tunable=False, ) parser.opt_list( "--dropout", default=0.2, type=float, help="gradient clipping", options=[0.0, 0.2], tunable=False, ) parser.opt_list( "--decoder_hidden", default=200, type=int, help="decoder hidden values", options=[100, 200, 500, 700], tunable=False, ) parser.add_argument("--gpus", type=str, default="-1", help="how many gpus to use in the node") parser.add_argument("--debug", default=False, action="store_true", help="if true, set debug modes") ## Evaluation args parser.add_argument( "--corrupt_type", default="rand_utt", type=str, help= "all/word_drop/word_order/word_repeat/rand_utt/model_false/rand_back/only_semantics/only_syntax/context_corrupt", ) parser.add_argument( "--corrupt_context_type", default="rand", type=str, help="rand/drop/shuffle/model_true/model_false/progress/none", ) parser.add_argument("--drop_per", default=0.50, type=float, help="drop percentage") parser.add_argument("--eval_val", default=False, action="store_true", help="only eval val set") parser.add_argument( "--model_response_pre", default="na", type=str, help="model response file prefix", ) parser.add_argument( "--load_model_responses", default=True, action="store_true", help="load model responses", ) parser.add_argument( "--corrupt_model_names", default="seq2seq", type=str, help="comma separated models", ) parser.add_argument( "--restore_version", default=-1, type=int, help="if > -1, restore training from the given version", ) # Baseline args parser.add_argument("--train_baseline", default="na", help="ruber/bilstm", type=str) ## RUBER parser.add_argument( "--word2vec_context_size", default=3, type=int, help="context size for word2vec training", ) parser.add_argument("--word2vec_embedding_dim", default=300, type=int, help="embedding dim") parser.add_argument("--word2vec_epochs", default=100, type=int, help="word2vec training epochs") parser.add_argument( "--word2vec_out", default="~/checkpoint/dialog_metric/ruber/w2v.pt", type=str, help="word2vec output location", ) parser.add_argument("--word2vec_lr", default=0.001, type=float, help="word2vec lr") parser.add_argument("--word2vec_batchsize", default=512, type=int) parser.add_argument("--ruber_ref_pooling_type", default="max_min", type=str, help="max_min/avg") parser.add_argument("--ruber_unref_pooling_type", default="max", type=str, help="max/mean") parser.add_argument("--ruber_load_emb", action="store_true", help="load trained word2vec") parser.add_argument("--ruber_lstm_dim", default=300, type=int, help="dimensions of ruber encoder") parser.add_argument("--ruber_mlp_dim", default=200, type=int, help="dimensions of ruber encoder") parser.add_argument("--ruber_dropout", default=0.1, type=float, help="ruber dropout") parser.add_argument("--num_words", default=-1, type=int) ## Data collection args parser.add_argument("--agent", type=str, default="kvmemnn", help="repeat/ir/seq2seq") parser.add_argument("--mode", type=str, default="train", help="train/test/valid") parser.add_argument( "--models", type=str, default="seq2seq,repeat", help="comma separated model values", ) parser.add_argument("--response_file", type=str, default="~/Projects/online_dialog_eval/elisa_data/") parser.add_argument( "--mf", type=str, default= "/checkpoint/parlai/zoo/convai2/seq2seq_naacl2019_abibaseline/model", help="only for special cases", ) parser.add_argument( "--only_data", action="store_true", default=False, help="only extract and store dialog data", ) ## SLURM args parser.add_argument( "--slurm_log_path", type=str, default="~/checkpoint/dialog_metrics/ckpt/", help="slurm log path", ) parser.add_argument("--per_experiment_nb_gpus", type=int, default=1, help="number of gpus") parser.add_argument("--per_experiment_nb_cpus", type=int, default=16, help="number of cpus") parser.add_argument("--nb_gpu_nodes", type=int, default=1, help="number of gpu nodes") parser.add_argument("--job_time", type=str, default="23:59:00", help="time") parser.add_argument("--gpu_type", type=str, default="volta", help="gpu type") parser.add_argument("--gpu_partition", type=str, default="learnfair", help="gpu type") parser.add_argument( "--nb_hopt_trials", type=int, default=1, help="how many grid search trials to run", ) parser.add_argument("--train_per_check", type=float, default=1.0) parser.add_argument("--val_per_check", type=float, default=1.0) parser.add_argument("--test_per_check", type=float, default=1.0) parser.add_argument( "--use_cluster", action="store_true", default=False, help="activate cluster mode", ) ## Inference args parser.add_argument("--model_name", type=str, default="na", help="model name") parser.add_argument("--model_version", type=str, default="version_0", help="model version") parser.add_argument("--use_ddp", action="store_true", default=False) parser.add_argument("--human_eval", action="store_true", default=False) parser.add_argument( "--human_eval_file", type=str, default="~/checkpoint/dialog_metric/controllable_dialogs.csv", ) parser.add_argument("--results_file", type=str, default="test_results.jsonl") ## Corruption args parser.add_argument( "--corrupt_pre", type=str, default="~/checkpoint/dialog_metric/convai2_data/convai2_test_", ) parser.add_argument("--corrupt_ne", type=int, default=1) parser.add_argument("--test_suffix", type=str, default="true_response") parser.add_argument("--test_column", type=str, default="true_response") if command: return parser.parse_args(command.split(" ")) else: return parser.parse_args()
def hparams(self): parser = HyperOptArgumentParser() parser = AdamW.add_optim_specific_args(parser) return parser.parse_args()
def hparams(self): parser = HyperOptArgumentParser() parser = WarmupConstant.add_scheduler_specific_args(parser) return parser.parse_args()
# Batching parser.add_argument("--batch_size", default=6, type=int, help="Batch size to be used.") parser.add_argument( "--accumulate_grad_batches", default=2, type=int, help=("Accumulated gradients runs K small batches of size N before " "doing a backwards pass."), ) parser.add_argument("--num_nodes", type=int, default=1) # gpu args parser.add_argument("--gpus", type=int, default=0, help="How many gpus") parser.add_argument( "--val_percent_check", default=1.0, type=float, help= ("If you don't want to use the entire dev set (for debugging or " "if it's huge), set how much of the dev set you want to use with this flag." ), ) parser = BERTClassifier.add_model_specific_args(parser) hparams = parser.parse_args() main(hparams)
# In paper, ant was dropped into 9 envs, but its S,A were same. No transfer # learning yet. exp = Experiment("meta learning shared hierarchies", save_dir="logs") parser = HyperOptArgumentParser(strategy="random_search") parser.opt_list( "--batch_size", default=128, type=int, tunable=True, options=[2**n for n in range(5, 10)], ) args = parser.parse_args() args.max_steps = 1000 args.subpolicy_duration = 200 args.num_policies = 10 args.max_buffer_size = 1_000_000 args.env_names = ["Ant-v2"] exp.argparse(args) State = Any Action = Any Timestep = int class MasterPolicy(nn.Module):
def test_add_dependent_params(tmpdir): # ----------------- # ae # ----------------- # arch params correctly added to parser parser = HyperOptArgumentParser(strategy='grid_search') utils.add_to_parser(parser, 'model_class', 'ae') utils.add_to_parser(parser, 'model_type', 'conv') utils.add_to_parser(parser, 'n_ae_latents', 32) utils.add_to_parser(parser, 'n_input_channels', 2) utils.add_to_parser(parser, 'y_pixels', 32) utils.add_to_parser(parser, 'x_pixels', 32) utils.add_to_parser(parser, 'ae_arch_json', None) utils.add_to_parser(parser, 'approx_batch_size', 200) utils.add_to_parser(parser, 'mem_limit_gb', 10) namespace, _ = parser.parse_known_args([]) utils.add_dependent_params(parser, namespace) assert '--architecture_params' in parser.opt_args # linear autoencoder parser = HyperOptArgumentParser(strategy='grid_search') utils.add_to_parser(parser, 'model_class', 'ae') utils.add_to_parser(parser, 'model_type', 'linear') utils.add_to_parser(parser, 'n_ae_latents', 32) utils.add_to_parser(parser, 'n_input_channels', 2) utils.add_to_parser(parser, 'y_pixels', 32) utils.add_to_parser(parser, 'x_pixels', 32) utils.add_to_parser(parser, 'ae_arch_json', None) utils.add_to_parser(parser, 'approx_batch_size', 200) utils.add_to_parser(parser, 'mem_limit_gb', 10) namespace, _ = parser.parse_known_args([]) utils.add_dependent_params(parser, namespace) print(parser) assert namespace.model_type == 'linear' assert namespace.n_latents == '32' # raise exception when max latents exceeded # parser = HyperOptArgumentParser(strategy='grid_search') # utils.add_to_parser(parser, 'model_class', 'ae') # utils.add_to_parser(parser, 'n_ae_latents', 100000) # utils.add_to_parser(parser, 'n_input_channels', 2) # utils.add_to_parser(parser, 'y_pixels', 32) # utils.add_to_parser(parser, 'x_pixels', 32) # utils.add_to_parser(parser, 'ae_arch_json', None) # utils.add_to_parser(parser, 'approx_batch_size', 200) # utils.add_to_parser(parser, 'mem_limit_gb', 10) # namespace, _ = parser.parse_known_args([]) # with pytest.raises(ValueError): # utils.add_dependent_params(parser, namespace) # ----------------- # vae # ----------------- # arch params correctly added to parser parser = HyperOptArgumentParser(strategy='grid_search') utils.add_to_parser(parser, 'model_class', 'vae') utils.add_to_parser(parser, 'model_type', 'conv') utils.add_to_parser(parser, 'n_ae_latents', 32) utils.add_to_parser(parser, 'n_input_channels', 2) utils.add_to_parser(parser, 'y_pixels', 32) utils.add_to_parser(parser, 'x_pixels', 32) utils.add_to_parser(parser, 'ae_arch_json', None) utils.add_to_parser(parser, 'approx_batch_size', 200) utils.add_to_parser(parser, 'mem_limit_gb', 10) namespace, _ = parser.parse_known_args([]) utils.add_dependent_params(parser, namespace) assert '--architecture_params' in parser.opt_args # ----------------- # neural # ----------------- # make tmp hdf5 file path = tmpdir.join('data.hdf5') idx_data = { 'i0': np.array([0, 1, 2]), 'i1': np.array([3, 4, 5]), 'i2': np.array([6, 7, 8]) } with h5py.File(path, 'w') as f: group0 = f.create_group('regions') # groupa = f.create_group('neural') group1 = group0.create_group('indxs') group1.create_dataset('i0', data=idx_data['i0']) group1.create_dataset('i1', data=idx_data['i1']) group1.create_dataset('i2', data=idx_data['i2']) # subsample idxs not added to parser when not requested parser = HyperOptArgumentParser(strategy='grid_search') utils.add_to_parser(parser, 'model_class', 'neural-ae') utils.add_to_parser(parser, 'subsample_method', 'none') namespace, _ = parser.parse_known_args([]) utils.add_dependent_params(parser, namespace) assert '--subsample_idxs_name' not in parser.opt_args # subsample idxs added to parser when requested (all datasets) parser = HyperOptArgumentParser(strategy='grid_search') utils.add_to_parser(parser, 'data_dir', tmpdir) utils.add_to_parser(parser, 'lab', '') utils.add_to_parser(parser, 'expt', '') utils.add_to_parser(parser, 'animal', '') utils.add_to_parser(parser, 'session', '') utils.add_to_parser(parser, 'model_class', 'neural-ae') utils.add_to_parser(parser, 'subsample_method', 'single') utils.add_to_parser(parser, 'subsample_idxs_dataset', 'all') namespace, _ = parser.parse_known_args([]) utils.add_dependent_params(parser, namespace) assert '--subsample_idxs_name' in parser.opt_args parser_vals = parser.opt_args['--subsample_idxs_name'].opt_values.keys() assert sorted(['i0', 'i1', 'i2']) == sorted(parser_vals) # subsample idxs added to parser when requested (single dataset) parser = HyperOptArgumentParser(strategy='grid_search') utils.add_to_parser(parser, 'data_dir', tmpdir) utils.add_to_parser(parser, 'lab', '') utils.add_to_parser(parser, 'expt', '') utils.add_to_parser(parser, 'animal', '') utils.add_to_parser(parser, 'session', '') utils.add_to_parser(parser, 'model_class', 'neural-ae') utils.add_to_parser(parser, 'subsample_method', 'single') utils.add_to_parser(parser, 'subsample_idxs_dataset', 'i0') namespace, _ = parser.parse_known_args([]) utils.add_dependent_params(parser, namespace) parser.parse_args([]) assert parser.parsed_args['subsample_idxs_name'] == 'i0' # raise exception when dataset is not a string parser = HyperOptArgumentParser(strategy='grid_search') utils.add_to_parser(parser, 'model_class', 'neural-ae') utils.add_to_parser(parser, 'subsample_method', 'single') utils.add_to_parser(parser, 'subsample_idxs_dataset', ['i0', 'i1']) namespace, _ = parser.parse_known_args([]) with pytest.raises(ValueError): utils.add_dependent_params(parser, namespace)