MEDfl 2.0.4.dev7__tar.gz → 2.0.4.dev8__tar.gz

{medfl-2.0.4.dev7 → medfl-2.0.4.dev8}/MEDfl/rw/client.py

@@ -1,4 +1,5 @@
 # client.py
+
 import argparse
 import pandas as pd
 import flwr as fl
@@ -7,11 +8,18 @@ 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
+from MEDfl.rw.model import Net  # votre définition de modèle
 import socket
-import platform 
+import platform
+import psutil
+import shutil
+
+try:
+    import GPUtil
+except ImportError:
+    GPUtil = None
+
 
-# Differential Privacy configuration class
 class DPConfig:
     """
     Configuration for differential privacy.
@@ -20,8 +28,9 @@ class DPConfig:
         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.
+        secure_rng (bool): Use a secure random generator.
     """
+
     def __init__(
         self,
         noise_multiplier: float = 1.0,
@@ -44,37 +53,44 @@ class FlowerClient(fl.client.NumPyClient):
     ):
         self.server_address = server_address
 
-        # 1. Load data from CSV
+        # 1) Chargement des données
         df = pd.read_csv(data_path)
         X = df.iloc[:, :-1].values
         y = df.iloc[:, -1].values
 
-        # Convert to tensors and store for metrics
+        # Métadonnées pour get_properties()
+        self.feature_names = df.columns[:-1].tolist()
+        self.target_name = df.columns[-1]
+        self.label_counts = df[self.target_name].value_counts().to_dict()
+        self.classes = sorted(self.label_counts.keys())
+
+        # Tenseurs pour les métriques
         self.X_tensor = torch.tensor(X, dtype=torch.float32)
         self.y_tensor = torch.tensor(y, dtype=torch.float32)
 
-        # Create DataLoader
+        # 2) 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
+        # 3) Modèle, critère, optimiseur
         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
+        # 4) Configuration DP (Opacus)
         self.privacy_engine = None
-        if dp_config is not None:
+        if dp_config:
             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(
+                (
+                    self.model,
+                    self.optimizer,
+                    self.train_loader,
+                ) = self.privacy_engine.make_private(
                     module=self.model,
                     optimizer=self.optimizer,
                     data_loader=self.train_loader,
@@ -83,7 +99,7 @@ class FlowerClient(fl.client.NumPyClient):
                     secure_rng=dp_config.secure_rng,
                 )
             except ImportError:
-                print("Opacus not installed, running without DP.")
+                print("Opacus non installé : exécution sans DP.")
 
     def get_parameters(self, config):
         return [val.cpu().numpy() for val in self.model.state_dict().values()]
@@ -94,21 +110,26 @@ class FlowerClient(fl.client.NumPyClient):
         self.model.load_state_dict(state_dict, strict=True)
 
     def fit(self, parameters, config):
-        # Update model parameters
         self.set_parameters(parameters)
         self.model.train()
 
+        local_epochs = config.get("local_epochs", 5)
         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)
+        print(f"Training for {local_epochs} epochs...")
 
-        avg_loss = total_loss / len(self.train_loader.dataset)
-        # Compute training metrics (accuracy, AUC) on full dataset
+        for epoch in range(local_epochs):
+            print(f"Epoch {epoch + 1}/{local_epochs}")
+            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) * local_epochs)
+
+        # Compute metrics after last epoch
         with torch.no_grad():
             logits = self.model(self.X_tensor).squeeze()
             probs = torch.sigmoid(logits).cpu().numpy()
@@ -116,21 +137,25 @@ class FlowerClient(fl.client.NumPyClient):
         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,
+            "os_type": os_type,
+            "train_loss": avg_loss,
+            "train_accuracy": acc,
+            "train_auc": auc,
+        }
 
-        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 = []
+        all_probs, all_true = [], []
         with torch.no_grad():
             for X_batch, y_batch in self.train_loader:
                 outputs = self.model(X_batch)
@@ -145,73 +170,105 @@ class FlowerClient(fl.client.NumPyClient):
         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}
