def eval_dataset_mp(args): (dataset_path, width, softmax_temp, opts, i, num_processes) = args model, _ = load_model(opts.model) val_size = opts.val_size // num_processes dataset = model.problem.make_dataset(filename=dataset_path, num_samples=val_size, offset=opts.offset + val_size * i) device = torch.device("cuda:{}".format(i)) return _eval_dataset(model, dataset, width, softmax_temp, opts, device)
def __init__(self, timer_flag=False): torch.set_grad_enabled(False) net = FaceBoxesNet(phase='test', size=None, num_classes=2) # initialize detector self.net = load_model(net, pretrained_path=pretrained_path, load_to_cpu=True) self.net.eval() # print('Finished loading model!') self.timer_flag = timer_flag
def eval_dataset(dataset_path, width, softmax_temp, opts): # Even with multiprocessing, we load the model here since it contains the name where to write results model, _ = load_model(opts.model) use_cuda = torch.cuda.is_available() and not opts.no_cuda if opts.multiprocessing: assert use_cuda, "Can only do multiprocessing with cuda" num_processes = torch.cuda.device_count() assert opts.val_size % num_processes == 0 with mp.Pool(num_processes) as pool: results = list(itertools.chain.from_iterable(pool.map( eval_dataset_mp, [(dataset_path, width, softmax_temp, opts, i, num_processes) for i in range(num_processes)] ))) else: device = torch.device("cuda:0" if use_cuda else "cpu") dataset = model.problem.make_dataset(filename=dataset_path, num_samples=opts.val_size, offset=opts.offset) results = _eval_dataset(model, dataset, width, softmax_temp, opts, device) # This is parallelism, even if we use multiprocessing (we report as if we did not use multiprocessing, e.g. 1 GPU) parallelism = opts.eval_batch_size costs, tours, durations = zip(*results) # Not really costs since they should be negative print("Average cost: {} +- {}".format(np.mean(costs), 2 * np.std(costs) / np.sqrt(len(costs)))) print("Average serial duration: {} +- {}".format( np.mean(durations), 2 * np.std(durations) / np.sqrt(len(durations)))) print("Average parallel duration: {}".format(np.mean(durations) / parallelism)) print("Calculated total duration: {}".format(timedelta(seconds=int(np.sum(durations) / parallelism)))) dataset_basename, ext = os.path.splitext(os.path.split(dataset_path)[-1]) model_name = "_".join(os.path.normpath(os.path.splitext(opts.model)[0]).split(os.sep)[-2:]) if opts.o is None: results_dir = os.path.join(opts.results_dir, model.problem.NAME, dataset_basename) os.makedirs(results_dir, exist_ok=True) out_file = os.path.join(results_dir, "{}-{}-{}{}-t{}-{}-{}{}".format( dataset_basename, model_name, opts.decode_strategy, width if opts.decode_strategy != 'greedy' else '', softmax_temp, opts.offset, opts.offset + len(costs), ext )) else: out_file = opts.o assert opts.f or not os.path.isfile( out_file), "File already exists! Try running with -f option to overwrite." save_dataset((results, parallelism), out_file) return costs, tours, durations
def eval_dataset(dataset_path, opts): model = load_model(opts.model) use_cuda = torch.cuda.is_available() and opts.no_cuda device = torch.device('cuda:0' if use_cuda else 'cpu') dataset = model.problem.make_dataset(filename=dataset_path, num_samples=opts.val_size, offset=opts.offset) results = _eval_dataset(model, dataset, opts, device) parallelism = opts.eval_batch_size costs, tours, durations = zip( *results) # Not really costs since they should be negative print("Average cost: {} +- {}".format( np.mean(costs), 2 * np.std(costs) / np.sqrt(len(costs)))) print("Average serial duration: {} +- {}".format( np.mean(durations), 2 * np.std(durations) / np.sqrt(len(durations)))) print("Average parallel duration: {}".format( np.mean(durations) / parallelism)) print("Calculated total duration: {}".format( timedelta(seconds=int(np.sum(durations) / parallelism)))) dataset_basename, ext = os.path.splitext(os.path.split(dataset_path)[-1]) model_name = "_".join( os.path.normpath(os.path.splitext(opts.model)[0]).split(os.sep)[-2:]) if opts.o is None: results_dir = os.path.join(opts.results_dir, model.problem.NAME, dataset_basename) os.makedirs(results_dir, exist_ok=True) out_file = os.path.join( results_dir, "{}-{}-{}-{}-{}{}".format(dataset_basename, model_name, opts.decode_strategy, opts.offset, opts.offset + len(costs), ext)) else: out_file = opts.o save_dataset((results, parallelism), out_file) return costs, tours, durations
def run(opts): # Pretty print the run args pp.pprint(vars(opts)) # Set the random seed torch.manual_seed(opts.seed) # Set the device opts.device = torch.device("cuda:0" if opts.use_cuda else "cpu") # Choose the dataset to use data_class = load_data_class(opts.dataset) # Load data from load_path data = data_class(root=opts.datadir, network=opts.network)[0] # Preprocess node features if opts.no_features: print('node ids used') data.x = torch.eye(data.num_nodes).to(opts.device) data = data.to(opts.device) model_class = load_model(opts) assert opts.problem in [ 'Prediction', 'Imputation', 'Imputation_eval' ], 'only support prediction or imputation of expression values' print(data) if opts.problem == 'Prediction': if not opts.embedding: supervised_prediction_eval(model_class, data, opts) else: embedding_prediction_eval(model_class, data, opts) elif opts.problem == 'Imputation_eval': imputation_eval(model_class, data, opts) elif opts.problem == 'Imputation': imputed = impute(model_class, data, opts) np.save(opts.model + opts.network + '_imputed.npy', imputed.cpu().detach().numpy())
valid_loader = AudioDataLoader(valid_data, num_workers=args.num_workers, batch_size=args.batch_size) valid_loader_list.append(valid_loader) for i in range(len(args.test_manifest_list)): test_data = SpectrogramDataset(audio_conf, manifest_filepath_list=[args.test_manifest_list[i]], label2id=label2id, normalize=True, augment=False) test_loader = AudioDataLoader(test_data, num_workers=args.num_workers) test_loader_list.append(test_loader) start_epoch = 0 metrics = None loaded_args = None print(constant.args.continue_from) if constant.args.continue_from != "": logging.info("Continue from checkpoint: " + constant.args.continue_from) model, opt, epoch, metrics, loaded_args, label2id, id2label = load_model( constant.args.continue_from) start_epoch = epoch # index starts from zero verbose = constant.args.verbose if loaded_args != None: # Unwrap nn.DataParallel if loaded_args.parallel: logging.info("unwrap from DataParallel") model = model.module # Parallelize the batch if args.parallel: model = nn.DataParallel(model, device_ids=args.device_ids) else: if constant.args.model == "TRFS": model = init_transformer_model(constant.args, label2id, id2label)
parser.add_argument('--input_dir', help='input image dir', required=True) parser.add_argument('--input_name', help='input image name', required=True) parser.add_argument('--mode', help='task to be done', default='transfer') parser.add_argument('--start_scale', help='injection scale', type=int, default='0') opt = parser.parse_args() opt = functions.post_config(opt) Gs = [] Zs = [] reals = [] NoiseAmp = [] Gs2 = [] dir2save = functions.generate_dir2save(opt) if dir2save is None: print('task does not exist') else: try: os.makedirs(dir2save) except OSError: pass real_in = functions.read_image(opt) functions.adjust_scales2image(real_in, opt) real_ = functions.read_image(opt) real = imresize(real_, opt.scale1, opt) reals = functions.creat_reals_pyramid(real, reals, opt) Gs, Zs, NoiseAmp, Gs2 = functions.load_model(opt) TuiGAN_transfer(Gs, Zs, reals, NoiseAmp, Gs2, opt)
valid_loader_list, test_loader_list = [], [] for i in range(len(args.valid_manifest_list)): if args.feat == "spectrogram": valid_data = SpectrogramDataset(vocab, args, audio_conf, manifest_filepath_list=[args.valid_manifest_list[i]], normalize=True, augment=args.augment, input_type=args.input_type) elif args.feat == "logfbank": valid_data = LogFBankDataset(vocab, args, audio_conf, manifest_filepath_list=[args.valid_manifest_list[i]], normalize=True, augment=False, input_type=args.input_type) valid_sampler = BucketingSampler(valid_data, batch_size=args.batch_size) valid_loader = AudioDataLoader(pad_token_id=0, dataset=valid_data, num_workers=args.num_workers) valid_loader_list.append(valid_loader) start_epoch = 0 metrics = None loaded_args = None if args.continue_from != "": logging.info("Continue from checkpoint:" + args.continue_from) model, vocab, opt, epoch, metrics, loaded_args = load_model(args.continue_from) start_epoch = (epoch) # index starts from zero verbose = args.verbose else: if args.model == "TRFS": model = init_transformer_model(args, vocab, is_factorized=args.is_factorized, r=args.r) opt = init_optimizer(args, model, "noam") else: logging.info("The model is not supported, check args --h") loss_type = args.loss if USE_CUDA: model = model.cuda() logging.info(model)
if not os.path.exists(model_dir): os.makedirs(model_dir, exist_ok=True) elif args['force']: print(f'overwriting model directory `{model_dir}`') else: raise Exception(f'model directory `{model_dir}` already exists, use --force if you want to overwrite the folder') # Set random seed set_seed(args['seed']) # Added here for reproductibility w2i, i2w = args['dataset_class'].LABEL2INDEX, args['dataset_class'].INDEX2LABEL metrics_scores = [] result_dfs = [] for i in range(args['k_fold']): # load model model, tokenizer, vocab_path, config_path = load_model(args) optimizer = optim.Adam(model.parameters(), lr=args['lr']) if args['fp16']: from apex import amp # Apex is only required if we use fp16 training model, optimizer = amp.initialize(model, optimizer, opt_level=args['fp16']) if args['device'] == "cuda": model = model.cuda() print("=========== FOLD-" + str(i+1) + " ===========") train_dataset_path = args['train_set_path'].format(i) train_dataset = args['dataset_class'](train_dataset_path, tokenizer, lowercase=args["lower"], no_special_token=args['no_special_token']) train_loader = args['dataloader_class'](dataset=train_dataset, max_seq_len=args['max_seq_len'], batch_size=args['train_batch_size'], num_workers=16, shuffle=False)
torch.backends.cudnn.benchmark = True torch.backends.cudnn.enabled = True discriminator = discriminator.to(device) generator = generator.to(device) if multi_gpu: generator = torch.nn.DataParallel(generator) discriminator = torch.nn.DataParallel(discriminator) if chkpdir and chkpname_dis and chkpname_gen: # load state of networks state_gen = load_model(chkpdir, chkpname_gen) state_dis = load_model(chkpdir, chkpname_dis) # load generator #generator = generator.to(device) if multi_gpu: #generator = DataParallel(generator) generator = generator.cuda() generator.load_state_dict(state_gen['model']) #generator = generator.to(device) optimizer_G.load_state_dict(state_gen['optimizer']) # load discriminator #discriminator = discriminator.to(device) if multi_gpu: #discriminator = DataParallel(discriminator)