MEDfl 2.0.5.dev1__tar.gz → 2.0.5.dev3__tar.gz

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

@@ -1,4 +1,4 @@
-# client.py
+# File: client.py
 
 import argparse
 import pandas as pd
@@ -112,6 +112,7 @@ class FlowerClient(fl.client.NumPyClient):
         Build model and (train, val, test) loaders once, using:
           - Server-enforced schema: config['features'] (comma-separated), config['target']
           - Split fractions: client overrides win; else use server's val_fraction/test_fraction
+          - NEW: if config['test_ids'] is set (per-client from strategy), use ID-based split
         """
         # ---------- schema from server (enforced if provided)
         srv_features = (config.get("features") or "").strip()
@@ -142,6 +143,21 @@ class FlowerClient(fl.client.NumPyClient):
         if not (0.0 <= val_frac < 1.0):
             raise ValueError(f"Invalid val_frac: {val_frac} (must be 0 <= val_frac < 1)")
 
+        # ---------- NEW: adopt test_ids / id_col from server config if provided
+        if (not self.test_ids or not self.test_ids.strip()) and config.get("test_ids"):
+            
+            # strategy (per_client) can inject test_ids as list or CSV; normalize to CSV string
+            ti = config.get("test_ids")
+            if isinstance(ti, (list, tuple, set)):
+                self.test_ids = ",".join(str(x) for x in ti)
+            else:
+                self.test_ids = str(ti)
+            
+            print(f"[Client] Using server-provided test_ids: {self.test_ids}")
+
+        if (not self.id_col) and config.get("id_col"):
+            self.id_col = str(config.get("id_col"))
+
         # ---------- extract arrays with the enforced schema
         X_all = self._df[feat_cols].values
         y_all = self._df[target_col].values
@@ -151,12 +167,18 @@ class FlowerClient(fl.client.NumPyClient):
         self.y_tensor = torch.tensor(y_all, dtype=torch.float32)
 
         # ---------- split
-        if self.test_ids and self.test_ids.strip():  # ID-based mode
+        if self.test_ids and self.test_ids.strip():  # ID-based mode (unchanged behavior, now also supports server-provided IDs)
             print("[Client] Using ID-based test selection")
             test_ids_list = [i.strip() for i in self.test_ids.split(',') if i.strip()]
 
             if self.id_col and self.id_col in self._df.columns:
                 id_series = self._df[self.id_col]
+                # Align types between id_series and test_ids_list
+                if np.issubdtype(id_series.dtype, np.number):
+                    test_ids_list = [int(i) for i in test_ids_list]
+                else:
+                    test_ids_list = [str(i) for i in test_ids_list]
+
             else:
                 print(f"[Client] Falling back to line numbers (index) as IDs since id_col='{self.id_col}' is invalid or not provided")
                 id_series = self._df.index
@@ -204,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, 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
@@ -242,17 +264,13 @@ class FlowerClient(fl.client.NumPyClient):
         self._initialized = True
         print(f"[Client] Initialized with features={feat_cols}, target={target_col}, val={val_frac}, test={self.effective_test_frac}")
 
-    # ---------- FL API
+    # ---------- FL API (unchanged behavior) ----------
 
     def get_parameters(self, config):
-        # Ensure the model/dataloaders are built before the very first call
         if not self._initialized:
-            # Use server config if provided; otherwise fall back to last-col target/all features
             try:
                 self._lazy_init_from_server_config(config if isinstance(config, dict) else {})
             except Exception as e:
-                # As a last resort, initialize with local defaults so Flower can proceed
-                # (server-enforced schema will still be used on first fit if present)
                 if not self._initialized:
                     self._lazy_init_from_server_config({})
         return [val.cpu().numpy() for val in self.model.state_dict().values()]
@@ -263,7 +281,6 @@ class FlowerClient(fl.client.NumPyClient):
         self.model.load_state_dict(state_dict, strict=True)
 
     def fit(self, parameters, config):
-        # Lazy init when we see the server config for the first time
         if not self._initialized:
             self._lazy_init_from_server_config(config)
 
@@ -286,7 +303,6 @@ class FlowerClient(fl.client.NumPyClient):
 
         avg_loss = total_loss / (len(self.train_loader.dataset) * local_epochs)
 
-        # Compute metrics on FULL data (keeps your previous behavior)
         with torch.no_grad():
             logits = self.model(self.X_tensor).squeeze()
             probs = torch.sigmoid(logits).cpu().numpy()
@@ -306,7 +322,6 @@ class FlowerClient(fl.client.NumPyClient):
             "train_loss": avg_loss,
             "train_accuracy": acc,
             "train_auc": auc,
-            # Helpful for debugging/visibility
             "features": ",".join(self.effective_features),
             "target": self.effective_target,
             "val_fraction": self.effective_val_frac,
@@ -316,14 +331,12 @@ class FlowerClient(fl.client.NumPyClient):
         return self.get_parameters(config), len(self.train_loader.dataset), metrics
 
     def evaluate(self, parameters, config):
-        # Ensure initialized (in case server calls evaluate before fit on round 1)
         if not self._initialized:
             self._lazy_init_from_server_config(config)
 
         self.set_parameters(parameters)
         self.model.eval()
 
-        # Evaluate on TEST split (not the training loader)
         total_loss = 0.0
         all_probs, all_true = [], []
         with torch.no_grad():
@@ -353,15 +366,9 @@ class FlowerClient(fl.client.NumPyClient):
         return float(avg_loss), len(self.test_loader.dataset), metrics
 
     def get_properties(self, config):
-        """
-        Return dataset statistics before training starts.
-        Only scalar values allowed (int, float, str, bool, bytes).
-        Note: before first fit, this uses fallback (last column is target).
-        """
         hostname = socket.gethostname()
         os_type = platform.system()
 
-        # If already initialized, report the effective (server-enforced) view
         if self._initialized:
             num_samples = int(self.X_tensor.shape[0])
             num_features = int(self.X_tensor.shape[1])
@@ -408,105 +415,7 @@ class FlowerClient(fl.client.NumPyClient):
         }
 
     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.add_argument(
-        "--server_address",
-        type=str,
-        required=True,
-        help="Adresse du serveur Flower (ex : 127.0.0.1:8080)",
-    )
-    parser.add_argument(
-        "--data_path",
-        type=str,
-        default="data/data.csv",
-        help="Chemin vers les données CSV",
-    )
-    parser.add_argument(
-        "--dp",
-        action="store_true",
-        help="Activer la confidentialité différentielle",
-    )
-    parser.add_argument(
-        "--noise_multiplier",
-        type=float,
-        default=1.0,
-        help="Noise multiplier pour DP",
-    )
-    parser.add_argument(
-        "--max_grad_norm",
-        type=float,
-        default=1.0,
-        help="Norme max pour le clipping",
-    )
-    parser.add_argument(
-        "--batch_size",
-        type=int,
-        default=32,
-        help="Taille du batch",
-    )
-    # NEW — client-local optional overrides (keeps all old args intact)
-    parser.add_argument(
-        "--val_frac",
-        type=float,
-        default=None,
-        help="Fraction de validation (priorité au client si fourni)",
-    )
-    parser.add_argument(
-        "--test_frac",
-        type=float,
-        default=None,
-        help="Fraction de test (priorité au client si fourni; ignoré si --test_ids fourni)",
-    )
-    parser.add_argument(
-        "--id_col",
-        type=str,
-        default=None,
-        help="Colonne des IDs pour la sélection du test (optionnel; fallback aux numéros de ligne si absent)",
-    )
-    parser.add_argument(
-        "--test_ids",
-        type=str,
-        default=None,
-        help="Liste d'IDs pour le test, séparés par virgule (ex: '1,3,5'; active le mode ID-based si fourni)",
-    )
-    parser.add_argument(
-        "--seed",
-        type=int,
-        default=42,
-        help="Graine aléatoire pour les splits",
-    )
-
-    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,
-        val_frac=args.val_frac,     # optional, overrides server if set
-        test_frac=args.test_frac,   # optional, overrides server if set
-        id_col=args.id_col,         # new
-        test_ids=args.test_ids,     # new
-        seed=args.seed,
-    )
-    client.start()

{medfl-2.0.5.dev1 → medfl-2.0.5.dev3}/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-2.0.5.dev1 → medfl-2.0.5.dev3}/MEDfl/rw/strategy.py

@@ -43,6 +43,30 @@ class Strategy:
       - Per-client & aggregated metric logging
       - Synchronous get_properties() inspection in configure_fit()
       - Saving global parameters every saveOnRounds to savingPath
+
+      Extended:
+      - split_mode:
+          * "global": use global val_fraction/test_fraction for all clients
+          * "per_client": use client_fractions[hostname] if present
+      - client_fractions:
+          {
+            "HOSTNAME_1": {
+               "val_fraction": float (optional),
+               "test_fraction": float (optional),
+               "test_ids": [..] or "id1,id2" (optional)
+            },
+            ...
+          }
+      - In per_client mode:
+          * if test_ids is present for a client:
+                -> send test_ids
+                -> do NOT use that client's test_fraction
+          * otherwise:
+                -> use that client's val_fraction/test_fraction if provided,
+                   else fall back to global val_fraction/test_fraction
+      - client id in this mapping = hostname from client.get_properties()
+      - id_col:
+          * column name used on clients to match test_ids (default "id")
     """
 
     def __init__(
@@ -68,6 +92,11 @@ class Strategy:
         target: str = "",
         val_fraction: float = 0.10,
         test_fraction: float = 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,
+        # NEW: id column for test_ids mapping
+        id_col: str = "id",
     ) -> None:
         self.name = name
         self.fraction_fit = fraction_fit
