def __init__(self, params, learner, dataset):
print('Using Federated Average to Train')
if(params["lamb"] > 0):
self.inner_opt = PROXSGD(params['learning_rate'], params["lamb"])
else:
self.inner_opt = tf.train.GradientDescentOptimizer(params['learning_rate'])
super(Server, self).__init__(params, learner, dataset)
def __init__(self, params, learner, dataset):
print('Using Federated SGD to Train')
self.inner_opt = PROXSGD(params['learning_rate'], params["lamb"])
self.dataset = params["dataset"]
#self.seed = 1
super(Server, self).__init__(params, learner, dataset)
class Server(BaseFedarated):
def __init__(self, params, learner, dataset):
print('Using Federated SGD to Train')
self.inner_opt = PROXSGD(params['learning_rate'], params["lamb"])
self.dataset = params["dataset"]
#self.seed = 1
super(Server, self).__init__(params, learner, dataset)
def train(self):
'''Train using Federated Proximal'''
print("Train using Federated Proximal SGD")
print('Training with {} workers ---'.format(self.clients_per_round))
model_len = process_grad(self.latest_model).size
for i in range(self.num_rounds):
# test model
if i % self.eval_every == 0:
stats = self.test(
) # have set the latest model for all clients
stats_train = self.train_error_and_loss()
tqdm.write('At round {} accuracy: {}'.format(
i,
np.sum(stats[3]) * 1.0 /
np.sum(stats[2]))) # testing accuracy
tqdm.write('At round {} training accuracy: {}'.format(
i,
np.sum(stats_train[3]) * 1.0 / np.sum(stats_train[2])))
tqdm.write('At round {} training loss: {}'.format(
i,
np.dot(stats_train[4], stats_train[2]) * 1.0 /
np.sum(stats_train[2])))
self.rs_glob_acc.append(
np.sum(stats[3]) * 1.0 / np.sum(stats[2]))
self.rs_train_acc.append(
np.sum(stats_train[3]) * 1.0 / np.sum(stats_train[2]))
self.rs_train_loss.append(
np.dot(stats_train[4], stats_train[2]) * 1.0 /
np.sum(stats_train[2]))
global_grads = np.zeros(model_len)
client_grads = np.zeros(model_len)
num_samples = []
local_grads = []
for c in self.clients:
num, client_grad = c.get_grads(model_len)
local_grads.append(client_grad)
num_samples.append(num)
global_grads = np.add(global_grads, client_grads * num)
global_grads = global_grads * 1.0 / \
np.sum(np.asarray(num_samples))
difference = 0
for idx in range(len(self.clients)):
difference += np.sum(
np.square(global_grads - local_grads[idx]))
difference = difference * 1.0 / len(self.clients)
tqdm.write('gradient difference: {}'.format(difference))
selected_clients = self.select_clients(
i, num_clients=self.clients_per_round)
csolns = [] # buffer for receiving client solutions
#self.inner_opt.set_params(self.latest_model, self.client_model)
for c in selected_clients:
# communicate the latest model
c.set_params(self.latest_model)
self.inner_opt.set_wzero(self.latest_model, c.model)
grads = c.get_raw_grads()
c.set_vzero(grads)
# solve minimization locally
soln, stats = c.solve_inner(self.optimizer,
num_epochs=self.num_epochs,
batch_size=self.batch_size)
# gather solutions from client
csolns.append(soln)
# track communication cost
self.metrics.update(rnd=i, cid=c.id, stats=stats)
# update model
print(self.parameters['weight'])
self.latest_model = self.aggregate(
csolns,
weighted=self.parameters['weight']) # Weighted = False / True
self.client_model.set_params(self.latest_model)
# final test model
stats = self.test()
stats_train = self.train_error_and_loss()
self.metrics.accuracies.append(stats)
self.metrics.train_accuracies.append(stats_train)
tqdm.write('At round {} accuracy: {}'.format(
self.num_rounds,
np.sum(stats[3]) * 1.0 / np.sum(stats[2])))
tqdm.write('At round {} training accuracy: {}'.format(
self.num_rounds,
np.sum(stats_train[3]) * 1.0 / np.sum(stats_train[2])))
# save server model
self.metrics.write()
prox = 0
if (self.parameters['lamb'] > 0):
prox = 1
self.save(prox=prox,
lamb=self.parameters['lamb'],
learning_rate=self.parameters["learning_rate"],
data_set=self.dataset,
num_users=self.clients_per_round,
batch=self.batch_size)
print("Test ACC:", self.rs_glob_acc)
print("Training ACC:", self.rs_train_acc)
print("Training Loss:", self.rs_train_loss)