MEDfl 2.0.5.dev2__py3-none-any.whl → 2.0.5.dev4__py3-none-any.whl

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

@@ -1,11 +1,8 @@
 import math
-from typing import List, Optional, Literal, Callable, Tuple
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
 
-Task = Literal["binary", "multiclass", "multilabel", "regression"]
-
 _ACTS = {
     "relu": nn.ReLU,
     "gelu": nn.GELU,
@@ -16,7 +13,7 @@ _ACTS = {
     "identity": nn.Identity,
 }
 
-def _make_activation(name: str) -> nn.Module:
+def _make_activation(name):
     if name not in _ACTS:
         raise ValueError(f"Unsupported activation '{name}'. Choose from {list(_ACTS)}")
     return _ACTS[name]()
@@ -35,16 +32,16 @@ class Net(nn.Module):
 
     def __init__(
         self,
-        input_dim: int,
-        hidden_dims: List[int] = [64, 32],
-        activation: str = "relu",
-        batchnorm: bool = True,
-        dropout: Optional[float | List[float]] = 0.0,
-        task: Task = "binary",
-        num_classes: Optional[int] = None,
-        output_bias: bool = True,
-        return_logits: bool = True,
-        weight_init: Literal["kaiming", "xavier", "none"] = "kaiming",
+        input_dim,
+        hidden_dims=[64, 32],
+        activation="relu",
+        batchnorm=True,
+        dropout=0.0,
+        task="binary",
+        num_classes=None,
+        output_bias=True,
+        return_logits=True,
+        weight_init="kaiming",
     ):
         super().__init__()
         self.task = task
@@ -78,10 +75,9 @@ class Net(nn.Module):
         else:
             raise ValueError("dropout must be float|list[float]|None")
 
-        layers = []
-        in_dim = input_dim
         self.blocks = nn.ModuleList()
-        for i, (h, p) in enumerate(zip(hidden_dims, dropout)):
+        in_dim = input_dim
+        for h, p in zip(hidden_dims, dropout):
             block = nn.ModuleDict({
                 "lin": nn.Linear(in_dim, h, bias=True),
                 "bn": nn.BatchNorm1d(h) if batchnorm else nn.Identity(),
@@ -98,11 +94,15 @@ class Net(nn.Module):
             self.apply(lambda m: self._init_weights(m, scheme=weight_init, activation=activation))
 
     @staticmethod
-    def _init_weights(m: nn.Module, scheme: str, activation: str):
+    def _init_weights(m, scheme, activation):
         if isinstance(m, nn.Linear):
             if scheme == "kaiming":
                 nonlinearity = "leaky_relu" if activation == "leaky_relu" else "relu"
-                nn.init.kaiming_uniform_(m.weight, a=math.sqrt(5) if activation == "leaky_relu" else 0, nonlinearity=nonlinearity)
+                nn.init.kaiming_uniform_(
+                    m.weight,
+                    a=math.sqrt(5) if activation == "leaky_relu" else 0,
+                    nonlinearity=nonlinearity,
+                )
             elif scheme == "xavier":
                 nn.init.xavier_uniform_(m.weight)
             if m.bias is not None:
@@ -110,7 +110,7 @@ class Net(nn.Module):
                 bound = 1 / math.sqrt(fan_in) if fan_in > 0 else 0
                 nn.init.uniform_(m.bias, -bound, bound)
 
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
+    def forward(self, x):
         for blk in self.blocks:
             x = blk["lin"](x)
             x = blk["bn"](x)
@@ -120,7 +120,7 @@ class Net(nn.Module):
         return logits if self.return_logits else self._apply_output_activation(logits)
 
     # Inference helpers
-    def _apply_output_activation(self, logits: torch.Tensor) -> torch.Tensor:
+    def _apply_output_activation(self, logits):
         if self.task == "binary":
             return torch.sigmoid(logits)               # (B, 1)
         elif self.task == "multiclass":
@@ -128,14 +128,15 @@ class Net(nn.Module):
         elif self.task == "multilabel":
             return torch.sigmoid(logits)               # (B, L)
         elif self.task == "regression":
-            return logits                               # raw regression output
+            return logits                              # raw regression output
         else:
             raise RuntimeError("Invalid task")
 
     @torch.no_grad()
-    def predict(self, x: torch.Tensor) -> torch.Tensor:
-        out = self.forward(x)                                  # always run forward
+    def predict(self, x):
+        out = self.forward(x)
         probs = self._apply_output_activation(out) if self.return_logits else out
+
         if self.task == "binary":
             return (probs >= 0.5).long()
         elif self.task == "multiclass":
@@ -144,4 +145,3 @@ class Net(nn.Module):
             return (probs >= 0.5).long()
         elif self.task == "regression":
             return probs
-

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/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.dev2.dist-info → medfl-2.0.5.dev4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MEDfl
-Version: 2.0.5.dev2
+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.dev2.dist-info → medfl-2.0.5.dev4.dist-info}/RECORD

@@ -20,17 +20,17 @@ 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=Ufa-VCbP83adEs7tV1ltDYakBV2Ge5GCPhjIJ7HsuJ8,17804
-MEDfl/rw/model.py,sha256=-YRBO5ZX_Ahp95lTisCUejlWJHS1Ly5TnRMp4LhA0Do,5759
-MEDfl/rw/server.py,sha256=TmcWUwMJ5BG7owqIVTtTC6w8bR02SESRT9lXh7BqlOg,4986
-MEDfl/rw/strategy.py,sha256=rrRUvuFxL4rdtjN-q-GgB_QQ4ntH9kSyIbTQtiASjVI,13779
+MEDfl/rw/client.py,sha256=iYA6GkCQ7YQ9B60OrkuDnHCFnMpE8fPdafiyBMknOP0,17493
+MEDfl/rw/model.py,sha256=IvC5a1ADyn7mKeSBq1Lk_UnkSJOCErPCmpEPSOFxHpk,5343
+MEDfl/rw/server.py,sha256=JBNSSX8tihrLIjgDTrGfmsXXOq_00gtS0s9qCgbqrHY,4834
+MEDfl/rw/strategy.py,sha256=uQvd9lS_PZc234ghBKvrhwdc7ooztHzewuvwpWzBsJ8,13206
 MEDfl/scripts/__init__.py,sha256=Pq1weevsPaU7MRMHfBYeyT0EOFeWLeVM6Y1DVz6jw1A,48
 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.5.dev2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-medfl-2.0.5.dev2.dist-info/METADATA,sha256=dZQUWWXwA-R_MHYDgp24UvIWeUmUf2RxNe4BTorptME,6914
-medfl-2.0.5.dev2.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
-medfl-2.0.5.dev2.dist-info/top_level.txt,sha256=dIL9X8HOFuaVSzpg40DVveDPrymWRoShHtspH7kkjdI,14
-medfl-2.0.5.dev2.dist-info/RECORD,,
+medfl-2.0.5.dev4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+medfl-2.0.5.dev4.dist-info/METADATA,sha256=XXERejCSaSWf9BYuGuG24uc1hakKPuDC12ctD_Ox9Co,6914
+medfl-2.0.5.dev4.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+medfl-2.0.5.dev4.dist-info/top_level.txt,sha256=dIL9X8HOFuaVSzpg40DVveDPrymWRoShHtspH7kkjdI,14
+medfl-2.0.5.dev4.dist-info/RECORD,,