@@ -94,41 +123,48 @@ class Strategy:
         self._val_fraction = val_fraction
         self._test_fraction = test_fraction
 
+        # NEW
+        self.split_mode = split_mode
+        self.client_fractions = client_fractions or {}
+        self.id_col = id_col
+
         self.strategy_object: Optional[fl.server.strategy.Strategy] = None
 
     def create_strategy(self) -> None:
         # 1) Pick the Flower Strategy class
         StrategyClass = getattr(fl.server.strategy, self.name)
 
-        # 2) Define on_fit_config_fn _before_ instantiation
+        # 2) Define on_fit_config_fn _before_ instantiation (global defaults)
         def fit_config_fn(server_round: int) -> Dict[str, Any]:
             return {
                 "local_epochs":   self.local_epochs,
                 "threshold":      self.threshold,
                 "learning_rate":  self.learning_rate,
                 "optimizer":      self.optimizer_name,
-                "features": self._features,           # e.g. "age,bmi,glucose"
-                "target": self._target,               # e.g. "outcome"
-                "val_fraction": float(self._val_fraction),
-                "test_fraction": float(self._test_fraction),
+                "features":       self._features,
+                "target":         self._target,
+                "val_fraction":   float(self._val_fraction),
+                "test_fraction":  float(self._test_fraction),
+                # NEW: always send id_col so clients know which column to use for test_ids
+                "id_col":         self.id_col,
             }
 
         # 3) Build params including on_fit_config_fn
         params: Dict[str, Any] = {
-            "fraction_fit":                  self.fraction_fit,
-            "fraction_evaluate":             self.fraction_evaluate,
-            "min_fit_clients":               self.min_fit_clients,
-            "min_evaluate_clients":          self.min_evaluate_clients,
-            "min_available_clients":         self.min_available_clients,
-            "evaluate_fn":                   self.evaluate_fn,
-            "on_fit_config_fn":              fit_config_fn,
-            "fit_metrics_aggregation_fn":    self.fit_metrics_aggregation_fn,
-            "evaluate_metrics_aggregation_fn": self.evaluate_metrics_aggregation_fn,
+            "fraction_fit":                     self.fraction_fit,
+            "fraction_evaluate":                self.fraction_evaluate,
+            "min_fit_clients":                  self.min_fit_clients,
+            "min_evaluate_clients":             self.min_evaluate_clients,
+            "min_available_clients":            self.min_available_clients,
+            "evaluate_fn":                      self.evaluate_fn,
+            "on_fit_config_fn":                 fit_config_fn,
+            "fit_metrics_aggregation_fn":       self.fit_metrics_aggregation_fn,
+            "evaluate_metrics_aggregation_fn":  self.evaluate_metrics_aggregation_fn,
         }
         if self.initial_parameters:
             params["initial_parameters"] = fl.common.ndarrays_to_parameters(self.initial_parameters)
         else:
