MEDfl 2.0.4.dev2__tar.gz → 2.0.4.dev4__tar.gz

{MEDfl-2.0.4.dev2 → MEDfl-2.0.4.dev4}/.gitignore

@@ -3,3 +3,4 @@ MEDfl.egg-info/
 fl-env/
 dist/
 build/
+notebooks/

{MEDfl-2.0.4.dev2 → MEDfl-2.0.4.dev4}/MEDfl/NetManager/database_connector.py

@@ -1,5 +1,5 @@
 import os
-import subprocess
+import subprocess , sys
 from sqlalchemy import create_engine
 from configparser import ConfigParser
 
@@ -34,7 +34,9 @@ class DatabaseManager:
         create_db_script_path = os.path.join(current_directory, '..', 'scripts', 'create_db.py')
 
         # Execute the create_db.py script
-        subprocess.run(['python3', create_db_script_path, path_to_csv], check=True)
+        print(sys.executable)
+        result = subprocess.run([sys.executable, create_db_script_path, path_to_csv],
+         capture_output=True, text=True)
 
         return
 

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

@@ -0,0 +1,231 @@
+# 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 torch.utils.data import TensorDataset, DataLoader
+from sklearn.metrics import accuracy_score, roc_auc_score
+from model import Net  # your model definition in model.py
+import socket
+import platform 
+
+# Differential Privacy configuration class
+class DPConfig:
+    """
+    Configuration for differential privacy.
+
+    Attributes:
+        noise_multiplier (float): Noise multiplier for DP.
+        max_grad_norm (float): Maximum gradient norm for clipping.
+        batch_size (int): Batch size for training.
+        secure_rng (bool): Whether to use secure random generator.
+    """
+    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):
+    def __init__(
+        self,
+        server_address: str,
+        data_path: str = "data/data.csv",
+        dp_config: DPConfig = None,
+    ):
+        self.server_address = server_address
+
+        # 1. Load data from CSV
+        df = pd.read_csv(data_path)
+        X = df.iloc[:, :-1].values
+        y = df.iloc[:, -1].values
+
+        # Convert to tensors and store for metrics
+        self.X_tensor = torch.tensor(X, dtype=torch.float32)
+        self.y_tensor = torch.tensor(y, dtype=torch.float32)
+
+        # Create DataLoader
+        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)
+
+        # 2. Initialize model, loss, 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)
+
+        # 3. Set up differential privacy if requested
+        self.privacy_engine = None
+        if dp_config is not None:
+            try:
+                from opacus import PrivacyEngine
+
+                # Instantiate engine without secure_rng argument
+                self.privacy_engine = PrivacyEngine()
+                # Attach privacy engine with secure_rng flag
+                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):
+        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):
+        # Update model parameters
+        self.set_parameters(parameters)
+        self.model.train()
+
+        total_loss = 0.0
+        for X_batch, y_batch in self.train_loader:
+            self.optimizer.zero_grad()
+            outputs = self.model(X_batch)
+            loss = self.criterion(outputs.squeeze(), y_batch)
+            loss.backward()
+            self.optimizer.step()
+            total_loss += loss.item() * X_batch.size(0)
+
+        avg_loss = total_loss / len(self.train_loader.dataset)
+        # Compute training metrics (accuracy, AUC) on full dataset
+        with torch.no_grad():
+            logits = self.model(self.X_tensor).squeeze()
+            probs = torch.sigmoid(logits).cpu().numpy()
+            y_true = self.y_tensor.cpu().numpy()
+        binary_preds = (probs >= 0.5).astype(int)
+        acc = accuracy_score(y_true, binary_preds)
+        auc = roc_auc_score(y_true, probs)
+        
+        hostname = socket.gethostname()
+        os_type = platform.system()
+
+        metrics = {"hostname": hostname, "train_loss": avg_loss, "train_accuracy": acc, "train_auc": auc , "os_type": os_type}
+        return self.get_parameters(config), len(self.train_loader.dataset), metrics
+
+    def evaluate(self, parameters, config):
+        # Update model parameters
+        self.set_parameters(parameters)
+        self.model.eval()
+
+        total_loss = 0.0
+        all_probs = []
+        all_true = []
+        with torch.no_grad():
+            for X_batch, y_batch in self.train_loader:
+                outputs = self.model(X_batch)
+                loss = self.criterion(outputs.squeeze(), y_batch)
+                total_loss += loss.item() * X_batch.size(0)
+                probs = torch.sigmoid(outputs.squeeze()).cpu().numpy()
+                all_probs.extend(probs.tolist())
+                all_true.extend(y_batch.cpu().numpy().tolist())
+
+        avg_loss = total_loss / len(self.train_loader.dataset)
+        binary_preds = [1 if p >= 0.5 else 0 for p in all_probs]
+        acc = accuracy_score(all_true, binary_preds)
+        auc = roc_auc_score(all_true, all_probs)
+
+        metrics = {"eval_loss": avg_loss, "eval_accuracy": acc, "eval_auc": auc}
+        print(f"Evaluation metrics: {metrics}")
+        return float(avg_loss), len(self.train_loader.dataset), metrics
+        
+# client.py - Update the get_properties method
+    def get_properties(self, config):
+        """
+        Return dataset statistics before training starts.
+
+        NOTE: Only scalar values (int, float, str, bool, bytes) are allowed.
+        Lists will cause the “not a 1:1 mapping” TypeError.
+        """
+        num_samples = len(self.X_tensor)
+        num_features = self.X_tensor.shape[1]
+        # Convert list to comma‑separated string
+        column_names = [f"feature_{i}" for i in range(num_features)]
+        columns_str = ",".join(column_names)
+
+        hostname = socket.gethostname()
+        os_type = platform.system()
+
+        return {
+            "hostname": hostname,
+            "os_type": os_type,
+            "num_samples": num_samples,
+            "num_features": num_features,
+            "columns": columns_str,  # now a single str, not a list
+        }
+
+
+    
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Flower client with DP support and metrics")
+    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",
+    )
+    parser.add_argument(
+        "--dp",
+        action="store_true",
+        help="Enable differential privacy",
+    )
+    parser.add_argument(
+        "--noise_multiplier",
+        type=float,
+        default=1.0,
+        help="Noise multiplier for DP",
+    )
+    parser.add_argument(
+        "--max_grad_norm",
+        type=float,
+        default=1.0,
+        help="Clip norm for DP",
+    )
+    parser.add_argument(
+        "--batch_size",
+        type=int,
+        default=32,
+        help="Batch size for training",
+    )
+    args = parser.parse_args()
+
+    dp_config = None
+    if args.dp:
+        dp_config = DPConfig(
+            noise_multiplier=args.noise_multiplier,
+            max_grad_norm=args.max_grad_norm,
+            batch_size=args.batch_size,
+        )
+
+    client = FlowerClient(
+        server_address=args.server_address,
+        data_path=args.data_path,
+        dp_config=dp_config,
+    )
+    fl.client.start_numpy_client(server_address=client.server_address, client=client)

