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))