MEDfl 2.0.4.dev8__tar.gz → 2.0.4.dev9__tar.gz

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

@@ -1,5 +1,7 @@
+# File: MEDfl/rw/strategy.py
+
 import flwr as fl
-from typing import Callable, Optional, Dict, Any, Tuple, List
+from typing import Callable, Optional, Dict, Any, List, Tuple
 from flwr.common import GetPropertiesIns
 from flwr.server.client_manager import ClientManager
 from flwr.server.client_proxy import ClientProxy
@@ -8,7 +10,6 @@ import time
 # ===================================================
 # Custom metric aggregation functions
 # ===================================================
-
 def aggregate_fit_metrics(
     results: List[Tuple[int, Dict[str, float]]]
 ) -> Dict[str, float]:
@@ -30,13 +31,13 @@ def aggregate_eval_metrics(
 # ===================================================
 # Strategy Wrapper
 # ===================================================
-
 class Strategy:
     """
     Flower Strategy wrapper:
-    - Custom metric aggregation
-    - Per-client & aggregated metric logging
-    - Synchronous get_properties() inspection in configure_fit()
+      - Dynamic hyperparameters via on_fit_config_fn
+      - Custom metric aggregation
+      - Per-client & aggregated metric logging
+      - Synchronous get_properties() inspection in configure_fit()
     """
 
     def __init__(
@@ -52,6 +53,9 @@ class Strategy:
         fit_metrics_aggregation_fn: Optional[Callable] = None,
         evaluate_metrics_aggregation_fn: Optional[Callable] = None,
         local_epochs: int = 1,
+        threshold: float = 0.5,
+        learning_rate: float = 0.01,
+        optimizer_name: str = "SGD",
     ) -> None:
         self.name = name
         self.fraction_fit = fraction_fit
@@ -65,11 +69,28 @@ class Strategy:
         self.fit_metrics_aggregation_fn = fit_metrics_aggregation_fn or aggregate_fit_metrics
         self.evaluate_metrics_aggregation_fn = evaluate_metrics_aggregation_fn or aggregate_eval_metrics
 
-        self.strategy_object: Optional[fl.server.strategy.Strategy] = None
+        # Dynamic hyperparams
         self.local_epochs = local_epochs
+        self.threshold = threshold
+        self.learning_rate = learning_rate
+        self.optimizer_name = optimizer_name
+
+        self.strategy_object: Optional[fl.server.strategy.Strategy] = None
 
     def create_strategy(self) -> None:
+        # 1) Pick the Flower Strategy class
         StrategyClass = getattr(fl.server.strategy, self.name)
+
+        # 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,
+            }
+
+        # 3) Build params including on_fit_config_fn
         params: Dict[str, Any] = {
             "fraction_fit": self.fraction_fit,
             "fraction_evaluate": self.fraction_evaluate,
@@ -77,90 +98,51 @@ class Strategy:
             "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:
             params["initial_parameters"] = fl.common.ndarrays_to_parameters(self.initial_parameters)
 
+        # 4) Instantiate the real Flower strategy
         strat = StrategyClass(**params)
 
-        # Wrap aggregate_fit to log metrics
+        # 5) Wrap aggregate_fit for logging
         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 i, (client_id, fit_res) in enumerate(results):
-                print(f" CTM Round {server_round} Client:{client_id.cid}: {fit_res.metrics}")
+            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}")
             agg_params, metrics = original_agg_fit(server_round, results, failures)
-            print(f"[Server] ✅ Round {server_round} - Aggregated Training Metrics: {metrics}\n")
+            print(f"[Server] ✅ Aggregated Training Metrics: {metrics}\n")
             return agg_params, metrics
         strat.aggregate_fit = logged_agg_fit
 
-        # original_handle_fit = strat.handle_fit
-        # def realtime_handle_fit(server_round, results, failures):
-        #     with self.lock:
-        #         for client_id, fit_res in results:
-        #             if client_id.cid not in self.current_round_results[server_round]:
-        #                 # New completion
-        #                 completion_time = time.time()
-        #                 self.current_round_results[server_round][client_id.cid] = completion_time
-                        
-        #                 # Get current leader
-        #                 times = self.current_round_results[server_round]
-        #                 if times:
-        #                     leader = min(times, key=times.get)
-        #                     lead_time = times[leader]
-        #                     delay = completion_time - lead_time
-                            
-        #                     print(f"[Server] 🚦 Round {server_round} - "
-        #                           f"Client {client_id.cid} finished: "
-        #                           f"{'🏁 FIRST' if delay == 0 else f'+{delay:.2f}s'}")
-            
-        #     return original_handle_fit(server_round, results, failures)
-        
-        # strat.handle_fit = realtime_handle_fit
-
-        # Wrap aggregate_evaluate to log metrics
+        # 6) Wrap aggregate_evaluate for logging
         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 i, (client_id, eval_res) in enumerate(results):
-                print(f" CEM Round {server_round} Client:{client_id.cid}: {eval_res.metrics}")
+            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}")
             loss, metrics = original_agg_eval(server_round, results, failures)
-            print(f"[Server] ✅ Round {server_round} - Aggregated Evaluation Metrics:")
-            print(f"    Loss: {loss}, Metrics: {metrics}\n")
+            print(f"[Server] ✅ Aggregated Evaluation Metrics: Loss={loss}, Metrics={metrics}\n")
             return loss, metrics
         strat.aggregate_evaluate = logged_agg_eval
 
-        # Wrap configure_fit to inspect client properties synchronously
+        # 7) Wrap configure_fit to log client properties
         original_conf_fit = strat.configure_fit
-        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
-            )
-
-            # Synchronously fetch & log properties
+        def wrapped_conf_fit(server_round: int, parameters, client_manager: ClientManager):
+            selected = original_conf_fit(server_round, parameters, client_manager)
             ins = GetPropertiesIns(config={})
             for client, _ in selected:
                 try:
                     props = client.get_properties(ins=ins, timeout=10.0, group_id=0)
-                    print(f"\n📋 [Round {server_round}] Client {client.cid} Properties: {props.properties}")
-                    
+                    print(f"📋 [Round {server_round}] {client.cid} props: {props.properties}")
                 except Exception as e:
                     print(f"⚠️ Failed to get properties from {client.cid}: {e}")
-
             return selected
-        
-        def fit_config_fn(server_round: int) -> Dict[str, Any]:
-            return {"local_epochs": self.local_epochs}
-
-        params["on_fit_config_fn"] = fit_config_fn
-
         strat.configure_fit = wrapped_conf_fit
+
+        # 8) Save the ready-to-use strategy
         self.strategy_object = strat

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MEDfl
-Version: 2.0.4.dev8
+Version: 2.0.4.dev9
 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.dev8 → medfl-2.0.4.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MEDfl
-Version: 2.0.4.dev8
+Version: 2.0.4.dev9
 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.dev8 → medfl-2.0.4.dev9}/setup.py

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