MEDfl 2.0.4.dev3__py3-none-any.whl → 2.0.4.dev5__py3-none-any.whl

MEDfl/LearningManager/model.py

@@ -214,10 +214,11 @@ class Model:
             torch.nn.Module: Loaded PyTorch model.
         """
         # Ensure models are loaded onto the CPU when CUDA is not available
+        torch_kwargs = {"weights_only": False}
         if torch.cuda.is_available():
-            loaded_model = torch.load(model_path)
+            loaded_model = torch.load(model_path , **torch_kwargs)
         else:
-            loaded_model = torch.load(model_path, map_location=torch.device('cpu'))
+            loaded_model = torch.load(model_path, map_location=torch.device('cpu') , **torch_kwargs)
         return loaded_model
 
 

MEDfl/LearningManager/utils.py

@@ -113,7 +113,7 @@ def custom_classification_report(y_true, y_pred_prob):
 
     auc = roc_auc_score(y_true, y_pred_prob)  # Calculate AUC
 
-    tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()
+    tn, fp, fn, tp = confusion_matrix(y_true, y_pred , labels=[0, 1]).ravel()
 
     # Accuracy
     denominator_acc = tp + tn + fp + fn

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/rw/client.py

@@ -1,9 +1,4 @@
 # client.py
-"""
-Federated Learning Client with Optional Differential Privacy.
-
-"""
-
 import argparse
 import pandas as pd
 import flwr as fl
@@ -12,22 +7,21 @@ 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
+from model import Net  # your model definition in model.py
 import socket
-import platform
-
+import platform 
 
+# Differential Privacy configuration class
 class DPConfig:
     """
-    Configuration for Differential Privacy (DP) settings.
+    Configuration for differential privacy.
 
     Attributes:
         noise_multiplier (float): Noise multiplier for DP.
-        max_grad_norm (float): Maximum gradient norm (clipping threshold).
+        max_grad_norm (float): Maximum gradient norm for clipping.
         batch_size (int): Batch size for training.
-        secure_rng (bool): Whether to use a secure RNG for DP noise.
+        secure_rng (bool): Whether to use secure random generator.
     """
-
     def __init__(
         self,
         noise_multiplier: float = 1.0,
@@ -42,54 +36,44 @@ class DPConfig:
 
 
 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 ----------
+        # 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)
 
-        # ---------- Model and Optimizer ----------
+        # 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)
 
-        # ---------- Differential Privacy ----------
+        # 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,
@@ -99,10 +83,149 @@ class FlowerClient(fl.client.NumPyClient):
                     secure_rng=dp_config.secure_rng,
                 )
             except ImportError:
-                print("⚠️ Opacus not installed, running without DP.")
+                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):
         """
