def main(): # random seed seed = 1234 np.random.seed(seed) torch.manual_seed(seed) torch.cuda.manual_seed_all(seed) # load dataset if args.dataset[0] == 'deepfashion': ds = pd.read_csv('./Anno/df_info.csv') from dataset import DeepFashionDataset as DataManager elif args.dataset[0] == 'fld': ds = pd.read_csv('./Anno/fld_info.csv') from dataset import FLDDataset as DataManager else: raise ValueError print('dataset : %s' % (args.dataset[0])) if not args.evaluate: train_dm = DataManager(ds[ds['evaluation_status'] == 'train'], root=args.root) train_dl = DataLoader(train_dm, batch_size=args.batchsize, shuffle=True) if os.path.exists('models') is False: os.makedirs('models') test_dm = DataManager(ds[ds['evaluation_status'] == 'test'], root=args.root) test_dl = DataLoader(test_dm, batch_size=args.batchsize, shuffle=False) # Load model print("Load the model...") net = Network(dataset=args.dataset, flag=args.glem).cuda() if not args.weight_file == None: weights = torch.load(args.weight_file) if args.update_weight: weights = utils.load_weight(net, weights) net.load_state_dict(weights) # evaluate only if args.evaluate: print("Evaluation only") test(net, test_dl, 0) return # learning parameters optimizer = torch.optim.Adam(net.parameters(), lr=args.learning_rate) lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 5, 0.1) print('Start training') for epoch in range(args.epoch): lr_scheduler.step() train(net, optimizer, train_dl, epoch) test(net, test_dl, epoch)
def main_unsupervised_new(used_labels=None): trainset = MNIST('train', used_labels) validset = MNIST('valid', used_labels) net = Network(trainset.n_classes, feature_size=128) params = net.parameters() criterion = LossUnsupervisedNew() optimizer = optim.SGD lr_scheduler = MultiStepLR trainer = SupervisedTrainer(configer, net, params, trainset, validset, criterion, optimizer, lr_scheduler, num_to_keep=5, resume=False, valid_freq=1, show_embedding=True) trainer.train() del trainer
prox=1).cuda() elif dim == 3: model = Network_MLP_Triple(num_ps, num_qs, num_rs, args.embedding_dim, args.weight_decay, prox=1).cuda() elif args.mode == 'proxydarts': model = Network_MLP(num_users, num_items, args.embedding_dim, args.weight_decay, prox=2).cuda() optimizer = torch.optim.Adagrad(model.parameters(), args.lr) arch_optimizer = torch.optim.Adam(model.arch_parameters(), args.arch_lr) losses = [] for train_epoch in range(args.train_epochs): if dim == 2: g, gp, loss, loss_valid = train_search(train_queue, valid_queue, model, optimizer, arch_optimizer, args) elif dim == 3: g, gp, loss, loss_valid = train_search_triple( train_queue, valid_queue, model, optimizer, arch_optimizer, args) losses.append(loss)
+ '.pth' model_url = fnmatch.filter(model_urls, pattern)[0] model_weights_path, results_path = download_model(model_url, ckpt_dir) df = pd.read_csv(results_path) row = df.iloc[0] if args.model in [ 'VGG11_bn', 'Resnet18', 'DenseNet3_40', 'LeNet', 'MobileNet' ]: model = Network().construct(args.model, row) else: raise Exception('Unknown model argument: {}'.format(args.model)) if args.print_layers: total_params = sum(p.numel() for p in model.parameters() if p.requires_grad) print('Total number of parameters: ', total_params, '\nlayers:') pp.pprint(list(name for (name, _) in model.named_parameters())) exit(code=0) state_dict = torch.load(model_weights_path, map_location=lambda storage, loc: storage) if args.new: state_dict = state_dict['model'] model.load_state_dict(state_dict, strict=True) model = model.to(device) model = model.eval() mean, std = get_mean_std(args.dataset)
def main(args): # Device device = ("cuda" if torch.cuda.is_available() else "cpu") print("Device: ", device) # Transform, Dataset and Dataloaders transform = transforms.Compose([transforms.ToTensor()]) train_datasets, test_datasets = {}, {} train_loaders, test_loaders = {}, {} permute_idx = [i for i in range(28 * 28)] for i in range(args.num_tasks): train_datasets[i] = PermutedMNIST(transform=transform, train=True, permute_idx=permute_idx) train_loaders[i] = torch.utils.data.DataLoader( train_datasets[i], batch_size=args.batch_size, shuffle=True) test_datasets[i] = PermutedMNIST(transform=transform, train=False, permute_idx=permute_idx) test_loaders[i] = torch.utils.data.DataLoader( test_datasets[i], batch_size=args.batch_size, shuffle=True) random.shuffle(permute_idx) # Model, Optimizer, Criterion, ewc_class if needed model = Network().to(device) optimizer = optim.Adam(model.parameters(), lr=1e-3) criterion = nn.CrossEntropyLoss() ewc_class = None # Recoders train_losses, train_accs, test_losses, test_accs = {}, {}, {}, {} # Train Proper for i in range(args.num_tasks): print("Currently Training on Task {}".format(i + 1)) curr_task = i # Initialize per task recorders train_losses[i], train_accs[i], test_losses[i], test_accs[ i] = [], [], [], [] NUM_EPOCHS = args.num_epochs_per_task for epoch in range(NUM_EPOCHS): # Train train_loss, train_acc = train(model, optimizer, criterion, train_loaders[i], device, args.ewc_train, ewc_class, args.ewc_weight, curr_task) print("[Train Epoch {:>5}/{}] loss: {:>0.4f} | acc: {:>0.4f}". format(epoch, NUM_EPOCHS, train_loss, train_acc)) # Record Loss train_losses[i].append(train_loss) train_accs[i].append(train_acc) # Test for j in range(i + 1): test_loss, test_acc = test(model, criterion, test_loaders[j], device) print( "[ Test Epoch {:>5}/{}] loss: {:>0.4f} | acc: {:>0.4f} [Task {}]" .format(epoch, NUM_EPOCHS, test_loss, test_acc, j)) test_losses[j].append(test_loss) test_accs[j].append(test_acc) if (args.ewc_train): # Consolidate ewc_class = EWC(model, train_loaders, curr_task, device) # Save Losses and Accuracies suffixes = "{}_{}_{}_{}_{}".format(str(args.num_tasks), str(args.num_epochs_per_task), str(args.ewc_weight), "ewc" if args.ewc_train else "std", args.custom_suffix) torch.save(train_losses, "train_losses_{}.txt".format(suffixes)) torch.save(train_accs, "train_accs_{}.txt".format(suffixes)) torch.save(test_losses, "test_losses_{}.txt".format(suffixes)) torch.save(test_accs, "test_accs_{}.txt".format(suffixes))
def train(train_feats, train_caps, val_feats, val_caps, train_prefix="", val_prefix="", epochs=EPOCHS, batch_size=BATCH_SIZE, max_seq_len=MAX_LEN, hidden_dim=HIDDEN_DIM, emb_dim=EMB_DIM, enc_seq_len=ENC_SEQ_LEN, enc_dim=ENC_DIM, clip_val=CLIP_VAL, teacher_force=TEACHER_FORCE_RAT, dropout_p=0.1, attn_activation="relu", epsilon=0.0005, weight_decay=WEIGHT_DECAY, lr=LEARNING_RATE, early_stopping=True, scheduler="step", attention=None, deep_out=False, checkpoint="", out_dir="Pytorch_Exp_Out", decoder=None): print("EXPERIMENT START ", time.asctime()) if not os.path.exists(out_dir): os.mkdir(out_dir) # 1. Load the data train_captions = open(train_caps, mode='r', encoding='utf-8') \ .read().strip().split('\n') train_features = open(train_feats, mode='r').read().strip().split('\n') train_features = [os.path.join(train_prefix, z) for z in train_features] assert len(train_captions) == len(train_features) if val_caps: val_captions = open(val_caps, mode='r', encoding='utf-8') \ .read().strip().split('\n') val_features = open(val_feats, mode='r').read().strip().split('\n') val_features = [os.path.join(val_prefix, z) for z in val_features] assert len(val_captions) == len(val_features) # 2. Preprocess the data train_captions = normalize_strings(train_captions) train_data = list(zip(train_captions, train_features)) train_data = filter_inputs(train_data) print("Total training instances: ", len(train_data)) if val_caps: val_captions = normalize_strings(val_captions) val_data = list(zip(val_captions, val_features)) val_data = filter_inputs(val_data) print("Total validation instances: ", len(val_data)) vocab = Vocab() vocab.build_vocab(map(lambda x: x[0], train_data), max_size=10000) vocab.save(path=os.path.join(out_dir, 'vocab.txt')) print("Vocabulary size: ", vocab.n_words) # 3. Initialize the network, optimizer & loss function net = Network(hid_dim=hidden_dim, out_dim=vocab.n_words, sos_token=0, eos_token=1, pad_token=2, teacher_forcing_rat=teacher_force, emb_dim=emb_dim, enc_seq_len=enc_seq_len, enc_dim=enc_dim, dropout_p=dropout_p, deep_out=deep_out, decoder=decoder, attention=attention) net.to(DEVICE) if checkpoint: net.load_state_dict(torch.load(checkpoint)) optimizer = torch.optim.Adam(net.parameters(), lr=lr, weight_decay=weight_decay) loss_function = nn.NLLLoss() scheduler = set_scheduler(scheduler, optimizer) # 4. Train prev_val_l = sys.maxsize total_instances = 0 total_steps = 0 train_loss_log = [] train_loss_log_batches = [] train_penalty_log = [] val_loss_log = [] val_loss_log_batches = [] val_bleu_log = [] prev_bleu = sys.maxsize train_data = DataLoader(captions=map(lambda x: x[0], train_data), sources=map(lambda x: x[1], train_data), batch_size=batch_size, vocab=vocab, max_seq_len=max_seq_len) if val_caps: val_data = DataLoader(captions=map(lambda x: x[0], val_data), sources=map(lambda x: x[1], val_data), batch_size=batch_size, vocab=vocab, max_seq_len=max_seq_len, val_multiref=True) training_start_time = time.time() for e in range(1, epochs + 1): print("Epoch ", e) tfr = _teacher_force(epochs, e, teacher_force) # train one epoch train_l, inst, steps, t, l_log, pen = train_epoch( model=net, loss_function=loss_function, optimizer=optimizer, data_iter=train_data, max_len=max_seq_len, clip_val=clip_val, epsilon=epsilon, teacher_forcing_rat=tfr) if scheduler is not None: scheduler.step() # epoch logs print("Training loss:\t", train_l) print("Instances:\t", inst) print("Steps:\t", steps) hours = t // 3600 mins = (t % 3600) // 60 secs = (t % 60) print("Time:\t{0}:{1}:{2}".format(hours, mins, secs)) total_instances += inst total_steps += steps train_loss_log.append(train_l) train_loss_log_batches += l_log train_penalty_log.append(pen) print() # evaluate if val_caps: val_l, l_log, bleu = evaluate(model=net, loss_function=loss_function, data_iter=val_data, max_len=max_seq_len, epsilon=epsilon) # validation logs print("Validation loss: ", val_l) print("Validation BLEU-4: ", bleu) if bleu > prev_bleu: torch.save(net.state_dict(), os.path.join(out_dir, 'net.pt')) val_loss_log.append(val_l) val_bleu_log.append(bleu) val_loss_log_batches += l_log #sample model print("Sampling training data...") print() samples = sample(net, train_data, vocab, samples=3, max_len=max_seq_len) for t, s in samples: print("Target:\t", t) print("Predicted:\t", s) print() # if val_caps: # print("Sampling validation data...") # print() # samples = sample(net, val_data, vocab, samples=3, max_len=max_seq_len) # for t, s in samples: # print("Target:\t", t) # print("Predicted:\t", s) # print() if val_caps: # If the validation loss after this epoch increased from the # previous epoch, wrap training. if prev_bleu > bleu and early_stopping: print("\nWrapping training after {0} epochs.\n".format(e + 1)) break prev_val_l = val_l prev_bleu = bleu # Experiment summary logs. tot_time = time.time() - training_start_time hours = tot_time // 3600 mins = (tot_time % 3600) // 60 secs = (tot_time % 60) print("Total training time:\t{0}:{1}:{2}".format(hours, mins, secs)) print("Total training instances:\t", total_instances) print("Total training steps:\t", total_steps) print() _write_loss_log("train_loss_log.txt", out_dir, train_loss_log) _write_loss_log("train_loss_log_batches.txt", out_dir, train_loss_log_batches) _write_loss_log("train_penalty.txt", out_dir, train_penalty_log) if val_caps: _write_loss_log("val_loss_log.txt", out_dir, val_loss_log) _write_loss_log("val_loss_log_batches.txt", out_dir, val_loss_log_batches) _write_loss_log("val_bleu4_log.txt", out_dir, val_bleu_log) print("EXPERIMENT END ", time.asctime())
src = (Path(__file__) / "..").resolve() for f in glob(str(src / "*.py")): shutil.copy(f, dst) if __name__ == "__main__": wandb_logger = WandbLogger(project="nnsplit") parser = ArgumentParser() parser = Network.add_model_specific_args(parser) parser = Trainer.add_argparse_args(parser) parser.set_defaults( gpus=1, max_epochs=1, reload_dataloaders_every_epoch=True, logger=wandb_logger, ) hparams = parser.parse_args() if hparams.logger: store_code(wandb_logger.experiment) model = Network(hparams) n_params = np.sum([np.prod(x.shape) for x in model.parameters()]) trainer = Trainer.from_argparse_args(hparams) print(f"Training model with {n_params} parameters.") trainer.fit(model) if hparams.logger: model.store(Path(wandb_logger.experiment.dir) / "model")
if __name__ == '__main__': print('Cross Entropy Test:', \ cross_entropy_with_logits(torch.tensor([0.0088, 0.1576, -0.0345, -0.0805]), \ torch.tensor([0.0000, 0.1429, 0.4286, 0.4286]))) in_shape = (8 * 3, 96, 96) action_space_size = 4 network = Network(in_shape, action_space_size, 'cuda') batch_size = 3 rollout_len = 5 batch = [] for i in range(batch_size): img = np.ones(in_shape) actions = [Action(2) for _ in range(rollout_len)] # (value, reward, empirical_policy) targets = [(0.7, 0.5, [0.25, 0.25, 0.25, 0.25]) for _ in range(rollout_len + 1)] batch.append((img, actions, targets)) optimizer = optim.SGD(network.parameters(), lr=0.001, momentum=0.9, weight_decay=1e-4) for i in range(1000): batch_update_weights(optimizer, network, batch)
class Agent(): def __init__(self, state_size, action_size, seed): self.state_size = state_size self.action_size = action_size self.seed = random.seed(seed) self.Q = Network(self.state_size, self.action_size, self.seed) self.Q_dash = Network(self.state_size, self.action_size, self.seed) self.optimizer = optim.Adam(self.Q.parameters(), lr=LR) self.replay = ReplayBuffer(self.seed) self.t_step = 0 def step(self, state, action, reward, next_state, done): self.replay.add(state, action, reward, next_state, done) self.t_step = (self.t_step + 1) % UPDATE_EVERY if self.t_step == 0: if len(self.replay) > BATCH_SIZE: experiences = self.replay.sample() self.learn_ddqn(experiences, GAMMA) def act(self, state, eps=0.): state = torch.from_numpy(state).float().unsqueeze(0).to(device) self.Q.eval() with torch.no_grad(): # done to avoid bt action_values = self.Q(state) self.Q.train() # Epsilon-greedy action selection if random.random() > eps: return np.argmax(action_values.cpu().data.numpy()) else: return random.choice(np.arange(self.action_size)) def learn_dqn(self, experiences, gamma): ''' Simple dqn with fixed target Q' and experience replay ''' states, actions, rewards, next_states, dones = experiences # Get max predicted Q values (for next states) from target model Q_targets_next = self.Q_dash(next_states).detach().max(1)[0].unsqueeze( 1) # Compute Q targets for current states # only get reward if its done Q_targets = rewards + (gamma * Q_targets_next * (1 - dones)) # Get expected Q values from local model Q_expected = self.Q(states).gather(1, actions) # Compute loss loss = F.mse_loss(Q_expected, Q_targets) # Minimize the loss self.optimizer.zero_grad() loss.backward() self.optimizer.step() self.soft_update(self.Q, self.Q_dash, TAU) def learn_ddqn(self, experiences, gamma): #double deep q learning states, actions, rewards, next_states, dones = experiences best_action_arg = self.Q(next_states).detach() a_best = best_action_arg.max(1)[1] Q_targets_next = self.Q_dash(next_states).detach().gather( 1, a_best.unsqueeze(1)) #Q_targets_next = Q_targets_all[np.arange(BATCH_SIZE), a_best].unsqueeze(1) Q_targets = rewards + (gamma * Q_targets_next * (1 - dones)) # Get expected Q values from local model Q_expected = self.Q(states).gather(1, actions) # Compute loss loss = F.mse_loss(Q_expected, Q_targets) # Minimize the loss self.optimizer.zero_grad() loss.backward() self.optimizer.step() self.soft_update(self.Q, self.Q_dash, TAU) def soft_update(self, local_model, target_model, tau): """Soft update model parameters. θ_target = τ*θ_local + (1 - τ)*θ_target Params ====== local_model (PyTorch model): weights will be copied from target_model (PyTorch model): weights will be copied to tau (float): interpolation parameter """ for target_param, local_param in zip(target_model.parameters(), local_model.parameters()): target_param.data.copy_(tau * local_param.data + (1.0 - tau) * target_param.data)