MEDfl 2.0.4.dev9__tar.gz → 2.0.4.dev11__tar.gz

{medfl-2.0.4.dev9 → medfl-2.0.4.dev11}/MEDfl/rw/strategy.py

@@ -1,5 +1,7 @@
 # File: MEDfl/rw/strategy.py
 
+import os
+import numpy as np
 import flwr as fl
 from typing import Callable, Optional, Dict, Any, List, Tuple
 from flwr.common import GetPropertiesIns
@@ -38,6 +40,7 @@ class Strategy:
       - Custom metric aggregation
       - Per-client & aggregated metric logging
       - Synchronous get_properties() inspection in configure_fit()
+      - Saving global parameters every saveOnRounds to savingPath
     """
 
     def __init__(
@@ -56,6 +59,9 @@ class Strategy:
         threshold: float = 0.5,
         learning_rate: float = 0.01,
         optimizer_name: str = "SGD",
+        savingPath: str = "",
+        saveOnRounds: int = 3,
+        total_rounds: int = 3,
     ) -> None:
         self.name = name
         self.fraction_fit = fraction_fit
@@ -74,6 +80,9 @@ class Strategy:
         self.threshold = threshold
         self.learning_rate = learning_rate
         self.optimizer_name = optimizer_name
+        self.savingPath = savingPath
+        self.saveOnRounds = saveOnRounds
+        self.total_rounds = total_rounds
 
         self.strategy_object: Optional[fl.server.strategy.Strategy] = None
 
@@ -84,22 +93,22 @@ class Strategy:
         # 2) Define on_fit_config_fn _before_ instantiation
         def fit_config_fn(server_round: int) -> Dict[str, Any]:
             return {
-                "local_epochs": self.local_epochs,
-                "threshold": self.threshold,
-                "learning_rate": self.learning_rate,
-                "optimizer": self.optimizer_name,
+                "local_epochs":   self.local_epochs,
+                "threshold":      self.threshold,
+                "learning_rate":  self.learning_rate,
+                "optimizer":      self.optimizer_name,
             }
 
         # 3) Build params including on_fit_config_fn
         params: Dict[str, Any] = {
-            "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,
-            "evaluate_fn": self.evaluate_fn,
-            "on_fit_config_fn": fit_config_fn,
-            "fit_metrics_aggregation_fn": self.fit_metrics_aggregation_fn,
+            "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,
+            "evaluate_fn":                   self.evaluate_fn,
+            "on_fit_config_fn":              fit_config_fn,
+            "fit_metrics_aggregation_fn":    self.fit_metrics_aggregation_fn,
             "evaluate_metrics_aggregation_fn": self.evaluate_metrics_aggregation_fn,
         }
         if self.initial_parameters:
@@ -108,37 +117,53 @@ class Strategy:
         # 4) Instantiate the real Flower strategy
         strat = StrategyClass(**params)
 
-        # 5) Wrap aggregate_fit for logging
+        # 5) Wrap aggregate_fit for logging (prints unchanged)
         original_agg_fit = strat.aggregate_fit
         def logged_agg_fit(server_round, results, failures):
-            print(f"\n[Server] 🔄 Round {server_round} – Client Training Metrics:")
-            for client_id, fit_res in results:
-                print(f"  • {client_id.cid}: {fit_res.metrics}")
+            print(f"\n[Server] 🔄 Round {server_round} - Client Training Metrics:")
+            for i, (client_id, fit_res) in enumerate(results):
+                print(f" CTM Round {server_round} Client:{client_id.cid}: {fit_res.metrics}")
             agg_params, metrics = original_agg_fit(server_round, results, failures)
-            print(f"[Server] ✅ Aggregated Training Metrics: {metrics}\n")
+            print(f"[Server] ✅ Round {server_round} - Aggregated Training Metrics: {metrics}\n")
+            # save the model parameters if savingPath is set on each saveOnRounds 
+            if self.savingPath and ((server_round % self.saveOnRounds == 0) or (self.total_rounds and server_round == self.total_rounds)):
+                arrays = fl.common.parameters_to_ndarrays(agg_params)
+                # Determine filename: final_model on last round else round_{n}
+                filename = f"round_{server_round}_final_model.npz" if server_round == self.total_rounds else f"round_{server_round}_model.npz"
+                filepath = os.path.join(self.savingPath, filename)
+                np.savez(filepath, *arrays)
             return agg_params, metrics
         strat.aggregate_fit = logged_agg_fit
 
-        # 6) Wrap aggregate_evaluate for logging
+        # 6) Wrap aggregate_evaluate for logging (prints unchanged)
         original_agg_eval = strat.aggregate_evaluate
         def logged_agg_eval(server_round, results, failures):
-            print(f"\n[Server] 📊 Round {server_round} – Client Evaluation Metrics:")
-            for client_id, eval_res in results:
-                print(f"  • {client_id.cid}: {eval_res.metrics}")
+            print(f"\n[Server] 📊 Round {server_round} - Client Evaluation Metrics:")
+            for i, (client_id, eval_res) in enumerate(results):
+                print(f" CEM Round {server_round} Client:{client_id.cid}: {eval_res.metrics}")
             loss, metrics = original_agg_eval(server_round, results, failures)
-            print(f"[Server] ✅ Aggregated Evaluation Metrics: Loss={loss}, Metrics={metrics}\n")
+            print(f"[Server] ✅ Round {server_round} - Aggregated Evaluation Metrics:")
+            print(f"    Loss: {loss}, Metrics: {metrics}\n")
             return loss, metrics
         strat.aggregate_evaluate = logged_agg_eval
 
-        # 7) Wrap configure_fit to log client properties
+        # 7) Wrap configure_fit to log client properties (prints unchanged)
         original_conf_fit = strat.configure_fit
-        def wrapped_conf_fit(server_round: int, parameters, client_manager: ClientManager):
-            selected = original_conf_fit(server_round, parameters, client_manager)
+        def wrapped_conf_fit(
+            server_round: int,
+            parameters,
+            client_manager: ClientManager
+        ):
+            selected = original_conf_fit(
+                server_round=server_round,
+                parameters=parameters,
+                client_manager=client_manager
+            )
             ins = GetPropertiesIns(config={})
             for client, _ in selected:
                 try:
                     props = client.get_properties(ins=ins, timeout=10.0, group_id=0)
-                    print(f"📋 [Round {server_round}] {client.cid} props: {props.properties}")
+                    print(f"\n📋 [Round {server_round}] Client {client.cid} Properties: {props.properties}")
                 except Exception as e:
                     print(f"⚠️ Failed to get properties from {client.cid}: {e}")
             return selected

{medfl-2.0.4.dev9 → medfl-2.0.4.dev11}/MEDfl.egg-info/PKG-INFO

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

{medfl-2.0.4.dev9 → medfl-2.0.4.dev11}/PKG-INFO

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

{medfl-2.0.4.dev9 → medfl-2.0.4.dev11}/setup.py

@@ -14,7 +14,7 @@ with open('requirements.txt') as f:
 
 setup(
     name="MEDfl",
-    version="2.0.4.dev9",
+    version="2.0.4.dev11",
     author="MEDomics consortium",
     author_email="medomics.info@gmail.com",
     description="Python Open-source package for simulating federated learning and differential privacy",