def __init__(self,
name,
latent_dim,
ob_dim,
in_layer=None,
out_activation=None,
hidden_dims=[64, 64, 64],
hidden_activation=tf.nn.tanh,
weight_init=tf.contrib.layers.xavier_initializer,
bias_init=tf.zeros_initializer):
with tf.variable_scope(name):
if in_layer is None:
self.zs = tf.placeholder(tf.float32,
shape=[None, latent_dim],
name='zs')
else:
self.zs = in_layer
self.decoder_network = MLP('decoder',
latent_dim,
ob_dim,
out_activation=out_activation,
hidden_dims=hidden_dims,
hidden_activation=hidden_activation,
weight_init=weight_init,
bias_init=bias_init,
in_layer=self.zs)
self.decoded = self.decoder_network.layers['out']
def __init__(self,
name,
latent_dim,
action_dim,
in_layer=None,
out_activation=None,
hidden_dims=[64, 64, 64],
hidden_activation=tf.nn.tanh,
weight_init=tf.contrib.layers.xavier_initializer,
bias_init=tf.zeros_initializer):
with tf.variable_scope(name):
if in_layer is None:
self.zs = tf.placeholder(tf.float32,
shape=[None, latent_dim],
name='zs')
else:
self.zs = in_layer
self.actions = tf.placeholder(tf.float32,
shape=[None, action_dim],
name='actions')
self.za_concat = tf.concat([self.zs, self.actions], axis=1)
self.model_network = MLP('model',
latent_dim + action_dim,
latent_dim,
out_activation=out_activation,
hidden_dims=hidden_dims,
hidden_activation=hidden_activation,
weight_init=weight_init,
bias_init=bias_init,
in_layer=self.za_concat)
self.pred_z = self.model_network.layers['out']
def __init__(
self,
name,
ob_dim,
latent_dim,
in_layer=None,
out_activation=None,
hidden_dims=[64, 64, 64],
hidden_activation=tf.nn.tanh,
weight_init=tf.contrib.layers.xavier_initializer,
bias_init=tf.zeros_initializer,
reuse_scope=False,
):
with tf.variable_scope(name, reuse=reuse_scope):
if in_layer is None:
self.obs = tf.placeholder(tf.float32,
shape=[None, ob_dim],
name='obs')
else:
self.obs = in_layer
self.mean_network = MLP('means',
ob_dim,
latent_dim,
out_activation=out_activation,
hidden_dims=hidden_dims,
hidden_activation=hidden_activation,
weight_init=weight_init,
bias_init=bias_init,
in_layer=self.obs)
self.means = self.mean_network.layers['out']
self.log_var_network = MLP('log_vars',
ob_dim,
latent_dim,
out_activation=out_activation,
hidden_dims=hidden_dims,
hidden_activation=hidden_activation,
weight_init=weight_init,
bias_init=bias_init,
in_layer=self.obs)
self.log_vars = self.log_var_network.layers['out']
self.distribution = DiagGaussian(self.means, self.log_vars)
self.zs = self.distribution.sample()
def define_agent(self, width, height, num_actions):
return DQNAgent(config=Config(num_actions=num_actions,
encoder=OneHotEncoder(width, height),
optimizer=AdamOptimizer(0.01),
network=MLP(),
policy=EpsilonGreedyPolicy(1, 0.01, 500),
discount=0.95,
capacity=100,
batch_size=16))
def define_agent(self, width, height, num_actions):
return NStepDQNAgent(
config=Config(num_actions=num_actions,
encoder=OneHotEncoder(width, height),
optimizer=AdamOptimizer(0.01),
network=MLP(),
policy=EpsilonGreedyPolicy(1, 0.01, 1000),
discount=0.95,
n_step=8))
def do_stuff(opt):
print(f'\nTraining {opt} for {args.num_epochs} epochs...')
net = CNN() if args.dataset == 'cifar' else MLP()
_, kwargs = misc.split_optim_dict(misc.optim_dict[opt])
optimizer = misc.task_to_optimizer(opt)(params=net.parameters(),
**kwargs)
optimizer = misc.wrap_optimizer(opt, optimizer)
return fit(net,
data,
optimizer,
num_epochs=args.num_epochs,
lr_schedule=True)
def do_stuff(opt):
print(f'\nTraining {opt} for {args.num_epochs} epochs...')
net = CNN() if args.dataset == 'cifar' else MLP()
_, kwargs = misc.split_optim_dict(misc.optim_dict[opt])
optimizer = misc.task_to_optimizer(opt)(params=net.parameters(),
**kwargs)
if 'lookahead' in opt.lower():
optimizer = optimizers.Lookahead(optimizer, k=5, alpha=0.5)
return fit(net,
data,
optimizer,
num_epochs=args.num_epochs,
lr_schedule=True)
def load_mlp_class_model(saved_model):
'''Load model weights from path saved_model.'''
config = ClassConfig
model_params = {
'input_shape': config.x_shape,
'classes': config.classes,
'batch_size': config.batch_size,
'hidden_units': config.hidden_units,
'mode': config.mode,
'dropout': False
}
model = MLP(model_params)
model.load_state_dict(torch.load(saved_model))
return model.eval()
def model(data, labels):
network = MLP(n_pixels, 10, args.units, args.nonlinear)
if cuda:
network.cuda()
optimizer = th.optim.Adam(network.parameters(), args.lr)
prediction_list = []
for i in range(args.T):
category = network(data)
prediction_list.append(category)
if i != args.T - 1:
loss = F.cross_entropy(category, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
return prediction_list
def init_net(self, parameters):
if not os.path.exists(parameters["save_dir"]):
os.makedirs(parameters["save_dir"])
model_params = {
'input_shape': self.x_shape,
'classes': self.y_shape,
'batch_size': self.batch_size,
'hidden_units': self.hidden_units,
'mode': self.mode
}
self.net = MLP(model_params).to(DEVICE)
self.optimiser = torch.optim.Adam(self.net.parameters(), lr=self.lr)
self.scheduler = torch.optim.lr_scheduler.StepLR(self.optimiser,
step_size=5000,
gamma=0.5)
print("MLP Parameters: ")
print(
f'batch size: {self.batch_size}, input shape: {model_params["input_shape"]}, hidden units: {model_params["hidden_units"]}, output shape: {model_params["classes"]}, lr: {self.lr}'
)
def __init__(self, opt):
super(VanillaAE, self).__init__()
self.opt = opt
self.device = torch.device("cuda:0" if not opt.no_cuda else "cpu")
nc = int(opt.nc)
imageSize = int(opt.imageSize)
nz = int(opt.nz)
nblk = int(opt.nblk)
# generator
self.netG = MLP(input_dim=nc * imageSize * imageSize,
output_dim=nc * imageSize * imageSize,
dim=nz,
n_blk=nblk,
norm='none',
activ='relu').to(self.device)
weights_init(self.netG)
if opt.netG != '':
self.netG.load_state_dict(
torch.load(opt.netG, map_location=self.device))
print_and_write_log(opt.train_log_file, 'netG:')
print_and_write_log(opt.train_log_file, str(self.netG))
# losses
self.criterion = nn.MSELoss()
# define focal frequency loss
self.criterion_freq = FFL(loss_weight=opt.ffl_w,
alpha=opt.alpha,
patch_factor=opt.patch_factor,
ave_spectrum=opt.ave_spectrum,
log_matrix=opt.log_matrix,
batch_matrix=opt.batch_matrix).to(
self.device)
# misc
self.to(self.device)
# optimizer
self.optimizerG = optim.Adam(self.netG.parameters(),
lr=opt.lr,
betas=(opt.beta1, opt.beta2))
def init_net(self, parameters):
model_params = {
'input_shape': self.x.shape[1] + 2,
'classes': 1 if len(self.y.shape) == 1 else self.y.shape[1],
'batch_size': self.batch_size,
'hidden_units': parameters['hidden_units'],
'mode': parameters['mode']
}
self.net = MLP(model_params).to(DEVICE)
self.optimiser = torch.optim.Adam(self.net.parameters(), lr=self.lr)
self.scheduler = torch.optim.lr_scheduler.StepLR(self.optimiser,
step_size=5000,
gamma=0.5)
print(f'Bandit {self.label} Parameters: ')
print(
f'buffer_size: {self.buffer_size}, batch size: {self.batch_size}, number of samples: {self.n_samples}, epsilon: {self.epsilon}'
)
print("MLP Parameters: ")
print(
f'input shape: {model_params["input_shape"]}, hidden units: {model_params["hidden_units"]}, output shape: {model_params["classes"]}, lr: {self.lr}'
)
def __init__(
self,
input_dim,
dim,
style_dim,
n_downsample,
n_res,
activ,
pad_type,
mlp_dim):
super(AdaINGen, self).__init__()
# style encoder
self.enc_style = StyleEncoder(4, input_dim, dim, style_dim, norm='none', activ=activ, pad_type=pad_type)
# content encoder
self.enc_content: ContentEncoder = ContentEncoder(n_downsample, n_res, input_dim, dim, 'in', activ, pad_type=pad_type)
self.dec: Decoder = Decoder(n_downsample, n_res, self.enc_content.output_dim, input_dim, res_norm='adain', activ=activ, pad_type=pad_type)
# MLP to generate AdaIN parameters
self.mlp = MLP(style_dim, self.get_num_adain_params(self.dec), mlp_dim, 3, norm='none', activ=activ)
def init_net(self, parameters):
if not os.path.exists(parameters["save_dir"]):
os.makedirs(parameters["save_dir"])
model_params = {
'input_shape': self.x_shape,
'classes': self.classes,
'batch_size': self.batch_size,
'hidden_units': self.hidden_units,
'mode': self.mode,
'dropout': self.dropout,
}
if self.dropout:
self.net = MLP_Dropout(model_params).to(DEVICE)
print('MLP Dropout Parameters: ')
print(f'batch size: {self.batch_size}, input shape: {model_params["input_shape"]}, hidden units: {model_params["hidden_units"]}, output shape: {model_params["classes"]}, lr: {self.lr}')
else:
self.net = MLP(model_params).to(DEVICE)
print('MLP Parameters: ')
print(f'batch size: {self.batch_size}, input shape: {model_params["input_shape"]}, hidden units: {model_params["hidden_units"]}, output shape: {model_params["classes"]}, lr: {self.lr}')
self.optimiser = torch.optim.SGD(self.net.parameters(), lr=self.lr)
self.scheduler = torch.optim.lr_scheduler.StepLR(self.optimiser, step_size=100, gamma=0.5)
def main(args):
torch.manual_seed(args.seed)
if not os.path.exists(args.res_dir):
os.mkdir(args.res_dir)
if not os.path.exists(
os.path.join(args.res_dir, args.type + str(args.noise))):
os.mkdir(os.path.join(args.res_dir, args.type + str(args.noise)))
if not os.path.exists(
os.path.join(args.res_dir, args.type + str(args.noise),
str(args.pace))):
os.mkdir(
os.path.join(args.res_dir, args.type + str(args.noise),
str(args.pace)))
if not os.path.exists(args.model_dir):
os.mkdir(args.model_dir)
res_dir = os.path.join(args.res_dir, args.type + str(args.noise),
str(args.pace))
data1 = dd.io.load(os.path.join(args.vec_dir, 'NYU_correlation_matrix.h5'))
data2 = dd.io.load(os.path.join(args.vec_dir, 'UM_correlation_matrix.h5'))
data3 = dd.io.load(os.path.join(args.vec_dir, 'USM_correlation_matrix.h5'))
data4 = dd.io.load(os.path.join(args.vec_dir,
'UCLA_correlation_matrix.h5'))
x1 = torch.from_numpy(data1['data']).float()
y1 = torch.from_numpy(data1['label']).long()
x2 = torch.from_numpy(data2['data']).float()
y2 = torch.from_numpy(data2['label']).long()
x3 = torch.from_numpy(data3['data']).float()
y3 = torch.from_numpy(data3['label']).long()
x4 = torch.from_numpy(data4['data']).float()
y4 = torch.from_numpy(data4['label']).long()
if args.overlap:
idNYU = dd.io.load('./idx/NYU_sub_overlap.h5')
idUM = dd.io.load('./idx/UM_sub_overlap.h5')
idUSM = dd.io.load('./idx/USM_sub_overlap.h5')
idUCLA = dd.io.load('./idx/UCLA_sub_overlap.h5')
else:
idNYU = dd.io.load('./idx/NYU_sub.h5')
idUM = dd.io.load('./idx/UM_sub.h5')
idUSM = dd.io.load('./idx/USM_sub.h5')
idUCLA = dd.io.load('./idx/UCLA_sub.h5')
if args.split == 0:
tr1 = idNYU['1'] + idNYU['2'] + idNYU['3'] + idNYU['4']
tr2 = idUM['1'] + idUM['2'] + idUM['3'] + idUM['4']
tr3 = idUSM['1'] + idUSM['2'] + idUSM['3'] + idUSM['4']
tr4 = idUCLA['1'] + idUCLA['2'] + idUCLA['3'] + idUCLA['4']
te1 = idNYU['0']
te2 = idUM['0']
te3 = idUSM['0']
te4 = idUCLA['0']
elif args.split == 1:
tr1 = idNYU['0'] + idNYU['2'] + idNYU['3'] + idNYU['4']
tr2 = idUM['0'] + idUM['2'] + idUM['3'] + idUM['4']
tr3 = idUSM['0'] + idUSM['2'] + idUSM['3'] + idUSM['4']
tr4 = idUCLA['0'] + idUCLA['2'] + idUCLA['3'] + idUCLA['4']
te1 = idNYU['1']
te2 = idUM['1']
te3 = idUSM['1']
te4 = idUCLA['1']
elif args.split == 2:
tr1 = idNYU['0'] + idNYU['1'] + idNYU['3'] + idNYU['4']
tr2 = idUM['0'] + idUM['1'] + idUM['3'] + idUM['4']
tr3 = idUSM['0'] + idUSM['1'] + idUSM['3'] + idUSM['4']
tr4 = idUCLA['0'] + idUCLA['1'] + idUCLA['3'] + idUCLA['4']
te1 = idNYU['2']
te2 = idUM['2']
te3 = idUSM['2']
te4 = idUCLA['2']
elif args.split == 3:
tr1 = idNYU['0'] + idNYU['1'] + idNYU['2'] + idNYU['4']
tr2 = idUM['0'] + idUM['1'] + idUM['2'] + idUM['4']
tr3 = idUSM['0'] + idUSM['1'] + idUSM['2'] + idUSM['4']
tr4 = idUCLA['0'] + idUCLA['1'] + idUCLA['2'] + idUCLA['4']
te1 = idNYU['3']
te2 = idUM['3']
te3 = idUSM['3']
te4 = idUCLA['3']
elif args.split == 4:
tr1 = idNYU['0'] + idNYU['1'] + idNYU['2'] + idNYU['3']
tr2 = idUM['0'] + idUM['1'] + idUM['2'] + idUM['3']
tr3 = idUSM['0'] + idUSM['1'] + idUSM['2'] + idUSM['3']
tr4 = idUCLA['0'] + idUCLA['1'] + idUCLA['2'] + idUCLA['3']
te1 = idNYU['4']
te2 = idUM['4']
te3 = idUSM['4']
te4 = idUCLA['4']
x1_train = x1[tr1]
y1_train = y1[tr1]
x2_train = x2[tr2]
y2_train = y2[tr2]
x3_train = x3[tr3]
y3_train = y3[tr3]
x4_train = x4[tr4]
y4_train = y4[tr4]
x1_test = x1[te1]
y1_test = y1[te1]
x2_test = x2[te2]
y2_test = y2[te2]
x3_test = x3[te3]
y3_test = y3[te3]
x4_test = x4[te4]
y4_test = y4[te4]
if args.sepnorm:
mean = x1_train.mean(0, keepdim=True)
dev = x1_train.std(0, keepdim=True)
x1_train = (x1_train - mean) / dev
x1_test = (x1_test - mean) / dev
mean = x2_train.mean(0, keepdim=True)
dev = x2_train.std(0, keepdim=True)
x2_train = (x2_train - mean) / dev
x2_test = (x2_test - mean) / dev
mean = x3_train.mean(0, keepdim=True)
dev = x3_train.std(0, keepdim=True)
x3_train = (x3_train - mean) / dev
x3_test = (x3_test - mean) / dev
mean = x4_train.mean(0, keepdim=True)
dev = x4_train.std(0, keepdim=True)
x4_train = (x4_train - mean) / dev
x4_test = (x4_test - mean) / dev
else:
mean = torch.cat((x1_train, x2_train, x3_train, x4_train),
0).mean(0, keepdim=True)
dev = torch.cat((x1_train, x2_train, x3_train, x4_train),
0).std(0, keepdim=True)
x1_train = (x1_train - mean) / dev
x1_test = (x1_test - mean) / dev
x2_train = (x2_train - mean) / dev
x2_test = (x2_test - mean) / dev
x3_train = (x3_train - mean) / dev
x3_test = (x3_test - mean) / dev
x4_train = (x4_train - mean) / dev
x4_test = (x4_test - mean) / dev
train1 = TensorDataset(x1_train, y1_train)
train_loader1 = DataLoader(train1,
batch_size=len(train1) // args.nsteps,
shuffle=True)
train2 = TensorDataset(x2_train, y2_train)
train_loader2 = DataLoader(train2,
batch_size=len(train2) // args.nsteps,
shuffle=True)
train3 = TensorDataset(x3_train, y3_train)
train_loader3 = DataLoader(train3,
batch_size=len(train3) // args.nsteps,
shuffle=True)
train4 = TensorDataset(x4_train, y4_train)
train_loader4 = DataLoader(train4,
batch_size=len(train4) // args.nsteps,
shuffle=True)
train_all = ConcatDataset([train1, train2, train3, train4])
train_loader = DataLoader(train_all, batch_size=500, shuffle=False)
test1 = TensorDataset(x1_test, y1_test)
test2 = TensorDataset(x2_test, y2_test)
test3 = TensorDataset(x3_test, y3_test)
test4 = TensorDataset(x4_test, y4_test)
test_loader1 = DataLoader(test1,
batch_size=args.test_batch_size1,
shuffle=False)
test_loader2 = DataLoader(test2,
batch_size=args.test_batch_size2,
shuffle=False)
test_loader3 = DataLoader(test3,
batch_size=args.test_batch_size3,
shuffle=False)
test_loader4 = DataLoader(test4,
batch_size=args.test_batch_size4,
shuffle=False)
tbs = [
args.test_batch_size1, args.test_batch_size2, args.test_batch_size3,
args.test_batch_size4
]
model1 = MLP(6105, args.dim, 2).to(device)
model2 = MLP(6105, args.dim, 2).to(device)
model3 = MLP(6105, args.dim, 2).to(device)
model4 = MLP(6105, args.dim, 2).to(device)
optimizer1 = optim.Adam(model1.parameters(),
lr=args.lr1,
weight_decay=5e-2)
optimizer2 = optim.Adam(model2.parameters(),
lr=args.lr2,
weight_decay=5e-2)
optimizer3 = optim.Adam(model3.parameters(),
lr=args.lr3,
weight_decay=5e-2)
optimizer4 = optim.Adam(model4.parameters(),
lr=args.lr4,
weight_decay=5e-2)
models = [model1, model2, model3, model4]
train_loaders = [
train_loader1, train_loader2, train_loader3, train_loader4
]
optimizers = [optimizer1, optimizer2, optimizer3, optimizer4]
model = MLP(6105, args.dim, 2).to(device)
print(model)
nnloss = nn.NLLLoss()
def train(epoch):
pace = args.pace
for i in range(4):
models[i].train()
if epoch <= 50 and epoch % 20 == 0:
for param_group1 in optimizers[i].param_groups:
param_group1['lr'] = 0.5 * param_group1['lr']
elif epoch > 50 and epoch % 20 == 0:
for param_group1 in optimizers[i].param_groups:
param_group1['lr'] = 0.5 * param_group1['lr']
#define weights
w = dict()
denominator = np.sum(np.array(tbs))
for i in range(4):
w[i] = 0.25 #tbs[i]/denominator
loss_all = dict()
num_data = dict()
for i in range(4):
loss_all[i] = 0
num_data[i] = 0
count = 0
for t in range(args.nsteps):
for i in range(4):
optimizers[i].zero_grad()
a, b = next(iter(train_loaders[i]))
num_data[i] += b.size(0)
a = a.to(device)
b = b.to(device)
output = models[i](a)
loss = nnloss(output, b)
loss.backward()
loss_all[i] += loss.item() * b.size(0)
optimizers[i].step()
count += 1
if count % pace == 0 or t == args.nsteps - 1:
with torch.no_grad():
for key in model.state_dict().keys():
if models[0].state_dict()[key].dtype == torch.int64:
model.state_dict()[key].data.copy_(
models[0].state_dict()[key])
else:
temp = torch.zeros_like(model.state_dict()[key])
# add noise
for s in range(4):
if args.type == 'G':
nn = tdist.Normal(
torch.tensor([0.0]),
args.noise *
torch.std(models[s].state_dict()
[key].detach().cpu()))
else:
nn = tdist.Laplace(
torch.tensor([0.0]),
args.noise *
torch.std(models[s].state_dict()
[key].detach().cpu()))
noise = nn.sample(models[s].state_dict()
[key].size()).squeeze()
noise = noise.to(device)
temp += w[s] * (models[s].state_dict()[key] +
noise)
# update global model
model.state_dict()[key].data.copy_(temp)
# updata local model
for s in range(4):
models[s].state_dict()[key].data.copy_(
model.state_dict()[key])
return loss_all[0] / num_data[0], loss_all[1] / num_data[1], \
loss_all[2] / num_data[2], loss_all[3] / num_data[3]
def test(federated_model, dataloader, train=False):
federated_model.eval()
test_loss = 0
correct = 0
outputs = []
preds = []
targets = []
for data, target in dataloader:
targets.append(target[0].detach().numpy())
data = data.to(device)
target = target.to(device)
output = federated_model(data)
outputs.append(output.detach().cpu().numpy())
test_loss += nnloss(output, target).item() * target.size(0)
pred = output.data.max(1)[1]
preds.append(pred.detach().cpu().numpy())
correct += pred.eq(target.view(-1)).sum().item()
test_loss /= len(dataloader.dataset)
correct /= len(dataloader.dataset)
if train:
print('Train set local: Average loss: {:.4f}, Average acc: {:.4f}'.
format(test_loss, correct))
else:
print('Test set local: Average loss: {:.4f}, Average acc: {:.4f}'.
format(test_loss, correct))
return test_loss, correct, targets, outputs, preds
best_acc = 0
best_epoch = 0
train_loss = dict()
for i in range(4):
train_loss[i] = list()
for epoch in range(args.epochs):
start_time = time.time()
print(f"Epoch Number {epoch + 1}")
l1, l2, l3, l4 = train(epoch)
print(
' L1 loss: {:.4f}, L2 loss: {:.4f}, L3 loss: {:.4f}, L4 loss: {:.4f}'
.format(l1, l2, l3, l4))
train_loss[0].append(l1)
train_loss[1].append(l2)
train_loss[2].append(l3)
train_loss[3].append(l4)
test(model, train_loader, train=True)
test(model, train_loader, train=True)
print('===NYU===')
_, acc1, targets1, outputs1, preds1 = test(model,
test_loader1,
train=False)
print('===UM===')
_, acc2, targets2, outputs2, preds2 = test(model,
test_loader2,
train=False)
print('===USM===')
_, acc3, targets3, outputs3, preds3 = test(model,
test_loader3,
train=False)
print('===UCLA===')
_, acc4, targets4, outputs4, preds4 = test(model,
test_loader4,
train=False)
if (acc1 + acc2 + acc3 + acc4) / 4 > best_acc:
best_acc = (acc1 + acc2 + acc3 + acc4) / 4
best_epoch = epoch
total_time = time.time() - start_time
print('Communication time over the network', round(total_time, 2),
's\n')
model_wts = copy.deepcopy(model.state_dict())
torch.save(model_wts, os.path.join(args.model_dir,
str(args.split) + '.pth'))
dd.io.save(os.path.join(res_dir, 'NYU_' + str(args.split) + '.h5'), {
'outputs': outputs1,
'preds': preds1,
'targets': targets1
})
dd.io.save(os.path.join(res_dir, 'UM_' + str(args.split) + '.h5'), {
'outputs': outputs2,
'preds': preds2,
'targets': targets2
})
dd.io.save(os.path.join(res_dir, 'USM_' + str(args.split) + '.h5'), {
'outputs': outputs3,
'preds': preds3,
'targets': targets3
})
dd.io.save(os.path.join(res_dir, 'UCLA_' + str(args.split) + '.h5'), {
'outputs': outputs4,
'preds': preds4,
'targets': targets4
})
dd.io.save(os.path.join(res_dir, 'train_loss.h5'), {'loss': train_loss})
print('Best Acc:', best_acc)
print('split:', args.split, ' noise:', args.noise, ' pace:', args.pace)
import torch
import sys
import argparse
from networks import CNN, SoftMax, MLP
from modules import buildModel, reconstructionAttack, buildDAELayer, buildDAESoftmaxModel
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
print('Running on', device)
print("Building Models")
print("SoftMax")
buildModel(SoftMax(), 0.1, True, True)
print("MLP")
buildModel(MLP(), 0.1, True, True)
print("DAE")
buildDAELayer(DAELayer(10304, 1000), lRate=1e-4, epochs=5000, plot=True)
buildDAELayer(DAELayer(1000, 300), lRate=1e-4, epochs=5000, plot=True)
buildDAESoftmaxModel(DAESoftMax(), lRate=1e-2, epochs=1000, plot=True)
print("CNN")
buildModel(CNN(), 0.001, True, True)
print("\nModel(s) is reconstructed with alpha =", 5000, "beta =", 100,
"gamma =", 0.01, "delta =", 0.1)
print("Attacking Models")
# SoftMax Model from paper
print("Softmax")
reconstructionAttack(SoftMax())
def __init__(self,
name,
ob_dim,
out_activation=None,
hidden_dims=[64, 64],
hidden_activation=tf.nn.tanh,
weight_init=tf.contrib.layers.xavier_initializer,
bias_init=tf.zeros_initializer,
discount=0.99,
learning_rate=1e-3):
self.last_loss = -np.log(0.5)
self.noise_param = 0
with tf.variable_scope(name):
self.obs = tf.placeholder(tf.float32,
shape=[None, ob_dim],
name='obs')
self.next_obs = tf.placeholder(tf.float32,
shape=[None, ob_dim],
name='next_obs')
# reward network. assumes rewards are functions of state only
self.reward_network = MLP('reward',
ob_dim,
1,
out_activation=out_activation,
hidden_dims=hidden_dims,
hidden_activation=hidden_activation,
weight_init=weight_init,
bias_init=bias_init,
in_layer=self.obs)
self.rewards = self.reward_network.layers['out']
# value network
self.value_network = MLP('value',
ob_dim,
1,
out_activation=out_activation,
hidden_dims=hidden_dims,
hidden_activation=hidden_activation,
weight_init=weight_init,
bias_init=bias_init,
in_layer=self.obs)
self.next_value_network = MLP('value',
ob_dim,
1,
out_activation=out_activation,
hidden_dims=hidden_dims,
hidden_activation=hidden_activation,
weight_init=weight_init,
bias_init=bias_init,
in_layer=self.next_obs,
reuse=True)
self.values = self.value_network.layers['out']
self.next_values = self.next_value_network.layers['out']
# estimate p(a | s, expert) as follows:
self.expert_action_log_probs = self.rewards + discount * self.next_values - self.values
self.policy_action_log_probs = tf.placeholder(
tf.float32, shape=[None, 1], name='policy_action_log_probs')
self.expert_log_probs = self.expert_action_log_probs - tf.reduce_logsumexp(
tf.stack((self.expert_action_log_probs,
self.policy_action_log_probs)),
axis=0)
# training
self.labels = tf.placeholder(
tf.float32, shape=[None, 1],
name='labels') # 1 if from expert else 0
# self.expert_loss = -tf.log(self.expert_probs)
# self.policy_loss = -tf.log(1-self.expert_probs)
self.loss = -tf.reduce_mean(
self.labels * self.expert_log_probs + (1 - self.labels) *
tf.log(1 - tf.exp(self.expert_log_probs) + 1e-8))
self.train_op = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(self.loss)
def __init__(
self,
name,
ob_dim,
action_dim,
var_network=False, # NN if true, else trainable params indep of obs
out_activation=None,
hidden_dims=[64, 64],
hidden_activation=tf.nn.tanh,
weight_init=tf.contrib.layers.xavier_initializer,
bias_init=tf.zeros_initializer,
optimizer=ClipPPO):
with tf.variable_scope(name):
self.obs = tf.placeholder(tf.float32,
shape=[None, ob_dim],
name='obs')
# policy net
self.mean_network = MLP('means',
ob_dim,
action_dim,
out_activation=out_activation,
hidden_dims=hidden_dims,
hidden_activation=hidden_activation,
weight_init=weight_init,
bias_init=bias_init,
in_layer=self.obs)
self.means = self.mean_network.layers['out']
if var_network:
self.log_var_network = MLP('log_vars',
ob_dim,
action_dim,
out_activation=out_activation,
hidden_dims=hidden_dims,
hidden_activation=hidden_activation,
weight_init=weight_init,
bias_init=bias_init,
in_layer=self.obs)
self.log_vars = self.log_var_network.layers['out']
else:
self.log_var_network = MLP('log_vars',
ob_dim,
action_dim,
out_activation=out_activation,
hidden_dims=[],
hidden_activation=hidden_activation,
weight_init=weight_init,
bias_init=bias_init,
in_layer=self.obs)
self.log_vars = self.log_var_network.layers['out']
self.distribution = DiagGaussian(self.means, self.log_vars)
self.sampled_actions = self.distribution.sample()
self.actions = tf.placeholder(tf.float32,
shape=[None, action_dim],
name='actions')
self.action_log_probs = self.distribution.log_prob(self.actions)
self.entropies = self.distribution.entropy()
# value net
self.value_network = MLP('values',
ob_dim,
1,
out_activation=out_activation,
hidden_dims=hidden_dims,
hidden_activation=hidden_activation,
weight_init=weight_init,
bias_init=bias_init,
in_layer=self.obs)
self.values = self.value_network.layers['out']
# training, PPO for now
self.optimizer = optimizer(ob_dim, action_dim, self)
def main(args):
if not os.path.exists(args.res_dir):
os.mkdir(args.res_dir)
if not os.path.exists(os.path.join(args.res_dir, args.trainsite)):
os.mkdir(os.path.join(args.res_dir, args.trainsite))
if not os.path.exists(args.model_dir):
os.mkdir(args.model_dir)
torch.manual_seed(args.seed)
data1 = dd.io.load(os.path.join(args.vec_dir, 'NYU_correlation_matrix.h5'))
data2 = dd.io.load(os.path.join(args.vec_dir, 'UM_correlation_matrix.h5'))
data3 = dd.io.load(os.path.join(args.vec_dir, 'USM_correlation_matrix.h5'))
data4 = dd.io.load(os.path.join(args.vec_dir,
'UCLA_correlation_matrix.h5'))
x1 = torch.from_numpy(data1['data']).float()
y1 = torch.from_numpy(data1['label']).long()
x2 = torch.from_numpy(data2['data']).float()
y2 = torch.from_numpy(data2['label']).long()
x3 = torch.from_numpy(data3['data']).float()
y3 = torch.from_numpy(data3['label']).long()
x4 = torch.from_numpy(data4['data']).float()
y4 = torch.from_numpy(data4['label']).long()
if args.sepnorm:
mean = x1.mean(0, keepdim=True)
dev = x1.std(0, keepdim=True)
x1 = (x1 - mean) / dev
mean = x2.mean(0, keepdim=True)
dev = x2.std(0, keepdim=True)
x2 = (x2 - mean) / dev
mean = x3.mean(0, keepdim=True)
dev = x3.std(0, keepdim=True)
x3 = (x3 - mean) / dev
mean = x4.mean(0, keepdim=True)
dev = x4.std(0, keepdim=True)
x4 = (x4 - mean) / dev
else:
if args.trainsite == 'NYU':
mean = x1.mean(0, keepdim=True)
dev = x1.std(0, keepdim=True)
elif args.trainsite == 'UM':
mean = x2.mean(0, keepdim=True)
dev = x2.std(0, keepdim=True)
elif args.trainsite == 'USM':
mean = x3.mean(0, keepdim=True)
dev = x3.std(0, keepdim=True)
elif args.trainsite == 'UCLA':
mean = x4.mean(0, keepdim=True)
dev = x4.std(0, keepdim=True)
x1 = (x1 - mean) / dev
x2 = (x2 - mean) / dev
x3 = (x3 - mean) / dev
x4 = (x4 - mean) / dev
datas = [
TensorDataset(x1, y1),
TensorDataset(x2, y2),
TensorDataset(x3, y3),
TensorDataset(x4, y4)
]
if args.trainsite == 'NYU':
train_loader = DataLoader(datas[0],
batch_size=args.batch_size,
shuffle=True)
elif args.trainsite == 'UM':
train_loader = DataLoader(datas[1],
batch_size=args.batch_size,
shuffle=True)
elif args.trainsite == 'USM':
train_loader = DataLoader(datas[2],
batch_size=args.batch_size,
shuffle=True)
elif args.trainsite == 'UCLA':
train_loader = DataLoader(datas[3],
batch_size=args.batch_size,
shuffle=True)
test_loader1 = DataLoader(datas[0],
batch_size=args.test_batch_size1,
shuffle=False)
test_loader2 = DataLoader(datas[1],
batch_size=args.test_batch_size2,
shuffle=False)
test_loader3 = DataLoader(datas[2],
batch_size=args.test_batch_size3,
shuffle=False)
test_loader4 = DataLoader(datas[3],
batch_size=args.test_batch_size4,
shuffle=False)
model = MLP(6105, args.dim, 2).to(device)
optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=5e-2)
print(model)
nnloss = nn.NLLLoss()
def train(data_loader, epoch):
model.train()
if epoch <= 50 and epoch % 20 == 0:
for param_group1 in optimizer.param_groups:
param_group1['lr'] = 0.5 * param_group1['lr']
elif epoch > 50 and epoch % 20 == 0:
for param_group1 in optimizer.param_groups:
param_group1['lr'] = 0.5 * param_group1['lr']
loss_all1 = 0
for data, target in data_loader:
optimizer.zero_grad()
data = data.to(device)
target = target.to(device)
output1 = model(data)
loss1 = nnloss(output1, target)
loss1.backward()
loss_all1 += loss1.item() * target.size(0)
optimizer.step()
return loss_all1 / (len(data_loader.dataset)), model
def test(data_loader, train=False):
model.eval()
test_loss = 0
correct = 0
outputs = []
preds = []
targets = []
for data, target in data_loader:
data = data.to(device)
targets.append(target[0].detach().numpy())
target = target.to(device)
output = federated_model(data)
outputs.append(output.detach().cpu().numpy())
test_loss += nnloss(output, target).item() * target.size(0)
pred = output.data.max(1)[1]
preds.append(pred.detach().cpu().numpy())
correct += pred.eq(target.view(-1)).sum().item()
test_loss /= len(data_loader.dataset)
correct /= len(data_loader.dataset)
if train:
print(
'Train set: Average loss: {:.4f}, Average acc: {:.4f}'.format(
test_loss, correct))
else:
print('Test set: Average loss: {:.4f}, Average acc: {:.4f}'.format(
test_loss, correct))
return test_loss, correct, targets, outputs, preds
for epoch in range(args.epochs):
start_time = time.time()
print(f"Epoch Number {epoch + 1}")
l1, federated_model = train(train_loader, epoch)
print(' L1 loss: {:.4f}'.format(l1))
print('===NYU===')
_, acc1, targets1, outputs1, preds1 = test(test_loader1, train=False)
print('===UM===')
_, acc2, targets2, outputs2, preds2 = test(test_loader2, train=False)
print('===USM===')
_, acc3, targets3, outputs3, preds3 = test(test_loader3, train=False)
print('===UCLA===')
_, acc4, targets4, outputs4, preds4 = test(test_loader4, train=False)
total_time = time.time() - start_time
print('Communication time over the network', round(total_time, 2),
's\n')
model_wts = copy.deepcopy(model.state_dict())
torch.save(model_wts, os.path.join(args.model_dir,
args.trainsite + '.pth'))
dd.io.save(os.path.join(args.res_dir, args.trainsite, 'NYU.h5'), {
'outputs': outputs1,
'preds': preds1,
'targets': targets1
})
dd.io.save(os.path.join(args.res_dir, args.trainsite, 'UM.h5'), {
'outputs': outputs2,
'preds': preds2,
'targets': targets2
})
dd.io.save(os.path.join(args.res_dir, args.trainsite, 'USM.h5'), {
'outputs': outputs3,
'preds': preds3,
'targets': targets3
})
dd.io.save(os.path.join(args.res_dir, args.trainsite, 'UCLA.h5'), {
'outputs': outputs4,
'preds': preds4,
'targets': targets4
})
def get_network(model, channel, num_classes, im_size=(32, 32)):
torch.random.manual_seed(int(time.time() * 1000) % 100000)
net_width, net_depth, net_act, net_norm, net_pooling = get_default_convnet_setting(
)
if model == 'MLP':
net = MLP(channel=channel, num_classes=num_classes)
elif model == 'ConvNet':
net = ConvNet(channel=channel,
num_classes=num_classes,
net_width=net_width,
net_depth=net_depth,
net_act=net_act,
net_norm=net_norm,
net_pooling=net_pooling,
im_size=im_size)
elif model == 'LeNet':
net = LeNet(channel=channel, num_classes=num_classes)
elif model == 'AlexNet':
net = AlexNet(channel=channel, num_classes=num_classes)
elif model == 'VGG11':
net = VGG11(channel=channel, num_classes=num_classes)
elif model == 'VGG11BN':
net = VGG11BN(channel=channel, num_classes=num_classes)
elif model == 'ResNet18':
net = ResNet18(channel=channel, num_classes=num_classes)
elif model == 'ResNet18BN_AP':
net = ResNet18BN_AP(channel=channel, num_classes=num_classes)
elif model == 'ConvNetD1':
net = ConvNet(channel=channel,
num_classes=num_classes,
net_width=net_width,
net_depth=1,
net_act=net_act,
net_norm=net_norm,
net_pooling=net_pooling)
elif model == 'ConvNetD2':
net = ConvNet(channel=channel,
num_classes=num_classes,
net_width=net_width,
net_depth=2,
net_act=net_act,
net_norm=net_norm,
net_pooling=net_pooling)
elif model == 'ConvNetD3':
net = ConvNet(channel=channel,
num_classes=num_classes,
net_width=net_width,
net_depth=3,
net_act=net_act,
net_norm=net_norm,
net_pooling=net_pooling)
elif model == 'ConvNetD4':
net = ConvNet(channel=channel,
num_classes=num_classes,
net_width=net_width,
net_depth=4,
net_act=net_act,
net_norm=net_norm,
net_pooling=net_pooling)
elif model == 'ConvNetW32':
net = ConvNet(channel=channel,
num_classes=num_classes,
net_width=32,
net_depth=net_depth,
net_act=net_act,
net_norm=net_norm,
net_pooling=net_pooling)
elif model == 'ConvNetW64':
net = ConvNet(channel=channel,
num_classes=num_classes,
net_width=64,
net_depth=net_depth,
net_act=net_act,
net_norm=net_norm,
net_pooling=net_pooling)
elif model == 'ConvNetW128':
net = ConvNet(channel=channel,
num_classes=num_classes,
net_width=128,
net_depth=net_depth,
net_act=net_act,
net_norm=net_norm,
net_pooling=net_pooling)
elif model == 'ConvNetW256':
net = ConvNet(channel=channel,
num_classes=num_classes,
net_width=256,
net_depth=net_depth,
net_act=net_act,
net_norm=net_norm,
net_pooling=net_pooling)
elif model == 'ConvNetAS':
net = ConvNet(channel=channel,
num_classes=num_classes,
net_width=net_width,
net_depth=net_depth,
net_act='sigmoid',
net_norm=net_norm,
net_pooling=net_pooling)
elif model == 'ConvNetAR':
net = ConvNet(channel=channel,
num_classes=num_classes,
net_width=net_width,
net_depth=net_depth,
net_act='relu',
net_norm=net_norm,
net_pooling=net_pooling)
elif model == 'ConvNetAL':
net = ConvNet(channel=channel,
num_classes=num_classes,
net_width=net_width,
net_depth=net_depth,
net_act='leakyrelu',
net_norm=net_norm,
net_pooling=net_pooling)
elif model == 'ConvNetNN':
net = ConvNet(channel=channel,
num_classes=num_classes,
net_width=net_width,
net_depth=net_depth,
net_act=net_act,
net_norm='none',
net_pooling=net_pooling)
elif model == 'ConvNetBN':
net = ConvNet(channel=channel,
num_classes=num_classes,
net_width=net_width,
net_depth=net_depth,
net_act=net_act,
net_norm='batchnorm',
net_pooling=net_pooling)
elif model == 'ConvNetLN':
net = ConvNet(channel=channel,
num_classes=num_classes,
net_width=net_width,
net_depth=net_depth,
net_act=net_act,
net_norm='layernorm',
net_pooling=net_pooling)
elif model == 'ConvNetIN':
net = ConvNet(channel=channel,
num_classes=num_classes,
net_width=net_width,
net_depth=net_depth,
net_act=net_act,
net_norm='instancenorm',
net_pooling=net_pooling)
elif model == 'ConvNetGN':
net = ConvNet(channel=channel,
num_classes=num_classes,
net_width=net_width,
net_depth=net_depth,
net_act=net_act,
net_norm='groupnorm',
net_pooling=net_pooling)
elif model == 'ConvNetNP':
net = ConvNet(channel=channel,
num_classes=num_classes,
net_width=net_width,
net_depth=net_depth,
net_act=net_act,
net_norm=net_norm,
net_pooling='none')
elif model == 'ConvNetMP':
net = ConvNet(channel=channel,
num_classes=num_classes,
net_width=net_width,
net_depth=net_depth,
net_act=net_act,
net_norm=net_norm,
net_pooling='maxpooling')
elif model == 'ConvNetAP':
net = ConvNet(channel=channel,
num_classes=num_classes,
net_width=net_width,
net_depth=net_depth,
net_act=net_act,
net_norm=net_norm,
net_pooling='avgpooling')
else:
net = None
exit('DC error: unknown model')
gpu_num = torch.cuda.device_count()
if gpu_num > 0:
device = 'cuda'
if gpu_num > 1:
net = nn.DataParallel(net)
else:
device = 'cpu'
net = net.to(device)
return net
def file_classify_demo(fobjs: List[FileInfo]):
words = {}
for fobj in filter(lambda x: not x.istest, fobjs):
for kw, freq in zip(fobj.keywords, fobj.kwfreq):
if kw in words:
words[kw] += freq
else:
words[kw] = freq
# make keyword score vec: train and test
all_wordvec = []
all_wordvec_test = []
labels_train = []
labels_test = []
for fobj in fobjs:
fobj.set_wordvec(words)
if not fobj.kwfreq:
continue
if not fobj.istest:
all_wordvec.append(fobj.wordvec)
labels_train.append(fobj.label)
# curlabel = [0] * 5
# curlabel[fobj.label] = 1
# labels.append(curlabel)
else:
all_wordvec_test.append(fobj.wordvec)
labels_test.append(fobj.label)
# pca make fingerprints
inputdim = 20
outputdim = 7
pca = PCA(n_components=inputdim)
pca.fit(all_wordvec)
fprints = pca.transform(all_wordvec)
fprints_test = pca.transform(all_wordvec_test)
print('PCA ratio sum:', sum(pca.explained_variance_ratio_))
print()
x_train = torch.from_numpy(fprints).float()
x_test = torch.from_numpy(fprints_test).float()
y_train = torch.Tensor(labels_train).long() # float()
train_dataset = TensorDataset(x_train, y_train)
dloader = DataLoader(train_dataset, batch_size=6, shuffle=True)
model = MLP(inputdim, outputdim)
optimizer = optim.Adam(model.parameters(), lr=0.01)
lossfunc = nn.CrossEntropyLoss()
epoch = 300 + 1
for ecnt in range(epoch):
for i, data in enumerate(dloader):
optimizer.zero_grad()
inputs, labels = data
inputs = torch.autograd.Variable(inputs)
labels = torch.autograd.Variable(labels)
outputs = model(inputs)
loss = lossfunc(outputs, labels) # / outputs.size()[0]
# loss = torch.Tensor([0])
# for b in range(outputs.size()[0]):
# loss += sum(abs(outputs[b] - labels[b]))
# loss /= outputs.size()[0]
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(),
5) # clip param important
optimizer.step()
# if i % 1 == 0:
# print(i, ":", loss)
# print(outputs)
# print(labels)
if ecnt % 20 == 0:
print('Epoch:', ecnt)
model.eval()
y_train_step = model(x_train)
y_train_step_label = np.argmax(y_train_step.data, axis=1)
y_test_step = model(x_test)
y_test_step_label = np.argmax(y_test_step.data, axis=1)
tran_accu = len(
list(
filter(lambda x: x == 0, y_train_step_label -
np.array(labels_train)))) / len(labels_train)
test_accu = len(
list(
filter(lambda x: x == 0, y_test_step_label -
np.array(labels_test)))) / len(labels_test)
print('tran_accu', tran_accu)
print('test_accu', test_accu)
print()
model.train()
# save model
save_path = r'.\ai\classify-demo.pth'
torch.save(model.state_dict(), save_path)
# load model
new_model = MLP(inputdim, outputdim)
new_model.load_state_dict(torch.load(save_path))
y_train_look = new_model(x_train)
y_test = new_model(x_test)
print(y_train_look)
print(y_test)
print(np.argmax(y_test.data, axis=1))
print(labels_test)
print(len(labels_test))
print(len(labels_train))
def main(args):
torch.manual_seed(args.seed)
if not os.path.exists(args.res_dir):
os.mkdir(args.res_dir)
if not os.path.exists(args.model_dir):
os.mkdir(args.model_dir)
if not os.path.exists(os.path.join(args.model_dir, args.site)):
os.mkdir(os.path.join(args.model_dir, args.site))
save_model_dir = os.path.join(args.model_dir, args.site)
data = dd.io.load(
os.path.join(args.vec_dir, args.site + '_correlation_matrix.h5'))
x = torch.from_numpy(data['data']).float()
y = torch.from_numpy(data['label']).long()
if args.site == 'NYU':
rep = 145 #7
elif args.site == 'UM':
rep = 265 #9
elif args.site == 'USM':
rep = 205 #8
elif args.site == 'UCLA':
rep = 85 #7
split_dir = os.path.join(args.id_dir, args.site + '_sub_overlap.h5')
if not os.path.exists(split_dir): #save splitting
n = len(y) // rep
ll = list(range(n))
random.seed(args.seed)
random.shuffle(ll)
list1 = dict()
for i in range(5): # 5 splits
list1[i] = list()
if i != 4:
temp = ll[i * n // 5:(i + 1) * n // 5]
else:
temp = ll[4 * n // 5:]
for t in temp:
list1[i] += [t * rep + j for j in range(rep)]
dd.io.save(
split_dir, {
'0': list1[0],
'1': list1[1],
'2': list1[2],
'3': list1[3],
'4': list1[4]
})
print("data saved")
id = dd.io.load(split_dir)
if args.split == 0:
tr = id['1'] + id['2'] + id['3'] + id['4']
te = id['0']
elif args.split == 1:
tr = id['0'] + id['2'] + id['3'] + id['4']
te = id['1']
elif args.split == 2:
tr = id['0'] + id['1'] + id['3'] + id['4']
te = id['2']
elif args.split == 3:
tr = id['0'] + id['1'] + id['2'] + id['4']
te = id['3']
elif args.split == 4:
tr = id['0'] + id['1'] + id['2'] + id['3']
te = id['4']
x_train = x[tr]
y_train = y[tr]
x_test = x[te]
y_test = y[te]
mean = x_train.mean(0, keepdim=True)
dev = x_train.std(0, keepdim=True)
x_train = (x_train - mean) / dev
x_test = (x_test - mean) / dev
train = TensorDataset(x_train, y_train)
train_loader = DataLoader(train, batch_size=args.batch_size, shuffle=True)
test = TensorDataset(x_test, y_test)
test_loader = DataLoader(test, batch_size=rep, shuffle=False)
model = MLP(6105, args.dim, 2).to(device)
optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=5e-2)
print(model)
def train(data_loader, optimizer, epoch):
model.train()
if epoch <= 50 and epoch % 20 == 0:
for param_group1 in optimizer.param_groups:
param_group1['lr'] = 0.5 * param_group1['lr']
elif epoch > 50 and epoch % 20 == 0:
for param_group1 in optimizer.param_groups:
param_group1['lr'] = 0.5 * param_group1['lr']
loss_all = 0
for data, target in data_loader:
optimizer.zero_grad()
data = data.to(device)
target = target.to(device)
output = model(data)
loss = nnloss(output, target)
loss.backward()
loss_all += loss.item() * target.size(0)
optimizer.step()
return loss_all / (len(data_loader.dataset))
def test(data_loader, train):
model.eval()
test_loss = 0
correct = 0
outputs = []
preds = []
targets = []
for data, target in data_loader:
data = data.to(device)
targets.append(target[0].detach().numpy())
target = target.to(device)
output = model(data)
outputs.append(output.detach().cpu().numpy())
test_loss += nnloss(output, target).item() * target.size(0)
pred = output.data.max(1)[1]
preds.append(pred.detach().cpu().numpy())
correct += pred.eq(target.view(-1)).sum().item()
test_loss /= len(data_loader.dataset)
correct /= len(data_loader.dataset)
if train:
print(
'Train set: Average loss: {:.4f}, Average acc: {:.4f}'.format(
test_loss, correct))
else:
print('Test set: Average loss: {:.4f}, Average acc: {:.4f}'.format(
test_loss, correct))
return targets, outputs, preds
for epoch in range(args.epochs):
start_time = time.time()
print(f"Epoch Number {epoch + 1}")
l1 = train(train_loader, optimizer, epoch)
print(' L1 loss: {:.4f}'.format(l1))
test(train_loader, train=True)
targets, outputs, preds = test(test_loader, train=False)
total_time = time.time() - start_time
print('Communication time over the network', round(total_time, 2),
's\n')
model_wts = copy.deepcopy(model.state_dict())
torch.save(model_wts, os.path.join(save_model_dir,
str(args.split) + '.pth'))
dd.io.save(
os.path.join(args.res_dir, args.site + '_' + str(args.split) + '.h5'),
{
'outputs': outputs,
'preds': preds,
'targets': targets
})
print('site:', args.site, ' split:', args.split)
parser.add_argument('--penalty', type=float, default=0)
parser.add_argument('--T', type=int, default=4)
parser.add_argument('--units', action=partition('-', int), default=(256, ))
args = parser.parse_args()
print args
if args.gpu < 0:
cuda = False
else:
cuda = True
th.cuda.set_device(args.gpu)
loader_dict, size = create_mnist_loaders(args.mnist_path, args.batch_size)
n_pixels = size[0] * size[1]
feature_extractor = MLP(n_pixels, args.n_features, args.units, args.nonlinear)
model = Network0(feature_extractor, args.n_features, size, args.T,
args.penalty)
if cuda:
model.cuda()
optimizer = th.optim.Adam(model.parameters(), args.lr)
visdom = Visdom(env=__file__)
tl_vis = TraceVisualizer(visdom, {'title': 'training loss'})
ta_vis = TraceVisualizer(visdom, {'title': 'training accuracy'})
va_vis = TraceVisualizer(visdom, {'title': 'validation accuracy'})
opts = {'width': args.mask_vis_width, 'height': args.mask_vis_height}
mask_vis_tuple = tuple(ImageVisualizer(visdom, opts) for _ in range(args.T))
from networks import CNN, SoftMax, MLP
from modules import buildModel, reconstructionAttack
print("Building Models")
print("SoftMax")
buildModel(SoftMax(), 0.1, True, True)
print("MLP")
buildModel(MLP(), 0.1, True, True)
print("DAE")
buildDAELayer(DAELayer(10304, 1000), lRate=1e-4, epochs=5000, plot=True)
buildDAELayer(DAELayer(1000, 300), lRate=1e-4, epochs=5000, plot=True)
buildDAESoftmaxModel(DAESoftMax(), lRate=1e-2, epochs=1000, plot=True)
print("CNN")
buildModel(CNN(), 0.001, True, True)
os.makedirs(opt.resf, exist_ok=True)
if opt.show_input:
resfwi = os.path.join(os.path.split(opt.resf)[0], os.path.split(opt.resf)[1] + '_with_input')
os.makedirs(resfwi, exist_ok=True)
opt.resfwi = resfwi
print_and_write_log(test_log_file, opt)
device = torch.device("cuda:0" if not opt.no_cuda else "cpu")
nc = int(opt.nc)
imageSize = int(opt.imageSize)
nz = int(opt.nz)
nblk = int(opt.nblk)
model_netG = MLP(input_dim=nc * imageSize * imageSize,
output_dim=nc * imageSize * imageSize,
dim=nz,
n_blk=nblk,
norm='none',
activ='relu').to(device)
model_netG.load_state_dict(torch.load(opt.netG, map_location=device))
print_and_write_log(test_log_file, 'netG:')
print_and_write_log(test_log_file, str(model_netG))
if opt.eval:
model_netG.eval()
for i, data in enumerate(tqdm(dataloader), 0):
img, img_path = data
img_name = os.path.splitext(os.path.basename(img_path[0]))[0] + '.png'
if i >= opt.num_test:
break
real = img.to(device)
def main(args):
seed = 999
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.backends.cudnn.deterministic = True
sites = ['NYU','UCLA','UM','USM']
models_cross = []
for file in sites:
if file != args.site:
model = MLP(6105,8,2).to(device)
model.load_state_dict(torch.load(os.path.join('./model/cross_overlap',file+'.pth')))
models_cross.append(model)
model_single = MLP(6105,8,2).to(device)
model_single.load_state_dict(torch.load(os.path.join('./model/single_overlap', args.site, str(args.split) + '.pth')))
data1 = dd.io.load(os.path.join(args.vec_dir,'NYU_correlation_matrix.h5'))
data2 = dd.io.load(os.path.join(args.vec_dir,'UM_correlation_matrix.h5'))
data3 = dd.io.load(os.path.join(args.vec_dir,'USM_correlation_matrix.h5'))
data4 = dd.io.load(os.path.join(args.vec_dir,'UCLA_correlation_matrix.h5'))
x1 = torch.from_numpy(data1['data']).float()
y1 = torch.from_numpy(data1['label']).long()
x2 = torch.from_numpy(data2['data']).float()
y2 = torch.from_numpy(data2['label']).long()
x3 = torch.from_numpy(data3['data']).float()
y3 = torch.from_numpy(data3['label']).long()
x4 = torch.from_numpy(data4['data']).float()
y4 = torch.from_numpy(data4['label']).long()
idNYU = dd.io.load('./idx/NYU_sub_overlap.h5')
idUM = dd.io.load('./idx/UM_sub_overlap.h5')
idUSM = dd.io.load('./idx/USM_sub_overlap.h5')
idUCLA = dd.io.load('./idx/UCLA_sub_overlap.h5')
if args.split == 0:
tr1 = idNYU['1'] + idNYU['2'] + idNYU['3'] + idNYU['4']
tr2 = idUM['1'] + idUM['2'] + idUM['3'] + idUM['4']
tr3 = idUSM['1'] + idUSM['2'] + idUSM['3'] + idUSM['4']
tr4 = idUCLA['1'] + idUCLA['2'] + idUCLA['3'] + idUCLA['4']
te1 = idNYU['0']
te2 = idUM['0']
te3 = idUSM['0']
te4 = idUCLA['0']
elif args.split == 1:
tr1 = idNYU['0'] + idNYU['2'] + idNYU['3'] + idNYU['4']
tr2 = idUM['0'] + idUM['2'] + idUM['3'] + idUM['4']
tr3 = idUSM['0'] + idUSM['2'] + idUSM['3'] + idUSM['4']
tr4 = idUCLA['0'] + idUCLA['2'] + idUCLA['3'] + idUCLA['4']
te1 = idNYU['1']
te2 = idUM['1']
te3 = idUSM['1']
te4 = idUCLA['1']
elif args.split == 2:
tr1 = idNYU['0'] + idNYU['1'] + idNYU['3'] + idNYU['4']
tr2 = idUM['0'] + idUM['1'] + idUM['3'] + idUM['4']
tr3 = idUSM['0'] + idUSM['1'] + idUSM['3'] + idUSM['4']
tr4 = idUCLA['0'] + idUCLA['1'] + idUCLA['3'] + idUCLA['4']
te1 = idNYU['2']
te2 = idUM['2']
te3 = idUSM['2']
te4 = idUCLA['2']
elif args.split == 3:
tr1 = idNYU['0'] + idNYU['1'] + idNYU['2'] + idNYU['4']
tr2 = idUM['0'] + idUM['1'] + idUM['2'] + idUM['4']
tr3 = idUSM['0'] + idUSM['1'] + idUSM['2'] + idUSM['4']
tr4 = idUCLA['0'] + idUCLA['1'] + idUCLA['2'] + idUCLA['4']
te1 = idNYU['3']
te2 = idUM['3']
te3 = idUSM['3']
te4 = idUCLA['3']
elif args.split == 4:
tr1 = idNYU['0'] + idNYU['1'] + idNYU['2'] + idNYU['3']
tr2 = idUM['0'] + idUM['1'] + idUM['2'] + idUM['3']
tr3 = idUSM['0'] + idUSM['1'] + idUSM['2'] + idUSM['3']
tr4 = idUCLA['0'] + idUCLA['1'] + idUCLA['2'] + idUCLA['3']
te1 = idNYU['4']
te2 = idUM['4']
te3 = idUSM['4']
te4 = idUCLA['4']
x1_train = x1[tr1]
y1_train = y1[tr1]
x2_train = x2[tr2]
y2_train = y2[tr2]
x3_train = x3[tr3]
y3_train = y3[tr3]
x4_train = x4[tr4]
y4_train = y4[tr4]
x1_test = x1[te1]
y1_test = y1[te1]
x2_test = x2[te2]
y2_test = y2[te2]
x3_test = x3[te3]
y3_test = y3[te3]
x4_test = x4[te4]
y4_test = y4[te4]
mean = x1_train.mean(0, keepdim=True)
dev = x1_train.std(0, keepdim=True)
x1_test = (x1_test - mean) / dev
mean = x2_train.mean(0, keepdim=True)
dev = x2_train.std(0, keepdim=True)
x2_test = (x2_test - mean) / dev
mean = x3_train.mean(0, keepdim=True)
dev = x3_train.std(0, keepdim=True)
x3_test = (x3_test - mean) / dev
mean = x4_train.mean(0, keepdim=True)
dev = x4_train.std(0, keepdim=True)
x4_test = (x4_test - mean) / dev
test1 = TensorDataset(x1_test, y1_test)
test2 = TensorDataset(x2_test, y2_test)
test3 = TensorDataset(x3_test, y3_test)
test4 = TensorDataset(x4_test, y4_test)
if args.site == 'NYU':
test = test1
elif args.site == 'UM':
test = test2
elif args.site == 'USM':
test = test3
elif args.site == 'UCLA':
test = test4
te_data = test.tensors[0].to(device)
te_outputs = []
targets = test.tensors[1].numpy()
preds =[]
#cross model
for model in models_cross:
model.eval()
te_output = model(te_data)
te_outputs.append(torch.exp(te_output))
# single_model
model_single.eval()
te_output = model_single(te_data)
te_outputs.append(torch.exp(te_output))
outputtorch = torch.stack(te_outputs,dim=0)
output_mean = torch.mean(outputtorch,dim=0)
preds = output_mean.data.max(1)[1].detach().cpu().numpy()
if not os.path.exists(args.res_dir):
os.mkdir(args.res_dir)
dd.io.save(os.path.join(args.res_dir, args.site+ '_' + str(args.split) + '.h5'),
{'preds': preds, 'targets': targets})
tf.reset_default_graph()
x_in = tf.placeholder( dtype = tf.float64, shape = [None,noFets])
y_in = tf.placeholder( dtype = tf.int64, shape = [None])
lmbdaIn = tf.placeholder( dtype = tf.float64, shape = [])
if regType == 1:
reg = tf.contrib.layers.l1_regularizer( lmbdaIn)
else:
reg = tf.contrib.layers.l2_regularizer( 2*lmbdaIn)
with tf.variable_scope("Model"):
logits = MLP( x_in, units, tf.nn.relu, outDim, reg = reg)
if outDim != 1:
loss = tf.losses.sparse_softmax_cross_entropy(
labels = y_in, logits = logits)
else:
loss = tf.losses.sigmoid_cross_entropy(
labels = y_in, logits = logits)
totalPar = 0
for iTens in tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope ='Model'):
if 'kernel:' in iTens.name or 'bias:' in iTens.name:
totalPar += np.prod( iTens.shape.as_list())
lossReg = tf.losses.get_regularization_loss() / totalPar
beta = int(args.beta[0])
gamma = float(args.gamma[0])
delta = float(args.delta[0])
print("\nModel(s) is reconstructed with alpha =", alpha, "beta =", beta,
"gamma =", gamma, "delta =", delta)
print("Models choosen", model)
if model == 'all':
# SoftMax Model from paper
print("Softmax")
reconstructionAttack(SoftMax(), alpha, beta, gamma, delta, True, False)
# MLP Model from paper
print("MLP")
reconstructionAttack(MLP(), alpha, beta, gamma, delta, True, False)
# DAE Model from paper
print("DAE")
reconstructionAttack(DAESoftMax(), alpha, beta, gamma, delta, True, False)
# CNN for comparison
print("CNN")
reconstructionAttack(CNN(), alpha, beta, gamma, delta, True, False)
else:
if model == 'Softmax':
# SoftMax Model from paper
print("Softmax")
reconstructionAttack(SoftMax(), alpha, beta, gamma, delta, True, False)
if model == 'MLP':
def main(args):
seed = 999
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.backends.cudnn.deterministic = True
models = []
if args.method == 'fed':
for i in range(5):
model = MLP(6105, 16, 2).to(device)
model.load_state_dict(
torch.load(os.path.join('./model/fed_overlap',
str(i) + '.pth')))
models.append(model)
elif args.method == 'single':
for i in range(5):
model = MLP(6105, 8, 2).to(device)
model.load_state_dict(
torch.load(
os.path.join('./model/single_overlap', args.site,
str(i) + '.pth')))
models.append(model)
elif args.method == 'mix':
for i in range(5):
model = MLP(6105, 16, 2).to(device)
model.load_state_dict(
torch.load(os.path.join('./model/mix_overlap',
str(i) + '.pth')))
models.append(model)
data1 = dd.io.load(os.path.join(args.vec_dir, 'NYU_correlation_matrix.h5'))
data2 = dd.io.load(os.path.join(args.vec_dir, 'UM_correlation_matrix.h5'))
data3 = dd.io.load(os.path.join(args.vec_dir, 'USM_correlation_matrix.h5'))
data4 = dd.io.load(os.path.join(args.vec_dir,
'UCLA_correlation_matrix.h5'))
x1 = torch.from_numpy(data1['data']).float()
y1 = torch.from_numpy(data1['label']).long()
x2 = torch.from_numpy(data2['data']).float()
y2 = torch.from_numpy(data2['label']).long()
x3 = torch.from_numpy(data3['data']).float()
y3 = torch.from_numpy(data3['label']).long()
x4 = torch.from_numpy(data4['data']).float()
y4 = torch.from_numpy(data4['label']).long()
idNYU = dd.io.load('./idx/NYU_sub_overlap.h5')
idUM = dd.io.load('./idx/UM_sub_overlap.h5')
idUSM = dd.io.load('./idx/USM_sub_overlap.h5')
idUCLA = dd.io.load('./idx/UCLA_sub_overlap.h5')
grad = dict()
for i in range(5):
if i == 0:
tr1 = idNYU['1'] + idNYU['2'] + idNYU['3'] + idNYU['4']
tr2 = idUM['1'] + idUM['2'] + idUM['3'] + idUM['4']
tr3 = idUSM['1'] + idUSM['2'] + idUSM['3'] + idUSM['4']
tr4 = idUCLA['1'] + idUCLA['2'] + idUCLA['3'] + idUCLA['4']
te1 = idNYU['0']
te2 = idUM['0']
te3 = idUSM['0']
te4 = idUCLA['0']
elif i == 1:
tr1 = idNYU['0'] + idNYU['2'] + idNYU['3'] + idNYU['4']
tr2 = idUM['0'] + idUM['2'] + idUM['3'] + idUM['4']
tr3 = idUSM['0'] + idUSM['2'] + idUSM['3'] + idUSM['4']
tr4 = idUCLA['0'] + idUCLA['2'] + idUCLA['3'] + idUCLA['4']
te1 = idNYU['1']
te2 = idUM['1']
te3 = idUSM['1']
te4 = idUCLA['1']
elif i == 2:
tr1 = idNYU['0'] + idNYU['1'] + idNYU['3'] + idNYU['4']
tr2 = idUM['0'] + idUM['1'] + idUM['3'] + idUM['4']
tr3 = idUSM['0'] + idUSM['1'] + idUSM['3'] + idUSM['4']
tr4 = idUCLA['0'] + idUCLA['1'] + idUCLA['3'] + idUCLA['4']
te1 = idNYU['2']
te2 = idUM['2']
te3 = idUSM['2']
te4 = idUCLA['2']
elif i == 3:
tr1 = idNYU['0'] + idNYU['1'] + idNYU['2'] + idNYU['4']
tr2 = idUM['0'] + idUM['1'] + idUM['2'] + idUM['4']
tr3 = idUSM['0'] + idUSM['1'] + idUSM['2'] + idUSM['4']
tr4 = idUCLA['0'] + idUCLA['1'] + idUCLA['2'] + idUCLA['4']
te1 = idNYU['3']
te2 = idUM['3']
te3 = idUSM['3']
te4 = idUCLA['3']
elif i == 4:
tr1 = idNYU['0'] + idNYU['1'] + idNYU['2'] + idNYU['3']
tr2 = idUM['0'] + idUM['1'] + idUM['2'] + idUM['3']
tr3 = idUSM['0'] + idUSM['1'] + idUSM['2'] + idUSM['3']
tr4 = idUCLA['0'] + idUCLA['1'] + idUCLA['2'] + idUCLA['3']
te1 = idNYU['4']
te2 = idUM['4']
te3 = idUSM['4']
te4 = idUCLA['4']
x1_train = x1[tr1]
x2_train = x2[tr2]
x3_train = x3[tr3]
x4_train = x4[tr4]
x1_test = x1[te1]
y1_test = y1[te1]
x2_test = x2[te2]
y2_test = y2[te2]
x3_test = x3[te3]
y3_test = y3[te3]
x4_test = x4[te4]
y4_test = y4[te4]
mean = x1_train.mean(0, keepdim=True)
dev = x1_train.std(0, keepdim=True)
x1_test = (x1_test - mean) / dev
mean = x2_train.mean(0, keepdim=True)
dev = x2_train.std(0, keepdim=True)
x2_test = (x2_test - mean) / dev
mean = x3_train.mean(0, keepdim=True)
dev = x3_train.std(0, keepdim=True)
x3_test = (x3_test - mean) / dev
mean = x4_train.mean(0, keepdim=True)
dev = x4_train.std(0, keepdim=True)
x4_test = (x4_test - mean) / dev
if args.ASD:
x1_test = x1_test[y1_test == 1]
y1_test = y1_test[y1_test == 1]
x2_test = x2_test[y2_test == 1]
y2_test = y2_test[y2_test == 1]
x3_test = x3_test[y3_test == 1]
y3_test = y3_test[y3_test == 1]
x4_test = x4_test[y4_test == 1]
y4_test = y4_test[y4_test == 1]
elif args.HC:
x1_test = x1_test[y1_test == 0]
y1_test = y1_test[y1_test == 0]
x2_test = x2_test[y2_test == 0]
y2_test = y2_test[y2_test == 0]
x3_test = x3_test[y3_test == 0]
y3_test = y3_test[y3_test == 0]
x4_test = x4_test[y4_test == 0]
y4_test = y4_test[y4_test == 0]
else:
x1_test = x1_test
y1_test = y1_test
x2_test = x2_test
y2_test = y2_test
x3_test = x3_test
y3_test = y3_test
x4_test = x4_test
y4_test = y4_test
test1 = TensorDataset(x1_test, y1_test)
test2 = TensorDataset(x2_test, y2_test)
test3 = TensorDataset(x3_test, y3_test)
test4 = TensorDataset(x4_test, y4_test)
test_loader1 = DataLoader(test1, batch_size=1, shuffle=False)
test_loader2 = DataLoader(test2, batch_size=1, shuffle=False)
test_loader3 = DataLoader(test3, batch_size=1, shuffle=False)
test_loader4 = DataLoader(test4, batch_size=1, shuffle=False)
if args.site == 'NYU':
test_loader = test_loader1
elif args.site == 'UM':
test_loader = test_loader2
elif args.site == 'USM':
test_loader = test_loader3
elif args.site == 'UCLA':
test_loader = test_loader4
grad[i] = list()
gdbp = GuidedBackPropogation(models[i])
models[i].eval()
for data, target in test_loader:
data = data.to(device)
data = data.requires_grad_()
out_b = gdbp(data)
out_b[:, target.item()].backward()
grad_b = gdbp.get(data)
grad[i].append(grad_b)
if args.ASD:
dd.io.save(
os.path.join('./interpretation',
args.method + '_' + args.site + '.h5'),
{'grad': grad})
elif args.HC:
dd.io.save(
os.path.join('./interpretation_hc',
args.method + '_' + args.site + '.h5'),
{'grad': grad})
else:
dd.io.save(
os.path.join('./interpretation_2class',
args.method + '_' + args.site + '.h5'),
{'grad': grad})
def main(args):
torch.manual_seed(args.seed)
if not os.path.exists(args.res_dir):
os.mkdir(args.res_dir)
if not os.path.exists(args.model_dir):
os.mkdir(args.model_dir)
data1 = dd.io.load(os.path.join(args.vec_dir, 'NYU_correlation_matrix.h5'))
data2 = dd.io.load(os.path.join(args.vec_dir, 'UM_correlation_matrix.h5'))
data3 = dd.io.load(os.path.join(args.vec_dir, 'USM_correlation_matrix.h5'))
data4 = dd.io.load(os.path.join(args.vec_dir,
'UCLA_correlation_matrix.h5'))
x1 = torch.from_numpy(data1['data']).float()
y1 = torch.from_numpy(data1['label']).long()
x2 = torch.from_numpy(data2['data']).float()
y2 = torch.from_numpy(data2['label']).long()
x3 = torch.from_numpy(data3['data']).float()
y3 = torch.from_numpy(data3['label']).long()
x4 = torch.from_numpy(data4['data']).float()
y4 = torch.from_numpy(data4['label']).long()
if args.overlap:
idNYU = dd.io.load('./idx/NYU_sub_overlap.h5')
idUM = dd.io.load('./idx/UM_sub_overlap.h5')
idUSM = dd.io.load('./idx/USM_sub_overlap.h5')
idUCLA = dd.io.load('./idx/UCLA_sub_overlap.h5')
else:
idNYU = dd.io.load('./idx/NYU_sub.h5')
idUM = dd.io.load('./idx/UM_sub.h5')
idUSM = dd.io.load('./idx/USM_sub.h5')
idUCLA = dd.io.load('./idx/UCLA_sub.h5')
if args.split == 0:
tr1 = idNYU['1'] + idNYU['2'] + idNYU['3'] + idNYU['4']
tr2 = idUM['1'] + idUM['2'] + idUM['3'] + idUM['4']
tr3 = idUSM['1'] + idUSM['2'] + idUSM['3'] + idUSM['4']
tr4 = idUCLA['1'] + idUCLA['2'] + idUCLA['3'] + idUCLA['4']
te1 = idNYU['0']
te2 = idUM['0']
te3 = idUSM['0']
te4 = idUCLA['0']
elif args.split == 1:
tr1 = idNYU['0'] + idNYU['2'] + idNYU['3'] + idNYU['4']
tr2 = idUM['0'] + idUM['2'] + idUM['3'] + idUM['4']
tr3 = idUSM['0'] + idUSM['2'] + idUSM['3'] + idUSM['4']
tr4 = idUCLA['0'] + idUCLA['2'] + idUCLA['3'] + idUCLA['4']
te1 = idNYU['1']
te2 = idUM['1']
te3 = idUSM['1']
te4 = idUCLA['1']
elif args.split == 2:
tr1 = idNYU['0'] + idNYU['1'] + idNYU['3'] + idNYU['4']
tr2 = idUM['0'] + idUM['1'] + idUM['3'] + idUM['4']
tr3 = idUSM['0'] + idUSM['1'] + idUSM['3'] + idUSM['4']
tr4 = idUCLA['0'] + idUCLA['1'] + idUCLA['3'] + idUCLA['4']
te1 = idNYU['2']
te2 = idUM['2']
te3 = idUSM['2']
te4 = idUCLA['2']
elif args.split == 3:
tr1 = idNYU['0'] + idNYU['1'] + idNYU['2'] + idNYU['4']
tr2 = idUM['0'] + idUM['1'] + idUM['2'] + idUM['4']
tr3 = idUSM['0'] + idUSM['1'] + idUSM['2'] + idUSM['4']
tr4 = idUCLA['0'] + idUCLA['1'] + idUCLA['2'] + idUCLA['4']
te1 = idNYU['3']
te2 = idUM['3']
te3 = idUSM['3']
te4 = idUCLA['3']
elif args.split == 4:
tr1 = idNYU['0'] + idNYU['1'] + idNYU['2'] + idNYU['3']
tr2 = idUM['0'] + idUM['1'] + idUM['2'] + idUM['3']
tr3 = idUSM['0'] + idUSM['1'] + idUSM['2'] + idUSM['3']
tr4 = idUCLA['0'] + idUCLA['1'] + idUCLA['2'] + idUCLA['3']
te1 = idNYU['4']
te2 = idUM['4']
te3 = idUSM['4']
te4 = idUCLA['4']
x1_train = x1[tr1]
y1_train = y1[tr1]
x2_train = x2[tr2]
y2_train = y2[tr2]
x3_train = x3[tr3]
y3_train = y3[tr3]
x4_train = x4[tr4]
y4_train = y4[tr4]
x1_test = x1[te1]
y1_test = y1[te1]
x2_test = x2[te2]
y2_test = y2[te2]
x3_test = x3[te3]
y3_test = y3[te3]
x4_test = x4[te4]
y4_test = y4[te4]
if args.sepnorm:
mean = x1_train.mean(0, keepdim=True)
dev = x1_train.std(0, keepdim=True)
x1_train = (x1_train - mean) / dev
x1_test = (x1_test - mean) / dev
mean = x2_train.mean(0, keepdim=True)
dev = x2_train.std(0, keepdim=True)
x2_train = (x2_train - mean) / dev
x2_test = (x2_test - mean) / dev
mean = x3_train.mean(0, keepdim=True)
dev = x3_train.std(0, keepdim=True)
x3_train = (x3_train - mean) / dev
x3_test = (x3_test - mean) / dev
mean = x4_train.mean(0, keepdim=True)
dev = x4_train.std(0, keepdim=True)
x4_train = (x4_train - mean) / dev
x4_test = (x4_test - mean) / dev
else:
mean = torch.cat((x1_train, x2_train, x3_train, x4_train),
0).mean(0, keepdim=True)
dev = torch.cat((x1_train, x2_train, x3_train, x4_train),
0).std(0, keepdim=True)
x1_train = (x1_train - mean) / dev
x1_test = (x1_test - mean) / dev
x2_train = (x2_train - mean) / dev
x2_test = (x2_test - mean) / dev
x3_train = (x3_train - mean) / dev
x3_test = (x3_test - mean) / dev
x4_train = (x4_train - mean) / dev
x4_test = (x4_test - mean) / dev
train = TensorDataset(
torch.cat((x1_train, x2_train, x3_train, x4_train), 0),
torch.cat((y1_train, y2_train, y3_train, y4_train), 0))
train_loader = DataLoader(train, batch_size=args.batch_size, shuffle=True)
test1 = TensorDataset(x1_test, y1_test)
test_loader1 = DataLoader(test1,
batch_size=args.test_batch_size1,
shuffle=False)
test2 = TensorDataset(x2_test, y2_test)
test_loader2 = DataLoader(test2,
batch_size=args.test_batch_size2,
shuffle=False)
test3 = TensorDataset(x3_test, y3_test)
test_loader3 = DataLoader(test3,
batch_size=args.test_batch_size3,
shuffle=False)
test4 = TensorDataset(x4_test, y4_test)
test_loader4 = DataLoader(test4,
batch_size=args.test_batch_size4,
shuffle=False)
model = MLP(6105, args.dim, 2).to(device)
optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=5e-2)
print(model)
nnloss = nn.NLLLoss()
def train(data_loader, epoch):
model.train()
if epoch <= 50 and epoch % 20 == 0:
for param_group1 in optimizer.param_groups:
param_group1['lr'] = 0.5 * param_group1['lr']
elif epoch > 50 and epoch % 20 == 0:
for param_group1 in optimizer.param_groups:
param_group1['lr'] = 0.5 * param_group1['lr']
loss_all1 = 0
for data, target in data_loader:
optimizer.zero_grad()
data = data.to(device)
target = target.to(device)
output1 = model(data)
loss1 = nnloss(output1, target)
loss1.backward()
loss_all1 += loss1.item() * target.size(0)
torch.nn.utils.clip_grad_norm_(model.parameters(), args.clip)
optimizer.step()
return loss_all1 / (len(data_loader.dataset))
def test(data_loader, train=False):
model.eval()
test_loss = 0
correct = 0
outputs = []
preds = []
targets = []
for data, target in data_loader:
data = data.to(device)
targets.append(target[0].detach().numpy())
target = target.to(device)
output = model(data)
outputs.append(output.detach().cpu().numpy())
test_loss += nnloss(output, target).item() * target.size(0)
pred = output.data.max(1)[1]
preds.append(pred.detach().cpu().numpy())
correct += pred.eq(target.view(-1)).sum().item()
test_loss /= len(data_loader.dataset)
correct /= len(data_loader.dataset)
if train:
print(
'Train set: Average loss: {:.4f}, Average acc: {:.4f}'.format(
test_loss, correct))
else:
print('Test set: Average loss: {:.4f}, Average acc: {:.4f}'.format(
test_loss, correct))
return test_loss, correct, targets, outputs, preds
best_acc = 0
best_epoch = 0
for epoch in range(args.epochs):
start_time = time.time()
print(f"Epoch Number {epoch + 1}")
l1 = train(train_loader, epoch)
test(train_loader, train=True)
print(' L1 loss: {:.4f}'.format(l1))
print('===NYU===')
_, acc1, targets1, outputs1, preds1 = test(test_loader1, train=False)
print('===UM===')
_, acc2, targets2, outputs2, preds2 = test(test_loader2, train=False)
print('===USM===')
_, acc3, targets3, outputs3, preds3 = test(test_loader3, train=False)
print('===UCLA===')
_, acc4, targets4, outputs4, preds4 = test(test_loader4, train=False)
if (acc1 + acc2 + acc3 + acc4) / 4 > best_acc:
best_acc = (acc1 + acc2 + acc3 + acc4) / 4
best_epoch = epoch
total_time = time.time() - start_time
print('Communication time over the network', round(total_time, 2),
's\n')
model_wts = copy.deepcopy(model.state_dict())
torch.save(model_wts, os.path.join(args.model_dir,
str(args.split) + '.pth'))
dd.io.save(os.path.join(args.res_dir, 'NYU_' + str(args.split) + '.h5'), {
'outputs': outputs1,
'preds': preds1,
'targets': targets1
})
dd.io.save(os.path.join(args.res_dir, 'UM_' + str(args.split) + '.h5'), {
'outputs': outputs2,
'preds': preds2,
'targets': targets2
})
dd.io.save(os.path.join(args.res_dir, 'USM_' + str(args.split) + '.h5'), {
'outputs': outputs3,
'preds': preds3,
'targets': targets3
})
dd.io.save(os.path.join(args.res_dir, 'UCLA_' + str(args.split) + '.h5'), {
'outputs': outputs4,
'preds': preds4,
'targets': targets4
})
print('Best Acc:', best_acc, 'Best Epoch:', best_epoch)
print('split:', args.split)