MEDfl 2.0.2__tar.gz → 2.0.4__tar.gz

medfl-2.0.4/MEDfl/rw/client.py

@@ -0,0 +1,39 @@
+import flwr as fl
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from model import Net
+
+# Dummy training data
+X_train = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
+y_train = torch.tensor([[1.0], [0.0]])
+
+class FlowerClient(fl.client.NumPyClient):
+    def __init__(self):
+        self.model = Net()
+        self.loss_fn = nn.MSELoss()
+        self.optimizer = optim.SGD(self.model.parameters(), lr=0.01)
+
+    def get_parameters(self, config):
+        return [val.cpu().numpy() for val in self.model.state_dict().values()]
+
+    def set_parameters(self, parameters):
+        params_dict = zip(self.model.state_dict().keys(), parameters)
+        state_dict = {k: torch.tensor(v) for k, v in params_dict}
+        self.model.load_state_dict(state_dict, strict=True)
+
+    def fit(self, parameters, config):
+        self.set_parameters(parameters)
+        self.model.train()
+        for _ in range(5):
+            self.optimizer.zero_grad()
+            output = self.model(X_train)
+            loss = self.loss_fn(output, y_train)
+            loss.backward()
+            self.optimizer.step()
+        return self.get_parameters(config), len(X_train), {}
+
+    def evaluate(self, parameters, config):
+        return 0.5, len(X_train), {}
+
+fl.client.start_numpy_client(server_address="100.65.215.27:8080", client=FlowerClient())

medfl-2.0.4/MEDfl/rw/model.py

@@ -0,0 +1,75 @@
+# client.py
+import argparse
+import pandas as pd
+import flwr as fl
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from MEDfl.rw.model import Net  # your model definition in model.py
+
+class FlowerClient(fl.client.NumPyClient):
+    def __init__(self, server_address: str, data_path: str = "data/data.csv"):
+        self.server_address = server_address
+
+        # 1. Load model
+        self.model = Net()
+        self.loss_fn = nn.MSELoss()
+        self.optimizer = optim.SGD(self.model.parameters(), lr=0.01)
+
+        # 2. Load data from CSV
+        df = pd.read_csv(data_path)
+        # Assume last column is label
+        X = df.iloc[:, :-1].values
+        y = df.iloc[:, -1].values
+
+        self.X_train = torch.tensor(X, dtype=torch.float32)
+        # If it's regression with single output; remove unsqueeze for multi-class
+        self.y_train = torch.tensor(y, dtype=torch.float32).unsqueeze(1)
+
+    def get_parameters(self, config):
+        return [val.cpu().numpy() for val in self.model.state_dict().values()]
+
+    def set_parameters(self, parameters):
+        params_dict = zip(self.model.state_dict().keys(), parameters)
+        state_dict = {k: torch.tensor(v) for k, v in params_dict}
+        self.model.load_state_dict(state_dict, strict=True)
+
+    def fit(self, parameters, config):
+        self.set_parameters(parameters)
+        self.model.train()
+        for _ in range(5):
+            self.optimizer.zero_grad()
+            preds = self.model(self.X_train)
+            loss = self.loss_fn(preds, self.y_train)
+            loss.backward()
+            self.optimizer.step()
+        # Return updated params, number of examples, and an empty metrics dict
+        return self.get_parameters(config), len(self.X_train), {}
+
+    def evaluate(self, parameters, config):
+        self.set_parameters(parameters)
+        self.model.eval()
+        with torch.no_grad():
+            preds = self.model(self.X_train)
+            loss = self.loss_fn(preds, self.y_train).item()
+        return float(loss), len(self.X_train), {}
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Flower client")
+    parser.add_argument(
+        "--server_address",
+        type=str,
+        required=True,
+        help="Address of the Flower server (e.g., 127.0.0.1:8080)",
+    )
+    parser.add_argument(
+        "--data_path",
+        type=str,
+        default="data/data.csv",
+        help="Path to your CSV training data",
+    )
+    args = parser.parse_args()
+
+    # Instantiate and start the client
+    client = FlowerClient(server_address=args.server_address, data_path=args.data_path)
+    fl.client.start_numpy_client(server_address=client.server_address, client=client)

medfl-2.0.4/MEDfl/rw/server.py