-        Get model parameters as a list of NumPy arrays.
+        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.
         """
-        return [val.cpu().numpy() for val in self.mo]()
+        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.dev3.dist-info → MEDfl-2.0.4.dev5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MEDfl
-Version: 2.0.4.dev3
+Version: 2.0.4.dev5
 Summary: Python Open-source package for simulating federated learning and differential privacy
 Home-page: https://github.com/MEDomics-UdeS/MEDfl
 Author: MEDomics consortium
@@ -28,13 +28,14 @@ Requires-Dist: Sphinx~=5.3.0
 Requires-Dist: SQLAlchemy~=1.4.47
 Requires-Dist: torch>=2.0.0
 Requires-Dist: datetime~=5.1
-Requires-Dist: scikit-learn~=1.6.1
+Requires-Dist: scikit-learn~=1.2.2
 Requires-Dist: sphinx-jsonschema==1.19.1
 Requires-Dist: sphinx-rtd-dark-mode==1.2.4
 Requires-Dist: plotly==5.19.0
 Requires-Dist: optuna==3.5.0
 Requires-Dist: mysql-connector-python~=9.3.0
 Requires-Dist: seaborn~=0.13.2
+Requires-Dist: flwr[simulation]
 
 # MEDfl: Federated Learning and Differential Privacy Simulation Tool for Tabular Data
 ![Python Versions](https://img.shields.io/badge/python-3.9-blue)

{MEDfl-2.0.4.dev3.dist-info → MEDfl-2.0.4.dev5.dist-info}/RECORD

@@ -4,15 +4,15 @@ MEDfl/LearningManager/client.py,sha256=9Y_Zb0yxvCxx3dVCPQ1bXS5mCKasylSBnoVj-RDN2
 MEDfl/LearningManager/dynamicModal.py,sha256=q8u7xPpj_TdZnSr8kYj0Xx7Sdz-diXsKBAfVce8-qSU,10534
 MEDfl/LearningManager/federated_dataset.py,sha256=InsZ5Rys2dgqaPxVyP5G3TrJMwiCNHOoTd3tCpUwUVM,2081
 MEDfl/LearningManager/flpipeline.py,sha256=5lT2uod5EqnkRQ04cgm0gYyZz0djumfIYipCrzX1fdo,7111
-MEDfl/LearningManager/model.py,sha256=vp8FIMxBdz3FTF5wJaea2IO_WGeANLZgBxTKVe3gW3Q,7456
+MEDfl/LearningManager/model.py,sha256=OZcVzIJ_Q5JMF8TfvqtY34FgeNZOqTocENmDKppQEmA,7537
 MEDfl/LearningManager/params.yaml,sha256=Ix1cNtlWr3vDC0te6pipl5w8iLADO6dZvwm633-VaIA,436
 MEDfl/LearningManager/params_optimiser.py,sha256=8e0gCt4imwQHlNSJ3A2EAuc3wSr6yfSI6JDghohfmZQ,17618
 MEDfl/LearningManager/plot.py,sha256=A6Z8wC8J-H-OmWBPKqwK5eiTB9vzOBGMaFv1SaNA9Js,7698
 MEDfl/LearningManager/server.py,sha256=oTgW3K1UT6m4SQBk23FIf23km_BDq9vvjeC6OgY8DNw,7077
 MEDfl/LearningManager/strategy.py,sha256=BHXpwmt7jx07y45YLUs8FZry2gYQbpiV4vNbHhsksQ4,3435
-MEDfl/LearningManager/utils.py,sha256=B4RULJp-puJr724O6teI0PxnUyPV8NG-uPC6jqaiDKI,9605
+MEDfl/LearningManager/utils.py,sha256=zk84uKR_iSsoz1uvKD-l4_jJWV3_5pfUWMIeLNcT1mU,9621
 MEDfl/NetManager/__init__.py,sha256=OpgsIiBg7UA6Bfnu_kqGfEPxU8JfpPxSFU98TOeDTP0,273
-MEDfl/NetManager/database_connector.py,sha256=G8DAsD_pAIK1U67x3Q8gmSJGW7iJyxQ_NE5lWpT-P0Q,1474
+MEDfl/NetManager/database_connector.py,sha256=L46vgTuQIzuk4PVWB7Mo1THX4aerIlIlAU5ZTIVGLs8,1553
 MEDfl/NetManager/dataset.py,sha256=HTV0jrJ4Qlhl2aSJzdFU1lkxGBKtmJ390eBpwfKf_4o,2777
 MEDfl/NetManager/flsetup.py,sha256=CVu_TIU7l3G6DDnwtY6JURbhIZk7gKC3unqWnU-YtlM,11434
 MEDfl/NetManager/net_helper.py,sha256=tyfxmpbleSdfPfo2ezKT0VOvZu660v9nhBuHCpl8pG4,6812
@@ -20,7 +20,7 @@ MEDfl/NetManager/net_manager_queries.py,sha256=j-CLQPjtTLyZuFPhIcwJStD7L7xtZpkmk
 MEDfl/NetManager/network.py,sha256=5t705fzWc-BRg-QPAbAcDv5ckDGzsPwj_Q5V0iTgkx0,6829
 MEDfl/NetManager/node.py,sha256=t90QuYZ8M1X_AG1bwTta0CnlOuodqkmpVda2K7NOgHc,6542
 MEDfl/rw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-MEDfl/rw/client.py,sha256=AQnLvM-pWVA2Md0GiRLB9C4s8S3TjcjjvN3U25ftpX4,3463
+MEDfl/rw/client.py,sha256=a9JpOSH2HItXsJKqLnvmEAbBcCKvgTTU526lff8pf-k,8013
 MEDfl/rw/model.py,sha256=OAoTmOw4zGWPa_ncDqNanLeucwWHmUydKED6zlB5Hps,1510
 MEDfl/rw/server.py,sha256=TmcWUwMJ5BG7owqIVTtTC6w8bR02SESRT9lXh7BqlOg,4986
 MEDfl/rw/strategy.py,sha256=aNlyQhHslmPJdiuJjsK9hu-IUJdrWR1yuGp7pNk4LeA,5974
@@ -29,8 +29,8 @@ MEDfl/scripts/base.py,sha256=QrmG7gkiPYkAy-5tXxJgJmOSLGAKeIVH6i0jq7G9xnA,752
 MEDfl/scripts/create_db.py,sha256=MnFtZkTueRZ-3qXPNX4JsXjOKj-4mlkxoRhSFdRcvJw,3817
 alembic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alembic/env.py,sha256=-aSZ6SlJeK1ZeqHgM-54hOi9LhJRFP0SZGjut-JnY-4,1588
-MEDfl-2.0.4.dev3.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-MEDfl-2.0.4.dev3.dist-info/METADATA,sha256=s5S0Ztt85jbo0x9kzkGRQDNrI9cMCed-qBWO4EA2q10,4326
-MEDfl-2.0.4.dev3.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-MEDfl-2.0.4.dev3.dist-info/top_level.txt,sha256=dIL9X8HOFuaVSzpg40DVveDPrymWRoShHtspH7kkjdI,14
-MEDfl-2.0.4.dev3.dist-info/RECORD,,
+MEDfl-2.0.4.dev5.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+MEDfl-2.0.4.dev5.dist-info/METADATA,sha256=rYlywNl8wr5CZiebY_qsA5iDemHvVyH6WOgou_-KAuw,4358
+MEDfl-2.0.4.dev5.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+MEDfl-2.0.4.dev5.dist-info/top_level.txt,sha256=dIL9X8HOFuaVSzpg40DVveDPrymWRoShHtspH7kkjdI,14
+MEDfl-2.0.4.dev5.dist-info/RECORD,,