def parse_args(config_file='configs.json'): ALL_CONFIG = json.load(open(config_file)) CONFIG = ALL_CONFIG["data_agnostic_configs"] # Set default values for data-agnostic configurations DEMO = CONFIG["demo"] DATASET = CONFIG["dataset"] BASIS = CONFIG["basis"] LR = CONFIG["learning_rate"] MOM = CONFIG["momentum"] WD = CONFIG["weight_decay"] NUM_ITER = CONFIG["number_iterations"] NUM_RESTARTS = CONFIG["number_restarts"] parser = argparse.ArgumentParser() parser.add_argument('--DEMO', type=str, default=DEMO, \ help='demo, boolean. Set True to run method over subset of 5 images \ (default). Set False to run over entire dataset.' ) parser.add_argument('--DATASET', type=str, default=DATASET,\ help='dataset, DEFAULT=mnist. SUPPORTED=[mnist, xray]') parser.add_argument('--BASIS', nargs='+', type=str, default=BASIS,\ help='basis, DEFAULT=csdip. SUPPORTED=[csdip, dct, wavelet]') parser.add_argument('--LR', type=float, default=LR,\ help='learning rate, DEFAULT=' + str(LR)) parser.add_argument('--MOM', type=float, default=MOM,\ help='RMSProp momentum hyperparameter, DEFAULT=' + str(MOM)) parser.add_argument('--WD', type=float, default=WD,\ help='l2 weight decay hyperparameter, DEFAULT=' + str(WD)) parser.add_argument('--NUM_ITER', type=int, default=NUM_ITER,\ help='number of iterative weight updates, DEFAULT=' + str(NUM_ITER)) parser.add_argument('--NUM_RESTARTS', type=int, default=NUM_RESTARTS,\ help='number of restarts, DEFAULT=' + str(NUM_RESTARTS)) parser.add_argument('--NUM_MEASUREMENTS', nargs='+', type=int, default = None, \ help='number of measurements, DEFAULT dependent on dataset') args = parser.parse_args() # set values for data-specific configurations SPECIFIC_CONFIG = ALL_CONFIG[args.DATASET] args.IMG_SIZE = SPECIFIC_CONFIG["img_size"] args.NUM_CHANNELS = SPECIFIC_CONFIG["num_channels"] args.Z_DIM = SPECIFIC_CONFIG["z_dim"] #input seed NUM_MEAS_DEFAULT = SPECIFIC_CONFIG["num_measurements"] if not args.NUM_MEASUREMENTS: args.NUM_MEASUREMENTS = NUM_MEAS_DEFAULT print(args) utils.check_args(args) # check to make sure args are correct return args
def main(): # Check and get arguments args = utils.check_args() configFile = args.config directory = args.directory gz = args.gz # If not config file within arguments if not configFile: utils.printWarning("Didn't find '--config' param. Try to read 'config.json'...") configFile = utils.is_valid_json_file('config.json') # Try read json config file try: config = utils.read_json(configFile) config = config['config'] ## TODO Exception to handle finally: utils.printSuccess("DONE") # If config was loaded if config: try: backupped = utils.make_backup(config, directory, gz) finally: utils.printSuccess("DONE") utils.printSuccess("Close connection...") utils.printSuccess("DONE")
def main(): flag_plot, flag_metrics = check_args() if (flag_plot, flag_metrics) == (-1, -1): return (mileage, price) = get_data() if (mileage, price) == (-1, -1): return # Normalize mileage and price for faster computation mileage_norm = [float(mileage[i])/max(mileage) for i in range(len(mileage))] price_norm = [float(price[i])/max(price) for i in range(len(price))] # Perform gradient descent. Learning rate can be tuned here. [theta_0, theta_1] = gradient_descent(mileage_norm, price_norm, l_r=0.1) # Denormalize theta_0 = theta_0 * max(price) theta_1 = theta_1 * (max(price) / max(mileage)) # Input theta values in the .csv file write_thetas(theta_0, theta_1) # Display information according to flags if flag_metrics == 1: display_metrics(theta_0, theta_1, mileage, price) if flag_plot == 1: mse = list() for i in range(len(mileage)): mse.append(predict(theta_0, theta_1, mileage[i])) display_plot(mileage, price, mse)
def parse_args(config_file='configs.json'): ALL_CONFIG = json.load(open(config_file)) CONFIG = ALL_CONFIG["data_agnostic_configs"] # Set default values for data-agnostic configurations DEMO = CONFIG["demo"] DATASET = CONFIG["dataset"] ALG = CONFIG["alg"] NUM_ITER = CONFIG["num_iterations"] parser = argparse.ArgumentParser() parser.add_argument('--DATASET', type=str, default=DATASET,\ help='dataset, DEFAULT=mnist. SUPPORTED=[mnist, xray, retino]') parser.add_argument('--ALG', nargs='+', type=str, default=ALG,\ help='algorithm, DEFAULT=csdip. SUPPORTED=[csdip, dct, wavelet]. BM3D-AMP, TVAL3 must be run in Matlab.') parser.add_argument('--NUM_MEASUREMENTS', nargs='+', type=int, default = None, \ help='number of measurements, DEFAULT dependent on dataset.') parser.add_argument('--DEMO', type=str, default=DEMO, \ help='demo, boolean. Set True to run method over subset of 5 images \ (default). Set False to run over entire dataset.' ) parser.add_argument('--NUM_ITER', type=int, default=NUM_ITER,\ help='number of iterative weight updates, DEFAULT=' + str(NUM_ITER)) parser.add_argument('--NUM_RESTARTS', type=int, default= None,\ help='number of restarts, DEFAULT dependent on dataset.') args = parser.parse_args() # set values for data-specific configurations SPECIFIC_CONFIG = ALL_CONFIG[args.DATASET] args.IMG_SIZE = SPECIFIC_CONFIG["img_size"] args.NUM_CHANNELS = SPECIFIC_CONFIG["num_channels"] args.Z_DIM = SPECIFIC_CONFIG["z_dim"] #input seed args.LR_FOLDER = SPECIFIC_CONFIG["lr_folder"] # if data-specific arg not set by user if not args.NUM_MEASUREMENTS: args.NUM_MEASUREMENTS = SPECIFIC_CONFIG["num_measurements"] if not args.NUM_RESTARTS: args.NUM_RESTARTS = SPECIFIC_CONFIG["num_restarts"] utils.check_args(args) # check to make sure args are correct return args
def main(): parser = build_parser() args = parser.parse_args() check_args(args) check_args_to_run(args) device = torch.device('cuda') if args.gpu and torch.cuda.is_available( ) else torch.device('cpu') if args.subcmd == 'citation': dataset = load_dataset(args.dataset) hparams = { 'input_dim': dataset.num_node_features, 'hidden_dim': args.hidden_dim, 'output_dim': dataset.num_classes, 'n_layers': args.n_layers, 'dropout': args.dropout, 'edge_dropout': args.edge_dropout, 'layer_wise_dropedge': args.layer_wise_dropedge } model_name = f'{args.model}-{args.n_layers}-hidden_dim={args.hidden_dim}-dropout={args.dropout}-edge_dropout={args.edge_dropout}-LW={args.layer_wise_dropedge}' model_path = f'pretrained_models/{model_name}_{args.dataset.lower()}' + '_{}.pth' histories = train_for_citation(args=args, hparams=hparams, dataset=dataset, device=device, model_path=model_path) plot_training( histories, title=f'{model_name} / {args.dataset.title()}', metric_name='accuracy', save_path=f'images/{model_name}_{args.dataset.lower()}.png')
def parse_args(): # 创建解释器对象ArgumentParser parser = argparse.ArgumentParser( description="Tensorflow implementation of GAN Variants") # 添加可选参数 parser.add_argument('--gan_type', type=str, default='GAN', choices=['GAN', 'CGAN'], help='The type of GAN', required=True) parser.add_argument('--dataset', type=str, default='fashion-mnist', help='The name of dataset') parser.add_argument('--epoch', type=int, default=20, help='The number of epochs to run') parser.add_argument('--batch_size', type=int, default=64, help='The size of batch') parser.add_argument('--z_dim', type=int, default=62, help='Dimension of noise vector') parser.add_argument('--checkpoint_dir', type=str, default='checkpoint', help='Directory name to save the checkpoints') parser.add_argument('--result_dir', type=str, default='results', help='Directory name to save the generated images') parser.add_argument('--log_dir', type=str, default='logs', help='Directory name to save training logs') return check_args(parser.parse_args())
def exec_command(self, command, args): """ the core method of commands exec, it tries to fetch the requested command, bind to the right context and call the associated function TODO: :param command: requested command :param args: arguments array :return: """ # save the found command and sub_command array complete_command_array = [command] try: if command == '': return if command in self.commands_map: # if we found the command but has the "ref" property, # so we need to reference to another object. Ex. short command q --references--> quit if 'ref' in self.commands_map[command]: com = self.commands_map[self.commands_map[command]['ref']] else: com = self.commands_map[command] # if we have no arguments no sub_command exist, else save the first argument last_function = False if len(args) > 0: possible_sub_command = args[0] else: possible_sub_command = None # now iterate while we have a valid sub_command, # when we don't find a valid sub_command exit and the new command will be the sub_command # save the sub_command parent prev_command = com while last_function is False: # if the sub command is a ref, catch the right command if 'ref' in com: com = prev_command['sub_commands'][com['ref']] if 'sub_commands' in com and possible_sub_command: if possible_sub_command in com['sub_commands']: prev_command = com com = com['sub_commands'][possible_sub_command] # pop the found sub_command so we can iterate on the remanings arguments complete_command_array.append(args.pop(0)) command = possible_sub_command # if there are arguments left if len(args) > 0: # take the first args (the next sub_command) possible_sub_command = args[0] else: last_function = True else: last_function = True else: last_function = True # if the sub_command is a reference to another associated sub_command if 'ref' in com: com = prev_command['sub_commands'][com['ref']] # if we have a function field just fetch the context and the function name, # bind them and call the function passing the arguments if 'function' in com: if 'args' in com['function']: args_check, args_error = utils.check_args( com['function']['args'], args) if args_check is False: raise Exception(args_error) context = self.context_map[com["function"]["context"]] funct = com["function"]["f"] call_method = getattr(context, funct) # we pass the command name (could be useful for the called function) # and possible arguments to the function call_method(command, *args) else: # if we have no method implementation of the command # print the help of the command # passing all the arguments list to help function (including the command) in a unique array self.exec_command('help', complete_command_array) else: print("command '" + command + "' not found") except Exception as e: if isinstance(e, UcError): print(utils.titlify('uc error')) print(str(e)) else: print(utils.error_format('exec_command', str(e))) self.exec_command('help', complete_command_array)
def parse_args(): desc = "Pytorch implementation of GAN collections" parser = argparse.ArgumentParser(description=desc) parser.add_argument('--gan_type', type=str, default='GAN', choices=[ 'GAN', 'Classifier', 'CGAN', 'BEGAN', 'WGAN', 'VAE', "CVAE", "WGAN_GP" ], help='The type of GAN') # , required=True) parser.add_argument('--dataset', type=str, default='mnist', choices=['mnist', 'fashion-mnist'], help='The name of dataset') parser.add_argument('--conditional', type=bool, default=False) parser.add_argument('--dir', type=str, default='./', help='Working directory') parser.add_argument('--save_dir', type=str, default='models', help='Directory name to save the model') parser.add_argument('--result_dir', type=str, default='results', help='Directory name to save results') parser.add_argument('--sample_dir', type=str, default='Samples', help='Directory name to save the generated images') parser.add_argument('--log_dir', type=str, default='logs', help='Directory name to save training logs') parser.add_argument('--epoch', type=int, default=25, help='The number of epochs to run') parser.add_argument('--batch_size', type=int, default=64, help='The size of batch') parser.add_argument('--num_examples', type=int, default=50000, help='The number of examples to use for train') parser.add_argument('--tau', type=float, default=0.0, help='ratio of training data.') parser.add_argument('--size_epoch', type=int, default=1000) parser.add_argument('--gpu_mode', type=bool, default=True) parser.add_argument('--device', type=int, default=0) parser.add_argument('--lrG', type=float, default=0.0002) parser.add_argument('--lrD', type=float, default=0.0002) parser.add_argument('--lrC', type=float, default=0.01) parser.add_argument('--momentum', type=float, default=0.5, metavar='M', help='SGD momentum (default: 0.5)') parser.add_argument('--beta1', type=float, default=0.5) parser.add_argument('--beta2', type=float, default=0.999) parser.add_argument('--seed', type=int, default=1664) parser.add_argument('--classify', type=bool, default=False) parser.add_argument('--TrainEval', type=bool, default=False) parser.add_argument('--knn', type=bool, default=False) parser.add_argument('--IS', type=bool, default=False) parser.add_argument('--FID', type=bool, default=False) parser.add_argument('--train_G', type=bool, default=False) return check_args(parser.parse_args())
type=str, default= 'check_points/pretrain_models/albert_large_zh/pytorch_albert_model.pth' ) parser.add_argument('--checkpoint_dir', type=str, default='check_points/DRCD/albert_large_zh/') parser.add_argument('--setting_file', type=str, default='setting.txt') parser.add_argument('--log_file', type=str, default='log.txt') # use some global vars for convenience args = parser.parse_args() args.checkpoint_dir += ('/epoch{}_batch{}_lr{}_warmup{}_anslen{}/'.format( args.train_epochs, args.n_batch, args.lr, args.warmup_rate, args.max_ans_length)) args = utils.check_args(args) os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu_ids device = torch.device("cuda") n_gpu = torch.cuda.device_count() print("device %s n_gpu %d" % (device, n_gpu)) print("device: {} n_gpu: {} 16-bits training: {}".format( device, n_gpu, args.float16)) # load the bert setting if 'albert' not in args.bert_config_file: bert_config = BertConfig.from_json_file(args.bert_config_file) else: bert_config = ALBertConfig.from_json_file(args.bert_config_file) # load data print('loading data...')
def main(): # set_rnd_seed(31) # reproducibility parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--data_dir_train', type=str, default='./data/brats_19/Train', metavar='DATA_TRAIN', help="data train directory") parser.add_argument('--data_dir_val', type=str, default='./data/brats_19/Validation', metavar='DATA_VAL', help="data validation directory") parser.add_argument('--log_dir', type=str, default='logs/', metavar='LOGS', help="logs directory") parser.add_argument('--models_dir', type=str, default='models/', metavar='MODELS', help="models directory") parser.add_argument('--batch_size', type=int, default=16, metavar='BATCH', help="batch size") parser.add_argument('--learning_rate', type=float, default=2.0e-5, metavar='LR', help="learning rate") parser.add_argument('--epochs', type=int, default=1e6, metavar='EPOCHS', help="number of epochs") parser.add_argument('--zdim', type=int, default=16, metavar='ZDIM', help="Number of dimensions in latent space") parser.add_argument('--load', type=str, default='', metavar='LOADDIR', help="time string of previous run to load from") parser.add_argument('--binary_input', type=bool, default=False, metavar='BINARYINPUT', help="True=one input channel for each tumor structure") parser.add_argument('--use_age', type=bool, default=False, metavar='AGE', help="use age in prediction") parser.add_argument('--use_rs', type=bool, default=False, metavar='RESECTIONSTATUS', help="use resection status in prediction") args = parser.parse_args() device = torch.device("cuda" if torch.cuda.is_available() else "cpu") print("Device in use: {}".format(device)) torch.set_default_tensor_type(torch.cuda.FloatTensor if torch.cuda. is_available() else torch.FloatTensor) logdir_suffix = '-%s-zdim=%d-beta=5000-alpha=%.5f-lr=%.5f-gamma=%d-batch=%d' % ( args.data_dir_train.replace("Train", "").replace(".", "").replace( "/", ""), args.zdim, alpha, args.learning_rate, gamma, args.batch_size) if args.use_age: logdir_suffix += "-age" if args.use_rs: logdir_suffix += "-rs" if args.binary_input: logdir_suffix += "-binary_input" if args.load == "": date_str = str(dt.now())[:-7].replace(":", "-").replace( " ", "-") + logdir_suffix else: date_str = args.load args.models_dir = join(args.models_dir, date_str) args.log_dir = join(args.log_dir, date_str) os.makedirs(args.log_dir, exist_ok=True) os.makedirs(args.models_dir, exist_ok=True) check_args(args) writer = SummaryWriter(args.log_dir + '-train') ## Get dataset data = get_all_data(args.data_dir_train, args.data_dir_val, orig_data_shape, binary_input=args.binary_input) x_data_train_labeled, x_data_train_unlabeled, x_data_val, y_data_train_labeled, y_data_val, y_dim = data if args.binary_input: n_labels = x_data_train_labeled.shape[1] else: n_labels = len( np.bincount(x_data_train_labeled[:10].astype(np.int8).flatten())) x_data_train_labeled = x_data_train_labeled.astype(np.int8) x_data_train_unlabeled = x_data_train_unlabeled.astype(np.int8) x_data_val = x_data_val.astype(np.int8) if args.use_age: age_std = 12.36 age_mean = 62.2 age_l = np.expand_dims(np.load(join(args.data_dir_train, "age_l.npy")), 1) age_u = np.expand_dims(np.load(join(args.data_dir_train, "age_u.npy")), 1) age_v = np.expand_dims(np.load(join(args.data_dir_val, "age.npy")), 1) age_l = (age_l - age_mean) / age_std age_u = (age_u - age_mean) / age_std age_v = (age_v - age_mean) / age_std else: age_l, age_u, age_v = [], [], [] if args.use_rs: rs_l = one_hot(np.load(join(args.data_dir_train, "rs_l.npy")), 2) rs_u = one_hot(np.load(join(args.data_dir_train, "rs_u.npy")), 2) rs_v = one_hot(np.load(join(args.data_dir_val, "rs.npy")), 2) else: rs_l, rs_u, rs_v = [], [], [] if args.use_rs and args.use_age: c_l = np.concatenate([age_l, rs_l], axis=1) c_u = np.concatenate([age_u, rs_u], axis=1) c_v = np.concatenate([age_v, rs_v], axis=1) c_dim = c_l.shape[1] elif args.use_rs: c_l, c_u, c_v = rs_l, rs_u, rs_v c_dim = c_l.shape[1] elif args.use_age: c_l, c_u, c_v = age_l, age_u, age_v c_dim = c_l.shape[1] else: c_l, c_u, c_v = np.array([]), np.array([]), np.array([]) c_dim = 0 y_data_val = y_data_val[:len(x_data_val)] print('x unlabeled data shape:', x_data_train_unlabeled.shape) print('x labeled data shape:', x_data_train_labeled.shape) print('x val data shape:', x_data_val.shape) assert data_shape == tuple(x_data_val.shape[2:]) print('input labels: %d' % n_labels) model = SemiVAE(args.zdim, y_dim, c_dim, n_labels=n_labels, binary_input=args.binary_input).to(device) print_num_params(model) optimizer = optim.Adam(model.parameters(), lr=args.learning_rate) start_epoch = 0 if args.load != "": print("Loading model from %s" % args.models_dir) nums = [int(i.split("_")[-1]) for i in os.listdir(args.models_dir)] start_epoch = max(nums) model_path = join(args.models_dir, "model_epoch_%d" % start_epoch) checkpoint = torch.load(model_path) model.load_state_dict(checkpoint['model_state_dict']) optimizer.load_state_dict(checkpoint['optimizer_state_dict']) if 'model_global_step' in checkpoint.keys(): model.global_step = checkpoint['model_global_step'] start_epoch = checkpoint['epoch'] print("Loaded model at epoch %d, total steps: %d" % (start_epoch, model.global_step)) t_start = dt.now() for epoch in range(int(start_epoch + 1), int(args.epochs)): train(x_data_train_unlabeled, x_data_train_labeled, y_data_train_labeled, x_data_val, y_data_val, c_l, c_u, c_v, args.batch_size, epoch, model, optimizer, device, log_interval, writer, args.log_dir, n_labels) if (dt.now() - t_start).total_seconds() > 3600 * 2: torch.save( { 'epoch': epoch, 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), 'model_global_step': model.global_step, }, join(args.models_dir, "model_epoch_%d" % epoch)) t_start = dt.now() sys.stdout.flush() # need this when redirecting to file
help="Contains full path to the root directory for symbols.", metavar="path", required=True) parser.add_argument("-o", "--out", dest="out", help="write the result into the out file. If omitted, the" " result is written into the stdout", metavar="file") parser.add_argument("--android_ndk_home", dest="ndk_home", help="path of the Android NDK home[optional]. If omitted," " get it from environment by \"ANDROID_NDK_HOME\"", metavar="path") except argparse.ArgumentError: pass if category: parser = parser.add_argument_group("memory") required = False parser.add_argument('-p', "--process", dest="process", help="Process name you want to parse the memory stack", metavar="process_name", required=required) parser.add_argument('-a', "--allocation", dest="alloc", help="The allocation memory stack file", metavar="file", required=required) if __name__ == '__main__': parser = argparse.ArgumentParser(description="Analyze the memory stack to check memory leak") generate_help(parser, False); args = parser.parse_args() rs = check_args(args) if not rs: rs = parse_memory_stack(args) exit(rs)
try: parser.add_argument('-s', "--symbols", dest="symbols", help="Contains full path to the root directory for symbols.", metavar="path", required=True) parser.add_argument("-o", "--out", dest="out", help="write the result into the out file. If omitted," " the result is written into the stdout", metavar="file") parser.add_argument("--android_ndk_home", dest="ndk_home", help="path of the Android NDK home[optional]. If omitted," " get it from environment by \"ANDROID_NDK_HOME\"", metavar="path") except argparse.ArgumentError: pass if category: parser = parser.add_argument_group("crash") required = False parser.add_argument('-d', "--dump", dest="dump", help="The crash dump. This is an optional parameter." " If omitted, parse_stack will read input data from stdin", metavar="file", required=required) if __name__ == '__main__': parser = argparse.ArgumentParser(description="Analyze the crash stack to print crash functions") generate_help(parser, False); args = parser.parse_args() rs = check_args(args) if not rs: rs = parse_crash_stack(args) exit(rs)
def main(): #### options parser = argparse.ArgumentParser() parser.add_argument('--gpu_ids', type=str, default='0,1,2,3,4,5,6,7') parser.add_argument('--batch_size', type=int, default=32) parser.add_argument('--dev_ratio', type=float, default=0.01) parser.add_argument('--lr_G', type=float, default=1e-4) parser.add_argument('--weight_decay_G', type=float, default=0) parser.add_argument('--beta1_G', type=float, default=0.9) parser.add_argument('--beta2_G', type=float, default=0.99) parser.add_argument('--lr_D', type=float, default=1e-4) parser.add_argument('--weight_decay_D', type=float, default=0) parser.add_argument('--beta1_D', type=float, default=0.9) parser.add_argument('--beta2_D', type=float, default=0.99) parser.add_argument('--lr_scheme', type=str, default='MultiStepLR') parser.add_argument('--niter', type=int, default=100000) parser.add_argument('--warmup_iter', type=int, default=-1) parser.add_argument('--lr_steps', type=list, default=[50000]) parser.add_argument('--lr_gamma', type=float, default=0.5) parser.add_argument('--pixel_criterion', type=str, default='l1') parser.add_argument('--pixel_weight', type=float, default=1e-2) parser.add_argument('--feature_criterion', type=str, default='l1') parser.add_argument('--feature_weight', type=float, default=1) parser.add_argument('--gan_type', type=str, default='ragan') parser.add_argument('--gan_weight', type=float, default=5e-3) parser.add_argument('--D_update_ratio', type=int, default=1) parser.add_argument('--D_init_iters', type=int, default=0) parser.add_argument('--print_freq', type=int, default=100) parser.add_argument('--val_freq', type=int, default=1000) parser.add_argument('--save_freq', type=int, default=10000) parser.add_argument('--crop_size', type=float, default=0.85) parser.add_argument('--lr_size', type=int, default=128) parser.add_argument('--hr_size', type=int, default=512) # network G parser.add_argument('--which_model_G', type=str, default='RRDBNet') parser.add_argument('--G_in_nc', type=int, default=3) parser.add_argument('--out_nc', type=int, default=3) parser.add_argument('--G_nf', type=int, default=64) parser.add_argument('--nb', type=int, default=16) # network D parser.add_argument('--which_model_D', type=str, default='discriminator_vgg_128') parser.add_argument('--D_in_nc', type=int, default=3) parser.add_argument('--D_nf', type=int, default=32) # data dir parser.add_argument('--hr_path', type=list, default=['data/celebahq-512/', 'data/ffhq-512/']) parser.add_argument('--lr_path', type=str, default='data/lr-128/') parser.add_argument('--checkpoint_dir', type=str, default='check_points/ESRGAN-V1/') parser.add_argument('--val_dir', type=str, default='dev_show') parser.add_argument('--training_state', type=str, default='check_points/ESRGAN-V1/state/') # resume the training parser.add_argument('--resume_state', type=str, default=None) parser.add_argument('--pretrain_model_G', type=str, default=None) parser.add_argument('--pretrain_model_D', type=str, default=None) parser.add_argument('--setting_file', type=str, default='setting.txt') parser.add_argument('--log_file', type=str, default='log.txt') args = check_args(parser.parse_args()) os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu_ids #### loading resume state if exists if args.resume_state is not None: # distributed resuming: all load into default GPU device_id = torch.cuda.current_device() resume_state = torch.load( args.resume_state, map_location=lambda storage, loc: storage.cuda(device_id)) else: resume_state = None # load dataset total_img_list = [] for hr_path in args.hr_path: total_img_list.extend(glob(hr_path + '/*')) random.shuffle(total_img_list) dev_list = total_img_list[:int(len(total_img_list) * args.dev_ratio)] train_list = total_img_list[int(len(total_img_list) * args.dev_ratio):] train_loader = create_dataloader(args, train_list, is_train=True, n_threads=len(args.gpu_ids.split(','))) dev_loader = create_dataloader(args, dev_list, is_train=False, n_threads=len(args.gpu_ids.split(','))) #### create model model = SRGANModel(args, is_train=True) if resume_state is not None: model.load() #### resume training if resume_state is not None: print('Resuming training from epoch: {}, iter: {}.'.format( resume_state['epoch'], resume_state['iter'])) start_epoch = resume_state['epoch'] current_step = resume_state['iter'] model.resume_training(resume_state) # handle optimizers and schedulers else: current_step = 0 start_epoch = 0 total_epochs = int(math.ceil(args.niter / len(train_loader))) #### training print('Start training from epoch: {:d}, iter: {:d}'.format( start_epoch, current_step)) for epoch in range(start_epoch, total_epochs + 1): for _, train_data in enumerate(train_loader): current_step += 1 if current_step > args.niter: break #### update learning rate model.update_learning_rate(current_step, warmup_iter=args.warmup_iter) #### training model.feed_data(train_data) model.optimize_parameters(current_step) #### log if current_step % args.print_freq == 0: logs = model.get_current_log() message = '<epoch:{:3d}, iter:{:8,d}, lr:{:.3e}> '.format( epoch, current_step, model.get_current_learning_rate()) for k, v in logs.items(): message += '{:s}: {:.4e} '.format(k, v) print(message) # validation if current_step % args.val_freq == 0: show_dir = os.path.join(args.checkpoint_dir, 'show_dir') os.makedirs(show_dir, exist_ok=True) dev_data = None for val_data in dev_loader: dev_data = val_data break model.feed_data(dev_data) model.test() visuals = model.get_current_visuals() display_online_results(visuals, current_step, show_dir, show_size=args.hr_size) #### save models and training states if current_step % args.save_freq == 0: print('Saving models and training states.') model.save(current_step) model.save_training_state(epoch, current_step) print('Saving the final model.') model.save('latest') print('End of training.')
def parse_args(): desc = "Pytorch implementation of GAN collections" parser = argparse.ArgumentParser(description=desc) parser.add_argument('--gan_type', type=str, default='CVAE', choices=['GAN', 'Classifier', 'CGAN', 'BEGAN', 'WGAN', 'WGAN_GP', 'VAE', "CVAE", "WGAN_GP"], help='The type of GAN') # , required=True) parser.add_argument('--dataset', type=str, default='mnist', choices=['mnist', 'fashion', 'cifar10'], help='The name of dataset') parser.add_argument('--conditional', type=bool, default=False) parser.add_argument('--upperbound', type=bool, default=False, help='This variable will be set to true automatically if task_type contains_upperbound') parser.add_argument('--method', type=str, default='Baseline', choices=['Baseline', 'Ewc', 'Ewc_samples', 'Generative_Replay', 'Rehearsal']) parser.add_argument('--context', type=str, default='Generation', choices=['Classification', 'Generation', 'Not_Incremental']) parser.add_argument('--dir', type=str, default='./Archives/', help='Working directory') parser.add_argument('--save_dir', type=str, default='models', help='Directory name to save the model') parser.add_argument('--result_dir', type=str, default='results', help='Directory name to save results') parser.add_argument('--sample_dir', type=str, default='Samples', help='Directory name to save the generated images') parser.add_argument('--log_dir', type=str, default='logs', help='Directory name to save training logs') parser.add_argument('--data_dir', type=str, default='Data', help='Directory name for data') parser.add_argument('--gen_dir', type=str, default='.', help='Directory name for data') parser.add_argument('--epochs', type=int, default=1, help='The number of epochs to run') parser.add_argument('--epoch_G', type=int, default=1, help='The number of epochs to run') parser.add_argument('--epoch_Review', type=int, default=50, help='The number of epochs to run') parser.add_argument('--batch_size', type=int, default=64, help='The size of batch') parser.add_argument('--size_epoch', type=int, default=1000) parser.add_argument('--gpu_mode', type=bool, default=True) parser.add_argument('--device', type=int, default=0) parser.add_argument('--verbose', type=bool, default=False) parser.add_argument('--lrG', type=float, default=0.0002) parser.add_argument('--lrD', type=float, default=0.0002) parser.add_argument('--lrC', type=float, default=0.01) parser.add_argument('--momentum', type=float, default=0.5, metavar='M', help='SGD momentum (default: 0.5)') parser.add_argument('--beta1', type=float, default=0.5) parser.add_argument('--beta2', type=float, default=0.999) parser.add_argument('--seed', type=int, default=1664) parser.add_argument('--eval', type=bool, default=True) parser.add_argument('--train_G', type=bool, default=False) parser.add_argument('--eval_C', type=bool, default=False) ############### UNUSED FLAGS ########################## parser.add_argument('--trainEval', type=bool, default=False) parser.add_argument('--knn', type=bool, default=False) parser.add_argument('--IS', type=bool, default=False) parser.add_argument('--FID', type=bool, default=False) parser.add_argument('--Fitting_capacity', type=bool, default=False) ####################################################### parser.add_argument('--num_task', type=int, default=10) parser.add_argument('--num_classes', type=int, default=10) parser.add_argument('--sample_transfer', type=int, default=5000) parser.add_argument('--task_type', type=str, default="disjoint", choices=['disjoint', 'permutations', 'upperbound_disjoint']) parser.add_argument('--samples_per_task', type=int, default=200) parser.add_argument('--lambda_EWC', type=int, default=5) parser.add_argument('--nb_samples_reharsal', type=int, default=10) parser.add_argument('--regenerate', type=bool, default=False) return check_args(parser.parse_args())
mpi_rank = hvd.local_rank() assert mpi_size == n_gpu training_hooks = [hvd.BroadcastGlobalVariablesHook(0)] print_rank0('GPU NUM', n_gpu) else: hvd = None mpi_size = 1 mpi_rank = 0 training_hooks = None print('GPU NUM', n_gpu) args.checkpoint_dir += ( '/epoch{}_batch{}_lr{}_warmup{}_anslen{}_tf/'.format( args.train_epochs, args.n_batch, args.lr, args.warmup_rate, args.max_ans_length)) args = utils.check_args(args, mpi_rank) print_rank0('######## generating data ########') if mpi_rank == 0: tokenizer = BertTokenizer(vocab_file=args.vocab_file, do_lower_case=True) assert args.vocab_size == len(tokenizer.vocab) if not os.path.exists(args.train_dir): json2features(args.train_file, [ args.train_dir.replace('_features_', '_examples_'), args.train_dir ], tokenizer, is_training=True) if not os.path.exists(args.dev_dir1) or not os.path.exists(
out_file = os.path.join(output, filename) torch.save(model.state_dict(), out_file) print("Best BLEU so far : {} (Epoch {})".format( best_bleu[0], best_bleu[1])) if logging: output_file = 'output_{}'.format(epoch) output_sentences = os.path.join(output, output_file) exh.write_text('\n'.join(generated_sentences), output_sentences) model.train(True) torch.set_grad_enabled(True) print("Epoch finished in {} seconds".format(time.time() - secs)) if epoch - best_bleu[1] == 3: break epoch += 1 if logging: scores['BLEU'] = bleus output_scores = os.path.join(output, 'scores.json') exh.write_json(scores, output_scores) print("Scores saved in {}".format(output_scores)) if __name__ == "__main__": args = check_args(sys.argv) run(args)
# # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # import argparse import crash_statck import memory_stack import utils if __name__=="__main__": parser = argparse.ArgumentParser(description="Analyze the android native crash stack or native memory stack") memory_stack.generate_help(parser, True); crash_statck.generate_help(parser, True); args = parser.parse_args() rs = utils.check_args(args) if rs: exit(rs) if args.alloc: rs = memory_stack.parse_memory_stack(args) else: rs = crash_statck.parse_crash_stack(args) exit(rs)