@@ -0,0 +1,82 @@
+import flwr as fl
+from flwr.server.strategy import FedAvg
+from flwr.server.server import ServerConfig
+from typing import Optional, Any, List, Tuple, Dict, Callable
+from MEDfl.rw.strategy import Strategy
+from MEDfl.rw.verbose_server import VerboseServer
+import time
+from flwr.server.client_manager import ClientManager
+from flwr.server.client_proxy import ClientProxy
+from flwr.common import GetPropertiesIns
+import asyncio
+
+class FederatedServer:
+    """
+    Wrapper for launching a Flower federated-learning server,
+    using a Strategy instance as its strategy attribute.
+    Now with client connection tracking.
+    """
+    def __init__(
+        self,
+        host: str = "0.0.0.0",
+        port: int = 8080,
+        num_rounds: int = 3,
+        strategy: Optional[Strategy] = None,
+        certificates: Optional[Any] = None,
+    ):
+        self.server_address = f"{host}:{port}"
+        self.server_config = ServerConfig(num_rounds=num_rounds)
+        # If no custom strategy provided, use default
+        self.strategy_wrapper = strategy or Strategy()
+        # Build the actual Flower strategy object
+        self.strategy_wrapper.create_strategy()
+        if self.strategy_wrapper.strategy_object is None:
+            raise ValueError("Strategy object not initialized. Call create_strategy() first.")
+        self.strategy = self.strategy_wrapper.strategy_object
+        self.certificates = certificates
+        self.connected_clients = []
+
+    def start(self) -> None:
+        """
+        Start the Flower server with the configured strategy.
+        Now tracks and logs client connections before starting.
+        """
+        print(f"Using strategy: {self.strategy_wrapper.name}")
+        print(f"Starting Flower server on {self.server_address} with strategy {self.strategy_wrapper.name}")
+        
+        # Create a custom client manager to track connections
+        client_manager = TrackingClientManager(self)
+        
+        fl.server.start_server(
+            server_address=self.server_address,
+            config=self.server_config,
+            strategy=self.strategy,
+            certificates=self.certificates,
+            client_manager=client_manager,
+        )
+
+class TrackingClientManager(fl.server.client_manager.SimpleClientManager):
+    """
+    Custom client manager that tracks and logs client connections.
+    """
+    def __init__(self, server: FederatedServer):
+        super().__init__()
+        self.server = server
+        self.client_properties = {}  # Store client properties
+
+    def register(self, client: ClientProxy) -> bool:
+        success = super().register(client)
+        if success and client.cid not in self.server.connected_clients:
+            # Run the async fetch synchronously
+            asyncio.run(self._fetch_and_log_hostname(client))
+        return success
+
+    async def _fetch_and_log_hostname(self, client: ClientProxy):
+        # try:
+        #     ins = GetPropertiesIns(config={})
+        #     props = await client.get_properties(ins=ins, timeout=10.0, group_id=0)
+        #     hostname = props.properties.get("hostname", "unknown")
+        # except Exception as e:
+        #     hostname = f"Error: {e}"
+        print(f"✅ Client connected - CID: {client.cid}")
+        self.server.connected_clients.append(client.cid)

medfl-2.0.4/MEDfl/rw/strategy.py

