MEDfl 2.0.4.dev1__tar.gz → 2.0.4.dev3__tar.gz

MEDfl-2.0.4.dev3/MEDfl/rw/client.py

@@ -0,0 +1,108 @@
+# client.py
+"""
+Federated Learning Client with Optional Differential Privacy.
+
+"""
+
+import argparse
+import pandas as pd
+import flwr as fl
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import TensorDataset, DataLoader
+from sklearn.metrics import accuracy_score, roc_auc_score
+from model import Net  # Local model definition
+import socket
+import platform
+
+
+class DPConfig:
+    """
+    Configuration for Differential Privacy (DP) settings.
+
+    Attributes:
+        noise_multiplier (float): Noise multiplier for DP.
+        max_grad_norm (float): Maximum gradient norm (clipping threshold).
+        batch_size (int): Batch size for training.
+        secure_rng (bool): Whether to use a secure RNG for DP noise.
+    """
+
+    def __init__(
+        self,
+        noise_multiplier: float = 1.0,
+        max_grad_norm: float = 1.0,
+        batch_size: int = 32,
+        secure_rng: bool = False,
+    ):
+        self.noise_multiplier = noise_multiplier
+        self.max_grad_norm = max_grad_norm
+        self.batch_size = batch_size
+        self.secure_rng = secure_rng
+
+
+class FlowerClient(fl.client.NumPyClient):
+    """
+    FlowerClient: A federated learning client that trains a PyTorch model
+    and optionally applies differential privacy.
+
+    """
+
+    def __init__(
+        self,
+        server_address: str,
+        data_path: str = "data/data.csv",
+        dp_config: DPConfig = None,
+    ):
+        """
+        Initialize client by loading data, creating model, optimizer,
+        and optionally enabling DP.
+
+        Args:
+            server_address (str): Flower server address.
+            data_path (str): Path to CSV dataset.
+            dp_config (DPConfig): Optional DP configuration.
+        """
+        self.server_address = server_address
+
+        # ---------- Load Data ----------
+        df = pd.read_csv(data_path)
+        X = df.iloc[:, :-1].values
+        y = df.iloc[:, -1].values
+
+        self.X_tensor = torch.tensor(X, dtype=torch.float32)
+        self.y_tensor = torch.tensor(y, dtype=torch.float32)
+
+        batch_size = dp_config.batch_size if dp_config else 32
+        dataset = TensorDataset(self.X_tensor, self.y_tensor)
+        self.train_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
+
+        # ---------- Model and Optimizer ----------
+        input_dim = X.shape[1]
+        self.model = Net(input_dim)
+        self.criterion = nn.BCEWithLogitsLoss()
+        self.optimizer = optim.SGD(self.model.parameters(), lr=0.01)
+
+        # ---------- Differential Privacy ----------
+        self.privacy_engine = None
+        if dp_config is not None:
+            try:
+                from opacus import PrivacyEngine
+
+                self.privacy_engine = PrivacyEngine()
+                self.model, self.optimizer, self.train_loader = self.privacy_engine.make_private(
+                    module=self.model,
+                    optimizer=self.optimizer,
+                    data_loader=self.train_loader,
+                    noise_multiplier=dp_config.noise_multiplier,
+                    max_grad_norm=dp_config.max_grad_norm,
+                    secure_rng=dp_config.secure_rng,
+                )
+            except ImportError:
+                print("⚠️ Opacus not installed, running without DP.")
+
+    def get_parameters(self, config):
+        """
+        Get model parameters as a list of NumPy arrays.
+        """
+        return [val.cpu().numpy() for val in self.mo]()

MEDfl-2.0.4.dev3/MEDfl/rw/model.py

@@ -0,0 +1,47 @@
+import torch.nn as nn
+import torch.nn.functional as F
+
+class Net(nn.Module):
+    """
+    Net defines a simple feedforward neural network with two hidden layers
+
+    """
+
+    def __init__(self, input_dim):
+        """
+        Initialize the layers of the network.
+
+        Args:
+            input_dim (int): Number of input features.
+        """
+        super().__init__()
+        # First fully connected layer: input_dim → 64
+        self.fc1 = nn.Linear(input_dim, 64)
+        # Second fully connected layer: 64 → 32
+        self.fc2 = nn.Linear(64, 32)
+        # Output layer: 32 → 1
+        self.fc3 = nn.Linear(32, 1)
+        # Dropout with 30% probability
+        self.dropout = nn.Dropout(0.3)
+        # Batch normalization layers for hidden layers
+        self.batchnorm1 = nn.BatchNorm1d(64)
+        self.batchnorm2 = nn.BatchNorm1d(32)
+
+    def forward(self, x):
+        """
+        Define the forward pass of the network.
+
+        Args:
+            x (torch.Tensor): Input tensor of shape (batch_size, input_dim).
+
+        Returns:
+            torch.Tensor: Output logits of shape (batch_size, 1).
+        """
+        # Hidden layer 1: linear → batchnorm → ReLU → dropout
+        x = F.relu(self.batchnorm1(self.fc1(x)))
+        x = self.dropout(x)
+        # Hidden layer 2: linear → batchnorm → ReLU → dropout
+        x = F.relu(self.batchnorm2(self.fc2(x)))
+        x = self.dropout(x)
+        # Output layer: linear
+        return self.fc3(x)  # raw logits for BCEWithLogitsLoss

