def __init__(self, temperature_sensor):
self.temperature_sensor = temperature_sensor
self.rotary_encoder = RotaryEncoder(self)
self.power = Power(POWER_PIN)
self.model = ServerModel(get_serial())
self.boil_temps = [60, 65, 70, 75, 80, 85, 90, 95, 100]
self.boil_volumes = [0.50, 0.75, 1.00, 1.25, 1.50, 1.75]
self.menu = RpiLCDMenu()
self.init_menu()
def main():
args = parse_args()
model_path = '%s/%s.py' % (args.dataset, args.model)
if not os.path.exists(model_path):
print('Please specify a valid dataset and a valid model.')
model_path = '%s.%s' % (args.dataset, args.model)
print('############################## %s ##############################' %
model_path)
mod = importlib.import_module(model_path)
ClientModel = getattr(mod, 'ClientModel')
tup = MAIN_PARAMS[args.dataset][args.t]
num_rounds = args.num_rounds if args.num_rounds != -1 else tup[0]
eval_every = args.eval_every if args.eval_every != -1 else tup[1]
clients_per_round = args.clients_per_round if args.clients_per_round != -1 else tup[
2]
# Suppress tf warnings
tf.logging.set_verbosity(tf.logging.WARN)
# Create 2 models
model_params = MODEL_PARAMS[model_path]
if args.lr != -1:
model_params_list = list(model_params)
model_params_list[0] = args.lr
model_params = tuple(model_params_list)
tf.reset_default_graph()
client_model = ClientModel(*model_params)
server_model = ServerModel(ClientModel(*model_params))
# Create server
server = Server(server_model)
# Create clients
clients = setup_clients(args.dataset, client_model)
print('%d Clients in Total' % len(clients))
print(
'Rounds Train_acc_avg p_10 p_90 Train_loss_avg p_10 p_90 Test_acc_avg p_10 p_90 Test_loss_avg p_10 p_90'
)
# Test untrained model on all clients
stat_metrics = server.test_model(clients)
all_ids, all_groups, all_num_samples = server.get_clients_test_info(
clients)
metrics_writer.print_metrics(0, all_ids, stat_metrics, all_groups,
all_num_samples, STAT_METRICS_PATH)
print_metrics(stat_metrics, all_num_samples, 0)
# Simulate training
for i in range(num_rounds):
#print('--- Round %d of %d: Training %d Clients ---' % (i+1, num_rounds, clients_per_round))
# Select clients to train this round
server.select_clients(online(clients), num_clients=clients_per_round)
c_ids, c_groups, c_num_samples = server.get_clients_test_info()
# Simulate server model training on selected clients' data
sys_metics = server.train_model(num_epochs=args.num_epochs,
batch_size=args.batch_size,
minibatch=args.minibatch)
metrics_writer.print_metrics(i, c_ids, sys_metics, c_groups,
c_num_samples, SYS_METRICS_PATH)
# Update server model
server.update_model()
# Test model on all clients
if (i + 1) % eval_every == 0 or (i + 1) == num_rounds:
stat_metrics = server.test_model(clients)
metrics_writer.print_metrics(i, all_ids, stat_metrics, all_groups,
all_num_samples, STAT_METRICS_PATH)
print_metrics(stat_metrics, all_num_samples, i + 1)
# Save server model
save_model(server_model, args.dataset, args.model)
# Close models
server_model.close()
client_model.close()
class Display(object):
def __init__(self, temperature_sensor):
self.temperature_sensor = temperature_sensor
self.rotary_encoder = RotaryEncoder(self)
self.power = Power(POWER_PIN)
self.model = ServerModel(get_serial())
self.boil_temps = [60, 65, 70, 75, 80, 85, 90, 95, 100]
self.boil_volumes = [0.50, 0.75, 1.00, 1.25, 1.50, 1.75]
self.menu = RpiLCDMenu()
self.init_menu()
def init_menu(self):
# Calibrate Submenu
self.read_temp_submenu = RpiLCDSubMenu(self.menu)
self.read_temp_submenu.append_item(
FunctionItem("Back", lambda: self.read_temp_submenu.exit()))
self.read_temp_submenu.append_item(MenuItem(self.getTemp()))
# Options Submenu
self.options_submenu = RpiLCDSubMenu(self.menu)
self.options_submenu.append_item(
FunctionItem("Setup", lambda: print("setup")))
self.options_submenu.append_item(
SubmenuItem("Read temp", self.read_temp_submenu,
self.options_submenu))
self.options_submenu.append_item(
FunctionItem("Back", lambda: self.options_submenu.exit()))
# Select-temperature Submenu
self.boil_temp_submenu = RpiLCDSubMenu(self.menu)
for t in self.boil_temps:
boil_message = FunctionItem(f"{t} C", self.boilTo, [t])
self.boil_temp_submenu.append_item(boil_message)
self.boil_temp_submenu.append_item(
FunctionItem("Back", lambda: self.boil_temp_submenu.exit()))
# Select-volume Submenu
self.boil_vol_submenu = RpiLCDSubMenu(self.menu)
for v in self.boil_volumes:
self.boil_vol_submenu.append_item(
SubmenuItem(f"{v:.2f} L", self.boil_temp_submenu,
self.boil_vol_submenu))
self.boil_vol_submenu.append_item(
FunctionItem("Back", lambda: self.boil_vol_submenu.exit()))
# Select-volume Submenu
self.calib_vol_submenu = RpiLCDSubMenu(self.menu)
for v in self.boil_volumes:
self.calib_vol_submenu.append_item(
FunctionItem(f"{v:.2f} L", self.calibrate, [v]))
self.boil_vol_submenu.append_item(
FunctionItem("Back", lambda: self.calib_vol_submenu.exit()))
# Main Menu
boil_item = SubmenuItem("Boil", self.boil_vol_submenu, self.menu)
temp_item = SubmenuItem("Calibrate", self.calib_vol_submenu, self.menu)
other_item = SubmenuItem("Options", self.options_submenu, self.menu)
self.menu.append_item(boil_item) \
.append_item(temp_item) \
.append_item(other_item)
self.menu.start()
def boilTo(self, t):
volume = self.boil_volumes[self.boil_vol_submenu.current_option]
time_pred = self.model.predict(volume, t).item()
print(f"{volume}L,{t}C: {time_pred:.1f}s")
self.menu.clearDisplay()
self.menu.message(f"{volume}L,{t}C: {time_pred:.1f}s")
self.power.on()
time.sleep(time_pred)
self.power.off()
self.menu.clearDisplay()
self.menu.message(f"Done! {t} C")
def calibrate(self, volume=1.5):
target_temp = 99
print(f"Calibrating...")
self.menu.clearDisplay()
self.menu.message(f"Boiling {volume}L…")
self.power.on()
go_on = True
st = time.time()
temps = []
times = []
while go_on:
temp_i = round(self.temperature_sensor.read(), 1)
time_i = time.time() - st
temps.append(temp_i)
times.append(time_i)
print(f"{time_i}, {temp_i}")
if temp_i > int(target_temp):
go_on = False
time.sleep(1)
self.power.off()
self.menu.message(f"Done! Sending data to the server…")
self.model.train(volume, temps, times)
self.menu.message(f"Model updated!")
print("Done training")
time.sleep(1)
self.menu.clearDisplay()
self.calib_vol_submenu.exit()
self.menu.exit()
self.init_menu()
def onRotaryNext(self):
print("next")
self.menu.processDown()
def onRotaryPrevious(self):
print("prev")
self.menu.processUp()
def onRotaryPressed(self):
print("pressed")
self.menu = self.menu.processEnter()
def getTemp(self):
temp = round(self.temperature_sensor.read(), 1)
return f"T: {temp:.1f} C"
def showTempPage(self):
prev_temp = 0.0
while True:
temp = round(self.temperature_sensor.read(), 1)
if temp != prev_temp:
prev_temp = temp
self.menu.clearDisplay()
self.menu.message(f"T: {temp:.1f} C")
time.sleep(1)
def main():
args = parse_args()
global_start_time = start_time = time.time()
# set torch seed
torch_seed = (args.seed + 25) // 2
torch.random.manual_seed(torch_seed)
model_path = '%s/%s.py' % (args.dataset, args.model)
if not os.path.exists(model_path):
print('Please specify a valid dataset and a valid model.')
model_path = '%s.%s' % (args.dataset, args.model)
print('############################## %s ##############################' % model_path)
mod = importlib.import_module(model_path)
ClientModel = getattr(mod, 'ClientModel')
tup = MAIN_PARAMS[args.dataset][args.t]
num_rounds = args.num_rounds if args.num_rounds != -1 else tup[0]
eval_every = args.eval_every if args.eval_every != -1 else tup[1]
clients_per_round = args.clients_per_round if args.clients_per_round != -1 else tup[2]
# Create 2 different models: one for server and one shared by all clients
print('Obtained Model Path : ' + str(model_path))
model_params = MODEL_PARAMS[model_path]
if args.lr != -1:
model_params_list = list(model_params)
model_params_list[0] = args.lr
model_params = tuple(model_params_list)
else:
args.lr = model_params[0]
if args.decay_lr_every is None:
args.decay_lr_every = 100 if args.dataset == 'femnist' else 50
print(args)
client_model = ClientModel(*model_params, seed=args.seed)
server_model = ServerModel(ClientModel(*model_params, seed=args.seed - 1))
# Set device
if args.gpu is not None and args.gpu >= 0 and args.gpu <= 4:
device = torch.device(f'cuda:{args.gpu}')
else:
device = torch.device('cpu')
if hasattr(client_model, 'set_device'):
client_model.set_device(device)
server_model.model.set_device(device)
# Create server
server = Server(server_model)
# Create clients
clients = setup_clients(args.dataset, model_name=args.model,
model=client_model, validation=args.validation,
seed=args.seed, split_by_user=args.split_by_user)
train_clients = clients['train_clients']
if args.split_by_user:
test_clients = clients['test_clients']
if args.validation:
validation_clients = clients['validation_clients']
else:
validation_clients = []
else:
test_clients = clients['train_clients']
if (
(args.dataset == 'sent140' and args.model in ['erm_lstm_log_reg',
'rsm_lstm_log_reg'])
or (args.dataset == 'shakespeare' and args.model in
['erm_lstm_log_reg'])
):
print('Data is not normalized here')
# no normalizing performed here
pass
else:
# normalize data:
dataset_file_constants_train = 'dataset_constants/' + args.dataset + '_train_mean_std'
with open(dataset_file_constants_train) as json_file:
data = json.load(json_file)
mean_train = data['mean']
std_train = data['mean']
dataset_file_constants_test = 'dataset_constants/' + args.dataset + '_test_mean_std'
with open(dataset_file_constants_test) as json_file:
data = json.load(json_file)
mean_test = data['mean']
std_test = data['mean']
for c in train_clients:
for i in range(len(c.train_data['x'])):
for j in range(len(c.train_data['x'][i])):
c.train_data['x'][i][j] = (c.train_data['x'][i][j] - mean_train[j])/std_train[j]
for c in test_clients:
for i in range(len(c.eval_data['x'])):
for j in range(len(c.eval_data['x'][i])):
c.eval_data['x'][i][j] = (c.eval_data['x'][i][j] - mean_test[j]) / std_test[j]
if args.validation:
for c in validation_clients:
for i in range(len(c.train_data['x'])):
for j in range(len(c.train_data['x'][i])):
c.train_data['x'][i][j] = (c.train_data['x'][i][j] - mean_train[j]) / std_train[j]
print('#Clients = %d ; setup time = %s' % (len(train_clients) + len(test_clients),
timedelta(seconds=round(time.time() - start_time))))
gc.collect() # free discarded memory in setup_clients
# Logging utilities
train_ids, train_groups, train_clients_num_train_samples, train_clients_num_test_samples = server.get_clients_info(train_clients)
test_ids, test_groups, test_clients_num_train_samples, test_clients_num_test_samples = server.get_clients_info(test_clients)
if args.validation:
validation_ids, validation_groups, validation_clients_num_train_samples, validation_clients_num_test_samples = server.get_clients_info(
validation_clients)
summary = None
def log_helper(iteration, path_for_validation, comm_rounds=None):
if comm_rounds is None:
comm_rounds = iteration
nonlocal summary
start_time = time.time()
if args.no_logging:
stat_metrics = None
else:
#stat_metrics = server.test_model(clients, train_and_test=True)
if args.split_by_user:
train_clients_stat_metrics = server.test_model(clients_to_test=train_clients, train_and_test=False,
split_by_user=args.split_by_user, train_users=True)
# writer_print_metrics(0, train_ids, train_clients_stat_metrics, train_groups,
# train_clients_num_train_samples, args.output_stat_file)
test_clients_stat_metrics = server.test_model(clients_to_test=test_clients, train_and_test=False,
split_by_user=args.split_by_user, train_users=False)
if args.validation:
validation_clients_stat_metrics = server.test_model(clients_to_test=validation_clients, train_and_test=False,
split_by_user=args.split_by_user, train_users=True)
# writer_print_metrics(0, test_ids, test_clients_stat_metrics, train_groups,
# test_clients__num_test_samples, args.output_stat_file)
else:
train_clients_stat_metrics = server.test_model(clients_to_test=train_clients, train_and_test=True,
split_by_user=args.split_by_user)
writer_print_metrics(0, train_ids, train_clients_stat_metrics, train_groups,
test_clients_num_train_samples, args.output_stat_file)
if args.split_by_user:
summary_iter_train, str_output_train = print_metrics(iteration, comm_rounds, train_clients_stat_metrics,
train_clients_num_train_samples, train_clients_num_test_samples,
time.time() - start_time, split_by_user=args.split_by_user,
train_users=True, full_record=args.full_record)
summary_iter_test, str_output_test = print_metrics(iteration, comm_rounds, test_clients_stat_metrics,
test_clients_num_train_samples, test_clients_num_test_samples,
time.time() - start_time, split_by_user=args.split_by_user,
train_users=False, full_record=args.full_record)
if args.validation:
summary_iter_validation, str_output_validation = print_metrics(iteration, comm_rounds, validation_clients_stat_metrics,
validation_clients_num_train_samples, validation_clients_num_test_samples,
time.time() - start_time, split_by_user=args.split_by_user,
train_users=True, validation=True, full_record=args.full_record)
print(str_output_train + str_output_validation + str_output_test)
else:
print(str_output_train + str_output_test)
else:
summary_iter_train = print_metrics(iteration, comm_rounds, train_clients_stat_metrics,
train_clients_num_test_samples, train_clients_num_test_samples,
time.time() - start_time, split_by_user=args.split_by_user,
full_record=args.full_record)
sys.stdout.flush()
if iteration == 0:
if args.split_by_user:
summary = pd.Series(summary_iter_train).to_frame().T
if args.validation:
summary_iter = {**summary_iter_train, **summary_iter_validation, **summary_iter_test}
summary = summary.append(summary_iter, ignore_index=True)
else:
summary_iter = {**summary_iter_train, **summary_iter_test}
summary = summary.append(summary_iter, ignore_index=True)
else:
summary = pd.Series(summary_iter_train).to_frame().T
else:
if args.split_by_user:
if args.validation:
summary_iter = {**summary_iter_train, **summary_iter_validation, **summary_iter_test}
summary = summary.append(summary_iter, ignore_index=True)
else:
summary_iter = {**summary_iter_train, **summary_iter_test}
summary = summary.append(summary_iter, ignore_index=True)
summary.to_csv(path_for_validation, mode='w', header=True, index=False)
return summary_iter_train
# Test untrained model on all clients
def reinit_clients():
for c in train_clients:
c.reinit_model()
for c in test_clients:
c.reinit_model()
if args.validation:
for c in validation_clients:
c.reinit_model()
# Simulate training
def main_training(path_for_validation, regularization_param=None):
# Required for initial logging to be correct when initializing from non-zero weights
if regularization_param is not None:
server.model.model.optimizer.lmbda = regularization_param
# Initialize diagnostics
s = log_helper(0, path_for_validation)
initial_loss = s.get(OptimLoggingKeys.TRAIN_LOSS_KEY[0], None)
initial_avg_loss = None
num_no_progress = 0
for i in range(num_rounds):
print('--- Round %d of %d: Training %d Clients ---' % (i + 1, num_rounds, clients_per_round))
sys.stdout.flush()
start_time = time.time()
# Select clients to train this round
server.select_clients(online(train_clients), num_clients=clients_per_round)
c_ids, c_groups, c_num_train_samples, c_num_test_samples = server.get_clients_info()
# Logging selection
# Simulate server model training on selected clients' data
sys_metrics, avg_loss, losses = server.train_model(num_epochs=args.num_epochs,
batch_size=args.batch_size,
minibatch=args.minibatch,
lr=args.lr,
lmbda=regularization_param,
run_simplicial_fl=args.run_simplicial_fl,
nonconformity_level=args.nonconformity_level,
)
updates = server.updates
writer_print_metrics(i, c_ids, sys_metrics, c_groups, c_num_test_samples, args.output_sys_file)
# Diagnostics - 1
if initial_avg_loss is None:
initial_avg_loss = avg_loss
# Update server model
total_num_comm_rounds, is_updated = server.update_model(aggregation=args.aggregation,
run_simplicial_fl=args.run_simplicial_fl,
nonconformity_level=args.nonconformity_level,
losses=losses)
# Diagnostics - 2
if is_updated:
num_no_progress = 0
else:
num_no_progress += 1
if num_no_progress > args.patience_iter:
print('No progress made in {} iterations. Quitting.'.format(num_no_progress))
sys.exit(1)
# Logging
#norm = _norm(server_model.model)
norm = np.linalg.norm(server_model.model.optimizer.w)
print('\t\t\tRound: {} AvgLoss: {:.3f} Norm: {:.2f} Time: {} Tot_time {}'.format(
i + 1, avg_loss, norm,
timedelta(seconds=round(time.time() - start_time)),
timedelta(seconds=round(time.time() - global_start_time))
), flush=True)
# Test model on all clients
if (
(i + 1) in [5, 10, 15, 20, 75]
or (i + 1) % eval_every == 0
or (i + 1) == num_rounds
):
s = log_helper(i + 1, path_for_validation, total_num_comm_rounds)
if OptimLoggingKeys.TRAIN_LOSS_KEY in s:
if initial_loss is not None and s[OptimLoggingKeys.TRAIN_LOSS_KEY][0] > 3 * initial_loss:
print('Loss > 3 * initial_loss. Exiting')
break
if math.isnan(s[OptimLoggingKeys.TRAIN_LOSS_KEY][0]):
print('Loss NaN. Exiting')
break
if args.no_logging:
# save model
save_model(server_model, args.dataset, args.model,
'{}_iteration{}'.format(args.output_summary_file + ".csv", i + 1))
if args.save_updates:
fn = '{}_updates_{}'.format(args.output_summary_file + '.csv', i+1)
selected_client_ids = [c.id for c in server.selected_clients]
with open(fn, 'wb') as f:
pkl.dump([[], selected_client_ids, updates], f)
if (i + 1) % args.decay_lr_every == 0:
args.lr /= args.lr_decay
# Save server model
if args.validation:
summary.to_csv(path_for_validation, mode='w', header=True, index=False)
else:
summary.to_csv(path_for_validation, mode='w', header=True, index=False)
#save_model(server_model, args.dataset, args.model, args.output_summary_file)
def validation_experiment():
list_path = [SUMMARY_METRICS_PATH_REG + args.dataset + '_' + args.model + '_reg_' + '_' + str(lmbda)
+ '.csv' for lmbda in REGULARIZATION_PARAMS]
for counter_reg in range(len(REGULARIZATION_PARAMS)):
reinit_clients()
main_training(list_path[counter_reg], regularization_param=REGULARIZATION_PARAMS[counter_reg])
if args.old_validation:
validation_experiment()
else:
main_training(args.output_summary_file + '.csv', regularization_param=args.reg_param)
print('Job complete. Total time taken:', timedelta(seconds=round(time.time() - global_start_time)))
def main():
args = utils.parse_args()
global_start_time = start_time = time.time()
model_path = '{}/{}.py'.format(args.dataset, args.model)
if not os.path.exists(model_path):
print('Please specify a valid dataset and a valid model.')
model_path = '{}.{}'.format(args.dataset, args.model)
print('############################## {} ##############################'.
format(model_path))
mod = importlib.import_module(model_path)
ClientModel = getattr(mod, 'ClientModel')
tup = MAIN_PARAMS[args.dataset]
num_rounds = args.num_rounds if args.num_rounds != -1 else tup[0]
eval_every = args.eval_every if args.eval_every != -1 else tup[1]
clients_per_round = args.clients_per_round if args.clients_per_round != -1 else tup[
2]
# Suppress tf warnings
tf.logging.set_verbosity(tf.logging.ERROR)
# Create 2 different models: one for server and one shared by all clients
model_params = MODEL_PARAMS[model_path]
if args.lr != -1:
model_params_list = list(model_params)
model_params_list[0] = args.lr
model_params = tuple(model_params_list)
else:
args.lr = model_params[0]
if args.decay_lr_every is None:
args.decay_lr_every = 100 if args.dataset == 'femnist' else 50
tf.reset_default_graph()
print(args)
client_model = ClientModel(*model_params, seed=args.seed)
server_model = ServerModel(ClientModel(*model_params, seed=args.seed - 1))
# Create server
server = Server(server_model)
# Create clients
clients, corrupted_client_ids = utils.setup_clients(
args.dataset,
args.data_dir,
model=client_model,
validation=args.validation,
seed=args.seed,
corruption=args.corruption,
fraction_corrupt=args.fraction_corrupt)
print('#Clients = %d ; setup time = %s' %
(len(clients), timedelta(seconds=round(time.time() - start_time))))
print('Using true labels for corrupted data as well')
gc.collect() # free discarded memory in setup_clients
# Logging utilities
all_ids, all_groups, all_num_train_samples, all_num_test_samples = server.get_clients_info(
clients)
summary = None
def log_helper(iteration, comm_rounds=None):
if comm_rounds is None:
comm_rounds = iteration
nonlocal summary
start_time = time.time()
if args.no_logging:
stat_metrics = None
else:
stat_metrics = server.test_model(clients, train_and_test=True)
summary_iter = utils.print_metrics(iteration, comm_rounds,
stat_metrics, all_num_train_samples,
all_num_test_samples,
time.time() - start_time)
if iteration == 0:
summary = pd.Series(summary_iter).to_frame().T
else:
summary = summary.append(summary_iter, ignore_index=True)
summary.to_csv(args.output_summary_file,
mode='w',
header=True,
index=False)
return summary_iter
# Test untrained model on all clients
s = log_helper(0)
# Initialize diagnostics
initial_loss = s.get(OptimLoggingKeys.TRAIN_LOSS_KEY, None)
num_no_progress = 0
# Simulate training
for i in range(num_rounds):
print('--- Round {} of {}: Training {} Clients ---'.format(
i + 1, num_rounds, clients_per_round))
sys.stdout.flush()
start_time = time.time()
# Select clients to train this round
server.select_clients(utils.online(clients),
num_clients=clients_per_round)
# Logging selection
num_corr, num_cl, corr_frac = utils.get_corrupted_fraction(
server.selected_clients, corrupted_client_ids)
print(
'\t\t\tCorrupted {:d} out of {:d} clients. {:.3f} fraction'.format(
num_corr, num_cl, corr_frac),
flush=True)
# Simulate server model training on selected clients' data
avg_loss, losses = server.train_model(num_epochs=args.num_epochs,
batch_size=args.batch_size,
minibatch=args.minibatch,
lr=args.lr)
# Update server model
total_num_comm_rounds, is_updated = server.update_model(
aggregation=args.aggregation,
corruption=args.corruption,
corrupted_client_ids=corrupted_client_ids,
maxiter=args.weiszfeld_maxiter)
# Quit if no progress made
if is_updated:
num_no_progress = 0
else:
num_no_progress += 1
if num_no_progress > args.patience_iter:
print('No progress made in {} iterations. Quitting.'.format(
num_no_progress))
sys.exit(1)
# Logging
norm = utils.model_norm(server_model.model)
print(
'\t\t\tRound: {} AvgLoss: {:.3f} Norm: {:.2f} Time: {} Tot_time {}'
.format(i + 1, avg_loss, norm,
timedelta(seconds=round(time.time() - start_time)),
timedelta(seconds=round(time.time() - global_start_time))),
flush=True)
# Test model on all clients
if ((i + 1) == 5 or (i + 1) % eval_every == 0 or (i + 1) == num_rounds
or (args.corruption == CORRUPTION_OMNISCIENT_KEY and
(i + 1) < 10)):
s = log_helper(i + 1, total_num_comm_rounds)
if OptimLoggingKeys.TRAIN_LOSS_KEY in s:
if initial_loss is not None and s[
OptimLoggingKeys.TRAIN_LOSS_KEY] > 3 * initial_loss:
print(
'Train_objective > 3 * initial_train_objective. Exiting'
)
break
if args.no_logging:
# save model
utils.save_model(
server_model, args.dataset, args.model,
'{}_iteration{}'.format(args.output_summary_file, i + 1))
if (i + 1) % args.decay_lr_every == 0:
args.lr /= args.lr_decay
# Save logs and server model
summary.to_csv(args.output_summary_file,
mode='w',
header=True,
index=False)
utils.save_model(server_model, args.dataset, args.model,
args.output_summary_file)
print('Job complete. Total time taken:',
timedelta(seconds=round(time.time() - global_start_time)))
# Close models
server_model.close()
client_model.close()
if __name__ == "__main__":
T = int(input("Введите время работы сервера: "))
L = 9
Mt = float(input("Введите мат. ожидание времени поступления задачи: "))
Ms = float(
input("Введите мат. ожидание времени выполнения задачи сервером: "))
Ds = Ms / 4.0
print("Ожидаемая дисперсия времени поступления задачи: ", Mt**2)
print("Ожидаемая дисперсия времени выполнения задачи сервером задачи: ",
Ds)
server_load_list = [] # список загруженности сервера
server_p_failurу = [] # список вероятностей отказа сервера
print("Выполняется моделирование.")
result_model = None
while True:
server_model = ServerModel(T, L, Ms, Ds, Mt)
server_model.run()
server_load = server_model.get_server_load()
server_load_list.append(server_load)
server_p_failurу.append(server_model.get_p_failure())
if server_load < 1 and server_load > 0.95:
print("""Потенциальная оптимальная конфигурация:
Загруженность сервера - {};
Мат. ожидание времени поступления задачи - {};
Мат. ожидание времени выполнения задачи сервером - {};""".
format(round(server_load, 6), round(Mt, 6), round(Ms, 6)))
print("Запуск тестирования конфигурации.")
avg_load = 0
# avg_not_run_tasks = 0
test_server_model = ServerModel(T, L, Ms, Ds, Mt)
for i in range(100):
if not args.iid and args.task == 'regression':
train_data, train_label, dict_users = linear_non_iid_data_generation(
'./data/ld_train_non_iid.csv', args.feature_dims, 300,
users_num_list[k])
train_label = np.expand_dims(train_label, axis=-1)
if not args.iid and args.task == 'classification':
train_data, train_label, dict_users = get_iris_classification_non_iid_data(
'./data/iris_training.csv', users_num_list[k],
args.user_classes)
args.is_reg = False
if args.algorithm == 'fsvgr':
tf.reset_default_graph()
server = ServerModel(args.feature_dims, args.hidden_dims,
args.output_dims, args.ag_scalar,
args.is_reg)
clients = FederatedClientsModel(
dict_users, args.feature_dims, args.hidden_dims,
args.output_dims, train_data, train_label,
local_iter_list[i], args.lr, args.lg_scalar, args.local_bs,
args.is_reg)
with tf.name_scope("global_training"):
with tf.Session() as sess:
log_dir = './log'
writer = tf.summary.FileWriter(
log_dir + '/global_training', sess.graph)
sess.run(tf.global_variables_initializer())
global_loss = []
global_acc = []