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)