{MEDfl-2.0.4.dev2 → MEDfl-2.0.4.dev4}/MEDfl/rw/strategy.py

@@ -123,9 +123,8 @@ class Strategy:
             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:")
-                    for k, v in props.properties.items():
-                        print(f"   {k}: {v}")
+                    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}")
 

{MEDfl-2.0.4.dev2 → MEDfl-2.0.4.dev4}/MEDfl.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MEDfl
-Version: 2.0.4.dev2
+Version: 2.0.4.dev4
 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.dev2 → MEDfl-2.0.4.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MEDfl
-Version: 2.0.4.dev2
+Version: 2.0.4.dev4
 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.dev2 → MEDfl-2.0.4.dev4}/notebooks/banchmarking/network_architecture/net_bachmarking_conf_1.ipynb

@@ -9,7 +9,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -22,75 +22,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\u001b[93mWARNING \u001b[0m:   DEPRECATED FEATURE: flwr.server.start_server() is deprecated.\n",
-      "\tInstead, use the `flower-superlink` CLI command to start a SuperLink as shown below:\n",
-      "\n",
-      "\t\t$ flower-superlink --insecure\n",
-      "\n",
-      "\tTo view usage and all available options, run:\n",
-      "\n",
-      "\t\t$ flower-superlink --help\n",
-      "\n",
-      "\tUsing `start_server()` is deprecated.\n",
-      "\n",
-      "            This is a deprecated feature. It will be removed\n",
-      "            entirely in future versions of Flower.\n",
-      "        \n",
-      "\u001b[92mINFO \u001b[0m:      Starting Flower server, config: num_rounds=3, no round_timeout\n",
-      "\u001b[92mINFO \u001b[0m:      Flower ECE: gRPC server running (3 rounds), SSL is disabled\n",
-      "\u001b[92mINFO \u001b[0m:      [INIT]\n",
-      "\u001b[92mINFO \u001b[0m:      Requesting initial parameters from one random client\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Starting Flower server on 0.0.0.0:8080\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\u001b[92mINFO \u001b[0m:      Flower server terminated gracefully.\n"
-     ]
-    },
-    {
-     "ename": "SystemExit",
-     "evalue": "0",
-     "output_type": "error",
-     "traceback": [
-      "An exception has occurred, use %tb to see the full traceback.\n",
-      "\u001b[31mSystemExit\u001b[39m\u001b[31m:\u001b[39m 0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/local/USHERBROOKE/saho6810/Bureau/UDS/MEDfl/fl-env/lib/python3.12/site-packages/IPython/core/interactiveshell.py:3678: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n",
-      "  warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n"
-     ]
-    }
-   ],
-   "source": [
-    "from MEDfl.rw.server.server import FederatedServer\n",
-    "\n",
-    "server = FederatedServer()\n",
-    "server.start()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
@@ -189,23 +121,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": []
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/home/local/USHERBROOKE/saho6810/Bureau/UDS/MEDfl/fl-env/bin/python\n"
+     ]
+    }
+   ],
    "source": [
     "db_manager.create_MEDfl_db(path_to_csv=\"../../data/masterDataSet/diabetes_dataset.csv\")\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
@@ -219,7 +159,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "../../..\\MEDfl\\NetManager\\network.py:51: RemovedIn20Warning: Deprecated API features detected! These feature(s) are not compatible with SQLAlchemy 2.0. To prevent incompatible upgrades prior to updating applications, ensure requirements files are pinned to \"sqlalchemy<2.0\". Set environment variable SQLALCHEMY_WARN_20=1 to show all deprecation warnings.  Set environment variable SQLALCHEMY_SILENCE_UBER_WARNING=1 to silence this message. (Background on SQLAlchemy 2.0 at: https://sqlalche.me/e/b8d9)\n",
+      "/home/local/USHERBROOKE/saho6810/Bureau/UDS/MEDfl/notebooks/banchmarking/network_architecture/../../../MEDfl/NetManager/network.py:51: RemovedIn20Warning: Deprecated API features detected! These feature(s) are not compatible with SQLAlchemy 2.0. To prevent incompatible upgrades prior to updating applications, ensure requirements files are pinned to \"sqlalchemy<2.0\". Set environment variable SQLALCHEMY_WARN_20=1 to show all deprecation warnings.  Set environment variable SQLALCHEMY_SILENCE_UBER_WARNING=1 to silence this message. (Background on SQLAlchemy 2.0 at: https://sqlalche.me/e/b8d9)\n",
       "  self.eng.execute(text(INSERT_NETWORK_QUERY), {\"name\": self.name})\n"
      ]
     }

{MEDfl-2.0.4.dev2 → MEDfl-2.0.4.dev4}/setup.py

@@ -14,7 +14,7 @@ with open('requirements.txt') as f:
 
 setup(
     name="MEDfl",
-    version="2.0.4.dev2",
+    version="2.0.4.dev4",
     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.dev2/MEDfl/rw/client.py

@@ -1,108 +0,0 @@
-# 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]()