def add_model_specific_args(parent_parser): p = HyperOptArgumentParser(parents=parent_parser, add_help=False, conflict_handler='resolve') p.add_argument('--dense_encoder', default=False, type=bool) p.add_argument('--code_size', default=512, type=int) p.add_argument('--out_channels', default=3, type=int) p.add_argument('--rec_decoder_convl', default=3, type=int) p.add_argument('--comp_decoder_convl', default=3, type=int) p.add_argument('--context_decoder_convl', default=3, type=int) if not parent_parser: # Name clash with parent p.add_argument('--in_channels', default=3, type=int) return p
def add_model_specific_args(parent_parser, root_dir): # pragma: no cover """ Parameters you define here will be available to your model through self.hparams :param parent_parser: :param root_dir: :return: """ parser = HyperOptArgumentParser( strategy=parent_parser.strategy, parents=[parent_parser] ) parser.add_argument("--beta", default=1, type=float) parser.add_argument("--bottleneck_size", default=10, type=int) parser.add_argument("--group_distance_scaling", default=1, type=float) parser.add_argument("--audio_size", default=80, type=int) parser.add_argument("--data_dim", default=140, type=int) parser.add_argument("--data_files", default="datafiles.json", type=str) parser.add_argument("--data_dir", default="/data_dir", type=str) parser.opt_list( "--batch_size", default=256 * 4, type=int, options=[32, 64, 128, 256], tunable=False, help="batch size will be divided over all gpus being used across all nodes", ) parser.opt_list( "--learning_rate", default=0.001 * 8, type=float, options=[0.0001, 0.0005, 0.001], tunable=True, ) return parser
default=10, options=[20, 30, 40, 50], type=int, tunable=True) parser.add_opt_argument_list('--embedding_dim', default=320, options=[100, 200, 320, 400], type=int, tunable=True) parser.add_opt_argument_list('--max_seq_len', default=50, options=[50, 70, 90, 110], type=int, tunable=True) parser.add_argument('--nb_epochs', default=5, type=int) parser.add_argument('--optimizer_name', default='adam') parser.add_argument('--eval_every_n_batches', default=200, type=int) parser.add_argument('--train_mode', default='train') parser.add_argument('--nb_grams', default=2, type=int) parser.add_argument('--root_dir', default='/home/ankur/smart-reply') parser.add_argument( '--dataset_train_path', default='/home/ankur/smart-reply/dataset/data/data/train.csv') parser.add_argument( '--dataset_test_path', default='/home/ankur/smart-reply/dataset/data/data/test.csv') parser.add_argument( '--dataset_val_path',
] checkpoint_path = experiment_folder + "/checkpoints/" + checkpoints[-1] model = BERTClassifier.load_from_metrics(weights_path=checkpoint_path, tags_csv=tags_csv_file) # Make sure model is in prediction mode model.eval() model.freeze() return model if __name__ == "__main__": parser = HyperOptArgumentParser(description="Minimalist BERT Classifier", add_help=True) parser.add_argument( "--experiment", required=True, type=str, help="Path to the experiment folder.", ) hparams = parser.parse_args() print("Loading model...") model = load_model_from_experiment(hparams.experiment) print(model) while 1: print( "Please write a movie review or quit to exit the interactive shell:" ) # Get input sentence input_sentence = input("> ") if input_sentence == "q" or input_sentence == "quit": break
if __name__ == '__main__': # dirs root_dir = os.path.dirname(os.path.realpath(__file__)) demo_log_dir = os.path.join(root_dir, 'pt_lightning_demo_logs') checkpoint_dir = os.path.join(demo_log_dir, 'model_weights') test_tube_dir = os.path.join(demo_log_dir, 'test_tube_data') # although we user hyperOptParser, we are using it only as argparse right now parent_parser = HyperOptArgumentParser(strategy='grid_search', add_help=False) # gpu args parent_parser.add_argument('--gpus', type=str, default='-1', help='how many gpus to use in the node.' ' value -1 uses all the gpus on the node') parent_parser.add_argument('--test_tube_save_path', type=str, default=test_tube_dir, help='where to save logs') parent_parser.add_argument('--model_save_path', type=str, default=checkpoint_dir, help='where to save model') parent_parser.add_argument('--experiment_name', type=str, default='pt_lightning_exp_a', help='test tube exp name')
def add_model_specific_args(parent_parser): parser = HyperOptArgumentParser(parents=[parent_parser]) parser.add_argument('--num_freq_mask', default=2, type=int) parser.add_argument('--num_time_mask', default=2, type=int) parser.add_argument('--freq_mask_length', default=20, type=int) parser.add_argument('--time_mask_length', default=20, type=int) parser.add_argument('--feature_dim', default=480, type=int) parser.add_argument('--model_size', default=512, type=int) parser.add_argument('--feed_forward_size', default=2048, type=int) parser.add_argument('--hidden_size', default=64, type=int) parser.add_argument('--dropout', default=0.1, type=float) parser.add_argument('--num_head', default=8, type=int) parser.add_argument('--num_encoder_layer', default=12, type=int) parser.add_argument('--num_decoder_layer', default=6, type=int) parser.add_argument('--vocab_path', default='testing_vocab.model', type=str) parser.add_argument('--max_feature_length', default=1024, type=int) parser.add_argument('--max_token_length', default=70, type=int) parser.add_argument('--share_weight', default=True, type=bool) parser.add_argument('--loss_lambda', default=0.65, type=float) parser.add_argument('--smoothing', default=0.1, type=float) parser.add_argument('--use_low_rank', default=False, type=bool) parser.add_argument('--lr', default=5e-5, type=float) parser.add_argument('--warm_up_step', default=16000, type=int) parser.add_argument('--factor', default=1, type=int) parser.add_argument('--enable_spec_augment', default=True, type=bool) parser.add_argument('--train_batch_size', default=64, type=int) parser.add_argument('--train_loader_num_workers', default=32, type=int) parser.add_argument('--val_batch_size', default=64, type=int) parser.add_argument('--val_loader_num_workers', default=16, type=int) return parser
# 5 START TRAINING # ------------------------ trainer.fit(model) if __name__ == "__main__": # ------------------------ # TRAINING ARGUMENTS # ------------------------ # these are project-wide arguments parser = HyperOptArgumentParser( strategy="random_search", description="Minimalist BERT Classifier", add_help=True, ) parser.add_argument("--seed", type=int, default=3, help="Training seed.") parser.add_argument( "--save_top_k", default=1, type=int, help= "The best k models according to the quantity monitored will be saved.", ) # Early Stopping parser.add_argument("--monitor", default="val_acc", type=str, help="Quantity to monitor.") parser.add_argument( "--metric_mode", default="max",
weight_decay_rate=hparams.wd) print(hparams, flush=True) # start trainer auc = train(vars(hparams), num_workers, node_id, fold, kfold, debug, path) print(auc) # save Experiment exp.add_scalar('auc', auc) exp.save() if __name__ == '__main__': # Set up our argparser and make the y_val tunable. parser = HyperOptArgumentParser(strategy='random_search') parser.add_argument('--test_tube_exp_name', default='tt_exp') parser.add_argument('--batch_size', default=80, type=int) parser.add_argument('--epochs', default=3, type=int) parser.add_argument('--gpus', default=2, type=int) parser.add_argument('--log_path', default=os.environ['SCRATCH'] + '/summer_school/hs_log') parser.opt_range('--lr', default=2e-4, type=float, tunable=True, low=1e-4, high=1e-3, nb_samples=100, log_base=10) parser.opt_range('--wd', default=1e-5, type=float, tunable=True, low=1e-7, high=1e-4, nb_samples=100, log_base=10) hyperparams = parser.parse_args() # Enable cluster training. cluster = SlurmCluster( hyperparam_optimizer=hyperparams, log_path=hyperparams.log_path, python_cmd='python3', )
tunable=False, low=0., high=.5, help='dropout fraction', default=0.) parser.opt_list('--batch_norm', action='store_true', dest='batch_norm', tunable=False, options=[True, False], help='batch normalization', default=False) parser.add_argument('--num_accumulate', action='store', dest='num_accumulate', type=int, help='nunumber of batch accumulations', default=1) parser.add_argument('--name', action='store', dest='name', type=str, help='experiment name', default=1) parser.add_argument('--version', action='store', dest='version', type=int, help='version number', default=None) parser.add_argument('--gpu',
def cnn_encoder_decoder_argparser(): # TODO: set min max size for vocab # TODO: specify optimizer # TODO: set max length of sentences # parser = argparse.ArgumentParser(description='Run Tests') parser = HyperOptArgumentParser(description='Run Tests', strategy='grid_search') parser.add_argument('--name', help="experiment name", default="rnn_encoder_decoder") parser.add_argument('--test', help="Run test instead of training/validation", action="store_true") parser.add_argument("--njobs", help="Number of jobs to use when loading data", type=int, default=1) parser.add_argument("--epoch", help="Number of epoch to run", type=int, default=10000) parser.add_argument("--batch_size", help="Batch size", type=int, default=32) parser.add_argument("--hidden_size", help="Hidden size", type=int, default=256) parser.add_argument("--embedding_size", help="Embedding size", type=int, default=256) parser.add_argument("--print_every", help="How frequently print result", type=int, default=100) parser.add_argument("--lr", help="Learning Rate", type=float, default=1e-03) parser.add_argument("--dropout", help="Dropout Rate", type=float, default=0) parser.add_argument( '--bidirectional', help="Use bidirectional RNN in encoder", action="store_true") # don't set this true in this model parser.add_argument('--cpu', help="Use cpu instead of gpu", action="store_true") parser.add_argument("--data", help="Directory where data is stored", default='../data/iwslt-zh-en/') parser.add_argument("--rnn_type", help="Which rnn to use (rnn, lstm, gru)", default='gru') parser.add_argument("--kernel_size", help="Kernel size of cnn layers in encoder", type=int, default=3) parser.add_argument("--num_encoder_layers", help="Number of cnn layers in encoder", type=int, default=1) parser.add_argument("--num_decoder_layers", help="Number of rnn layers in encoder", type=int, default=1) parser.add_argument("--early_stopping", help="Stop if validation does not improve", type=int, default=10) parser.add_argument('--l2_penalty', help="L2 pelnalty coefficient in optimizer", type=float, default=0) #1e-06 parser.add_argument('--clip', help="clip coefficient in optimizer", type=float, default=1) parser.add_argument('--teacher_forcing', help="probability of performing teacher forcing", type=float, default=0.5) parser.add_argument("--max_sentence_length", help="maximum sentence length", type=int, default=50) parser.add_argument('--split_chinese_into_characters', help="Split chinese into characters", action="store_true") parser.add_argument( "--min_freq", help="Vocabulary needs to be present at least this amount of time", type=int, default=3) parser.add_argument("--max_vocab_size", help="At most n vocaburaries are kept in the model", type=int, default=100000) parser.add_argument("--source_lang", help="Source language (vi, zh)", default="zh") parser.add_argument("--logs_path", help="Path to save training logs", type=str, default="../training_logs/") parser.add_argument("--model_weights_path", help="Path to save best model weights", type=str, default="../model_weights/") parser.add_argument('--save_all_epoch', help="save all epoch", action="store_true") parser.add_argument('--relu', help="use relu in decoder after embedding", action="store_true") parser.add_argument('--attention', help="use luong attention decoder", action="store_true") parser.add_argument("--attn_model", help="dot, general, or concat", default='general') parser.add_argument("--preprocess_version", help="Version of preprocessing", type=int, default=2) parser.add_argument( '--freeze_all_words', help="freeze word embedding and use character embedding from ELMo", action="store_true") parser.add_argument("--encoder_word_embedding", help="Word embedding weights file", default=None) parser.add_argument("--decoder_word_embedding", help="Word embedding weights file", default=None) return parser
def add_model_specific_args(parent_parser): from test_tube import HyperOptArgumentParser parser = HyperOptArgumentParser(parents=[parent_parser], add_help=False) parser.add_argument('--base_encoder', type=str, default='resnet18') parser.add_argument('--emb_dim', type=int, default=128) parser.add_argument('--num_workers', type=int, default=8) parser.add_argument('--num_negatives', type=int, default=65536) parser.add_argument('--encoder_momentum', type=float, default=0.999) parser.add_argument('--softmax_temperature', type=float, default=0.07) parser.add_argument('--optimizer', type=str, default='SGD') parser.add_argument('--optimizer-parameters', type=json.loads, default=json.dumps({ "lr": 0.03, "momentum": 0.9, "weight_decay": 1.0e-4 })) # parser.add_argument('--learning_rate', type=float, default=0.03) # parser.add_argument('--momentum', type=float, default=0.9) # parser.add_argument('--weight_decay', type=float, default=1e-4) parser.add_argument('--data_dir', type=str, default='./') parser.add_argument('--dataset', type=str, default='cifar10', help='cifar10, stl10, imagenet2012') parser.add_argument('--batch_size', type=int, default=256) parser.add_argument('--use_mlp', action='store_true') parser.add_argument('--meta_root', default='.', type=str, help='path to meta.bin for imagenet') return parser
def add_model_specific_args(parent_parser, root_dir): parser = HyperOptArgumentParser(strategy=parent_parser.strategy, parents=[parent_parser]) parser.set_defaults(nb_hopt_trials=1000) parser.set_defaults(min_nb_epochs=1000) parser.set_defaults(max_nb_epochs=1100) parser.set_defaults(early_stop_metric='val_nce') parser.set_defaults(model_save_monitor_value='val_nce') parser.set_defaults(model_save_monitor_mode='min') parser.set_defaults(early_stop_mode='min') # CIFAR 10 dataset_name = 'CIFAR10' image_height = 32 nb_classes = 10 patch_size = 8 patch_overlap = 4 # dataset options parser.opt_list('--nb_classes', default=nb_classes, type=int, options=[10], tunable=False) parser.opt_list('--patch_size', default=patch_size, type=int, options=[10], tunable=False) parser.opt_list('--patch_overlap', default=patch_overlap, type=int, options=[10], tunable=False) # network params parser.add_argument('--image_height', type=int, default=image_height) # trainin params parser.add_argument('--dataset_name', type=str, default=dataset_name) parser.add_argument('--batch_size', type=int, default=200, help='input batch size (default: 200)') parser.opt_list( '--learning_rate', type=float, default=0.0002, options=[ 2e-4 * (1 / 64), 2e-4 * (1 / 32), 2e-4 * (1 / 16), 2e-4 * (1 / 8), 2e-4 * (1 / 4), 2e-4 * (1 / 2), 2e-4 * (1 / 4), 2e-4, 2e-4 * 4, #2e-4*4, 2e-4 * 8, ], tunable=False) # data parser.opt_list('--cifar10_root', default=f'{root_dir}/fisherman/datasets', type=str, tunable=False) return parser
def add_model_specific_args(parent_parser, root_dir): # pragma: no cover """ Parameters you define here will be available to your model through self.hparams :param parent_parser: :param root_dir: :return: """ parser = HyperOptArgumentParser(strategy=parent_parser.strategy, parents=[parent_parser]) parser.add_argument('--log_dir', default='logs', type=str) parser.add_argument('--checkpoint_dir', default='checkpoints', type=str) # data parser.add_argument('--training_set_path', default='data/training', type=str) parser.add_argument('--validation_set_path', default='data/validation', type=str) parser.add_argument('--test_task_set_path', default='data/test_task', type=str) parser.add_argument('--unique_steps', default=8., type=float) parser.add_argument('--sampling_rate', default=44100, type=float) parser.add_argument('--dummy_datasets', default=False, type=bool) # preprocessing parser.add_argument('--cqt_fmin', default=30., type=float) parser.add_argument('--cqt_n_bins', default=292, type=int) parser.add_argument('--cqt_bins_per_octave', default=32, type=int) parser.add_argument('--cqt_hop_length', default=256, type=int) parser.add_argument('--cqt_filter_scale', default=0.5, type=float) parser.add_argument('--scalogram_output_power', default=1., type=float) parser.add_argument('--scalogram_pooling', nargs='+', default=(1, 2), type=int) parser.add_argument('--phase', default=True, type=bool) parser.add_argument('--audio_noise', default=0., type=float) # training parser.opt_list('--optimizer_name', default='adam', type=str, options=['adam'], tunable=False) parser.opt_list('--learning_rate', default=0.0001, type=float, options=[0.0001, 0.0005, 0.001], tunable=True) parser.add_argument('--batch_size', default=32, type=int) parser.add_argument('--score_over_all_timesteps', default=True, type=bool) parser.add_argument('--visible_steps', default=60, type=int) parser.add_argument('--prediction_steps', default=16, type=int) parser.add_argument('--wasserstein_penalty', default=0., type=float) parser.add_argument('--detach_targets', default=False, type=bool) parser.add_argument('--file_batch_size', default=1, type=int) parser.add_argument('--use_all_GPUs', default=True, type=bool) parser.add_argument('--warmup_steps', default=0, type=int) parser.add_argument('--annealing_steps', default=1e6, type=int) # encoder parser.add_argument('--enc_channels', nargs='+', default=(1, 32, 32, 64, 64, 128, 128, 256, 512), type=int) parser.add_argument('--enc_kernel_1_w', nargs='+', default=(1, 3, 1, 3, 1, 3, 1, 3), type=int) parser.add_argument('--enc_kernel_1_h', nargs='+', default=(65, 3, 33, 3, 16, 3, 9, 3), type=int) parser.add_argument('--enc_kernel_2_w', nargs='+', default=(3, 3, 3, 3, 3, 3, 3, 3), type=int) parser.add_argument('--enc_kernel_2_h', nargs='+', default=(3, 3, 3, 3, 3, 3, 3, 3), type=int) parser.add_argument('--enc_padding_1', nargs='+', default=(0, 1, 0, 1, 0, 1, 0, 0), type=int) parser.add_argument('--enc_padding_2', nargs='+', default=(1, 1, 1, 1, 1, 1, 1, 0), type=int) parser.add_argument('--enc_pooling_1', nargs='+', default=(1, 1, 1, 1, 1, 1, 1, 1), type=int) parser.add_argument('--enc_pooling_2', nargs='+', default=(1, 1, 1, 1, 1, 1, 1, 1), type=int) parser.add_argument('--enc_stride_1', nargs='+', default=(1, 1, 1, 1, 1, 1, 1, 1), type=int) parser.add_argument('--enc_stride_2', nargs='+', default=(2, 1, 2, 1, 2, 1, 1, 1), type=int) parser.add_argument('--enc_batch_norm', default=True, type=bool) parser.add_argument('--enc_batch_norm_affine', default=False, type=bool) parser.add_argument('--enc_dropout', default=0.2, type=float) parser.add_argument('--enc_residual', default=True, type=bool) parser.add_argument('--enc_bias', default=True, type=bool) # ar model parser.add_argument('--ar_channels', nargs='+', default=(512, 512, 512, 512, 512, 256, 256, 256, 256, 256), type=int) parser.add_argument('--ar_kernel_sizes', nargs='+', default=(5, 4, 1, 3, 3, 1, 3, 1, 5), type=int) parser.add_argument('--ar_pooling', nargs='+', default=(1, 1, 2, 1, 1, 2, 1, 1, 1), type=int) parser.add_argument('--ar_stride', nargs='+', default=(1, 1, 1, 1, 1, 1, 1, 1, 1), type=int) parser.add_argument('--ar_self_attention', nargs='+', default=(False, True, False, False, True, False, True, False, False), type=bool) parser.add_argument('--ar_batch_norm', default=True, type=bool) parser.add_argument('--ar_batch_norm_affine', default=False, type=bool) parser.add_argument('--ar_dropout', default=0.2, type=float) parser.add_argument('--ar_residual', default=True, type=bool) parser.add_argument('--ar_bias', default=True, type=bool) return parser
torch.FloatTensor(content['wordEmbeddings']).to(device) } print('Training div: {} BLength {} {}'.format( train_div, p2r_data['bridge_length'], len(p2r_data['bridge_ids'].tolist()))) return p2r_data if __name__ == '__main__': # use default args given by lightning root_dir = os.path.dirname( os.path.realpath(sys.modules['__main__'].__file__)) parent_parser = HyperOptArgumentParser(strategy='grid_search', add_help=False) parent_parser.add_argument('--root_dir', default=root_dir, type=str) parent_parser.add_argument('--exp_name', default='p2r_experiment', type=str) # allow model to overwrite or extend args parser = P2rSystem.add_model_specific_args(parent_parser, root_dir) hparams = parser.parse_args() p2r_data = loadData(hparams.data_root, hparams.train_div) # train model # for trial_hparams in hparams.trials(2): main(hparams, p2r_data)
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('--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()
parser = HyperOptArgumentParser(usage=usage_str, description=description_str, formatter_class=argparse.ArgumentDefaultsHelpFormatter, strategy='random_search') parser.opt_range('--step', type=float, dest='step', default=.001, help='step size/learning rate', tunable=True, nb_samples=100, low=.0001, high=.001) parser.opt_range('--l2lam_init', action='store', type=float, dest='l2lam_init', default=.001, tunable=False, low=.0001, high=100, help='initial l2 regularization') parser.opt_list('--solver', action='store', dest='solver', type=str, tunable=False, options=['sgd', 'adam'], help='optimizer/solver ("adam", "sgd")', default="adam") parser.opt_range('--cg_max_iter', action='store', dest='cg_max_iter', type=int, tunable=False, low=1, high=20, help='max number of conjgrad iterations', default=10) parser.opt_range('--batch_size', action='store', dest='batch_size', type=int, tunable=False, low=1, high=20, help='batch size', default=2) parser.opt_range('--num_unrolls', action='store', dest='num_unrolls', type=int, tunable=False, low=1, high=10, nb_samples=4, help='number of unrolls', default=4) parser.opt_range('--num_admm', action='store', dest='num_admm', type=int, tunable=False, low=1, high=10, nb_samples=4, help='number of ADMM iterations', default=3) parser.opt_list('--network', action='store', dest='network', type=str, tunable=False, options=['ResNet', 'ResNet5Block'], help='which denoiser network to use', default='ResNet') parser.opt_list('--latent_channels', action='store', dest='latent_channels', type=int, tunable=False, options=[16, 32, 64, 128], help='number of latent channels', default=64) parser.opt_range('--num_blocks', action='store', dest='num_blocks', type=int, tunable=False, low=1, high=4, nb_samples=3, help='number of ResNetBlocks', default=3) parser.opt_range('--dropout', action='store', dest='dropout', type=float, tunable=False, low=0., high=.5, help='dropout fraction', default=0.) parser.opt_list('--batch_norm', action='store_true', dest='batch_norm', tunable=False, options=[True, False], help='batch normalization', default=False) parser.add_argument('--num_accumulate', action='store', dest='num_accumulate', type=int, help='nunumber of batch accumulations', default=1) parser.add_argument('--name', action='store', dest='name', type=str, help='experiment name', default=1) parser.add_argument('--version', action='store', dest='version', type=int, help='version number', default=None) parser.add_argument('--gpu', action='store', dest='gpu', type=str, help='gpu number(s)', default=None) parser.add_argument('--num_epochs', action='store', dest='num_epochs', type=int, help='number of epochs', default=20) parser.add_argument('--random_seed', action='store', dest='random_seed', type=int, help='random number seed for numpy', default=723) parser.add_argument('--recon', action='store', type=str, dest='recon', default='cgsense', help='reconstruction method') parser.add_argument('--data_file', action='store', dest='data_file', type=str, help='data.h5', default=None) parser.add_argument('--data_val_file', action='store', dest='data_val_file', type=str, help='data.h5', default=None) parser.add_argument('--num_data_sets', action='store', dest='num_data_sets', type=int, help='number of data sets to use', default=None) parser.add_argument('--num_workers', action='store', type=int, dest='num_workers', help='number of workers', default=0) parser.add_argument('--shuffle', action='store_true', dest='shuffle', help='shuffle input data files each epoch', default=False) parser.add_argument('--clip_grads', action='store', type=float, dest='clip_grads', help='clip norm of gradient vector to val', default=0) parser.add_argument('--cg_eps', action='store', type=float, dest='cg_eps', help='conjgrad eps', default=1e-4) parser.add_argument('--stdev', action='store', type=float, dest='stdev', help='complex valued noise standard deviation', default=0.) parser.add_argument('--max_norm_constraint', action='store', type=float, dest='max_norm_constraint', help='norm constraint on weights', default=None)
# 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('--path', default='some/path') 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)
if __name__ == '__main__': # use default args root_dir = os.path.dirname(os.path.realpath(__file__)) demo_log_dir = os.path.join(root_dir, 'pt_lightning_demo_logs') checkpoint_dir = os.path.join(demo_log_dir, 'model_weights') test_tube_dir = os.path.join(demo_log_dir, 'test_tube_data') slurm_out_dir = os.path.join(demo_log_dir, 'slurm_scripts') parent_parser = HyperOptArgumentParser(strategy='grid_search', add_help=False) # cluster args not defined inside the model parent_parser.add_argument('--per_experiment_nb_gpus', type=int, default=8, help='how many gpus to use in a node') parent_parser.add_argument('--nb_gpu_nodes', type=int, default=2, help='how many nodes to use in a cluster') parent_parser.add_argument('--test_tube_save_path', type=str, default=test_tube_dir, help='where to save logs') parent_parser.add_argument('--slurm_log_path', type=str, default=slurm_out_dir, help='where to save slurm meta') parent_parser.add_argument('--model_save_path', type=str, default=checkpoint_dir, help='where to save model') parent_parser.add_argument('--distributed_backend', type=str, default='ddp', help='ddp or ddp2') parent_parser.add_argument('--experiment_name', type=str, default='pt_lightning_exp_a', help='test tube exp name') parent_parser.add_argument('--num_hyperparam_trials', type=int, default=6, help='how many grid search trials to run')
def _train(_hparams): model = CNN(_hparams) trainer = Trainer( logger=TestTubeLogger(save_dir=".", name="logs_{}".format(_hparams.name)), gpus=_hparams.gpus, row_log_interval=10, log_save_interval=100, # fast_dev_run=True, # overfit_pct=0.01, early_stop_callback=EarlyStopping(patience=3), ) trainer.fit(model) trainer.test() if __name__ == '__main__': parser = HyperOptArgumentParser(strategy='grid_search', add_help=False) parser.add_argument('--gpus', type=str, default=None) parser.add_argument('--train', action='store_true') parser.add_argument('--name', default='CNN', type=str) parser = CNN.add_model_specific_args(parser) hparams = parser.parse_args() if not torch.cuda.is_available(): hparams.gpus = None if hparams.train: _train(hparams)
def add_model_specific_args( cls, parser: HyperOptArgumentParser) -> HyperOptArgumentParser: """ Parser for Estimator specific arguments/hyperparameters. :param parser: HyperOptArgumentParser obj Returns: - updated parser """ parser.add_argument( "--encoder_model", default="bert-base-uncased", type=str, help="Encoder model to be used.", ) parser.add_argument( "--encoder_learning_rate", default=1e-05, type=float, help="Encoder specific learning rate.", ) parser.add_argument( "--learning_rate", default=3e-05, type=float, help="Classification head learning rate.", ) parser.opt_list( "--nr_frozen_epochs", default=1, type=int, help="Number of epochs we want to keep the encoder model frozen.", tunable=True, options=[0, 1, 2, 3, 4, 5], ) # Data Args: parser.add_argument( "--label_set", default="pos,neg", type=str, help="Classification labels set.", ) parser.add_argument( "--train_csv", default="data/imdb_reviews_train.csv", type=str, help="Path to the file containing the train data.", ) parser.add_argument( "--dev_csv", default="data/imdb_reviews_test.csv", type=str, help="Path to the file containing the dev data.", ) parser.add_argument( "--test_csv", default="data/imdb_reviews_test.csv", type=str, help="Path to the file containing the dev data.", ) parser.add_argument( "--loader_workers", default=8, type=int, help="How many subprocesses to use for data loading. 0 means that \ the data will be loaded in the main process.", ) return parser
# run hopt # creates and submits jobs to slurm cluster.optimize_parallel_cluster_gpu( main, nb_trials=24, job_name='grid_test' ) if __name__ == '__main__': # subclass of argparse parser = HyperOptArgumentParser(strategy='grid_search') # params we don't want to search over. will use the default value parser.add_argument('--slurm_log_path', default=os.getcwd(), type=str, help='Save experiments here') parser.add_argument('--vocab_size', default=3432, type=int) parser.add_argument('--embed_size', default=150, type=int) parser.add_argument('--hidden_size', default=250, type=int) parser.add_argument('--num_workers', default=4, type=int) parser.add_argument('--num_layers', default=2, type=int) parser.add_argument('--batch_size', default=32, type=int) # params we want to search over #parser.opt_list('--embed_size', default=100, type=int, tunable=True, options=[150, 200, 250, 300]) #arser.opt_list('--hidden_size', default=100, type=int, tunable=True, options=[100, 200, 300]) #parser.opt_list('--num_layers', default=1, type=int, tunable=True, options=[1, 2]) #parser.opt_list('--batch_size', default=32, type=int, tunable=True, options=[32, 64, 128]) #parser.opt_list('--num_workers', default=15, type=int, tunable=True, options=[15])
def add_model_specific_args(parent_parser, root_dir): # pragma: no cover parser = HyperOptArgumentParser(strategy=parent_parser.strategy, parents=[parent_parser]) parser.set_defaults(device=torch.device( 'cuda' if torch.cuda.is_available() else 'cpu')) # network params parser.opt_list('--gcn_mid_dim', default=256, type=int, options=[128, 256, 512, 1024], tunable=True) parser.opt_list('--gcn_output_dim', default=256, type=int, options=[128, 256, 512, 1024], tunable=True) parser.opt_list('--txtcnn_drop_prob', default=0.0, options=[0.0, 0.1, 0.2], type=float, tunable=True) parser.opt_list('--gcn_drop_prob', default=0.5, options=[0.2, 0.5], type=float, tunable=True) parser.opt_list('--warploss_margin', default=0.4, type=float, tunable=True) parser.opt_list('--freeze_embeddings', default=True, options=[True, False], type=lambda x: (str(x).lower() == 'true'), tunable=True) parser.opt_list('--txtcnn_pfilter_num1', default=64, options=[16, 32, 64, 128], type=int, tunable=True) parser.opt_list('--txtcnn_pfilter_num2', default=64, options=[16, 32, 64, 128], type=int, tunable=True) parser.opt_list('--txtcnn_pfilter_num3', default=64, options=[16, 32, 64, 128], type=int, tunable=True) parser.opt_list('--txtcnn_pfilter_num4', default=64, options=[16, 32, 64, 128], type=int, tunable=True) parser.opt_list('--txtcnn_rfilter_num1', default=64, options=[16, 32, 64, 128], type=int, tunable=True) parser.opt_list('--txtcnn_rfilter_num2', default=32, options=[16, 32, 64, 128], type=int, tunable=True) # data parser.add_argument('--data_root', default=os.path.join(root_dir, 'data'), type=str) parser.add_argument('--top_t', default=6, type=int) parser.add_argument('--total_onehop', default=20, type=int) parser.add_argument('--total', default=50, type=int) parser.add_argument('--shuffle', default=True, type=lambda x: (str(x).lower() == 'true')) parser.add_argument('--train_div', default=1.0, type=float) # training params (opt) parser.opt_list('--batch_size', default=64, options=[32, 64, 128, 256], type=int, tunable=False) parser.opt_list('--max_nb_epochs', default=8, options=[256, 512, 1024], type=int, tunable=False) parser.opt_list('--learning_rate', default=0.0005, options=[0.0001, 0.0005, 0.001], type=float, tunable=True) parser.opt_list('--weight_decay', default=0.001, options=[0.0001, 0.0005, 0.001], type=float, tunable=True) parser.add_argument('--model_save_path', default=os.path.join(root_dir, 'experiment'), type=str) return parser
# Pretend to train. x = torch.rand((1, hparams.x_val)) for train_step in range(0, 100): y = torch.rand((hparams.x_val, 1)) out = x.mm(y) exp.log({'fake_err': out.item()}) # Save exp when . exp.save() if __name__ == '__main__': # 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='/some/path/to/log') parser.opt_list('--y_val', default=12, options=[1, 2, 3, 4, 5, 6], tunable=True) parser.opt_list('--x_val', default=12, options=[20, 12, 30, 45], tunable=True) hyperparams = parser.parse_args() # Enable cluster training. cluster = SlurmCluster(hyperparam_optimizer=hyperparams, log_path=hyperparams.log_path, python_cmd='python3',
def add_model_specific_args(parent_parser): parser = HyperOptArgumentParser(strategy=parent_parser.strategy, parents=[parent_parser], add_help=False) parser.opt_list('--q_drop', default=0.35, options=[0.25, 0.3, 0.35, 0.15, 0.4, 0.1], type=float, tunable=False) parser.add_argument('--q_hid_dim', default=1024, type=int) parser.add_argument('--padding_idx', type=int, default=0) parser.add_argument('--net_init', default='k_u') parser.opt_list('--iter_num', default=3, options=[1, 2, 3, 4, 5], type=int) parser.add_argument('--g_init_method', default='full', type=str) parser.add_argument('--stem_in_dim', default=2048, type=int) parser.add_argument('--stem_out_dim', default=1024, type=int) parser.opt_list('--stem_norm', default='custom', options=['custom', 'layer', 'weight'], type=str, tunable=False) parser.opt_list('--stem_orders', default='dlna', options=['dlna', 'dnla'], type=str, tunable=False) parser.opt_list('--stem_drop', default=0.35, options=[0.3, 0.35, 0.4], type=int) parser.opt_list('--stem_method', default='linear', options=['linear', 'film', 'double_linear'], type=str) parser.add_argument('--stem_use_act', action='store_true') parser.opt_list('--e_f_norm', default='weight', options=['custom', 'layer', 'weight'], type=str, tunable=False) parser.opt_list('--e_f_orders', default='dlna', options=['dlna', 'dnla'], type=str, tunable=False) parser.opt_list('--e_f_drop', default=0.35, options=[0.3, 0.35, 0.4], type=int) parser.add_argument('--e_dim', default=512, type=int) parser.opt_list('--e_f_method', default='mul_film', options=['mul_film', 'cat_film'], type=str) parser.add_argument('--e_f_use_nGeo', action='store_true', default=True) parser.opt_list('--e_w_method', default='linear_softmax_8', options=['linear_softmax_10', 'linear_softmax_12'], type=str) parser.opt_list('--e_w_norm', default='weight', options=['custom', 'layer', 'weight'], type=str, tunable=False) parser.opt_list('--e_w_orders', default='dlna', options=['dlna', 'dnla'], type=str, tunable=False) parser.opt_list('--e_w_drop', default=0.35, options=[0.3, 0.35, 0.4], type=int) parser.opt_list('--e_p_method', default='linear', options=['linear', 'share'], type=str) parser.opt_list('--e_p_norm', default='weight', options=['custom', 'layer', 'weight'], type=str, tunable=False) parser.opt_list('--e_p_orders', default='dlna', options=['dlna', 'dnla'], type=str, tunable=False) parser.opt_list('--e_p_drop', default=0.35, options=[0.3, 0.35, 0.4], type=int) parser.opt_list('--e_p_act', default='relu', options=['relu', 'swish', 'elu'], type=str, tunable=False) parser.opt_list('--n_f_method', default='film', options=['linear', 'film'], type=str) parser.opt_list('--n_f_drop', default=0.35, options=[0.3, 0.35, 0.4], type=int) parser.opt_list('--n_geo_method', default='cat', options=['cat', 'sum', 'linear_cat'], type=str) parser.add_argument('--n_geo_reuse', action='store_true', default=True) parser.add_argument('--n_geo_dim', default=64, type=int) parser.add_argument('--n_geo_out_dim', default=64, type=int) parser.opt_list('--n_geo_norm', default='weight', options=['custom', 'layer', 'weight'], type=str, tunable=False) parser.opt_list('--n_geo_orders', default='lna', options=['lna', 'nla'], type=str, tunable=False) parser.opt_list('--e_geo_method', default='linear', options=['linear', 'cat'], type=str) parser.add_argument('--e_geo_dim', default=128, type=int) parser.add_argument('--e_geo_out_dim', default=128, type=int) parser.add_argument('--e_geo_reuse', action='store_true', default=True) parser.add_argument('--e_geo_aug', action='store_true') parser.opt_list('--e_geo_norm', default='weight', options=['custom', 'layer', 'weight'], type=str, tunable=False) parser.opt_list('--e_geo_orders', default='lna', options=['lna', 'nla'], type=str, tunable=False) parser.opt_list('--cls_method', default='linear', options=['linear'], type=str) parser.opt_list('--cls_norm', default='weight', options=['custom', 'layer', 'weight'], type=str, tunable=False) parser.opt_list('--cls_orders', default='dlna', options=['dlna', 'dnla'], type=str, tunable=False) parser.opt_list('--cls_drop', default=0.35, options=[0.3, 0.35, 0.4], type=int) parser.opt_list('--cls_act', default='relu', options=['relu', 'swish'], type=str, tunable=False) parser.opt_list('--f_c_norm', type=str, default='weight', options=['weight', 'custom', 'layer']) parser.opt_list('--f_c_drop', default=0., options=[0.3, 0.35, 0.4], type=int) parser.opt_list('--f_c_orders', default='dln', options=['dln', 'dnl'], type=str, tunable=False) parser.opt_list('--f_x_norm', default='layer', options=['custom', 'layer', 'weight'], type=str, tunable=False) parser.opt_list('--f_x_orders', default='dln', options=['dln', 'dnl'], type=str, tunable=False) parser.add_argument('--f_x_norm_affine', action='store_true') parser.opt_list('--f_act', default='relu', options=['relu', 'swish', 'elu'], type=str, tunable=False) parser.opt_list('--pool_method', default='mix', options=['mix', 'mean', 'max'], type=str) parser.opt_list('--lr', default=2.5e-4, type=float, options=[2.5e-4, 3.5e-4], tunable=False) parser.opt_list('--sched_factor', default=0.5, type=float, options=[0.1, 0.8, 0.6, 0.3], tunable=False) parser.opt_list('--optimizer', type=str, default='adam', options=['adam', 'sgd']) parser.opt_list('--sched', type=str, default='plat', options=['plat', 'cyclic', 'sgdr']) parser.opt_list('--dataset', default='vqa2_cp', type=str, options=['vaq2_cp', 'gqa_lcgn']) parser.add_argument('--epochs', default=12, type=int) parser.add_argument('--batch_size', default=64, type=int) parser.add_argument('--num_workers', default=5, type=int) parser.add_argument('--grad_clip', default=0., type=float) parser.add_argument('--weight_decay', default=0., type=float) parser.add_argument('--use_warmup', action='store_true') return parser
if __name__ == '__main__': # dirs root_dir = os.path.dirname(os.path.realpath(__file__)) demo_log_dir = os.path.join(root_dir, 'pt_lightning_demo_logs') checkpoint_dir = os.path.join(demo_log_dir, 'model_weights') test_tube_dir = os.path.join(demo_log_dir, 'test_tube_data') # although we user hyperOptParser, we are using it only as argparse right now parent_parser = HyperOptArgumentParser(strategy='grid_search', add_help=False) # gpu args parent_parser.add_argument('--test_tube_save_path', type=str, default=test_tube_dir, help='where to save logs') parent_parser.add_argument('--model_save_path', type=str, default=checkpoint_dir, help='where to save model') parent_parser.add_argument('--experiment_name', type=str, default='pt_lightning_exp_a', help='test tube exp name') # allow model to overwrite or extend args parser = LightningTemplateModel.add_model_specific_args( parent_parser, root_dir) hyperparams = parser.parse_args()
options=[20, 30, 40, 50], type=int, tunnable=True) parser.add_opt_argument_list('--embedding_dim', default=320, options=[100, 200, 320, 400], type=int, tunnable=True) parser.add_opt_argument_list('--max_seq_len', default=50, options=[50, 70, 90, 110], type=int, tunnable=True) # training params parser.add_argument('--nb_epochs', default=1000, type=int) parser.add_argument('--optimizer_name', default='adam') parser.add_argument('--eval_every_n_batches', default=200, type=int) parser.add_argument('--save_every_n_batches', default=10000, type=int) parser.add_argument('--train_mode', default='train') # model params parser.add_argument('--nb_grams', default=2, type=int) # path params parser.add_argument('--root_dir', default='./data') parser.add_argument('--dataset_train_path', default='./data/train.csv') parser.add_argument('--dataset_test_path', default='./data/test.csv') parser.add_argument('--dataset_val_path', default='./data/val.csv') parser.add_argument('--vocab_path', default='./data/vocabulary.txt')
def add_model_specific_args(parent_parser): parser = HyperOptArgumentParser(parents=[parent_parser]) parser.add_argument('--num_freq_mask', default=1, type=int) parser.add_argument('--num_time_mask', default=1, type=int) parser.add_argument('--freq_mask_length', default=10, type=int) parser.add_argument('--time_mask_length', default=20, type=int) parser.add_argument('--feature_dim', default=320, type=int) parser.add_argument('--model_size', default=512, type=int) parser.add_argument('--feed_forward_size', default=512, type=int) parser.add_argument('--hidden_size', default=64, type=int) parser.add_argument('--dropout', default=0.1, type=float) parser.add_argument('--num_head', default=4, type=int) parser.add_argument('--num_layer', default=4, type=int) parser.add_argument('--vocab_path', default='testing_vocab.model', type=str) parser.add_argument('--max_feature_length', default=1024, type=int) parser.add_argument('--max_token_length', default=50, type=int) parser.add_argument('--lr', default=3e-4, type=float) parser.add_argument('--enable_spec_augment', default=False, type=bool) parser.add_argument('--train_batch_size', default=16, type=int) parser.add_argument('--train_loader_num_workers', default=4, type=int) parser.add_argument('--val_batch_size', default=16, type=int) parser.add_argument('--val_loader_num_workers', default=4, type=int) return parser
GPUs = ['0', '1', '2', '4'] os.environ["CUDA_VISIBLE_DEVICES"] = GPUs[job_index_nb] main_trainer(trial_params) if __name__ == '__main__': parser = HyperOptArgumentParser(strategy='random_search') parser.add_opt_argument_list('--time_steps', default=3, options=[3, 5, 7, 9, 11], type=int, help='number of sequential readings', tunnable=False) # model params parser.add_opt_argument_list('--gamma', default=0.00001, options=[0.00001], type=int, tunnable=False) parser.add_opt_argument_list('--kernel', default='rbf', options=['rbf'], type=str, tunnable=False) parser.add_opt_argument_list('--C', default=4, options=[4, 5, 6], type=int, tunnable=False) parser.add_argument('--nb_trials', default=200, type=int) # path vars parser.add_argument('--data_path', default='/Users/waf/Developer/temp_floor/floor/data/in_out_classifier_data/data') parser.add_argument('--model_save_path', default='/Users/waf/Developer/temp_floor/floor/logs/weights/svm') parser.add_argument('--tt_save_path', default='/Users/waf/Developer/temp_floor/floor/logs/training_logs/svm') parser.add_argument('--tt_name', default='svm_final_1') parser.add_argument('--tt_description', default='hyperopt') parser.add_argument('--debug', default=False, type=bool) parser.add_argument('--local', default=True, type=bool) parser.add_json_config_argument('--config', default='/Users/waf/Developer/temp_floor/floor/logs/run_configs/local.json') hyperparams = parser.parse_args() os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" if hyperparams.local:
feed_dict = {input_x: text_enc, input_y: labels_enc} out_value, out_score = sess.run([value, score], feed_dict=feed_dict) print('label: ', labels[out_value]) print('score: ', out_score) if __name__ == '__main__': parser = HyperOptArgumentParser(strategy='random_search') # path params parser.add_opt_argument_list('--lr_1', default=0.0001, options=[0.0001, 0.0002, 0.0004, 0.0008, 0.001, 0.002], type=float, tunnable=True) parser.add_opt_argument_list('--batch_size', default=10, options=[20, 30, 40, 50], type=int, tunnable=True) parser.add_opt_argument_list('--embedding_dim', default=320, options=[100, 200, 320, 400], type=int, tunnable=True) parser.add_argument('--root_dir', default='./data') parser.add_argument('--dataset_train_path', default='./data/train.csv') parser.add_argument('--dataset_test_path', default='./data/test.csv') parser.add_argument('--dataset_val_path', default='./data/val.csv') parser.add_argument('--vocab_path', default='./data/vocabulary.txt') parser.add_opt_argument_list('--max_seq_len', default=50, options=[50, 70, 90, 110], type=int, tunnable=True) parser.add_argument('--epoch', default=0) parser.add_argument('--step', default='FINAL') parser.add_argument('--model_save_dir', default='./experiments') parser.add_argument('--test_tube_dir', default='') # experiment params parser.add_argument('--exp_name', default='dual_conv_dense') hparams = parser.parse_args() test_main(hparams=hparams)
checkpoint_path = experiment_folder + "/checkpoints/" + checkpoints[-1] model = BERTClassifier.load_from_metrics(weights_path=checkpoint_path, tags_csv=tags_csv_file) # Make sure model is in prediction mode model.eval() model.freeze() return model if __name__ == "__main__": parser = HyperOptArgumentParser(description="Minimalist BERT Classifier", add_help=True) parser.add_argument( "--experiment", default= '../../data/experiments/lightning_logs/version_29-04-2020--22-14-10', type=str, help="Path to the experiment folder.") hparams = parser.parse_args() print("Loading model...") model = load_model_from_experiment(hparams.experiment) print(model) print("Please write a movie review or quit to exit the interactive shell:") # Get input sentence test_path = '../../data/output/test.csv' test = pd.read_csv(test_path, encoding='utf-8') labels = [] for index in range(test.shape[0]):