MEDfl 2.0.5.dev3__tar.gz → 2.0.5.dev4__tar.gz

{medfl-2.0.5.dev3 → medfl-2.0.5.dev4}/MEDfl/rw/client.py

@@ -35,10 +35,10 @@ class DPConfig:
 
     def __init__(
         self,
-        noise_multiplier: float = 1.0,
-        max_grad_norm: float = 1.0,
-        batch_size: int = 32,
-        secure_rng: bool = False,
+        noise_multiplier=1.0,
+        max_grad_norm=1.0,
+        batch_size=32,
+        secure_rng=False,
     ):
         self.noise_multiplier = noise_multiplier
         self.max_grad_norm = max_grad_norm
@@ -49,15 +49,15 @@ class DPConfig:
 class FlowerClient(fl.client.NumPyClient):
     def __init__(
         self,
-        server_address: str,
-        data_path: str = "data/data.csv",
-        dp_config: DPConfig = None,
+        server_address,
+        data_path="data/data.csv",
+        dp_config=None,
         # NEW (optional client overrides; do NOT remove old args)
-        val_frac: float | None = None,
-        test_frac: float | None = None,
-        id_col: str | None = None,
-        test_ids: str | None = None,
-        seed: int = 42,
+        val_frac=None,
+        test_frac=None,
+        id_col=None,
+        test_ids=None,
+        seed=42,
     ):
         self.server_address = server_address
         self.dp_config = dp_config
@@ -83,31 +83,31 @@ class FlowerClient(fl.client.NumPyClient):
         self.y_tensor = torch.tensor(y_default, dtype=torch.float32)
 
         # Placeholders; we lazily build loaders/model on the first fit when we see server config
-        self.train_loader: DataLoader | None = None
-        self.val_loader: DataLoader | None = None
-        self.test_loader: DataLoader | None = None
+        self.train_loader = None
+        self.val_loader = None
+        self.test_loader = None
 
-        self.model: Net | None = None
+        self.model = None
         self.criterion = nn.BCEWithLogitsLoss()
-        self.optimizer: optim.Optimizer | None = None
+        self.optimizer = None
 
         # Effective settings (filled at first fit)
-        self.effective_features: list[str] = self.feature_names[:]
-        self.effective_target: str = self.target_name
-        self.effective_val_frac: float = float(self.client_val_frac) if self.client_val_frac is not None else 0.0
-        self.effective_test_frac: float = float(self.client_test_frac) if self.client_test_frac is not None else 0.0
+        self.effective_features = self.feature_names[:]
+        self.effective_target = self.target_name
+        self.effective_val_frac = float(self.client_val_frac) if self.client_val_frac is not None else 0.0
+        self.effective_test_frac = float(self.client_test_frac) if self.client_test_frac is not None else 0.0
 
         self._initialized = False
         self._dp_attached = False  # to avoid wrapping twice
 
     # ---------- helpers
 
-    def _mk_loader(self, X: np.ndarray, y: np.ndarray, batch_size: int, shuffle: bool) -> DataLoader:
+    def _mk_loader(self, X, y, batch_size, shuffle):
         x_t = torch.tensor(X, dtype=torch.float32)
         y_t = torch.tensor(y, dtype=torch.float32)
         return DataLoader(TensorDataset(x_t, y_t), batch_size=batch_size, shuffle=shuffle)
 
-    def _lazy_init_from_server_config(self, config: dict):
+    def _lazy_init_from_server_config(self, config):
         """
         Build model and (train, val, test) loaders once, using:
           - Server-enforced schema: config['features'] (comma-separated), config['target']
@@ -226,7 +226,7 @@ class FlowerClient(fl.client.NumPyClient):
         # ---------- build loaders
         batch_size = self.dp_config.batch_size if self.dp_config else 32
         self.train_loader = self._mk_loader(X_train, y_train, batch_size, shuffle=True)
-        self.val_loader = self._mk_loader(X_val, y_val, batch_size= batch_size, shuffle=False) if len(y_val) else None
+        self.val_loader = self._mk_loader(X_val, y_val, batch_size=batch_size, shuffle=False) if len(y_val) else None
         self.test_loader = self._mk_loader(X_test, y_test, batch_size, shuffle=False)
 
         # ---------- model/optimizer
@@ -414,7 +414,7 @@ class FlowerClient(fl.client.NumPyClient):
             "gpu_count": gpu_count,
         }
 
-    def start(self) -> None:
+    def start(self):
         fl.client.start_numpy_client(
             server_address=self.server_address,
             client=self,

{medfl-2.0.5.dev3 → medfl-2.0.5.dev4}/MEDfl/rw/server.py

@@ -1,7 +1,6 @@
 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
@@ -29,11 +28,11 @@ class FederatedServer:
 
     def __init__(
         self,
-        host: str = "0.0.0.0",
-        port: int = 8080,
-        num_rounds: int = 3,
-        strategy: Optional[Strategy] = None,
-        certificates: Optional[Any] = None,
+        host="0.0.0.0",
+        port=8080,
+        num_rounds=3,
+        strategy=None,
+        certificates=None,
     ):
         """
         Initialize the FederatedServer.
@@ -60,7 +59,7 @@ class FederatedServer:
         self.connected_clients = []  # Track connected client IDs
 
 
-    def start(self) -> None:
+    def start(self):
         """
         Start the Flower server with the configured strategy and track client connections.
         """