+        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.
+        Only scalar values allowed (int, float, str, bool, bytes).
         """
+        hostname = socket.gethostname()
+        os_type = platform.system()
         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()
+        features_str = ",".join(self.feature_names)
+        classes_str = ",".join(map(str, self.classes))
+        dist_str = ",".join(f"{cls}:{cnt}" for cls, cnt in self.label_counts.items())
+
+        cpu_physical = psutil.cpu_count(logical=False)
+        cpu_logical = psutil.cpu_count(logical=True)
+        total_mem_gb = round(psutil.virtual_memory().total / (1024**3), 2)
+        driver_present = shutil.which('nvidia-smi') is not None
+        gpu_count = 0
+        if GPUtil and driver_present:
+            try:
+                gpu_count = len(GPUtil.getGPUs())
+            except Exception:
+                gpu_count = 0
 
         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
+            "features": features_str,
+            "target": self.target_name,
+            "classes": classes_str,
+            "label_distribution": dist_str,
+            "cpu_physical_cores": cpu_physical,
+            "cpu_logical_cores": cpu_logical,
+            "total_memory_gb": total_mem_gb,
+            "gpu_driver_present": str(driver_present),
+            "gpu_count": gpu_count,
         }
 
+    def start(self) -> None:
+        """
+        Start this client against its configured server_address.
+        Blocks until the server shuts down.
+        """
+        fl.client.start_numpy_client(
+            server_address=self.server_address,
+            client=self,
+        )
+
 
-    
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Flower client with DP support and metrics")
+    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)",
+        help="Adresse du serveur Flower (ex : 127.0.0.1:8080)",
     )
     parser.add_argument(
         "--data_path",
         type=str,
         default="data/data.csv",
-        help="Path to your CSV training data",
+        help="Chemin vers les données CSV",
     )
     parser.add_argument(
         "--dp",
         action="store_true",
-        help="Enable differential privacy",
+        help="Activer la confidentialité différentielle",
     )
     parser.add_argument(
         "--noise_multiplier",
         type=float,
         default=1.0,
-        help="Noise multiplier for DP",
+        help="Noise multiplier pour DP",
     )
     parser.add_argument(
         "--max_grad_norm",
         type=float,
         default=1.0,
-        help="Clip norm for DP",
+        help="Norme max pour le clipping",
     )
     parser.add_argument(
         "--batch_size",
         type=int,
         default=32,
-        help="Batch size for training",
+        help="Taille du batch",
     )
     args = parser.parse_args()
 
@@ -228,4 +285,4 @@ if __name__ == "__main__":
         data_path=args.data_path,
         dp_config=dp_config,
     )
-    fl.client.start_numpy_client(server_address=client.server_address, client=client)
+    client.start()

{medfl-2.0.4.dev7 → medfl-2.0.4.dev8}/MEDfl/rw/strategy.py

@@ -96,29 +96,29 @@ class Strategy:
             return agg_params, metrics
         strat.aggregate_fit = logged_agg_fit
 
-        original_handle_fit = strat.handle_fit
-        def realtime_handle_fit(server_round, results, failures):
-            with self.lock:
-                for client_id, fit_res in results:
-                    if client_id.cid not in self.current_round_results[server_round]:
-                        # New completion
-                        completion_time = time.time()
-                        self.current_round_results[server_round][client_id.cid] = completion_time
+        # original_handle_fit = strat.handle_fit
+        # def realtime_handle_fit(server_round, results, failures):
+        #     with self.lock:
+        #         for client_id, fit_res in results:
+        #             if client_id.cid not in self.current_round_results[server_round]:
+        #                 # New completion
+        #                 completion_time = time.time()
+        #                 self.current_round_results[server_round][client_id.cid] = completion_time
                         
-                        # Get current leader
-                        times = self.current_round_results[server_round]
-                        if times:
-                            leader = min(times, key=times.get)
-                            lead_time = times[leader]
-                            delay = completion_time - lead_time
+        #                 # Get current leader
+        #                 times = self.current_round_results[server_round]
+        #                 if times:
+        #                     leader = min(times, key=times.get)
+        #                     lead_time = times[leader]
+        #                     delay = completion_time - lead_time
                             
-                            print(f"[Server] 🚦 Round {server_round} - "
-                                  f"Client {client_id.cid} finished: "
-                                  f"{'🏁 FIRST' if delay == 0 else f'+{delay:.2f}s'}")
+        #                     print(f"[Server] 🚦 Round {server_round} - "
+        #                           f"Client {client_id.cid} finished: "
+        #                           f"{'🏁 FIRST' if delay == 0 else f'+{delay:.2f}s'}")
             
-            return original_handle_fit(server_round, results, failures)
+        #     return original_handle_fit(server_round, results, failures)
         
-        strat.handle_fit = realtime_handle_fit
+        # strat.handle_fit = realtime_handle_fit
 
         # Wrap aggregate_evaluate to log metrics
         original_agg_eval = strat.aggregate_evaluate

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MEDfl
-Version: 2.0.4.dev7
+Version: 2.0.4.dev8
 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.dev7 → medfl-2.0.4.dev8}/PKG-INFO

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

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