MEDfl 0.2.1__py3-none-any.whl → 2.0.1__py3-none-any.whl

MEDfl/LearningManager/server.py

@@ -1,189 +1,181 @@
-#!/usr/bin/env python3
-
-import copy
-from typing import Dict, Optional, Tuple
-
-import flwr as fl
-import torch
-
-from .client import FlowerClient
-from .federated_dataset import FederatedDataset
-from .model import Model
-from .strategy import Strategy
-
-
-class FlowerServer:
-    """
-    A class representing the central server for Federated Learning using Flower.
-
-    Attributes:
-        global_model (Model): The global model that will be federated among clients.
-        strategy (Strategy): The strategy used for federated learning, specifying communication and aggregation methods.
-        num_rounds (int): The number of federated learning rounds to perform.
-        num_clients (int): The number of clients participating in the federated learning process.
-        fed_dataset (FederatedDataset): The federated dataset used for training and evaluation.
-        diff_priv (bool): Whether differential privacy is used during the federated learning process.
-        accuracies (List[float]): A list to store the accuracy of the global model during each round.
-        losses (List[float]): A list to store the loss of the global model during each round.
-        flower_clients (List[FlowerClient]): A list to store the FlowerClient objects representing individual clients.
-     
-    """
-
-    def __init__(
-        self,
-        global_model: Model,
-        strategy: Strategy,
-        num_rounds: int,
-        num_clients: int,
-        fed_dataset: FederatedDataset,
-        diff_privacy: bool = False,
-        client_resources: Optional[Dict[str, float]] = {'num_cpus': 1, 'num_gpus': 0.0}
-    ) -> None:
-        """
-        Initialize a FlowerServer object with the specified parameters.
-
-        Args:
-            global_model (Model): The global model that will be federated among clients.
-            strategy (Strategy): The strategy used for federated learning, specifying communication and aggregation methods.
-            num_rounds (int): The number of federated learning rounds to perform.
-            num_clients (int): The number of clients participating in the federated learning process.
-            fed_dataset (FederatedDataset): The federated dataset used for training and evaluation.
-            diff_privacy (bool, optional): Whether differential privacy is used during the federated learning process.
-                                           Default is False.
-        """
-        self.device = torch.device(
-            f"cuda" if torch.cuda.is_available() else "cpu"
-        )
-        self.global_model = global_model
-        self.params = global_model.get_parameters()
-        self.global_model.model = global_model.model.to(self.device)
-        self.num_rounds = num_rounds
-        self.num_clients = num_clients
-        self.fed_dataset = fed_dataset
-        self.strategy = strategy
-        self.client_resources = client_resources
-        setattr(
-            self.strategy.strategy_object,
-            "min_available_clients",
-            self.num_clients,
-        )
-        setattr(
-            self.strategy.strategy_object,
-            "initial_parameters",
-            fl.common.ndarrays_to_parameters(self.params),
-        )
-        setattr(self.strategy.strategy_object, "evaluate_fn", self.evaluate)
-        self.fed_dataset = fed_dataset
-        self.diff_priv = diff_privacy
-        self.accuracies = []
-        self.losses = []
-        self.auc = []
-        self.flower_clients = []
-        self.validate()
-
-    def validate(self) -> None:
-        """Validate global_model, strategy, num_clients, num_rounds, fed_dataset, diff_privacy"""
-        if not isinstance(self.global_model, Model):
-            raise TypeError("global_model argument must be a Model instance")
-
-        # if not isinstance(self.strategy, Strategy):
-        #     print(self.strategy)
-        #     print(isinstance(self.strategy, Strategy))
-        #     raise TypeError("strategy argument must be a Strategy instance")
-
-        if not isinstance(self.num_clients, int):
-            raise TypeError("num_clients argument must be an int")
-
-        if not isinstance(self.num_rounds, int):
-            raise TypeError("num_rounds argument must be an int")
-
-        if not isinstance(self.diff_priv, bool):
-            raise TypeError("diff_priv argument must be a bool")
-
-    def client_fn(self, cid) -> FlowerClient:
-        """
-        Return a FlowerClient object for a specific client ID.
-
-        Args:
-            cid: The client ID.
-
-        Returns:
-            FlowerClient: A FlowerClient object representing the individual client.
-        """
-        
-        device = torch.device(
-            f"cuda:{int(cid) % 4}" if torch.cuda.is_available() else "cpu"
-        )
-        client_model = copy.deepcopy(self.global_model)
-      
-        trainloader = self.fed_dataset.trainloaders[int(cid)]
-        valloader = self.fed_dataset.valloaders[int(cid)]
-        # this helps in making plots
-        
-        client = FlowerClient(
-            cid, client_model, trainloader, valloader, self.diff_priv
-        )
-        self.flower_clients.append(client)
-        return client
-
-    def evaluate(
-        self,
-        server_round: int,
-        parameters: fl.common.NDArrays,
-        config: Dict[str, fl.common.Scalar],
-    ) -> Optional[Tuple[float, Dict[str, fl.common.Scalar]]]:
-        """
-        Evaluate the global model on the validation dataset and update the accuracies and losses.
-
-        Args:
-            server_round (int): The current round of the federated learning process.
-            parameters (fl.common.NDArrays): The global model parameters.
-            config (Dict[str, fl.common.Scalar]): Configuration dictionary.
-
-        Returns:
-            Optional[Tuple[float, Dict[str, fl.common.Scalar]]]: The evaluation loss and accuracy.
-        """
-        testloader = self.fed_dataset.valloaders[0]
-        
-        self.global_model.set_parameters(
-            parameters
-        )  # Update model with the latest parameters
-        loss, accuracy ,auc = self.global_model.evaluate(testloader, self.device)
-        self.auc.append(auc)
-        self.losses.append(loss)
-        self.accuracies.append(accuracy)
-
-        if hasattr(self.strategy, 'study') and 0 < server_round <= self.strategy.HPO_factor*self.num_rounds  and (server_round  -1) %(self.strategy.hpo_rate )==0:
-            
-            print("================ Weeeee aaaaaareee hre ========================")
-
-            for trail in self.strategy.trail:
-
-                self.strategy.study.tell(trail , auc) 
-        
-        return loss, {"accuracy": accuracy}
-
-    def run(self) -> None:
-        """
-        Run the federated learning process using Flower simulation.
-
-        Returns:
-            History: The history of the accuracies and losses during the training of each node 
-        """
-         # Increase the object store memory to the minimum allowed value or higher
-        ray_init_args = {"include_dashboard": False
-                         , "object_store_memory": 78643200
-                        }
-        self.fed_dataset.eng = None
-        
-        history = fl.simulation.start_simulation(
-            client_fn=self.client_fn,
-            num_clients=self.num_clients,
-            config=fl.server.ServerConfig(self.num_rounds),
-            strategy=self.strategy.strategy_object,
-            ray_init_args=ray_init_args,
-            client_resources = self.client_resources
-        )
-
-        return history
-
+#!/usr/bin/env python3
+
+import copy
+from typing import Dict, Optional, Tuple
+
+import flwr as fl
+import torch
+
+from .client import FlowerClient
+from .federated_dataset import FederatedDataset
+from .model import Model
+from .strategy import Strategy
+
+
+class FlowerServer:
+    """
+    A class representing the central server for Federated Learning using Flower.
+
+    Attributes:
+        global_model (Model): The global model that will be federated among clients.
+        strategy (Strategy): The strategy used for federated learning, specifying communication and aggregation methods.
+        num_rounds (int): The number of federated learning rounds to perform.
+        num_clients (int): The number of clients participating in the federated learning process.
+        fed_dataset (FederatedDataset): The federated dataset used for training and evaluation.
+        diff_priv (bool): Whether differential privacy is used during the federated learning process.
+        accuracies (List[float]): A list to store the accuracy of the global model during each round.
+        losses (List[float]): A list to store the loss of the global model during each round.
+        flower_clients (List[FlowerClient]): A list to store the FlowerClient objects representing individual clients.
+     
+    """
+
+    def __init__(
+        self,
+        global_model: Model,
+        strategy: Strategy,
+        num_rounds: int,
+        num_clients: int,
+        fed_dataset: FederatedDataset,
+        diff_privacy: bool = False,
+        client_resources: Optional[Dict[str, float]] = {'num_cpus': 1, 'num_gpus': 0.0}
+    ) -> None:
+        """
+        Initialize a FlowerServer object with the specified parameters.
+
+        Args:
+            global_model (Model): The global model that will be federated among clients.
+            strategy (Strategy): The strategy used for federated learning, specifying communication and aggregation methods.
+            num_rounds (int): The number of federated learning rounds to perform.
+            num_clients (int): The number of clients participating in the federated learning process.
+            fed_dataset (FederatedDataset): The federated dataset used for training and evaluation.
+            diff_privacy (bool, optional): Whether differential privacy is used during the federated learning process.
+                                           Default is False.
+        """
+        self.device = torch.device(
+            f"cuda" if torch.cuda.is_available() else "cpu"
+        )
+        self.global_model = global_model
+        self.params = global_model.get_parameters()
+        self.global_model.model = global_model.model.to(self.device)
+        self.num_rounds = num_rounds
+        self.num_clients = num_clients
+        self.fed_dataset = fed_dataset
+        self.strategy = strategy
+        self.client_resources = client_resources
+        setattr(
+            self.strategy.strategy_object,
+            "min_available_clients",
+            self.num_clients,
+        )
+        setattr(
+            self.strategy.strategy_object,
+            "initial_parameters",
+            fl.common.ndarrays_to_parameters(self.params),
+        )
+        setattr(self.strategy.strategy_object, "evaluate_fn", self.evaluate)
+        self.fed_dataset = fed_dataset
+        self.diff_priv = diff_privacy
+        self.accuracies = []
+        self.losses = []
+        self.auc = []
+        self.flower_clients = []
+        self.validate()
+
+    def validate(self) -> None:
+        """Validate global_model, strategy, num_clients, num_rounds, fed_dataset, diff_privacy"""
+        if not isinstance(self.global_model, Model):
+            raise TypeError("global_model argument must be a Model instance")
+
+        # if not isinstance(self.strategy, Strategy):
+        #     print(self.strategy)
+        #     print(isinstance(self.strategy, Strategy))
+        #     raise TypeError("strategy argument must be a Strategy instance")
+
+        if not isinstance(self.num_clients, int):
+            raise TypeError("num_clients argument must be an int")
+
+        if not isinstance(self.num_rounds, int):
+            raise TypeError("num_rounds argument must be an int")
+
+        if not isinstance(self.diff_priv, bool):
+            raise TypeError("diff_priv argument must be a bool")
+
+    def client_fn(self, cid) -> FlowerClient:
+        """
+        Return a FlowerClient object for a specific client ID.
+
+        Args:
+            cid: The client ID.
+
+        Returns:
+            FlowerClient: A FlowerClient object representing the individual client.
+        """
+        
+        device = torch.device(
+            f"cuda:{int(cid) % 4}" if torch.cuda.is_available() else "cpu"
+        )
+        client_model = copy.deepcopy(self.global_model)
+      
+        trainloader = self.fed_dataset.trainloaders[int(cid)]
+        valloader = self.fed_dataset.valloaders[int(cid)]
+        # this helps in making plots
+        
+        client = FlowerClient(
+            cid, client_model, trainloader, valloader, self.diff_priv
+        )
+        self.flower_clients.append(client)
+        return client
+
+    def evaluate(
+        self,
+        server_round: int,
+        parameters: fl.common.NDArrays,
+        config: Dict[str, fl.common.Scalar],
+    ) -> Optional[Tuple[float, Dict[str, fl.common.Scalar]]]:
+        """
+        Evaluate the global model on the validation dataset and update the accuracies and losses.
+
+        Args:
+            server_round (int): The current round of the federated learning process.
+            parameters (fl.common.NDArrays): The global model parameters.
+            config (Dict[str, fl.common.Scalar]): Configuration dictionary.
+
+        Returns:
+            Optional[Tuple[float, Dict[str, fl.common.Scalar]]]: The evaluation loss and accuracy.
+        """
+        testloader = self.fed_dataset.valloaders[0]
+        
+        self.global_model.set_parameters(
+            parameters
+        )  # Update model with the latest parameters
+        loss, accuracy ,auc = self.global_model.evaluate(testloader, self.device)
+        self.auc.append(auc)
+        self.losses.append(loss)
+        self.accuracies.append(accuracy)
+        
+        return loss, {"accuracy": accuracy}
+
+    def run(self) -> None:
+        """
+        Run the federated learning process using Flower simulation.
+
+        Returns:
+            History: The history of the accuracies and losses during the training of each node 
+        """
+         # Increase the object store memory to the minimum allowed value or higher
+        ray_init_args = {"include_dashboard": False
+                         , "object_store_memory": 78643200
+                        }
+        self.fed_dataset.eng = None
+        
+        history = fl.simulation.start_simulation(
+            client_fn=self.client_fn,
+            num_clients=self.num_clients,
+            config=fl.server.ServerConfig(self.num_rounds),
+            strategy=self.strategy.strategy_object,
+            ray_init_args=ray_init_args,
+            client_resources = self.client_resources
+        )
+
+        return history
+