@@ -89,7 +88,7 @@ class TrackingClientManager(fl.server.client_manager.SimpleClientManager):
         client_properties (dict): Placeholder for storing client-specific properties.
     """
 
-    def __init__(self, server: FederatedServer):
+    def __init__(self, server):
         """
         Initialize the TrackingClientManager.
 
@@ -100,7 +99,7 @@ class TrackingClientManager(fl.server.client_manager.SimpleClientManager):
         self.server = server
         self.client_properties = {}
 
-    def register(self, client: ClientProxy) -> bool:
+    def register(self, client):
         """
         Register a client and log its connection.
 
@@ -116,7 +115,7 @@ class TrackingClientManager(fl.server.client_manager.SimpleClientManager):
             asyncio.run(self._fetch_and_log_hostname(client))
         return success
 
-    async def _fetch_and_log_hostname(self, client: ClientProxy):
+    async def _fetch_and_log_hostname(self, client):
         """
         Asynchronously fetch and log the client's hostname or CID.
 

{medfl-2.0.5.dev3 → medfl-2.0.5.dev4}/MEDfl/rw/strategy.py

@@ -3,7 +3,6 @@
 import os
 import numpy as np
 import flwr as fl
-from typing import Callable, Optional, Dict, Any, List, Tuple
 from flwr.common import GetPropertiesIns
 from flwr.server.client_manager import ClientManager
 from flwr.server.client_proxy import ClientProxy
@@ -14,18 +13,14 @@ import torch
 # ===================================================
 # Custom metric aggregation functions
 # ===================================================
-def aggregate_fit_metrics(
-    results: List[Tuple[int, Dict[str, float]]]
-) -> Dict[str, float]:
+def aggregate_fit_metrics(results):
     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]:
+def aggregate_eval_metrics(results):
     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
@@ -71,33 +66,33 @@ class Strategy:
 
     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,
-        local_epochs: int = 1,
-        threshold: float = 0.5,
-        learning_rate: float = 0.01,
-        optimizer_name: str = "SGD",
-        savingPath: str = "",
-        saveOnRounds: int = 3,
-        total_rounds: int = 3,
-        features: str = "",
-        target: str = "",
-        val_fraction: float = 0.10,
-        test_fraction: float = 0.10,
+        name="FedAvg",
+        fraction_fit=1.0,
+        fraction_evaluate=1.0,
+        min_fit_clients=2,
+        min_evaluate_clients=2,
+        min_available_clients=2,
+        initial_parameters=None,
+        evaluate_fn=None,
+        fit_metrics_aggregation_fn=None,
+        evaluate_metrics_aggregation_fn=None,
+        local_epochs=1,
+        threshold=0.5,
+        learning_rate=0.01,
+        optimizer_name="SGD",
+        savingPath="",
+        saveOnRounds=3,
+        total_rounds=3,
+        features="",
+        target="",
+        val_fraction=0.10,
+        test_fraction=0.10,
         # NEW: splitting control (added at the end to not break existing calls)
-        split_mode: str = "global",                  # "global" or "per_client"
-        client_fractions: Optional[Dict[str, Dict[str, Any]]] = None,
+        split_mode="global",                  # "global" or "per_client"
+        client_fractions=None,
         # NEW: id column for test_ids mapping
-        id_col: str = "id",
-    ) -> None:
+        id_col="id",
+    ):
         self.name = name
         self.fraction_fit = fraction_fit
         self.fraction_evaluate = fraction_evaluate
@@ -128,14 +123,14 @@ class Strategy:
         self.client_fractions = client_fractions or {}
         self.id_col = id_col
 
-        self.strategy_object: Optional[fl.server.strategy.Strategy] = None
+        self.strategy_object = None
 
-    def create_strategy(self) -> None:
+    def create_strategy(self):
         # 1) Pick the Flower Strategy class
         StrategyClass = getattr(fl.server.strategy, self.name)
 
         # 2) Define on_fit_config_fn _before_ instantiation (global defaults)
-        def fit_config_fn(server_round: int) -> Dict[str, Any]:
+        def fit_config_fn(server_round):
             return {
                 "local_epochs":   self.local_epochs,
                 "threshold":      self.threshold,
@@ -150,7 +145,7 @@ class Strategy:
             }
 
         # 3) Build params including on_fit_config_fn
-        params: Dict[str, Any] = {
+        params = {
             "fraction_fit":                     self.fraction_fit,
             "fraction_evaluate":                self.fraction_evaluate,
             "min_fit_clients":                  self.min_fit_clients,
@@ -226,9 +221,9 @@ class Strategy:
         original_conf_fit = strat.configure_fit
 
         def wrapped_conf_fit(
-            server_round: int,
+            server_round,
             parameters,
-            client_manager: ClientManager
+            client_manager
         ):
             selected = original_conf_fit(
                 server_round=server_round,

{medfl-2.0.5.dev3 → medfl-2.0.5.dev4}/MEDfl.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MEDfl
-Version: 2.0.5.dev3
+Version: 2.0.5.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.5.dev3 → medfl-2.0.5.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MEDfl
-Version: 2.0.5.dev3
+Version: 2.0.5.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.5.dev3 → medfl-2.0.5.dev4}/notebooks/data/eicu_sapsii_data.csv

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
-name: medfl-2.0.5.dev3/notebooks/data/eicu_sapsii_data.csv
+name: medfl-2.0.5.dev4/notebooks/data/eicu_sapsii_data.csv
 size: 48904729 bytes
 sha256: 79203f34470b04f3b2e8cc5b3374b48e54f8a6bb6f484f259889adf7c7dff77d

{medfl-2.0.5.dev3 → medfl-2.0.5.dev4}/setup.py

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