MEDfl-2.0.4.dev3/MEDfl/rw/server.py

@@ -0,0 +1,135 @@
+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
+import asyncio
+from flwr.server.client_manager import ClientManager
+from flwr.server.client_proxy import ClientProxy
+from flwr.common import GetPropertiesIns
+from flwr.common import GetPropertiesIns
+
+
+class FederatedServer:
+    """
+    FederatedServer wraps the launch and configuration of a Flower federated learning server.
+
+    Attributes:
+        server_address (str): Server host and port in the format "host:port".
+        server_config (ServerConfig): Configuration for the Flower server.
+        strategy_wrapper (Strategy): Wrapper around the actual Flower strategy.
+        strategy (flwr.server.Strategy): Actual Flower strategy instance.
+        certificates (Any): Optional TLS certificates.
+        connected_clients (list): List of connected client IDs.
+
+    Methods:
+        start():
+            Launch the Flower server with the specified strategy and log client connections.
+    """
+
+    def __init__(
+        self,
+        host: str = "0.0.0.0",
+        port: int = 8080,
+        num_rounds: int = 3,
+        strategy: Optional[Strategy] = None,
+        certificates: Optional[Any] = None,
+    ):
+        """
+        Initialize the FederatedServer.
+
+        Args:
+            host (str): Hostname or IP to bind the server to.
+            port (int): Port to listen on.
+            num_rounds (int): Number of federated learning rounds to execute.
+            strategy (Optional[Strategy]): Optional custom strategy wrapper.
+            certificates (Optional[Any]): Optional TLS certificates.
+        """
+        # Server address and configuration
+        self.server_address = f"{host}:{port}"
+        self.server_config = ServerConfig(num_rounds=num_rounds)
+
+        # Use custom or default strategy
+        self.strategy_wrapper = strategy or Strategy()
+        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 = []  # Track connected client IDs
+
+
+    def start(self) -> None:
+        """
+        Start the Flower server with the configured strategy and track client connections.
+        """
+        print(f"Using strategy: {self.strategy_wrapper.name}")
+        print(f"Starting Flower server on {self.server_address} with strategy {self.strategy_wrapper.name}")
+
+        # Use a custom client manager that logs client connections
+        client_manager = TrackingClientManager(self)
+
+        # Launch the Flower server
+        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):
+    """
+    TrackingClientManager extends the default SimpleClientManager to log client connections.
+
+    Attributes:
+        server (FederatedServer): The FederatedServer instance this manager belongs to.
+        client_properties (dict): Placeholder for storing client-specific properties.
+    """
+
+    def __init__(self, server: FederatedServer):
+        """
+        Initialize the TrackingClientManager.
+
+        Args:
+            server (FederatedServer): Reference to the FederatedServer.
+        """
+        super().__init__()
+        self.server = server
+        self.client_properties = {}
+
+    def register(self, client: ClientProxy) -> bool:
+        """
+        Register a client and log its connection.
+
+        Args:
+            client (ClientProxy): The client proxy being registered.
+
+        Returns:
+            bool: True if the client was registered successfully.
+        """
+        success = super().register(client)
+        if success and client.cid not in self.server.connected_clients:
+            # Run the asynchronous hostname fetch synchronously
+            asyncio.run(self._fetch_and_log_hostname(client))
+        return success
+
+    async def _fetch_and_log_hostname(self, client: ClientProxy):
+        """
+        Asynchronously fetch and log the client's hostname or CID.
+
+        Args:
+            client (ClientProxy): The client proxy.
+        """
+        # Optional: uncomment to fetch hostname from client properties
+        # 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.dev3/MEDfl/rw/strategy.py

