import numpy as np import argparse import torch import torch.nn as nn import random import math import os import copy from torchvision import models from easyfsl.methods import PrototypicalNetworks from easyfsl.utils import evaluate from logging import WARNING from utils_aggregation import aggregate, aggregate_krum, aggregate_median, aggregate_qffl, aggregate_trimmed_avg, weighted_loss_avg from Client_setup import setup_client from utils_training import train random_seed = 0 np.random.seed(random_seed) torch.manual_seed(random_seed) random.seed(random_seed) class federated_training(): def __init__( self, method, run_name, model, station_properties, rounds, epochs, num_clients, init_weights_pth, weighted_loss, embedding_diff, embedding_diff_plus_loss, emb_diff_to_server, momentum_vector, lossfunction, env, mode=False, ): self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu") self.model = model print(f"printing path of global model -------------------{init_weights_pth}") self.init_weights = torch.load(init_weights_pth, map_location=self.device) self.method = method self.rounds = rounds self.epochs = epochs self.global_model = copy.deepcopy(network_) self.global_model.load_state_dict(self.init_weights) self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu") self.momentum_vector: momentum_vector self.station_train_loaders = {} self.station_valid_loaders = {} self.global_model_stations = {} self.globel_model_second = {} self.station_properties = station_properties self.run_name = run_name self.clients = num_clients self.log_files = [] self.local_model_pth = [] self.weighted_loss = weighted_loss self.embedding_diff = embedding_diff self.embedding_diff_plus_loss = embedding_diff_plus_loss self.emb_diff_to_server = emb_diff_to_server self.log_emb_diff = [] self.init_weights_list = list(self.init_weights.values()) self.server_momentum = 0.0 self.server_learning_rate = 1.0 self.mode = mode self.lsfunction = lossfunction self.env_list_all = env print(f"current device is {self.device}") def setup_clients(self, num_clients, station_properties, fed_method, run_name, station_train_loaders, station_valid_loaders, global_model_stations, globel_model_second, log_files, local_md_pth, log_emb_diff, env_list): for station_number in range(0, num_clients): self.setup_client(station_properties, station_number, fed_method, run_name, station_train_loaders, station_valid_loaders, global_model_stations, globel_model_second, log_files, local_md_pth, log_emb_diff, env_list[station_number]) def setup_client(self, station_properties, station_number, fed_method, run_name, station_train_loaders, station_valid_loaders, global_model_stations, globel_model_second, log_files, local_md_pth, log_emb_diff, env_list): setup_client(station_properties, station_number, fed_method, run_name, station_train_loaders, station_valid_loaders, global_model_stations, globel_model_second, log_files, local_md_pth, log_emb_diff, env_list) def get_parameters(self, net): print("Im Under get_parameters") return [val.cpu().numpy() for _, val in net.state_dict().items()] def set_parameters(self, net, parameters): print("Im Under set_parameters") parameters = [param.cpu().numpy() if isinstance(param, torch.Tensor) else param for param in parameters] parameters = [torch.from_numpy(param).to(self.device) for param in parameters] state_dict = dict(zip(net.state_dict().keys(), parameters)) net.load_state_dict(state_dict, strict=True) def test(self, net, remote_valid_dataset): """Evaluate the network on the entire test set.""" # Evaluate and save the model if it's the best net.to(self.device) net.eval() validation_accuracy = evaluate(net, remote_valid_dataset, self.device, tqdm_prefix="Validation") return validation_accuracy def fit(self, weights_array_numexpl, server_round): if self.method == "FedAvg": print("-------------------------Im using FedAvg--------------------------------") updated_weights = aggregate(weights_array_numexpl) elif self.method == "FedAvgM": print("-------------------------Im using FedAvgM--------------------------------") fedavg_result = aggregate(weights_array_numexpl) assert self.init_weights is not None, "Model needs to be initialized." init_weights_list_device = [x.to(self.device) for x in self.init_weights_list] fedavg_result_device = [y.to(self.device) for y in fedavg_result] pseudo_gradient = [x - y for x, y in zip(init_weights_list_device, fedavg_result_device)] if isinstance(self.server_momentum, float): print("momentum is float") else: print("its tuple") print({"im underb server momentum calculation-------------------------------"}) if self.server_momentum > 0.0: if server_round > 1: assert self.momentum_vector, "Momentum should have been created on round 1." self.momentum_vector = [ self.server_momentum * x + y for x, y in zip(self.momentum_vector, pseudo_gradient) ] else: self.momentum_vector = pseudo_gradient # Assign pseudo-gradient as momentum pseudo_gradient = self.momentum_vector # SGD update updated_weights = [ x - self.server_learning_rate * y for x, y in zip(init_weights_list_device, pseudo_gradient) ] # Update current weights self.init_weights_list = init_weights_list_device elif self.method == "FedMedian": print("-------------------------Im using FedMedian--------------------------------") updated_weights = aggregate_median(weights_array_numexpl) return updated_weights def train_fedretaed(self): ##set up for clients self.setup_clients(self.clients, self.station_properties, self.method, self.run_name, self.station_train_loaders, self.station_valid_loaders, self.global_model_stations, self.globel_model_second, self.log_files, self.local_model_pth, self.log_emb_diff, self.env_list_all) prev_round_diff = [0] * self.clients ##added weights_epoch_diff = [0] * self.clients ##added ###########################early-epoch based methods starts here################################ for rn in range(self.rounds): print(f"im runnning for round :{rn + 1}") print(f"weights_epoch_diff for round :{rn + 1} are---- {weights_epoch_diff}") # (math.floor(max(diff_2)/max(diff)*7)) if rn == 1: eps = self.epochs - 1 for i in range(len(prev_round_diff)): prev_round_diff[i] = weights_epoch_diff[i] elif rn > 1: eps = max((math.floor(max(weights_epoch_diff) / max(prev_round_diff) * eps)), 2) eps = min(self.epochs, eps) eps = eps - 1 for i in range(len(prev_round_diff)): prev_round_diff[i] = weights_epoch_diff[i] else: eps = self.epochs - 1 # for rn ==0 new_epoch = [eps]*self.clients if rn > 0: weights = [x / max(weights_epoch_diff) for x in weights_epoch_diff] new_epoch = [math.floor(x * y) for x, y in zip(new_epoch, weights)] new_epoch = [x + 1 for x in new_epoch] print(f"epochs for round :{rn + 1} are---- {new_epoch}") ################################################################################################################# s_m = [120, 160] s_g = 0.1 lr = 1e-2 results_fed = [] start_emb_df_accumulated = [0] * self.clients for station_number, model in enumerate(self.global_model_stations.values(), start=0): layer_diff_list = [] if self.mode: new_epoch = new_epoch # ---------------------------------------added else: new_epoch = [self.epochs, self.epochs, self.epochs, self.epochs] if self.emb_diff_to_server: emb_diff_epoch = train(self.station_train_loaders[f"station_{station_number}_train_loaders"], station_model=model, model=model, global_model=self.globel_model_second[f"station_{station_number}_globalsecond"], n_epochs=new_epoch[station_number], learning_rate=lr, scheduler_milestones=s_m, scheduler_gamma=s_g, LOG_FILE=self.log_files[station_number], emb_diff_to_server=self.emb_diff_to_server, local_model=self.local_model_pth[station_number], round=rn + 1, embedding_diff=self.embedding_diff, embedding_diff_plus_loss=self.embedding_diff_plus_loss, LOG_FILE_emb=self.log_emb_diff[station_number], station_n=station_number, ls_function=self.lsfunction) start_emb_df_accumulated[station_number] = emb_diff_epoch results = self.get_parameters(model), len(self.station_train_loaders), { "embedding_diff": start_emb_df_accumulated[station_number]} else: embedding_loss = train(self.station_train_loaders[f"station_{station_number}_train_loaders"], station_model=model, model=model, global_model=self.globel_model_second[f"station_{station_number}_globalsecond"], n_epochs=new_epoch[station_number], learning_rate=lr, scheduler_milestones=s_m, scheduler_gamma=s_g, LOG_FILE=self.log_files[station_number], emb_diff_to_server=self.emb_diff_to_server, local_model=self.local_model_pth[station_number], round=rn + 1, embedding_diff=self.embedding_diff, embedding_diff_plus_loss=self.embedding_diff_plus_loss, LOG_FILE_emb=self.log_emb_diff[station_number], station_n=station_number, ls_function=self.lsfunction) results = self.get_parameters(model), len(self.station_train_loaders), {} results_fed.append(results) weights_epoch_diff[station_number] = embedding_loss.item() aggregate_weights = self.fit(results_fed, rn) root_folder = self.method + self.run_name root_folder = os.path.join("../Output", root_folder) if aggregate_weights is not None: try: state_dict = dict() for idx, param_tensor in enumerate(self.global_model.state_dict()): state_dict[param_tensor] = torch.from_numpy( aggregate_weights[idx].cpu().numpy()) # Convert tensor to NumPy array print( "im saving model under following folder -----------------------------------------------------------------------") model_dir = os.path.join(root_folder, "model") os.makedirs(model_dir, exist_ok=True) model_file = os.path.join(model_dir, f"round--{rn + 1}_weights.h5") self.global_model.load_state_dict(state_dict, strict=False) torch.save(self.global_model.state_dict(), model_file) except Exception as e: print(f"Error saving weights for round {rn + 1}: {e}") for station_number, model in enumerate(self.global_model_stations.values(), start=1): self.set_parameters(model, aggregate_weights) if __name__ == "__main__": station_properties = { "permutatiion": [[0, 1, 2, 5], [0, 1, 2, 5]], "label_list": [[0, 1, 2, 5], [0, 1, 2, 5]], "similarity_labels": [[0, 1, 2, 3, 4, 5, 7, 10], [0, 1, 2, 4, 5, 6, 7, 10], [0, 1, 2, 4, 5, 7, 8, 10], [0, 1, 2, 4, 5, 7, 9, 10]], "n_way": 4, "n_shot": 2, "n_query": 8, "n_tasks_per_epoch": 10, # 250 "n_validation_tasks": 1, # 150 "n_workers": 0, "train_test_spl": "./workspace/Jammer_detection/Datasets/Diff_env_daten/base_data/train_random_dep_new.txt", "root_dir": "./workspace/Jammer_detection/Datasets/Diff_env_daten/base_data/data", "norm_vals": "./workspace/Jammer_detection/Datasets/norm_vals.npy", "global_model_path": "./workspace/Jammer_detection/Src/Linkhalle_federated/Src/outputs/2024-04-10/trained_0123/trained_0123/model_weights0epoch100.h5" } ##########traniner settings############ ##define model model = models.resnet18(pretrained=False) model.fc = nn.Identity() network_ = PrototypicalNetworks(model) init_weights_pth = "./workspace/Jammer_detection/Src/federated_synthetic_data/outputs/2024-02-27/18-12-02/model_global_synthetic/model_weights0epoch100.h5" parser = argparse.ArgumentParser(description="Federated Training Argument Parser") parser.add_argument("--method", type=str, required=True, help="Training method") parser.add_argument("--run_name", type=str, required=True, help="Name of the run") parser.add_argument("--model", type=str, default=network_, help="Model name") parser.add_argument("--station_properties", default=station_properties, help="Properties for clients") parser.add_argument("--rounds", type=int, default=10, help="Number of rounds") parser.add_argument("--epochs", type=int, default=5, help="Number of epochs") parser.add_argument("--num_clients", type=int, default=2, help="Number of clients") parser.add_argument("--init_weights_pth", type=str, default=init_weights_pth, help="initial weights path") parser.add_argument("--weighted_loss", type=bool, default=False, help="weighted_loss") parser.add_argument("--embedding_diff", type=bool, default=False, help="embedding_diff") parser.add_argument("--embedding_diff_plus_loss", type=bool, default=False, help="embedding_diff_plus_loss") parser.add_argument("--emb_diff_to_server", type=bool, default=False, help="emb_diff_to_server") parser.add_argument("--momentum_vector", type=int, default=None, help="momentum vector") parser.add_argument("--lossfunction", type=str, default=None, help="loss function") parser.add_argument("--env", type=list, default=[[2, 3, 11, 4, 5], [6, 7, 8, 9, 10]], help="env list") parser.add_argument("--mode", type=bool, default=False, help="epoch difference") # Add more arguments as needed args = parser.parse_args() print(f"embeding diff to server value is : {args.emb_diff_to_server}") federated_training = federated_training( args.method, args.run_name, args.model, args.station_properties, args.rounds, args.epochs, args.num_clients, args.init_weights_pth, args.weighted_loss, args.embedding_diff, args.embedding_diff_plus_loss, args.emb_diff_to_server, args.momentum_vector, args.lossfunction, args.env, args.mode ) federated_training.train_fedretaed()