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)