@@ -0,0 +1,140 @@
+import flwr as fl
+from typing import Callable, Optional, Dict, Any, Tuple, List
+
+# Custom aggregation for client-returned metrics
+
+from typing import List, Tuple, Dict
+
+# Custom aggregation for client-returned metrics
+def aggregate_fit_metrics(
+    results: List[Tuple[int, Dict[str, float]]]
+) -> Dict[str, float]:
+    """
+    Weighted aggregation of training metrics across clients.
+    Expects each tuple (num_examples, metrics_dict) to include
+    'train_loss', 'train_accuracy', 'train_auc'.
+    """
+    # Sum total examples
+    total_examples = sum(num_examples for num_examples, _ in results)
+    # Weighted averages
+    loss = sum(metrics.get("train_loss", 0.0) * num_examples
+               for num_examples, metrics in results) / total_examples
+    accuracy = sum(metrics.get("train_accuracy", 0.0) * num_examples
+                   for num_examples, metrics in results) / total_examples
+    auc = sum(metrics.get("train_auc", 0.0) * num_examples
+              for num_examples, metrics in results) / total_examples
+    return {"train_loss": loss, "train_accuracy": accuracy, "train_auc": auc}
+
+
+def aggregate_eval_metrics(
+    results: List[Tuple[int, Dict[str, float]]]
+) -> Dict[str, float]:
+    """
+    Weighted aggregation of evaluation metrics across clients.
+    Expects each tuple (num_examples, metrics_dict) to include
+    'eval_loss', 'eval_accuracy', 'eval_auc'.
+    """
+    total_examples = sum(num_examples for num_examples, _ in results)
+    loss = sum(metrics.get("eval_loss", 0.0) * num_examples
+               for num_examples, metrics in results) / total_examples
+    accuracy = sum(metrics.get("eval_accuracy", 0.0) * num_examples
+                   for num_examples, metrics in results) / total_examples
+    auc = sum(metrics.get("eval_auc", 0.0) * num_examples
+              for num_examples, metrics in results) / total_examples
+    return {"eval_loss": loss, "eval_accuracy": accuracy, "eval_auc": auc}
+
+class Strategy:
+    """
+    A wrapper for Flower server strategies, with custom metric aggregation
+    and console logs on aggregation/evaluation completion.
+    """
+    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: Optional[List[Any]] = None,
+        evaluate_fn: Optional[Callable[
+            [int, fl.common.Parameters, Dict[str, Any]],
+            Tuple[float, Dict[str, float]]
+        ]] = None,
+        fit_metrics_aggregation_fn: Optional[
+            Callable[[List[Tuple[int, fl.common.FitRes]]], Dict[str, float]]
+        ] = None,
+        evaluate_metrics_aggregation_fn: Optional[
+            Callable[[List[Tuple[int, fl.common.EvaluateRes]]], Dict[str, float]]
+        ] = None,
+    ) -> None:
+        self.name = name
+        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 or []
+        self.evaluate_fn = evaluate_fn
+        # Use custom aggregators if provided, else default to ours
+        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
+
+    def create_strategy(self) -> None:
+        # 1) Instantiate the underlying Flower strategy
+        StrategyClass = getattr(fl.server.strategy, self.name)
+        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,
+            # Plug in our custom aggregators
+            "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
+            )
+
+        strat = StrategyClass(**params)
+
+        # 2) Wrap aggregate_fit to log
+        original_agg_fit = strat.aggregate_fit
+        def logged_aggregate_fit(rnd, results, failures):
+            # Print individual client fit metrics
+            print(f"\n[Server] 🔄 Round {rnd} - Client Training Metrics:")
+            for i, (client_id, fit_res) in enumerate(results):
+                print(f"  Client {client_id.cid}: {fit_res.metrics}")
+
+            # Call original aggregation function
+            aggregated_params, metrics = original_agg_fit(rnd, results, failures)
+
+            # Print aggregated metrics
+            print(f"[Server] ✅ Round {rnd} - Aggregated Training Metrics: {metrics}\n")
+            return aggregated_params, metrics
+
+        strat.aggregate_fit = logged_aggregate_fit  # type: ignore
+
+        # 3) Wrap aggregate_evaluate to log
+        original_agg_eval = strat.aggregate_evaluate
+        def logged_aggregate_evaluate(rnd, results, failures):
+            # Print individual client evaluation metrics
+            print(f"\n[Server] 📊 Round {rnd} - Client Evaluation Metrics:")
+            for i, (client_id, eval_res) in enumerate(results):
+                print(f"  Client {client_id.cid}: {eval_res.metrics}")
+
+            # Call original aggregation function
+            loss, metrics = original_agg_eval(rnd, results, failures)
+
+            # Print aggregated metrics
+            print(f"[Server] ✅ Round {rnd} - Aggregated Evaluation Metrics:")
+            print(f"  Loss: {loss}, Metrics: {metrics}\n")
+            return loss, metrics
+
+        strat.aggregate_evaluate = logged_aggregate_evaluate  # type: ignore
+
+        self.strategy_object = strat

medfl-2.0.4/MEDfl/rw/verbose_server.py

@@ -0,0 +1,21 @@
+from flwr.server import Server
+from flwr.server.client_manager import SimpleClientManager
+from flwr.server.client_proxy import ClientProxy
+from flwr.common.logger import log
+from logging import INFO
+
+class VerboseServer(Server):
+    def __init__(self, strategy):
+        super().__init__(client_manager=SimpleClientManager(), strategy=strategy)
+
+    def client_manager_fn(self):
+        return self.client_manager
+
+    def on_client_connect(self, client: ClientProxy):
+        super().on_client_connect(client)
+        log(INFO, f"[Server] ➕ Client connected: {client.cid}")
+        log(INFO, f"[Server] Currently connected: {len(self.client_manager.all().values())} clients")
+
+    def on_client_disconnect(self, client: ClientProxy):
+        super().on_client_disconnect(client)
+        log(INFO, f"[Server] ❌ Client disconnected: {client.cid}")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MEDfl
-Version: 2.0.2
+Version: 2.0.4
 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.2 → medfl-2.0.4}/MEDfl.egg-info/SOURCES.txt

@@ -40,7 +40,12 @@ MEDfl/NetManager/net_manager_queries.py
 MEDfl/NetManager/network.py
 MEDfl/NetManager/node.py
 MEDfl/rw/__init__.py
+MEDfl/rw/client.py
+MEDfl/rw/model.py
 MEDfl/rw/rwConfig.py
+MEDfl/rw/server.py
+MEDfl/rw/strategy.py
+MEDfl/rw/verbose_server.py
 MEDfl/scripts/__init__.py
 MEDfl/scripts/base.py
 MEDfl/scripts/create_db.py

{medfl-2.0.2 → medfl-2.0.4}/PKG-INFO

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

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