loss = criterion(log_outputs, labels) loss.backward() optimizer.step() accs.append(metrics.logit2acc(log_outputs.data, labels)) training_loss += loss.cpu().data.numpy()[0] logger.add(epoch, tr_loss=training_loss/steps, tr_acc=np.mean(accs)) # Ens 100 test net.train() acc, nll = utils.evaluate(net, testloader, num_ens=100) logger.add(epoch, te_nll_ens100=nll, te_acc_ens100=acc) # Stochastic test net.train() acc, nll = utils.evaluate(net, testloader, num_ens=1) logger.add(epoch, te_nll_stoch=nll, te_acc_stoch=acc) # Test-time averaging net.train() acc, nll = utils.evaluate(net, testloader, num_ens=10) logger.add(epoch, te_nll_ens10=nll, te_acc_ens10=acc) logger.add(epoch, time=time()-t0) logger.iter_info() logger.save(silent=True) torch.save(net.state_dict(), logger.checkpoint) logger.save()
class BaseAgent(object): def __init__(self, config): torch.manual_seed(config.experiment.seed) self.config = config self.env = config.env.init_env() self.eps = np.finfo(np.float32).eps.item() self.device = config.training.device self.memory = Memory() self.logger = Logger(config) self.model = None self.policy = None self.episode = 1 self.episode_steps = 0 def convert_data(self, x): if type(x) == torch.Tensor: return x.data.cpu().tolist() elif type(x) == bool: return int(x) elif type(x) == np.ndarray: return list(x) else: return x def log(self, run_avg): print("Episode {} \t avg length: {} \t reward: {}".format( self.episode, round(run_avg.get_value("moves"), 2), round(run_avg.get_value("return"), 2), )) self.logger.save() self.logger.save_checkpoint(self) if self.config.experiment.save_episode_data: self.logger.save_episode_data(self.episode) self.logger.plot("return") self.logger.plot("moves") def collect_samples(self, run_avg, timestep): num_steps = 0 while num_steps < self.config.training.update_every: print("Starting episode {} at timestep {}".format( self.episode, timestep + num_steps)) episode_data, episode_return, episode_length = self.sample_episode( self.episode, timestep + num_steps, run_avg) num_steps += episode_length run_avg.update_variable("return", episode_return) run_avg.update_variable("moves", episode_length) self.episode += 1 if (self.config.experiment.save_episode_data and self.episode % self.config.experiment.every_n_episodes == 0): print("Pushed episode data at episode: {}".format( self.episode)) self.logger.push_episode_data(episode_data) if self.episode % self.config.experiment.log_interval == 0: self.log(run_avg) return num_steps def sample_episode(self, episode, step, run_avg): episode_return = 0 self.episode_steps = 0 episode_data = defaultdict(list, {"episode": int(episode)}) state = self.env.reset() for t in range(self.config.training.max_episode_length): state = torch.from_numpy(state).float().to(self.device) with torch.no_grad(): transition, state, done = self.step(state) for key, val in transition.items(): episode_data[key].append(self.convert_data(val)) episode_return += transition["reward"] if self.config.experiment.render: self.env.render() if (step + t + 1) % self.config.experiment.num_steps_between_plot == 0: summary = { "steps": step + t + 1, "return": run_avg.get_value("return"), "moves": run_avg.get_value("moves"), } self.logger.push(summary) self.episode_steps += 1 if self.episode_steps == self.config.training.max_episode_length: done = True if done: break episode_length = t + 1 return episode_data, episode_return, episode_length def train(self): run_avg = RunningAverage() timestep = 0 print("Max Timesteps: {}".format(self.config.training.max_timesteps)) while timestep <= self.config.training.max_timesteps: num_steps = self.collect_samples(run_avg, timestep) timestep += num_steps self.update() self.memory.clear() print("Training complete") def evaluate(self): timestep = 0 run_avg = RunningAverage() # Iterate through episodes while timestep <= self.config.eval.n_eval_steps: num_steps = self.collect_samples(run_avg, timestep) timestep += num_steps print("Evaluation complete") def step(self): return NotImplementedError def update(self): return NotImplementedError
loss = criterion(outputs, labels) loss.backward() optimizer.step() accs.append(metrics.logit2acc(outputs.data, labels)) # probably a bad way to calculate accuracy training_loss += loss.cpu().data.numpy()[0] logger.add(epoch, tr_loss=training_loss/steps, tr_acc=np.mean(accs)) # Deterministic test net.eval() acc, nll = utils.evaluate(net, testloader, num_ens=1) logger.add(epoch, te_nll_det=nll, te_acc_det=acc) # Stochastic test net.train() acc, nll = utils.evaluate(net, testloader, num_ens=1) logger.add(epoch, te_nll_stoch=nll, te_acc_stoch=acc) # Test-time averaging net.train() acc, nll = utils.evaluate(net, testloader, num_ens=20) logger.add(epoch, te_nll_ens=nll, te_acc_ens=acc) logger.add(epoch, time=time()-t0) logger.iter_info() logger.save(silent=True) torch.save(net.state_dict(), logger.checkpoint) logger.save()
def main(): fmt = { 'tr_loss': '3.1e', 'tr_acc': '.4f', 'te_acc_det': '.4f', 'te_acc_stoch': '.4f', 'te_acc_ens': '.4f', 'te_acc_perm_sigma': '.4f', 'te_acc_zero_mean': '.4f', 'te_acc_perm_sigma_ens': '.4f', 'te_acc_zero_mean_ens': '.4f', 'te_nll_det': '.4f', 'te_nll_stoch': '.4f', 'te_nll_ens': '.4f', 'te_nll_perm_sigma': '.4f', 'te_nll_zero_mean': '.4f', 'te_nll_perm_sigma_ens': '.4f', 'te_nll_zero_mean_ens': '.4f', 'time': '.3f' } fmt = {**fmt, **{'la%d' % i: '.4f' for i in range(4)}} args = get_args() logger = Logger("lenet5-VDO", fmt=fmt) trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transforms.ToTensor()) train_sampler = torch.utils.data.BatchSampler( torch.utils.data.RandomSampler(trainset), batch_size=args.batch_size, drop_last=False) trainloader = torch.utils.data.DataLoader(trainset, batch_sampler=train_sampler, num_workers=args.workers, pin_memory=True) testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transforms.ToTensor()) test_sampler = torch.utils.data.BatchSampler( torch.utils.data.SequentialSampler(testset), batch_size=args.batch_size, drop_last=False) testloader = torch.utils.data.DataLoader(testset, batch_sampler=test_sampler, num_workers=args.workers, pin_memory=True) net = LeNet5() net = net.to(device=args.device, dtype=args.dtype) if args.print_model: logger.print(net) criterion = metrics.SGVLB(net, len(trainset)).to(device=args.device, dtype=args.dtype) optimizer = optim.Adam(net.parameters(), lr=args.learning_rate) epochs = args.epochs lr_start = args.learning_rate for epoch in trange(epochs): # loop over the dataset multiple times t0 = time() utils.adjust_learning_rate( optimizer, metrics.lr_linear(epoch, 0, epochs, lr_start)) net.train() training_loss = 0 accs = [] steps = 0 for i, (inputs, labels) in enumerate(tqdm(trainloader), 0): steps += 1 inputs, labels = inputs.to( device=args.device, dtype=args.dtype), labels.to(device=args.device) optimizer.zero_grad() outputs = net(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() accs.append(metrics.logit2acc( outputs.data, labels)) # probably a bad way to calculate accuracy training_loss += loss.item() logger.add(epoch, tr_loss=training_loss / steps, tr_acc=np.mean(accs)) # Deterministic test net.eval() acc, nll = utils.evaluate(net, testloader, device=args.device, num_ens=1) logger.add(epoch, te_nll_det=nll, te_acc_det=acc) # Stochastic test net.train() acc, nll = utils.evaluate(net, testloader, device=args.device, num_ens=1) logger.add(epoch, te_nll_stoch=nll, te_acc_stoch=acc) # Test-time averaging net.train() acc, nll = utils.evaluate(net, testloader, device=args.device, num_ens=20) logger.add(epoch, te_nll_ens=nll, te_acc_ens=acc) # Zero-mean net.train() net.dense1.set_flag('zero_mean', True) acc, nll = utils.evaluate(net, testloader, device=args.device, num_ens=1) net.dense1.set_flag('zero_mean', False) logger.add(epoch, te_nll_zero_mean=nll, te_acc_zero_mean=acc) # Permuted sigmas net.train() net.dense1.set_flag('permute_sigma', True) acc, nll = utils.evaluate(net, testloader, device=args.device, num_ens=1) net.dense1.set_flag('permute_sigma', False) logger.add(epoch, te_nll_perm_sigma=nll, te_acc_perm_sigma=acc) # Zero-mean test-time averaging net.train() net.dense1.set_flag('zero_mean', True) acc, nll = utils.evaluate(net, testloader, device=args.device, num_ens=20) net.dense1.set_flag('zero_mean', False) logger.add(epoch, te_nll_zero_mean_ens=nll, te_acc_zero_mean_ens=acc) # Permuted sigmas test-time averaging net.train() net.dense1.set_flag('permute_sigma', True) acc, nll = utils.evaluate(net, testloader, device=args.device, num_ens=20) net.dense1.set_flag('permute_sigma', False) logger.add(epoch, te_nll_perm_sigma_ens=nll, te_acc_perm_sigma_ens=acc) logger.add(epoch, time=time() - t0) las = [ np.mean(net.conv1.log_alpha.data.cpu().numpy()), np.mean(net.conv2.log_alpha.data.cpu().numpy()), np.mean(net.dense1.log_alpha.data.cpu().numpy()), np.mean(net.dense2.log_alpha.data.cpu().numpy()) ] logger.add(epoch, **{'la%d' % i: las[i] for i in range(4)}) logger.iter_info() logger.save(silent=True) torch.save(net.state_dict(), logger.checkpoint) logger.save()