MEDfl 0.2.0__tar.gz → 0.2.1__tar.gz

{MEDfl-0.2.0 → MEDfl-0.2.1}/MEDfl/LearningManager/client.py

@@ -7,6 +7,8 @@ from .model import Model
 from .utils import params
 import torch
 
+import optuna
+
 class FlowerClient(fl.client.NumPyClient):
     """
     FlowerClient class for creating MEDfl clients.
@@ -107,6 +109,7 @@ class FlowerClient(fl.client.NumPyClient):
         Returns:
             Tuple: Parameters of the local model, number of training examples, and privacy information.
         """
+
         print('\n -------------------------------- \n  this is the config of the client')
         print(f"[Client {self.cid}] fit, config: {config}")
         # print(config['epochs'])
@@ -147,4 +150,32 @@ class FlowerClient(fl.client.NumPyClient):
         self.losses.append(loss)
         self.accuracies.append(accuracy)
         
+        print(f"[ ============== From evaluate ==== Client {self.cid}] fit, config: {config}")
+
+
+        # if('study' in config):
+        #     if 0 < config['server_round'] <= config['HPO_factor']*config['server_rounds']  and (config['server_round']  -1) %(config['HPO_RATE'] )==0:
+        #        print("==================== this is th optimisations info ===================")
+        #        print(auc) 
+        #        print(config['trail'])
+        #        print('---------') 
+        #        print(config['study'].trials[0].state) 
+        #        try:
+        #             # Call tell() method to report the result
+        #             config['study'].tell(config['trail'], auc)
+                    
+        #             # Fetch the updated trial from the study
+        #             updated_trial = config['trail']
+                    
+        #             # Check the state of the trial
+        #             if updated_trial.state == optuna.trial.TrialState.COMPLETE:
+        #                 print(f"Trial {updated_trial.number} completed successfully with value {updated_trial.value}")
+        #             else:
+        #                 print(f"Trial {updated_trial.number} is in state {updated_trial.state}")
+                
+        #        except Exception as e:
+        #             # Handle and log any errors
+        #             print(f"Error during tell(): {e}")
+
+        
         return float(loss), len(self.valloader), {"accuracy": float(accuracy)}

{MEDfl-0.2.0 → MEDfl-0.2.1}/MEDfl/LearningManager/server.py

@@ -152,6 +152,14 @@ class FlowerServer:
         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}
 

{MEDfl-0.2.0 → MEDfl-0.2.1}/MEDfl/LearningManager/strategy.py

@@ -35,7 +35,8 @@ class  Strategy:
         min_evaluate_clients: int = 2,
         min_available_clients: int = 2,
         initial_parameters = [],
-        evaluation_methode = "centralized"
+        evaluation_methode = "centralized" , 
+        config = None
     ) -> None:
         """
         Initialize a Strategy object with the specified parameters.
@@ -57,12 +58,62 @@ class  Strategy:
         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.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.params_config = params_config
+        self.HPO_factor = hpo_factor
+        self.config = params_config
+        self.opt_metric = metric
     
  
     def create_strategy(self):
@@ -73,10 +124,15 @@ class  Strategy:
             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
+            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}")
+    
     
 

{MEDfl-0.2.0 → MEDfl-0.2.1}/MEDfl/NetManager/database_connector.py

@@ -34,7 +34,7 @@ class DatabaseManager:
         create_db_script_path = os.path.join(current_directory, '..', 'scripts', 'create_db.py')
 
         # Execute the create_db.py script
-        subprocess.run(['python3', create_db_script_path, path_to_csv], check=True)
+        subprocess.run(['python', create_db_script_path, path_to_csv], check=True)
 
         return
 

{MEDfl-0.2.0 → MEDfl-0.2.1}/MEDfl.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MEDfl
-Version: 0.2.0
+Version: 0.2.1
 Summary: Python Open-source package for simulating federated learning and differential privacy
 Home-page: https://github.com/MEDomics-UdeS/MEDfl
 Author: MEDomics consortium

{MEDfl-0.2.0 → MEDfl-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MEDfl
-Version: 0.2.0
+Version: 0.2.1
 Summary: Python Open-source package for simulating federated learning and differential privacy
 Home-page: https://github.com/MEDomics-UdeS/MEDfl
 Author: MEDomics consortium