if use_cuda: X_s, X_t1, X_t2, = X_s.cuda(), X_t1.cuda(), X_t2.cuda() Y_s, Y_t1, Y_t2, = Y_s.cuda(), Y_t1.cuda(), Y_t2.cuda() X_s_, X_t1_, X_t2_ = X_s_.cuda(), X_t1_.cuda(), X_t2_.cuda() all_accs = [] maxa = 0 for _ in range(2): for dr in dropouts: for al in alphas: model = LinearModel(bow_size, graph_size, dr) if use_cuda: model = model.cuda() optimizer = optim.Adam(model.parameters(), lr=lr) for p in model.parameters(): p.requires_grad = True accs, loss = [], [] for epoch in range(n_epochs): train_model(model, optimizer, loss_class, loss_domain, X_s, X_s_, Y_s, X_t1, X_t1_, al) acc, l = eval_model(model, loss_class, loss_domain, X_t2, X_t2_, Y_t2) accs.append(acc) loss.append(l) max_acc = max(accs) all_accs.append(max_acc) del model, optimizer gc.collect()
def main(): # Training settings parser = argparse.ArgumentParser(description='PyTorch MNIST Example') parser.add_argument('--batch-size', type=int, default=64, metavar='N', help='input batch size for training (default: 64)') parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N', help='input batch size for testing (default: 1000)') parser.add_argument('--epochs', type=int, default=1, metavar='N', help='number of epochs to train (default: 14)') parser.add_argument('--lr', type=float, default=1.0, metavar='LR', help='learning rate (default: 1.0)') parser.add_argument('--gamma', type=float, default=0.7, metavar='M', help='Learning rate step gamma (default: 0.7)') parser.add_argument('--no-cuda', action='store_true', default=False, help='disables CUDA training') parser.add_argument('--dry-run', action='store_true', default=False, help='quickly check a single pass') parser.add_argument('--seed', type=int, default=1, metavar='S', help='random seed (default: 1)') parser.add_argument('--log-interval', type=int, default=200, metavar='N', help='how many batches to wait before logging training status') parser.add_argument('--save-model', action='store_true', default=False, help='For Saving the current Model') parser.add_argument('--attack', action='store_true', default=False, help='attack model') parser.add_argument('--LP', type=str, default="l2", help='Random Corruption Norm Constrain') parser.add_argument('--eps', type=float, default=1e-4, help='Random Corruption Epsilon') parser.add_argument('--attack_lr', type=float, default=1e-3, help='Grad based attacker learning rate') args = parser.parse_args() use_cuda = not args.no_cuda and torch.cuda.is_available() torch.manual_seed(args.seed) device = torch.device("cuda" if use_cuda else "cpu") train_kwargs = {'batch_size': args.batch_size} test_kwargs = {'batch_size': args.test_batch_size} if use_cuda: cuda_kwargs = {'num_workers': 1, 'pin_memory': True, 'shuffle': True} train_kwargs.update(cuda_kwargs) test_kwargs.update(cuda_kwargs) transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) dataset1 = datasets.MNIST('./', train=True, download=True, transform=transform) dataset2 = datasets.MNIST('./', train=False, transform=transform) train_loader = torch.utils.data.DataLoader(dataset1, **train_kwargs) test_loader = torch.utils.data.DataLoader(dataset2, **test_kwargs) model = LinearModel().to(device) # Net().to(device) optimizer = optim.Adadelta(model.parameters(), lr=args.lr) scheduler = StepLR(optimizer, step_size=1, gamma=args.gamma) for epoch in range(1, args.epochs + 1): train(args, model, device, train_loader, optimizer, epoch) test(model, device, test_loader) scheduler.step() if args.attack: print("start attack") attacker = GradAttacker(model.parameters(), lr=args.attack_lr, eps=args.eps, LP=args.LP) train(args, model, device, train_loader, optimizer=attacker, epoch='attack epoch') print("Accuracy After attack:") test(model, device, test_loader) if args.save_model: torch.save(model.state_dict(), "mnist_linear.pt")
H1 = D_in // 4 H2 = H1 // 2 D_out = 2 f1 = MLP(D_in=D_in, H1=H1, H2=H2, D_out=D_out, dropout=dropout).cuda() f1_optimizer = optim.Adam(f1.parameters(), lr=learning_rate, weight_decay=5e-3) std = train_loader.dataset.X.std(axis=0).reshape(-1, 1) mean = train_loader.dataset.X.mean(axis=0).reshape(-1, 1) prior_info = np.concatenate((std, mean), axis=1) prior_info = torch.FloatTensor(prior_info).cuda() f2 = LinearModel(D_in=prior_info.shape[1], D_out=1).cuda() f2_optimizer = optim.Adam(f2.parameters(), lr=prior_learning_rate) APExp = egexplainer.VariableBatchExplainer(train_loader.dataset) losses_with_prior.append( train_with_learned_prior(f1, f2, f1_optimizer, f2_optimizer, CrossEntropyLoss(), train_loader, valid_loader, test_loader, patience, APExp, prior_info)) losses_no_prior = np.array(losses_no_prior) losses_with_prior = np.array(losses_with_prior) no_prior_mean_losses.append(losses_no_prior.mean()) with_prior_mean_losses.append(losses_with_prior.mean()) no_prior_loss_std.append(sem(losses_no_prior))