MEDfl 2.0.1__tar.gz → 2.0.3__tar.gz

medfl-2.0.3/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.3/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.3/MEDfl/rw/rwConfig.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+
+@dataclass
+class RealWorldConfig:
+    """
+    Configuration pour un déploiement fédéré en « real world ».
+
+    Attributes:
+        server_address: Adresse et port du serveur Flower (ex: "0.0.0.0:8080").
+        num_rounds: Nombre total de tours (rounds) de fédération.
+        fraction_fit: Fraction des clients participant à la phase de fit chaque round.
+        fraction_eval: Fraction des clients participant à la phase d'évaluation chaque round.
+        min_fit_clients: Nombre minimum de clients requis pour lancer la phase de fit.
+        min_eval_clients: Nombre minimum de clients requis pour la phase d'évaluation.
+    """
+    server_address: str
+    num_rounds: int
+    fraction_fit: float
+    fraction_eval: float
+    min_fit_clients: int
+    min_eval_clients: int

medfl-2.0.3/MEDfl/rw/server.py

@@ -0,0 +1,42 @@
+
+import flwr as fl
+from flwr.server.strategy import FedAvg
+from flwr.server.server import ServerConfig
+from typing import  Optional, Any
+from MEDfl.rw.strategy import Strategy
+
+class FederatedServer:
+    """
+    Wrapper for launching a Flower federated-learning server,
+    using a Strategy instance as its strategy attribute.
+    """
+    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
+
+    def start(self) -> None:
+        """
+        Start the Flower server with the configured strategy.
+        """
+        print(f"Starting Flower server on {self.server_address} with strategy {self.strategy_wrapper.name}")
+        fl.server.start_server(
+            server_address=self.server_address,
+            config=self.server_config,
+            strategy=self.strategy,
+            certificates=self.certificates,
+        )

medfl-2.0.3/MEDfl/rw/strategy.py

@@ -0,0 +1,122 @@
+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):
+            aggregated_params, metrics = original_agg_fit(rnd, results, failures)
+            print(f"[Server] ✔ Round {rnd} fit complete → Metrics: {metrics}")
+            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):
+            loss, metrics = original_agg_eval(rnd, results, failures)
+            print(results)
+            print(f"[Server] ✔ Round {rnd} eval complete → Loss: {loss}, Metrics: {metrics}")
+            return loss, metrics
+        strat.aggregate_evaluate = logged_aggregate_evaluate  # type: ignore
+
+        self.strategy_object = strat

{medfl-2.0.1 → medfl-2.0.3}/MEDfl.egg-info/PKG-INFO

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

@@ -39,6 +39,12 @@ MEDfl/NetManager/net_helper.py
 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/scripts/__init__.py
 MEDfl/scripts/base.py
 MEDfl/scripts/create_db.py

{medfl-2.0.1 → medfl-2.0.3}/PKG-INFO

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

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