def main(size, k, steps, output_path): # utils.random_seed(2**7) utils.random_seed(2**10) size = size, size camera = Camera(vector(0, 0, -1)) objects = ObjectList(randomize_objects()) with Pool(os.cpu_count()) as pool: image = pool.imap( partial( render_row, size=size, camera=camera, objects=objects, k=k, max_steps=steps, ), range(size[0]), ) image = list(tqdm(image, total=size[0])) image = torch.stack(image, 1) image = image.clamp(0, 1) image = image.flip(1) image = to_pil_image(image) os.makedirs(output_path, exist_ok=True) image.save( os.path.join(output_path, "{}_{}_{}.png".format(size[0], k, steps))) plt.imshow(image) plt.show()
def train(pretext_model="Pretext_1593000476"): # Reproducibility를 위한 모든 random seed 고정 random_seed() arg_parser = argparse.ArgumentParser() arg_parser.add_argument("--epochs", type=int, default=110) arg_parser.add_argument("--lr", type=float, default=0.001) arg_parser.add_argument("--batch_size", type=int, default=8) arg_parser.add_argument("--num_instances", type=int, default=16) arg_parser.add_argument("--pretrained_weight", type=str, default=f"results/train/weights/{pretext_model}.pt") args = arg_parser.parse_args() train_meta = pd.read_csv("/datasets/objstrgzip/03_face_verification_angle/train/train_meta.csv") num_classes = len(set(train_meta["face_id"].values)) # 모델 로드 model = Triarchy(args, num_classes, train=True) # Train dataset의 표정 및 camera angle을 학습하도록 한 pretext model 가중치 로드 pretrained_weight = torch.load(args.pretrained_weight) pretrained_weight.pop("fc.weight") pretrained_weight.pop("fc.bias") model.load_state_dict(pretrained_weight, strict=False) # Trainer 인스턴스 생성 및 학습 trainer = Trainer(model, args) trainer.train() return trainer.model_name
def get_vae(vae_type: str, device, seed=defaults.seed, **kwargs): assert vae_type.lower() in ['b', 'h'] #'h' for original vae use_cuda = False if device == 'cpu' else True random_seed(seed, use_cuda) model = BetaVAE_H(**kwargs) if vae_type is 'h' else BetaVAE_B(**kwargs) model.name = f'{get_cls_name(model)}_seed:{seed}' model = model.to(device) return model
def render_row(i, size, camera: Camera, objects: ObjectList, k, max_steps): utils.random_seed(i) row = torch.zeros(3, size[1], dtype=torch.float) for j in range(size[1]): for _ in range(k): y = (i + random.random()) / size[0] x = (j + random.random()) / size[1] ray = camera.ray_to_position(x, y) row[:, j] += ray_trace(ray, objects, max_steps=max_steps) row[:, j] /= k return row
def make_env(name): env = gym.make(name) env = gym.wrappers.Monitor(env, 'videos/', force=True, video_callable=lambda e: False) env.seed(utils.random_seed()) return env
def main(config_path, **kwargs): config = load_config(config_path, **kwargs) del kwargs random_seed(config.seed) eval_transform = build_transforms(config) eval_dataset = Dataset2020Test(os.path.join(config.dataset_path, "2020"), transform=eval_transform) eval_data_loader = torch.utils.data.DataLoader( eval_dataset, batch_size=config.eval.batch_size // 2, shuffle=False, drop_last=False, num_workers=config.workers, ) all_logits = Concat(1) for fold in range(1, FOLDS + 1): model = Model(config.model).to(DEVICE) saver = Saver({ "model": model, }) restore_path = os.path.join(config.experiment_path, "F{}".format(fold), "checkpoint_best.pth") saver.load(restore_path, keys=["model"]) logits, all_ids = predict_fold(model, eval_data_loader, fold=fold) all_logits.update(logits.cpu()) all_logits = all_logits.compute() print(all_logits.shape) all_probs = all_logits.sigmoid().mean(1) print(all_probs.shape, len(all_ids)) submission = pd.DataFrame({ "image_name": all_ids, "target": all_probs.data.cpu().numpy(), }).set_index("image_name") submission.to_csv(os.path.join(config.experiment_path, "submission.csv"))
def make_atari_env(name, history_len): from gym.envs.atari.atari_env import AtariEnv from gym.wrappers.monitor import Monitor env = AtariEnv(game=name, frameskip=4, obs_type='image') env = Monitor(env, 'videos/', force=True, video_callable=lambda e: False) env = wrappers.wrap_deepmind(env) env = wrappers.HistoryWrapper(env, history_len) env.seed(utils.random_seed()) return env
def main(args): random_seed(args.seed) if torch.cuda.is_available(): if not args.cuda: print( "WARNING: You have a CUDA device, so you should probably run with --cuda") args.device = torch.device("cuda" if args.cuda else "cpu") most_common_first_words = get_popular_first_words(args) tokenizer = AutoTokenizer.from_pretrained(args.model_path) model = AutoModelWithLMHead.from_pretrained(args.model_path, pad_token_id=tokenizer.eos_token_id ).to(args.device) model.eval() print('loaded model') soft = torch.nn.Softmax(0) generated_strings = list() for word_id, word in tqdm.tqdm(enumerate(most_common_first_words)): input_ids = tokenizer.encode(word, return_tensors='pt') input_ids = input_ids.repeat( args.sentences_per_unique_start, 1).to( args.device) output = model.generate( input_ids, do_sample=args.do_sample, max_length=args.max_length, min_length=args.min_length, top_k=args.top_k, top_p=args.top_p, repetition_penalty=args.repetition_penalty, temperature=args.temperature, ) utt = [tokenizer.decode(i, skip_special_tokens=True) for i in output] generated_strings.extend(utt) json.dump(generated_strings, Path(args.out_path).open('w'))
def main_worker(gpu, args, result_dir): torch.backends.cudnn.benchmark = True random_seed(args.seed) torch.cuda.set_device(gpu) train_dataset, test_dataset, train_loader, test_loader = parse_dataset( args.dataset, args.batch_size) model = parse_model(args.model, train_dataset) model = model.cuda(gpu) print('number of prarmeters:', sum([p.numel() for p in model.parameters()])) optimizer = parse_algo(args.algo, model, wd=args.wd, lr=args.lr, momentum=args.momentum, gamma=args.gamma, b0=args.b0) loss = parse_loss(args.loss) epochs = parse_epochs(args.epochs) logger = Logger(os.path.join(result_dir, 'log.txt')) for arg in vars(args): logger.print(arg, '=', getattr(args, arg)) train_logger = TableLogger(os.path.join(result_dir, 'train.log'), ['epoch', 'loss', 'acc']) test_logger = TableLogger(os.path.join(result_dir, 'test.log'), ['epoch', 'loss', 'acc']) for epoch in range(0, epochs[-1]): adjust_lr(args.lr, args.gamma, epochs, epoch, optimizer) train(model, loss, epoch, train_loader, optimizer, logger, train_logger, gpu, args.print_freq) if test_dataset is not None: test(model, loss, epoch, test_loader, logger, test_logger, gpu, args.print_freq)
def main_worker(gpu, parallel, args, result_dir): if parallel: args.rank = args.rank + gpu torch.distributed.init_process_group(backend='nccl', init_method=args.dist_url, world_size=args.world_size, rank=args.rank) torch.backends.cudnn.benchmark = True random_seed(args.seed + args.rank) # make data aug different for different processes torch.cuda.set_device(gpu) assert args.batch_size % args.world_size == 0 from dataset import load_data, get_statistics, default_eps, input_dim train_loader, test_loader = load_data(args.dataset, 'data/', args.batch_size // args.world_size, parallel, augmentation=True, classes=None) mean, std = get_statistics(args.dataset) num_classes = len(train_loader.dataset.classes) from model.bound_module import Predictor, BoundFinalIdentity from model.mlp import MLPFeature, MLP from model.conv import ConvFeature, Conv model_name, params = parse_function_call(args.model) if args.predictor_hidden_size > 0: model = locals()[model_name](input_dim=input_dim[args.dataset], **params) predictor = Predictor(model.out_features, args.predictor_hidden_size, num_classes) else: model = locals()[model_name](input_dim=input_dim[args.dataset], num_classes=num_classes, **params) predictor = BoundFinalIdentity() model = Model(model, predictor, eps=0) model = model.cuda(gpu) if parallel: model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[gpu]) loss_name, params = parse_function_call(args.loss) loss = Loss(globals()[loss_name](**params), args.kappa) output_flag = not parallel or gpu == 0 if output_flag: logger = Logger(os.path.join(result_dir, 'log.txt')) for arg in vars(args): logger.print(arg, '=', getattr(args, arg)) logger.print(train_loader.dataset.transform) logger.print(model) logger.print('number of params: ', sum([p.numel() for p in model.parameters()])) logger.print('Using loss', loss) train_logger = TableLogger(os.path.join(result_dir, 'train.log'), ['epoch', 'loss', 'acc']) test_logger = TableLogger(os.path.join(result_dir, 'test.log'), ['epoch', 'loss', 'acc']) else: logger = train_logger = test_logger = None optimizer = AdamW(model, lr=args.lr, weight_decay=args.wd, betas=(args.beta1, args.beta2), eps=args.epsilon) if args.checkpoint: assert os.path.isfile(args.checkpoint) if parallel: torch.distributed.barrier() checkpoint = torch.load( args.checkpoint, map_location=lambda storage, loc: storage.cuda(gpu)) state_dict = checkpoint['state_dict'] if next(iter(state_dict))[0:7] == 'module.' and not parallel: new_state_dict = OrderedDict([(k[7:], v) for k, v in state_dict.items()]) state_dict = new_state_dict elif next(iter(state_dict))[0:7] != 'module.' and parallel: new_state_dict = OrderedDict([('module.' + k, v) for k, v in state_dict.items()]) state_dict = new_state_dict model.load_state_dict(state_dict) optimizer.load_state_dict(checkpoint['optimizer']) print("=> loaded '{}'".format(args.checkpoint)) if parallel: torch.distributed.barrier() if args.eps_test is None: args.eps_test = default_eps[args.dataset] if args.eps_train is None: args.eps_train = args.eps_test args.eps_train /= std args.eps_test /= std up = torch.FloatTensor((1 - mean) / std).view(-1, 1, 1).cuda(gpu) down = torch.FloatTensor((0 - mean) / std).view(-1, 1, 1).cuda(gpu) attacker = AttackPGD(model, args.eps_test, step_size=args.eps_test / 4, num_steps=20, up=up, down=down) args.epochs = [int(epoch) for epoch in args.epochs.split(',')] schedule = create_schedule(args, len(train_loader), model, loss, optimizer) if args.visualize and output_flag: from torch.utils.tensorboard import SummaryWriter writer = SummaryWriter(result_dir) else: writer = None for epoch in range(args.start_epoch, args.epochs[-1]): if parallel: train_loader.sampler.set_epoch(epoch) train_loss, train_acc = train(model, loss, epoch, train_loader, optimizer, schedule, logger, train_logger, gpu, parallel, args.print_freq) test_loss, test_acc = test(model, loss, epoch, test_loader, logger, test_logger, gpu, parallel, args.print_freq) if writer is not None: writer.add_scalar('curve/p', get_p_norm(model), epoch) writer.add_scalar('curve/train loss', train_loss, epoch) writer.add_scalar('curve/test loss', test_loss, epoch) writer.add_scalar('curve/train acc', train_acc, epoch) writer.add_scalar('curve/test acc', test_acc, epoch) if epoch % 50 == 49: if logger is not None: logger.print( 'Generate adversarial examples on training dataset and test dataset (fast, inaccurate)' ) robust_train_acc = gen_adv_examples(model, attacker, train_loader, gpu, parallel, logger, fast=True) robust_test_acc = gen_adv_examples(model, attacker, test_loader, gpu, parallel, logger, fast=True) if writer is not None: writer.add_scalar('curve/robust train acc', robust_train_acc, epoch) writer.add_scalar('curve/robust test acc', robust_test_acc, epoch) if epoch % 5 == 4: certified_acc = certified_test(model, args.eps_test, up, down, epoch, test_loader, logger, gpu, parallel) if writer is not None: writer.add_scalar('curve/certified acc', certified_acc, epoch) if epoch > args.epochs[-1] - 3: if logger is not None: logger.print("Generate adversarial examples on test dataset") gen_adv_examples(model, attacker, test_loader, gpu, parallel, logger) certified_test(model, args.eps_test, up, down, epoch, test_loader, logger, gpu, parallel) schedule(args.epochs[-1], 0) if output_flag: logger.print( "Calculate certified accuracy on training dataset and test dataset" ) certified_test(model, args.eps_test, up, down, args.epochs[-1], train_loader, logger, gpu, parallel) certified_test(model, args.eps_test, up, down, args.epochs[-1], test_loader, logger, gpu, parallel) if output_flag: torch.save( { 'state_dict': model.state_dict(), 'optimizer': optimizer.state_dict(), }, os.path.join(result_dir, 'model.pth')) if writer is not None: writer.close()
tokenizer=tokenizer, train_examples=train_examples, dev_examples=dev_examples, pattern=config.pattern, train_enhancement=augment_examples if config.data_augment else None, test_examples=None) logging.info("dev_evaluate: {}".format(dev_evaluate)) if config.pattern == 'full_train': model_save(config, model_example) return dev_evaluate if __name__ == '__main__': config = RobertaPairConfig() random_seed(config.seed) logging_filename = None if config.is_logging2file is True: file = time.strftime('%Y-%m-%d_%H-%M-%S') + '.log' logging_filename = os.path.join(config.logging_dir, file) if not os.path.exists(config.logging_dir): os.makedirs(config.logging_dir) logging.basicConfig(filename=logging_filename, format='%(levelname)s: %(message)s', level=logging.INFO) roberta_pair_task(config)
if __name__ == '__main__': arguments = docopt(__doc__, version='0.1.1rc') max_steps = humanfriendly.parse_size(arguments['--max_steps']) modes = {0: arguments['--left'], 1: arguments['--right']} trainall = arguments['--trainall'] agents = {0: arguments['<left>'], 1: arguments['<right>']} names = {0: arguments['--left_name'], 1: arguments['--right_name']} game = arguments['<game>'] animation = arguments['--animation'] numplots = int(arguments['--numplots']) seed = int(arguments['--seed']) verbose = arguments['--verbose'] utils.random_seed(seed) if trainall: modes[0] = modes[1] = True G = create_game(game, max_steps) def done(*args): if args and len(args): print('Caught signal {}'.format(args[0])) G.done() os.makedirs('data/', exist_ok=True) for j in range(2): if modes[j]: save_agent( G.players[j],
def main(**kwargs): config = C( random_seed=42, learning_rate=1e-4, horizon=32, discount=0.99, num_episodes=100000, num_workers=32, entropy_weight=1e-2, log_interval=100, ) for k in kwargs: config[k] = kwargs[k] utils.random_seed(config.random_seed) writer = SummaryWriter(config.experiment_path) # build env env = VecEnv([build_env for _ in range(config.num_workers)]) env = wrappers.TensorboardBatchMonitor(env, writer, log_interval=config.log_interval, fps_mul=0.5) env = wrappers.Torch(env) # build agent and optimizer agent = Agent(env.observation_space, env.action_space) optimizer = torch.optim.Adam(agent.parameters(), config.learning_rate * config.num_workers, betas=(0.0, 0.999)) # train metrics = { "episode/return": Stack(), "episode/length": Stack(), "rollout/reward": Stack(), "rollout/value_target": Stack(), "rollout/value": Stack(), "rollout/td_error": Stack(), "rollout/entropy": Stack(), "rollout/actor_loss": Stack(), "rollout/critic_loss": Stack(), "rollout/loss": Stack(), } episode = 0 opt_step = 0 pbar = tqdm(total=config.num_episodes) env.seed(config.random_seed) obs = env.reset() action = torch.zeros(config.num_workers, dtype=torch.int) memory = agent.zero_memory(config.num_workers) while episode < config.num_episodes: memory = tuple(x.detach() for x in memory) history = collect_rollout() rollout = history.build() _, value_prime, _ = agent(obs_prime, action, memory_prime) # value_target = utils.n_step_bootstrapped_return( # reward_t=rollout.reward, # done_t=rollout.done, # value_prime=value_prime.detach(), # gamma=config.discount, # ) value_target = utils.generalized_advantage_estimation( reward_t=rollout.reward, value_t=rollout.value.detach(), value_prime=value_prime.detach(), done_t=rollout.done, gamma=config.discount, lambda_=0.96, ) value_target += rollout.value.detach() td_error = value_target - rollout.value critic_loss = td_error.pow(2) actor_loss = (-rollout.log_prob * td_error.detach() - config.entropy_weight * rollout.entropy) loss = actor_loss + 0.5 * critic_loss optimizer.zero_grad() loss.sum(1).mean().backward() # nn.utils.clip_grad_norm_(agent.parameters(), 0.01) optimizer.step() opt_step += 1 metrics["rollout/reward"].update(rollout.reward.detach()) metrics["rollout/value"].update(rollout.value.detach()) metrics["rollout/value_target"].update(value_target.detach()) metrics["rollout/td_error"].update(td_error.detach()) metrics["rollout/entropy"].update(rollout.entropy.detach()) metrics["rollout/actor_loss"].update(actor_loss.detach()) metrics["rollout/critic_loss"].update(critic_loss.detach()) metrics["rollout/loss"].update(loss.detach()) if opt_step % 10 == 0: # td_error_std_normalized = td_error.std() / value_target.std() print("log rollout") total_norm = torch.norm( torch.stack([ torch.norm(p.grad.detach(), 2.0) for p in agent.parameters() ]), 2.0) writer.add_scalar(f"rollout/grad_norm", total_norm, global_step=episode) for k in [ "rollout/reward", "rollout/value_target", "rollout/value", "rollout/td_error", ]: v = metrics[k].compute_and_reset() writer.add_scalar(f"{k}/mean", v.mean(), global_step=episode) writer.add_histogram(f"{k}/hist", v, global_step=episode) for k in [ "rollout/entropy", "rollout/actor_loss", "rollout/critic_loss", "rollout/loss", ]: v = metrics[k].compute_and_reset() writer.add_scalar(f"{k}/mean", v.mean(), global_step=episode) writer.flush() # writer.add_scalar( # "rollout/td_error_std_normalized", td_error_std_normalized, global_step=episode # ) # writer.add_histogram("rollout/reward", rollout.reward, global_step=episode) env.close() writer.close()
requirements = { '--bptt': Use(int), '--batch-size': Use(int), '--embed': Use(int), '--hidden': Use(int), '--lr': Use(float), '--epoch': Use(int), '--clip': Use(float), '--device': Or(None, Use(int)), '--seed': Use(int), object: object, } args = Schema(requirements).validate(args) seed = args['--seed'] random_seed(seed) root = args['--root'] bptt = args['--bptt'] batch_size = args['--batch-size'] train_loader, valid_loader, test_loader, num_labels = prepare_data( root, bptt, batch_size) num_embeds = args['--embed'] num_hidden = args['--hidden'] lr = args['--lr'] model, criterion, optimizer = prepare_model(num_labels, num_embeds, num_hidden, lr) num_epochs = args['--epoch'] clip = args['--clip']
parser.add_argument('--seed', type=int, default=42) args = parser.parse_args() return args def main(args): if args.distribution_type == 'gauss': mu = torch.ones(args.dim) sigma = torch.randn(args.dim, args.dim) sigma = torch.mm(sigma, sigma.t()) sigma.add_(torch.eye(args.dim)) potential = GaussPotential(mu, sigma) trajs, potential_grads = [], [] for _ in trange(args.n_trajs): traj, pot_grad = RWM(potential, args.gamma, args.n_burn, args.n_sample) trajs.append(traj) potential_grads.append(pot_grad) trajs = torch.stack(trajs, dim=0) potential_grads = torch.stack(potential_grads, dim=0) Path(args.save_path).parent.mkdir(exist_ok=True, parents=True) pickle.dump([trajs, potential_grads], Path(args.save_path).open('wb')) if __name__ == '__main__': args = parse_arguments() random_seed(args.seed) main(args)
if __name__ == '__main__': arguments = docopt(__doc__, version='0.1.1rc') max_steps = humanfriendly.parse_size(arguments['--max_steps']) modes = {0: arguments['--left'], 1: arguments['--right']} trainall = arguments['--trainall'] agents = {0: arguments['<left>'], 1: arguments['<right>']} names = {0: arguments['--left_name'], 1: arguments['--right_name']} game = arguments['<game>'] animation = arguments['--animation'] numplots = int(arguments['--numplots']) seed = int(arguments['--seed']) verbose = arguments['--verbose'] utils.random_seed(seed) if trainall: modes[0] = modes[1] = True G = create_game(game, max_steps) def done(*args): if args and len(args): print('Caught signal {}'.format(args[0])) G.done() os.makedirs('data/', exist_ok=True) for j in range(2): if modes[j]: save_agent(G.players[j], 'data/{}.pickle'.format(G.players[j].full_name(G)))
# log_scale = np.logspace(1,0,num = 10)/10 log_scale = range(0,500,50) for i in log_scale: NovelThresh = i print(i) max_steps = i # title = '' + str(Epsilon) + str(NovelThresh) + str(NovelCoeff) title = 'RandomAcion2' for run in range(num_runs): # initialize all the values for each run grid.env_init() agent.agent_init(Epsilon,NovelCoeff,NovelThresh) print('Run:', run) # random.seed() # This line makes true random action selection. utils.random_seed(run) # TODO: Make a way for the figures to be stored over multiple runs. for episode in range(num_episodes): ''' Initialize for each episode ''' im_diff = [0] is_terminal = False start_state = grid.env_start() l_action = agent.agent_start(start_state) step_count = 0 # print('Episode:', episode) average_reward_per_episode = 0 prev_mean_val = 0 while not is_terminal:
import os import torch import random import json from torchtext import data from config import configs from utils import random_seed import re pattern = re.compile( r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+', re.S) _ = random_seed(configs['seed']) tokenizer = configs['tokenizer'] pad_index = configs['pad_index'] root_path = configs['root_path'] pretrained_weights = configs['pretrained_weights'] data_size = configs['data_size'] def DataSelection(input_file, output_file): w = open(output_file, "w") w_c, r_c = 0, 0 for line in open(input_file, "r"): r_c += 1 line_dict = json.loads(line) if (line_dict["is_answerable"] == 1) and (line_dict["questionType"] == "descriptive") and \ (len(line_dict["review_snippets"]) == 10): new_q = pattern.sub("", line_dict["questionText"]) if len(new_q.split(" ")) <= 2: continue line_dict["questionText"] = new_q
Copyright (c) 2020 Palo Alto Networks """ import os import utils import mnist import numpy as np from progress.bar import Bar from PIL import Image, ImageDraw from random import randint, uniform, seed from sklearn.metrics import accuracy_score from sklearn.ensemble import RandomForestClassifier from sklearn.model_selection import train_test_split from scipy.ndimage import median_filter, gaussian_filter, binary_dilation seed(utils.random_seed()) np.random.seed(utils.random_seed()) if not os.path.isdir("data"): os.mkdir("data") # Size of validation and test sets VAL_SIZE = 10000 TEST_SIZE = 10000 # Number of training, validation, test noise images to add N_TRAIN_NOISE_IMAGES = 50000 N_VAL_NOISE_IMAGES = 10000 N_TEST_NOISE_IMAGES = 10000 # Minimum confidence of the RF used during stroke noise generation RF_CONF = 0.3
def main(config_path, **kwargs): config = load_config(config_path, **kwargs) del kwargs random_seed(config.seed) box_coder = BoxCoder(config.model.levels) train_transform = T.Compose([ Resize(config.resize_size), RandomCrop(config.crop_size), RandomFlipLeftRight(), ApplyTo( "image", T.Compose([ T.ColorJitter(brightness=0.3, contrast=0.3, saturation=0.3), T.ToTensor(), T.Normalize(mean=MEAN, std=STD), ]), ), FilterBoxes(), BuildTargets(box_coder), ]) eval_transform = T.Compose([ Resize(config.resize_size), RandomCrop(config.crop_size), ApplyTo( "image", T.Compose([ T.ToTensor(), T.Normalize(mean=MEAN, std=STD), ]), ), FilterBoxes(), BuildTargets(box_coder), ]) if config.dataset == "coco": Dataset = CocoDataset else: raise AssertionError("invalid config.dataset {}".format( config.dataset)) train_dataset = Dataset(config.dataset_path, subset="train", transform=train_transform) eval_dataset = Dataset(config.dataset_path, subset="eval", transform=eval_transform) class_names = train_dataset.class_names train_data_loader = torch.utils.data.DataLoader( train_dataset, batch_size=config.train.batch_size, drop_last=True, shuffle=True, num_workers=config.workers, collate_fn=collate_fn, worker_init_fn=worker_init_fn, ) if config.train_steps is not None: train_data_loader = DataLoaderSlice(train_data_loader, config.train_steps) eval_data_loader = torch.utils.data.DataLoader( eval_dataset, batch_size=config.eval.batch_size, drop_last=False, shuffle=True, num_workers=config.workers, collate_fn=collate_fn, worker_init_fn=worker_init_fn, ) model = FCOS(config.model, num_classes=Dataset.num_classes) if config.model.freeze_bn: model = BatchNormFreeze(model) model = model.to(DEVICE) optimizer = build_optimizer(model.parameters(), config) saver = Saver({"model": model, "optimizer": optimizer}) start_epoch = 0 if config.restore_path is not None: saver.load(config.restore_path, keys=["model"]) if os.path.exists(os.path.join(config.experiment_path, "checkpoint.pth")): start_epoch = saver.load( os.path.join(config.experiment_path, "checkpoint.pth")) scheduler = build_scheduler(optimizer, config, len(train_data_loader), start_epoch) for epoch in range(start_epoch, config.train.epochs): train_epoch( model=model, optimizer=optimizer, scheduler=scheduler, data_loader=train_data_loader, box_coder=box_coder, class_names=class_names, epoch=epoch, config=config, ) gc.collect() # eval_epoch( # model=model, # data_loader=eval_data_loader, # box_coder=box_coder, # class_names=class_names, # epoch=epoch, # config=config) gc.collect() saver.save(os.path.join(config.experiment_path, "checkpoint.pth"), epoch=epoch + 1)
def main(config_path, **kwargs): config = load_config(config_path, **kwargs) config.experiment_path = os.path.join(config.experiment_path, "F{}".format(config.fold)) del kwargs random_seed(config.seed) train_transform, eval_transform = build_transforms(config) train_dataset = ConcatDataset( [ Dataset2020KFold( os.path.join(config.dataset_path, "2020"), train=True, fold=config.fold, transform=train_transform, ), Dataset2019(os.path.join(config.dataset_path, "2019"), transform=train_transform), ] ) eval_dataset = Dataset2020KFold( os.path.join(config.dataset_path, "2020"), train=False, fold=config.fold, transform=eval_transform, ) train_data_loader = torch.utils.data.DataLoader( train_dataset, batch_size=config.train.batch_size, shuffle=True, drop_last=True, num_workers=config.workers, ) eval_data_loader = torch.utils.data.DataLoader( eval_dataset, batch_size=config.eval.batch_size, shuffle=False, drop_last=False, num_workers=config.workers, ) model = Model(config.model).to(DEVICE) optimizer = build_optimizer(model.parameters(), config) scheduler = build_scheduler(optimizer, config, len(train_data_loader)) saver = Saver( { "model": model, "optimizer": optimizer, "scheduler": scheduler, } ) if config.restore_path is not None: saver.load(config.restore_path, keys=["model"]) best_score = 0.0 for epoch in range(1, config.train.epochs + 1): optimizer.train() train_epoch(model, train_data_loader, optimizer, scheduler, epoch=epoch, config=config) score = eval_epoch(model, eval_data_loader, epoch=epoch, config=config) # saver.save(os.path.join(config.experiment_path, 'eval', 'checkpoint_{}.pth'.format(epoch)), epoch=epoch) if score > best_score: best_score = score saver.save( os.path.join(config.experiment_path, "checkpoint_best.pth".format(epoch)), epoch=epoch, ) optimizer.eval() score = eval_epoch(model, eval_data_loader, epoch=epoch, config=config, suffix="ema") # saver.save(os.path.join(config.experiment_path, 'eval', 'ema', 'checkpoint_{}.pth'.format(epoch)), epoch=epoch) if score > best_score: best_score = score saver.save( os.path.join(config.experiment_path, "checkpoint_best.pth".format(epoch)), epoch=epoch, )
pass if len(candidates) == 0: break top_beams = sorted(candidates.items(), key=lambda x: -x[1][1])[:beam_size] # beam_score sorting for top_beam_i, top_beam in enumerate(top_beams): top_candidates[top_beam_i] = top_beam[1] outputs.append(top_candidates[0][0]) return outputs if __name__ == "__main__": # ----Hyperparameters & PTEncoder---- pretrained_config = AutoConfig.from_pretrained(configs['pretrained_weights'], output_hidden_states=True) pretrained_encoder = AutoModel.from_pretrained(configs['pretrained_weights'], config=pretrained_config).cuda() tokenizer = configs['tokenizer'] multi_gpu = random_seed(configs['seed']) epochs = configs['epochs'] task = configs['task'] if 'fp16' in configs: fp16 = configs['fp16'] else: fp16 = None # ----Loading data and initializing model---- logger.info('Loading data...') running_data = AmazonQA() logger.info( "Size of train, valid and test data: %s, %s, %s" % (len(running_data.train.examples), len(running_data.dev.examples), len(running_data.test.examples))) batch_size = configs['batch_size']
def main(**kwargs): config = C( random_seed=42, learning_rate=1e-3, horizon=16, discount=0.995, num_observations=1000000, num_workers=32, entropy_weight=1e-2, episode_log_interval=100, opt_log_interval=10, average_reward_lr=0.001, clip_grad_norm=None, model=C( num_features=64, encoder=C(type="minigrid", ), memory=C(type="lstm", ), ), ) for k in kwargs: config[k] = kwargs[k] utils.random_seed(config.random_seed) writer = SummaryWriter(config.experiment_path) # build env env = VecEnv([build_env for _ in range(config.num_workers)]) env = wrappers.TensorboardBatchMonitor( env, writer, log_interval=config.episode_log_interval, fps_mul=0.5) env = wrappers.Torch(env) # build agent and optimizer agent = Agent( env.observation_space, env.action_space, **config.model, ) optimizer = torch.optim.Adam( agent.parameters(), config.learning_rate, betas=(0.0, 0.999), ) average_reward = 0 # load state # state = torch.load("./state.pth") # agent.load_state_dict(state["agent"]) # optimizer.load_state_dict(state["optimizer"]) # train metrics = { "episode/return": Stack(), "episode/length": Stack(), "rollout/reward": Stack(), "rollout/value_target": Stack(), "rollout/value": Stack(), "rollout/td_error": Stack(), "rollout/entropy": Stack(), "rollout/actor_loss": Stack(), "rollout/critic_loss": Stack(), "rollout/loss": Stack(), } opt_step = 0 observation_step = 0 pbar = tqdm(total=config.num_observations) env.seed(config.random_seed) obs = env.reset() action = torch.zeros(config.num_workers, dtype=torch.int) memory = agent.zero_memory(config.num_workers) # r_stats = utils.RunningStats() while observation_step < config.num_observations: history = History() memory = agent.detach_memory(memory) for i in range(config.horizon): transition = history.append_transition() dist, value, memory_prime = agent(obs, action, memory) transition.record(value=value, entropy=dist.entropy()) action = select_action(dist) transition.record(log_prob=dist.log_prob(action)) obs_prime, reward, done, info = env.step(action) observation_step += config.num_workers pbar.update(config.num_workers) # for r in reward: # r_stats.push(r) # reward = reward / r_stats.standard_deviation() transition.record(reward=reward, done=done) memory_prime = agent.reset_memory(memory_prime, done) obs, memory = obs_prime, memory_prime for i in info: if "episode" not in i: continue metrics["episode/return"].update(i["episode"]["r"]) metrics["episode/length"].update(i["episode"]["l"]) rollout = history.build() _, value_prime, _ = agent(obs_prime, action, memory_prime) # value_target = utils.n_step_bootstrapped_return( # reward_t=rollout.reward, # done_t=rollout.done, # value_prime=value_prime.detach(), # discount=config.discount, # ) advantage = utils.generalized_advantage_estimation( reward_t=rollout.reward, value_t=rollout.value.detach(), value_prime=value_prime.detach(), done_t=rollout.done, gamma=config.discount, lambda_=0.96, ) value_target = advantage + rollout.value.detach() # value_target = utils.differential_n_step_bootstrapped_return( # reward_t=rollout.reward, # done_t=rollout.done, # value_prime=value_prime.detach(), # average_reward=average_reward, # ) td_error = value_target - rollout.value critic_loss = 0.5 * td_error.pow(2) actor_loss = (-rollout.log_prob * td_error.detach() - config.entropy_weight * rollout.entropy) loss = actor_loss + critic_loss optimizer.zero_grad() agg(loss).backward() if config.clip_grad_norm is not None: nn.utils.clip_grad_norm_(agent.parameters(), config.clip_grad_norm) optimizer.step() average_reward += config.average_reward_lr * agg( td_error.detach()) # TODO: do not use td-error opt_step += 1 metrics["rollout/reward"].update(rollout.reward.detach()) metrics["rollout/value"].update(rollout.value.detach()) metrics["rollout/value_target"].update(value_target.detach()) metrics["rollout/td_error"].update(td_error.detach()) metrics["rollout/entropy"].update(rollout.entropy.detach()) metrics["rollout/actor_loss"].update(actor_loss.detach()) metrics["rollout/critic_loss"].update(critic_loss.detach()) metrics["rollout/loss"].update(loss.detach()) if opt_step % config.opt_log_interval == 0: print("log metrics") writer.add_scalar("rollout/average_reward", average_reward, global_step=observation_step) grad_norm = torch.norm( torch.stack([ torch.norm(p.grad.detach(), 2.0) for p in agent.parameters() ]), 2.0) writer.add_scalar("rollout/grad_norm", grad_norm, global_step=observation_step) for k in [ "rollout/reward", "rollout/value_target", "rollout/value", "rollout/td_error", ]: v = metrics[k].compute_and_reset() writer.add_scalar(f"{k}/mean", v.mean(), global_step=observation_step) writer.add_histogram(f"{k}/hist", v, global_step=observation_step) for k in [ "rollout/entropy", "rollout/actor_loss", "rollout/critic_loss", "rollout/loss", ]: v = metrics[k].compute_and_reset() writer.add_scalar(f"{k}/mean", v.mean(), global_step=observation_step) for k in [ "episode/return", "episode/length", ]: v = metrics[k].compute_and_reset() writer.add_scalar(f"{k}/mean", v.mean(), global_step=observation_step) writer.add_histogram(f"{k}/hist", v, global_step=observation_step) writer.flush() # torch.save( # { # "agent": agent.state_dict(), # "optimizer": optimizer.state_dict(), # "average_reward": average_reward, # }, # "./state.pth", # ) env.close() writer.close()