MEDfl/LearningManager/strategy.py

@@ -1,138 +1,82 @@
-
-from collections import OrderedDict
-from typing import Dict, List, Optional, Tuple
-
-import flwr as fl
-import numpy as np
-
-import optuna
-
-
-
-
-class  Strategy:
-    """
-    A class representing a strategy for Federated Learning.
-
-    Attributes:
-        name (str): The name of the strategy. Default is "FedAvg".
-        fraction_fit (float): Fraction of clients to use for training during each round. Default is 1.0.
-        fraction_evaluate (float): Fraction of clients to use for evaluation during each round. Default is 1.0.
-        min_fit_clients (int): Minimum number of clients to use for training during each round. Default is 2.
-        min_evaluate_clients (int): Minimum number of clients to use for evaluation during each round. Default is 2.
-        min_available_clients (int): Minimum number of available clients required to start a round. Default is 2.
-        initial_parameters (Optional[]): The initial parameters of the server model 
-    Methods:
-     
-    """
-
-    def __init__(
-        self,
-        name: str = "FedAvg",
-        fraction_fit: float = 1.0,
-        fraction_evaluate: float = 1.0,
-        min_fit_clients: int = 2,
-        min_evaluate_clients: int = 2,
-        min_available_clients: int = 2,
-        initial_parameters = [],
-        evaluation_methode = "centralized" , 
-        config = None
-    ) -> None:
-        """
-        Initialize a Strategy object with the specified parameters.
-
-        Args:
-            name (str): The name of the strategy. Default is "FedAvg".
-            fraction_fit (float): Fraction of clients to use for training during each round. Default is 1.0.
-            fraction_evaluate (float): Fraction of clients to use for evaluation during each round. Default is 1.0.
-            min_fit_clients (int): Minimum number of clients to use for training during each round. Default is 2.
-            min_evaluate_clients (int): Minimum number of clients to use for evaluation during each round. Default is 2.
-            min_available_clients (int): Minimum number of available clients required to start a round. Default is 2.
-            initial_parameters (Optional[]): The initial parametres of the server model 
-            evaluation_methode ( "centralized" | "distributed")
-        """
-        self.fraction_fit = fraction_fit
-        self.fraction_evaluate = fraction_evaluate
-        self.min_fit_clients = min_fit_clients
-        self.min_evaluate_clients = min_evaluate_clients
-        self.min_available_clients = min_available_clients
-        self.initial_parameters = initial_parameters
-        self.evaluate_fn = None
-        self.name = name 
-        self.config = config
-        self.server_round = 0
-
-    def get_trial(self, trial_number):
-        # Retrieve the trial from the study
-        trial = next((t for t in self.study.trials if t.number == trial_number), None)
-        if trial:
-            return trial
-        else:
-            return "Trial not found"
-        
-    def fit_config(self , server_round: int):
-        """Return training configuration dict for each round.
-
-        Perform two rounds of training with one local epoch, increase to two local
-        epochs afterwards.
-        """
-        config  = self.config 
-        
-        if hasattr(self, 'study'):
-            if 0 < server_round <= 0.7*10  and (server_round - 1 ) % self.hpo_rate == 0 : 
-                if(self.server_round < server_round):
-                    self.server_round = server_round
-                    self.trail = []
-                    
-                
-
-                print('================= this is the server trails')
-                print(self.trail)
-
-                trail = self.study.ask()
-                self.trail.append(trail)
-                learning_rate = trail.suggest_float('learning_rate', 1e-5, 1e-1)
-                print(self.study.trials)
-                print(trail.number)
-                config = {
-                    "trail" : trail ,
-                    "server_rounds":  5 , 
-                    "server_round" : server_round , 
-                    "HPO_factor" : 0.5 , 
-                    "study" : self.study , 
-                    "HPO_RATE" : self.hpo_rate , 
-                    "params" : {
-                    "learning_rate" : learning_rate
-                  }
-                  }
-                
-        return config
-
-    def optuna_fed_optimization(self, direction:str , hpo_rate:int , hpo_factor ,  params_config , sampler="TPESampler" , metric='AUC'):
-        self.study = optuna.create_study(direction=direction , sampler=self.get_sampler_by_name(sampler)())
-        self.hpo_rate = hpo_rate
-        self.HPO_factor = hpo_factor
-        self.config = params_config
-        self.opt_metric = metric
-    
- 
-    def create_strategy(self):
-        self.strategy_object = self.get_strategy_by_name()(
-            fraction_fit=self.fraction_fit,
-            fraction_evaluate=self.fraction_evaluate,
-            min_fit_clients=self.min_fit_clients,
-            min_evaluate_clients=self.min_evaluate_clients,
-            min_available_clients=self.min_available_clients,
-            initial_parameters=fl.common.ndarrays_to_parameters(self.initial_parameters),
-            evaluate_fn=self.evaluate_fn , 
-            on_fit_config_fn = self.fit_config ,
-            on_evaluate_config_fn = self.fit_config
-        )
-    def get_strategy_by_name(self):
-        return eval(f"fl.server.strategy.{self.name}")
-    
-    def get_sampler_by_name(self , name) : 
-        return eval(f"optuna.samplers.{name}")
-    
-    
-
+
+from collections import OrderedDict
+from typing import Dict, List, Optional, Tuple
+
+import flwr as fl
+import numpy as np
+
+import optuna
+
+
+
+
+class  Strategy:
+    """
+    A class representing a strategy for Federated Learning.
+
+    Attributes:
+        name (str): The name of the strategy. Default is "FedAvg".
+        fraction_fit (float): Fraction of clients to use for training during each round. Default is 1.0.
+        fraction_evaluate (float): Fraction of clients to use for evaluation during each round. Default is 1.0.
+        min_fit_clients (int): Minimum number of clients to use for training during each round. Default is 2.
+        min_evaluate_clients (int): Minimum number of clients to use for evaluation during each round. Default is 2.
+        min_available_clients (int): Minimum number of available clients required to start a round. Default is 2.
+        initial_parameters (Optional[]): The initial parameters of the server model 
+    Methods:
+     
+    """
+
+    def __init__(
+        self,
+        name: str = "FedAvg",
+        fraction_fit: float = 1.0,
+        fraction_evaluate: float = 1.0,
+        min_fit_clients: int = 2,
+        min_evaluate_clients: int = 2,
+        min_available_clients: int = 2,
+        initial_parameters = [],
+        evaluation_methode = "centralized"
+    ) -> None:
+        """
+        Initialize a Strategy object with the specified parameters.
+
+        Args:
+            name (str): The name of the strategy. Default is "FedAvg".
+            fraction_fit (float): Fraction of clients to use for training during each round. Default is 1.0.
+            fraction_evaluate (float): Fraction of clients to use for evaluation during each round. Default is 1.0.
+            min_fit_clients (int): Minimum number of clients to use for training during each round. Default is 2.
+            min_evaluate_clients (int): Minimum number of clients to use for evaluation during each round. Default is 2.
+            min_available_clients (int): Minimum number of available clients required to start a round. Default is 2.
+            initial_parameters (Optional[]): The initial parametres of the server model 
+            evaluation_methode ( "centralized" | "distributed")
+        """
+        self.fraction_fit = fraction_fit
+        self.fraction_evaluate = fraction_evaluate
+        self.min_fit_clients = min_fit_clients
+        self.min_evaluate_clients = min_evaluate_clients
+        self.min_available_clients = min_available_clients
+        self.initial_parameters = initial_parameters
+        self.evaluate_fn = None
+        self.name = name
+    
+    def optuna_fed_optimization(self, direction:str , hpo_rate:int , params_config):
+        self.study = optuna.create_study(direction=direction)
+        self.hpo_rate = hpo_rate
+        self.params_config = params_config
+    
+ 
+    def create_strategy(self):
+        self.strategy_object = self.get_strategy_by_name()(
+            fraction_fit=self.fraction_fit,
+            fraction_evaluate=self.fraction_evaluate,
+            min_fit_clients=self.min_fit_clients,
+            min_evaluate_clients=self.min_evaluate_clients,
+            min_available_clients=self.min_available_clients,
+            initial_parameters=fl.common.ndarrays_to_parameters(self.initial_parameters),
+            evaluate_fn=self.evaluate_fn
+        )
+    def get_strategy_by_name(self):
+        return eval(f"fl.server.strategy.{self.name}")
+    
+    
+