-            # NEW: derive initial params from server-specified features
+            # derive initial params from server-specified features
             feat_cols = [c.strip() for c in (self._features or "").split(",") if c.strip()]
             if not feat_cols:
                 raise ValueError(
@@ -145,6 +181,7 @@ class Strategy:
 
         # 5) Wrap aggregate_fit for logging (prints unchanged)
         original_agg_fit = strat.aggregate_fit
+
         def logged_agg_fit(server_round, results, failures):
             print(f"\n[Server] 🔄 Round {server_round} - Client Training Metrics:")
             for i, (client_id, fit_res) in enumerate(results):
@@ -152,17 +189,26 @@ class Strategy:
             agg_params, metrics = original_agg_fit(server_round, results, failures)
             print(f"[Server] ✅ Round {server_round} - Aggregated Training Metrics: {metrics}\n")
             # save the model parameters if savingPath is set on each saveOnRounds 
-            if self.savingPath and ((server_round % self.saveOnRounds == 0) or (self.total_rounds and server_round == self.total_rounds)):
+            if self.savingPath and (
+                (server_round % self.saveOnRounds == 0)
+                or (self.total_rounds and server_round == self.total_rounds)
+            ):
                 arrays = fl.common.parameters_to_ndarrays(agg_params)
                 # Determine filename: final_model on last round else round_{n}
-                filename = f"round_{server_round}_final_model.npz" if server_round == self.total_rounds else f"round_{server_round}_model.npz"
+                filename = (
+                    f"round_{server_round}_final_model.npz"
+                    if server_round == self.total_rounds
+                    else f"round_{server_round}_model.npz"
+                )
                 filepath = os.path.join(self.savingPath, filename)
                 np.savez(filepath, *arrays)
             return agg_params, metrics
+
         strat.aggregate_fit = logged_agg_fit
 
         # 6) Wrap aggregate_evaluate for logging (prints unchanged)
         original_agg_eval = strat.aggregate_evaluate
+
         def logged_agg_eval(server_round, results, failures):
             print(f"\n[Server] 📊 Round {server_round} - Client Evaluation Metrics:")
             for i, (client_id, eval_res) in enumerate(results):
@@ -171,10 +217,14 @@ class Strategy:
             print(f"[Server] ✅ Round {server_round} - Aggregated Evaluation Metrics:")
             print(f"    Loss: {loss}, Metrics: {metrics}\n")
             return loss, metrics
+
         strat.aggregate_evaluate = logged_agg_eval
 
-        # 7) Wrap configure_fit to log client properties (prints unchanged)
+        # 7) Wrap configure_fit to:
+        #    - log client properties (unchanged)
+        #    - apply split_mode/client_fractions to fit_ins.config (NEW)
         original_conf_fit = strat.configure_fit
+
         def wrapped_conf_fit(
             server_round: int,
             parameters,
@@ -185,14 +235,72 @@ class Strategy:
                 parameters=parameters,
                 client_manager=client_manager
             )
+
             ins = GetPropertiesIns(config={})
-            for client, _ in selected:
+
+            for client, fit_ins in selected:
+                hostname = None
                 try:
                     props = client.get_properties(ins=ins, timeout=10.0, group_id=0)
                     print(f"\n📋 [Round {server_round}] Client {client.cid} Properties: {props.properties}")
+                    hostname = props.properties.get("hostname", None)
                 except Exception as e:
                     print(f"⚠️ Failed to get properties from {client.cid}: {e}")
+
+                # Fallback: if no hostname returned, use Flower cid
+                if not hostname:
+                    hostname = client.cid
+
+                # Keep same object
+                cfg = fit_ins.config
+
+                if self.split_mode == "per_client":
+                    # Lookup by hostname (preferred) or cid
+                    per_cfg = (
+                        self.client_fractions.get(hostname)
+                        or self.client_fractions.get(client.cid)
+                        or {}
+                    )
+
+                    # val_fraction: per-client override if present
+                    if "val_fraction" in per_cfg:
+                        try:
+                            cfg["val_fraction"] = float(per_cfg["val_fraction"])
+                        except Exception:
+                            pass  # keep existing if invalid
+
+                    # test: prefer test_ids if provided
+                    if "test_ids" in per_cfg and per_cfg["test_ids"]:
+                        test_ids_val = per_cfg["test_ids"]
+                        if isinstance(test_ids_val, (list, tuple, set)):
+                            test_ids_str = ",".join(str(x) for x in test_ids_val)
+                        else:
+                            test_ids_str = str(test_ids_val)
+                        cfg["test_ids"] = test_ids_str
+                        # when using explicit IDs, do not force a test_fraction for this client
+                        if "test_fraction" in cfg:
+                            del cfg["test_fraction"]
+                        # ensure id_col is sent so client can map IDs
+                        cfg["id_col"] = self.id_col
+                    else:
+                        # no test_ids -> use per-client test_fraction if present
+                        if "test_fraction" in per_cfg:
+                            try:
+                                cfg["test_fraction"] = float(per_cfg["test_fraction"])
+                            except Exception:
+                                pass  # keep existing if invalid
+                        # if no test_ids: id_col not strictly required, leave as-is
+                else:
+                    # split_mode == "global": enforce global fractions, clear any test_ids
+                    if "test_ids" in cfg:
+                        del cfg["test_ids"]
+                    cfg["val_fraction"] = float(self._val_fraction)
+                    cfg["test_fraction"] = float(self._test_fraction)
+                    # also send id_col so clients know column name if needed
+                    cfg["id_col"] = self.id_col
+
             return selected
+
         strat.configure_fit = wrapped_conf_fit
 
         # 8) Save the ready-to-use strategy

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

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

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

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

{medfl-2.0.5.dev1 → medfl-2.0.5.dev3}/notebooks/eicu_test_1.csv

@@ -15,7 +15,7 @@ stay180870,site71,Midwest,18,0,0,6,3,0,6,0,0,0,0,13,0,0,0,1
 stay181437,site63,Midwest,15,0,0,8,0,0,6,0,0,2,0,0,0,0,0,0
 stay182413,site58,Midwest,12,0,11,6,0,0,6,9,0,0,0,5,0,0,3,0
 stay186957,site73,Midwest,7,0,0,6,0,0,6,0,0,0,0,5,0,0,0,0
-stay187667,site73,Midwest,15,0,0,6,6,0,10,0,0,4,3,5,0,0,0,0
+stay187667,site73,Midwest,15,0,0,6,6,0,10,0,0,4,3,5,0,0,0,00
 stay187743,site63,Midwest,15,0,0,6,0,0,6,0,5,2,0,5,0,3,0,0
 stay189842,site66,Midwest,18,0,0,6,3,0,0,0,0,2,0,5,1,0,0,0
 stay205928,site67,Midwest,7,0,0,6,3,0,6,0,0,0,0,5,0,0,0,0

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

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