@@ -0,0 +1,134 @@
+import flwr as fl
+from typing import Callable, Optional, Dict, Any, Tuple, List
+from flwr.common import GetPropertiesIns
+from flwr.server.client_manager import ClientManager
+from flwr.server.client_proxy import ClientProxy
+
+# ===================================================
+# Custom metric aggregation functions
+# ===================================================
+
+def aggregate_fit_metrics(
+    results: List[Tuple[int, Dict[str, float]]]
+) -> Dict[str, float]:
+    total = sum(n for n, _ in results)
+    loss = sum(m.get("train_loss", 0.0) * n for n, m in results) / total
+    acc = sum(m.get("train_accuracy", 0.0) * n for n, m in results) / total
+    auc = sum(m.get("train_auc", 0.0) * n for n, m in results) / total
+    return {"train_loss": loss, "train_accuracy": acc, "train_auc": auc}
+
+def aggregate_eval_metrics(
+    results: List[Tuple[int, Dict[str, float]]]
+) -> Dict[str, float]:
+    total = sum(n for n, _ in results)
+    loss = sum(m.get("eval_loss", 0.0) * n for n, m in results) / total
+    acc = sum(m.get("eval_accuracy", 0.0) * n for n, m in results) / total
+    auc = sum(m.get("eval_auc", 0.0) * n for n, m in results) / total
+    return {"eval_loss": loss, "eval_accuracy": acc, "eval_auc": auc}
+
+# ===================================================
+# Strategy Wrapper
+# ===================================================
+
+class Strategy:
+    """
+    Flower Strategy wrapper:
+    - Custom metric aggregation
+    - Per-client & aggregated metric logging
+    - Synchronous get_properties() inspection in configure_fit()
+    """
+
+    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] = None,
+        fit_metrics_aggregation_fn: Optional[Callable] = None,
+        evaluate_metrics_aggregation_fn: Optional[Callable] = 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
+
+        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:
+        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,
+            "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)
+
+        # Wrap aggregate_fit to log metrics
+        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}")
+            agg_params, metrics = original_agg_fit(server_round, results, failures)
+            print(f"[Server] ✅ Round {server_round} - Aggregated Training Metrics: {metrics}\n")
+            return agg_params, metrics
+        strat.aggregate_fit = logged_agg_fit
+
+        # Wrap aggregate_evaluate to log metrics
+        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}")
+            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")
+            return loss, metrics
+        strat.aggregate_evaluate = logged_agg_eval
+
+        # Wrap configure_fit to inspect client properties synchronously
+        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
+            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}")
+                    
+                except Exception as e:
+                    print(f"⚠️ Failed to get properties from {client.cid}: {e}")
+
+            return selected
+
+        strat.configure_fit = wrapped_conf_fit
+        self.strategy_object = strat

{MEDfl-2.0.4.dev1 → MEDfl-2.0.4.dev3}/MEDfl.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MEDfl
-Version: 2.0.4.dev1
+Version: 2.0.4.dev3
 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.dev1 → MEDfl-2.0.4.dev3}/MEDfl.egg-info/SOURCES.txt

@@ -42,10 +42,8 @@ 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.4.dev1 → MEDfl-2.0.4.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MEDfl
-Version: 2.0.4.dev1
+Version: 2.0.4.dev3
 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.dev1 → MEDfl-2.0.4.dev3}/setup.py

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

MEDfl-2.0.4.dev1/MEDfl/rw/client.py

@@ -1,39 +0,0 @@
-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.dev1/MEDfl/rw/model.py

@@ -1,19 +0,0 @@
-import torch.nn as nn
-import torch.nn.functional as F
-
-class Net(nn.Module):
-    def __init__(self, input_dim):
-        super().__init__()
-        self.fc1 = nn.Linear(input_dim, 64)
-        self.fc2 = nn.Linear(64, 32)
-        self.fc3 = nn.Linear(32, 1)
-        self.dropout = nn.Dropout(0.3)
-        self.batchnorm1 = nn.BatchNorm1d(64)
-        self.batchnorm2 = nn.BatchNorm1d(32)
-
-    def forward(self, x):
-        x = F.relu(self.batchnorm1(self.fc1(x)))
-        x = self.dropout(x)
-        x = F.relu(self.batchnorm2(self.fc2(x)))
-        x = self.dropout(x)
-        return self.fc3(x)  # raw logits for BCEWithLogitsLoss

MEDfl-2.0.4.dev1/MEDfl/rw/rwConfig.py

@@ -1,21 +0,0 @@
-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.4.dev1/MEDfl/rw/server.py

@@ -1,82 +0,0 @@
-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)