def main():
utils.init_out_dir()
last_epoch = utils.get_last_checkpoint_step()
if last_epoch >= args.epoch:
exit()
if last_epoch >= 0:
my_log('\nCheckpoint found: {}\n'.format(last_epoch))
else:
utils.clear_log()
model = RNN(args.device, Number_qubits = args.N,charset_length = args.charset_length,\
hidden_size = args.hidden_size, num_layers = args.num_layers)
model.train(False)
print('number of qubits: ', model.Number_qubits)
my_log('Total nparams: {}'.format(utils.get_nparams(model)))
model.to(args.device)
params = [x for x in model.parameters() if x.requires_grad]
optimizer = torch.optim.AdamW(params,
lr=args.lr,
weight_decay=args.weight_decay)
if last_epoch >= 0:
utils.load_checkpoint(last_epoch, model, optimizer)
# Quantum state
ghz = GHZ(Number_qubits=args.N)
c_fidelity = classical_fidelity(model, ghz)
# c_fidelity = cfid(model, ghz, './data.txt')
print(c_fidelity)
if args.model not in model_dict:
print("Model not found !!!")
print("valid models are:", list(model_dict.keys()))
exit(1)
LOGDIR = 'logs/{}'.format(args.expname)
os.makedirs(LOGDIR, exist_ok=True)
os.makedirs(LOGDIR + '/models', exist_ok=True)
logger = Logger(os.path.join(LOGDIR, 'logs.log'))
model = model_dict[args.model]
model = model.to(device)
torch.save(model.state_dict(),
'{}/models/dense_net{}.pkl'.format(LOGDIR, '_0'))
model.train()
nparams = get_nparams(model)
try:
from torchsummary import summary
summary(model, input_size=(1, 640, 400))
print("Max params:", 1024 * 1024 / 4.0)
logger.write_summary(str(model.parameters))
except:
print("Torch summary not found !!!")
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,
'min',
patience=5)
criterion = CrossEntropyLoss2d()
def main():
start_time = time.time()
utils.init_out_dir()
last_epoch = utils.get_last_checkpoint_step()
if last_epoch >= args.epoch:
exit()
if last_epoch >= 0:
my_log('\nCheckpoint found: {}\n'.format(last_epoch))
else:
utils.clear_log()
utils.print_args()
model = RNN(args.device, Number_qubits = args.N,charset_length = args.charset_length,\
hidden_size = args.hidden_size, num_layers = args.num_layers)
data = prepare_data(args.N, './data.txt')
ghz = GHZ(Number_qubits=args.N)
model.train(True)
my_log('Total nparams: {}'.format(utils.get_nparams(model)))
model.to(args.device)
params = [x for x in model.parameters() if x.requires_grad]
optimizer = torch.optim.AdamW(params,
lr=args.lr,
weight_decay=args.weight_decay)
if last_epoch >= 0:
utils.load_checkpoint(last_epoch, model, optimizer)
init_time = time.time() - start_time
my_log('init_time = {:.3f}'.format(init_time))
my_log('Training...')
start_time = time.time()
best_fid = 0
trigger = 0 # once current fid is less than best fid, trigger+=1
for epoch_idx in range(last_epoch + 1, args.epoch + 1):
for batch_idx in range(int(args.Ns / args.batch_size)):
optimizer.zero_grad()
# idx = np.random.randint(low=0,high=int(args.Ns-1),size=(args.batch_size,))
idx = np.arange(args.batch_size) + batch_idx * args.batch_size
train_data = data[idx]
loss = -model.log_prob(
torch.from_numpy(train_data).to(args.device)).mean()
loss.backward()
if args.clip_grad:
clip_grad_norm_(params, args.clip_grad)
optimizer.step()
print('epoch_idx {} current loss {:.8g}'.format(
epoch_idx, loss.item()))
print('Evaluating...')
# Evaluation
current_fid = classical_fidelity(model, ghz, print_prob=False)
if current_fid > best_fid:
trigger = 0 # reset
my_log('epoch_idx {} loss {:.8g} fid {} time {:.3f}'.format(
epoch_idx, loss.item(), current_fid,
time.time() - start_time))
best_fid = current_fid
if (args.out_filename and args.save_epoch
and epoch_idx % args.save_epoch == 0):
state = {
'model': model.state_dict(),
'optimizer': optimizer.state_dict(),
}
torch.save(
state, '{}_save/{}.state'.format(args.out_filename,
epoch_idx))
else:
trigger = trigger + 1
if trigger > 4:
break
os.makedirs(LOGDIR, exist_ok=True)
os.makedirs(path2model, exist_ok=True)
os.makedirs(path2checkpoint, exist_ok=True)
os.makedirs(path2writer, exist_ok=True)
os.makedirs(path2op, exist_ok=True)
model = model_dict[args.model]
netDict = load_from_file([args.loadfile,
os.path.join(path2checkpoint, 'checkpoint.pt')])
startEp = netDict['epoch'] if 'epoch' in netDict.keys() else 0
if 'state_dict' in netDict.keys():
model.load_state_dict(netDict['state_dict'])
print('Parameters: {}'.format(get_nparams(model)))
model = model if not args.useMultiGPU else torch.nn.DataParallel(model)
model = model.to(device).to(args.prec)
f = open(os.path.join('curObjects',
'baseline',
'cond_'+str(args.curObj)+'.pkl'), 'rb')
_, _, testObj = pickle.load(f)
testObj.path2data = os.path.join(args.path2data, 'Datasets', 'All')
testObj.augFlag = False
testloader = DataLoader(testObj,
batch_size=args.batchsize,
shuffle=False,
num_workers=args.workers,
def main():
start_time = time.time()
utils.init_out_dir()
last_epoch = utils.get_last_checkpoint_step()
if last_epoch >= args.epoch:
exit()
if last_epoch >= 0:
my_log('\nCheckpoint found: {}\n'.format(last_epoch))
else:
utils.clear_log()
utils.print_args()
flow = build_mera()
flow.train(True)
my_log('nparams in each RG layer: {}'.format(
[utils.get_nparams(layer) for layer in flow.layers]))
my_log('Total nparams: {}'.format(utils.get_nparams(flow)))
# Use multiple GPUs
if args.cuda and torch.cuda.device_count() > 1:
flow = utils.data_parallel_wrap(flow)
params = [x for x in flow.parameters() if x.requires_grad]
optimizer = torch.optim.AdamW(params,
lr=args.lr,
weight_decay=args.weight_decay)
if last_epoch >= 0:
utils.load_checkpoint(last_epoch, flow, optimizer)
train_split, val_split, data_info = utils.load_dataset()
train_loader = torch.utils.data.DataLoader(train_split,
args.batch_size,
shuffle=True,
num_workers=1,
pin_memory=True)
init_time = time.time() - start_time
my_log('init_time = {:.3f}'.format(init_time))
my_log('Training...')
start_time = time.time()
for epoch_idx in range(last_epoch + 1, args.epoch + 1):
for batch_idx, (x, _) in enumerate(train_loader):
optimizer.zero_grad()
x = x.to(args.device)
x, ldj_logit = utils.logit_transform(x)
log_prob = flow.log_prob(x)
loss = -(log_prob + ldj_logit) / (args.nchannels * args.L**2)
loss_mean = loss.mean()
loss_std = loss.std()
utils.check_nan(loss_mean)
loss_mean.backward()
if args.clip_grad:
clip_grad_norm_(params, args.clip_grad)
optimizer.step()
if args.print_step and batch_idx % args.print_step == 0:
bit_per_dim = (loss_mean.item() + log(256)) / log(2)
my_log(
'epoch {} batch {} bpp {:.8g} loss {:.8g} +- {:.8g} time {:.3f}'
.format(
epoch_idx,
batch_idx,
bit_per_dim,
loss_mean.item(),
loss_std.item(),
time.time() - start_time,
))
if (args.out_filename and args.save_epoch
and epoch_idx % args.save_epoch == 0):
state = {
'flow': flow.state_dict(),
'optimizer': optimizer.state_dict(),
}
torch.save(state,
'{}_save/{}.state'.format(args.out_filename, epoch_idx))
if epoch_idx > 0 and (epoch_idx - 1) % args.keep_epoch != 0:
os.remove('{}_save/{}.state'.format(args.out_filename,
epoch_idx - 1))
if (args.plot_filename and args.plot_epoch
and epoch_idx % args.plot_epoch == 0):
with torch.no_grad():
do_plot(flow, epoch_idx)