FedModelKit 0.6.1__tar.gz → 0.6.6__tar.gz

{fedmodelkit-0.6.1 → fedmodelkit-0.6.6}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: FedModelKit
-Version: 0.6.1
-Summary: This package contains the core components and protocols for creating, managing, and registering federated learning models using MLflow. It provides utilities for defining local learners, aggregation strategies, and integrating them with MLflow for tracking and deployment.
+Version: 0.6.6
+Summary: LOW_LEVEL_API: This package contains the core components and protocols for creating, managing, and registering federated learning models using MLflow. It provides utilities for defining local learners, aggregation strategies, and integrating them with MLflow for tracking and deployment.
 Author-email: ceresale <alessandro.ceresi@upm.es>
 License-File: LICENSE
 Requires-Python: >=3.13

{fedmodelkit-0.6.1 → fedmodelkit-0.6.6}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "FedModelKit"
-version = "0.6.1"
-description = "This package contains the core components and protocols for creating, managing, and registering federated learning models using MLflow. It provides utilities for defining local learners, aggregation strategies, and integrating them with MLflow for tracking and deployment."
+version = "0.6.6"
+description = "LOW_LEVEL_API: This package contains the core components and protocols for creating, managing, and registering federated learning models using MLflow. It provides utilities for defining local learners, aggregation strategies, and integrating them with MLflow for tracking and deployment."
 readme = "README.md"
 authors = [
     { name = "ceresale", email = "alessandro.ceresi@upm.es" }

{fedmodelkit-0.6.1 → fedmodelkit-0.6.6}/src/FedModelKit/cli.py

@@ -25,14 +25,14 @@ def create_structure(exp_name: str = "new_experiment") -> None:
             f"{exp_name}": {
                 "__init__.py": get_init_template(),
                 "task.py": get_task_template(),
-                "server_app.py": get_server_template(),
-                "client_app.py": get_client_template(),                
+                "server_app.py": get_server_template(exp_name),
+                "client_app.py": get_client_template(exp_name),                
             },
         },
         "pyproject.toml": get_extern_pyproject_template(exp_name),
         "uv.lock": get_uv_template(),
         "README.md": get_readme_template(),
-        "ds.ipynb": get_ds_template(),
+        "ds.ipynb": get_ds_template(exp_name),
     }
 
 

fedmodelkit-0.6.6/src/FedModelKit/templates/client_app_template.py

@@ -0,0 +1,106 @@
+import numpy as np
+import pandas as pd
+import pickle
+from pathlib import Path
+from flwr.client import ClientApp
+from flwr.common import Message, Context
+from flwr.common.record import RecordDict, MetricRecord, ConfigRecord
+from sklearn.preprocessing import OneHotEncoder
+import FedModelKit as msi
+import FedModelKit as msi
+
+from EXPERIMENT_NAME.task import Net # Type: ignore[import]
+
+
+# Initialize the Flower ClientApp
+app = ClientApp()
+
+@app.query()
+def query(msg: Message, ctx: Context) -> Message:
+    """
+    Query function to be executed by the Flower client. This function handles the
+    initial configuration sent by the server.
+    """
+
+    # Retrieve the configuration sent by the server
+    fancy_config = msg.content.config_records['fancy_config']
+    
+    # Instantiate the federated model
+    federated_model = Net()
+
+    # Load the client split data using the load_data function
+    federated_model.prepare_data(fancy_config['client_id'], fancy_config['num_clients'])
+
+    # Store the local learner and the data split in the context
+    # To store in context other objects, you can use ctx.state.<object_name> = <object>
+    ctx.state.local_learner = federated_model
+
+    return Message(RecordDict(), reply_to=msg)
+
+@app.train()
+def train(msg: Message, ctx: Context):
+    """
+    Train function to be executed by the Flower client.
+    This function handles the training of the local model using the data provided.
+    """
+
+    # Retrieve the local learner and the client split from the context
+    local_learner = ctx.state.local_learner
+
+    # Retrieve configuration sent by the server - example
+    #fancy_config = msg.content.configs_records['fancy_config']
+    #local_epochs = fancy_config['local_epochs']
+
+    # Retrieve the model parameters sent by the server
+    fancy_parameters = msg.content.array_records['fancy_model']
+    local_learner.set_parameters(fancy_parameters)    
+
+    # Perform local training and obtain training metrics
+    train_metrics = local_learner.train_round()
+
+    # Retrieve the trained model parameters
+    new_array_records = local_learner.get_parameters()
+
+    # Construct a reply message carrying updated model parameters and generated metrics
+    reply_content = RecordDict()
+    reply_content.array_records['fancy_model_returned'] = new_array_records
+    reply_content.metric_records['train_metrics'] = MetricRecord(train_metrics)
+
+    # Store the metrics and the local learner in the context for future reference
+    ctx.state.metric_records['prev'] = MetricRecord(train_metrics)
+    ctx.state.local_learner =  local_learner
+
+    # Return the reply message to the server
+    return Message(reply_content, reply_to=msg)
+
+@app.evaluate()
+def eval(msg: Message, ctx: Context):
+    """
+    Evaluate function to be executed by the Flower client.
+    This function handles the evaluation of the local model using the data provided.
+    """
+
+    # Retrieve the local learner and the client split from the context
+    local_learner = ctx.state.local_learner
+
+    # Retrieve configuration sent by the server - example
+    #fancy_config = msg.content.configs_records['fancy_config']
+    #local_epochs = fancy_config['local_epochs']
+
+    # Retrieve the model parameters sent by the server
+    fancy_parameters = msg.content.array_records['fancy_model']
+    local_learner.set_parameters(fancy_parameters)
+
+    # Evaluate the model and obtain evaluation metrics
+    eval_metrics = local_learner.evaluate()
+
+    # Construct a reply message with evaluation metrics
+    reply_content = RecordDict()
+    reply_content.metric_records['eval_metrics'] = MetricRecord(eval_metrics)
+
+    # Store the metrics and the local learner in the context for future reference
+    ctx.state.metric_records['prev'] = MetricRecord(eval_metrics)
+    ctx.state.local_learner =  local_learner
+
+    # Return the reply message to the server
+    return Message(reply_content, reply_to=msg)

{fedmodelkit-0.6.1 → fedmodelkit-0.6.6}/src/FedModelKit/templates/ds_template.ipynb

@@ -131,7 +131,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "SYFT_FLWR_PROJECT_PATH = Path(\"./fl-diabetes-prediction\")\n",
+    "SYFT_FLWR_PROJECT_PATH = Path(\"./EXPERIMENT_NAME\")\n",
     "assert SYFT_FLWR_PROJECT_PATH.exists()"
    ]
   },
@@ -184,7 +184,7 @@
    "outputs": [],
    "source": [
     "# clean up\n",
-    "!rm -rf {SYFT_FLWR_PROJECT_PATH / \"fl_diabetes_prediction\" / \"__pycache__\"}\n",
+    "!rm -rf {SYFT_FLWR_PROJECT_PATH / \"EXPERIMENT_NAME\" / \"__pycache__\"}\n",
     "!rm -rf weights/"
    ]
   },
@@ -229,7 +229,7 @@
    "outputs": [],
    "source": [
     "# clean up before submitting jobs\n",
-    "!rm -rf {SYFT_FLWR_PROJECT_PATH / \"fl_diabetes_prediction\" / \"__pycache__\"}\n",
+    "!rm -rf {SYFT_FLWR_PROJECT_PATH / \"EXPERIMENT_NAME\" / \"__pycache__\"}\n",
     "!rm -rf {SYFT_FLWR_PROJECT_PATH / \"simulation_logs\"}\n",
     "!rm -rf weights/"
    ]

fedmodelkit-0.6.6/src/FedModelKit/templates/server_app_template.py

@@ -0,0 +1,144 @@
+
+# from tkinter import Grid
+from typing import List
+import time
+
+import flwr as fl
+from flwr.common import (
+    Context,
+    NDArrays,
+    Message,
+    MessageType,
+    Metrics,
+    RecordDict,
+    ConfigRecord,
+    DEFAULT_TTL,
+)
+from flwr.server import Grid
+
+from EXPERIMENT_NAME.task import Net, Strategy #type: ignore[import]
+
+
+# Run via `flower-server-app server:app`
+app = fl.server.ServerApp()
+
+
+
+
+@app.main()
+def main(grid: Grid, context: Context):
+    """
+    Main function to run the federated learning server.
+
+    Structure:
+    - Send a query message to clients for creating the local learner and loading the data
+    - Start global epochs loop for training and evaluation
+        - Send training messages to clients
+        - Aggregate parameters received from clients
+        - Send evaluation messages to clients
+        - Aggregate evaluation metrics
+    """
+    print("Starting test run")
+
+    # Get node IDs of connected clients
+    node_ids = grid.get_node_ids()
+
+    # Initialize the federated model
+    global_model = Net()
+    aggregation_strategy = Strategy()
+
+    # Send a query message to clients for creating the local learner and loading the data
+    messages = []
+    for idx, node_id in enumerate(node_ids):
+        # Create messages to send to clients
+        record_dict = RecordDict()
+
+        # Add a config with information to send the client for the query
+        record_dict.config_records["fancy_config"] = ConfigRecord({"num_clients": len(node_ids), "client_id": idx})
+
+        # Create a query message for each client
+        message = Message(
+            content=record_dict,
+            message_type=MessageType.QUERY,
+            dst_node_id=node_id,
+            group_id=str(1),
+            ttl=DEFAULT_TTL,
+        )
+        messages.append(message)
+
+    # Send training messages to clients
+    all_replies = list(grid.send_and_receive(messages))
+    print(f"Received {len(all_replies)} answers")
+    
+
+    # Run federated training and evaluation for a fixed number of rounds
+    for server_round in range(3):
+        print(f"Commencing server train and evaluation round {server_round + 1}")
+
+        messages = []
+        for idx, node_id in enumerate(node_ids):
+            # Create messages to send to clients
+            record_dict = RecordDict()
+
+            # Add model parameters to record
+            record_dict.array_records["fancy_model"] = global_model.get_parameters()
+            # Add a config with information to send the client for training
+            record_dict.config_records["fancy_config"] = ConfigRecord({"local_epochs": 3})
+
+            # Create a training message for each client
+            message = Message(
+                content=record_dict,
+                message_type=MessageType.TRAIN,
+                dst_node_id=node_id,
+                group_id=str(server_round),
+                ttl=DEFAULT_TTL,
+            )
+            messages.append(message)
+
+        # Send training messages to clients
+        all_replies = list(grid.send_and_receive(messages))
+        print(f"Received {len(all_replies)} results")
+
+        # Print metrics received from clients
+        for reply in all_replies:
+            print(reply.content.metric_records)
+
+        # Aggregate parameters received from clients
+        array_records_list = [reply.content.array_records["fancy_model_returned"] for reply in all_replies]
+        new_array_records = aggregation_strategy.aggregate_parameters(array_records_list)
+        global_model.set_parameters(new_array_records)
+
+        # Evaluate the updated global model
+        messages = []
+        for idx, node_id in enumerate(node_ids):
+            # Create evaluation messages for clients
+            record_dict = RecordDict()
+
+            # Add updated model parameters to record
+            record_dict.array_records["fancy_model"] = new_array_records
+            # Add a config with information to send the client for evaluation
+            record_dict.config_records["fancy_config"] = ConfigRecord({"local_epochs": 3})
+
+            # Create an evaluation message for each client
+            message = Message(
+                content=record_dict,
+                message_type=MessageType.EVALUATE,
+                dst_node_id=node_id,
+                group_id=str(server_round),
+                ttl=DEFAULT_TTL,
+            )
+            messages.append(message)
+
+        # Send evaluation messages to clients
+        all_replies = list(grid.send_and_receive(messages))
+        print(f"Received {len(all_replies)} results")
+
+        # Print evaluation metrics received from clients
+        metrics_records_list = [reply.content.metric_records['eval_metrics'] for reply in all_replies]
+        for i, reply in enumerate(all_replies):
+            print(f"Client {i+1} metrics:   ", reply.content.metric_records['eval_metrics'])
+
+        # Aggregate evaluation metrics
+        print("Aggregated metrics result:   ", aggregation_strategy.aggregate_metrics(metrics_records_list))
+    
+    print("🎉🎉🎉 Successfully completed federated learning run! 🎉🎉🎉")

fedmodelkit-0.6.6/src/FedModelKit/templates/task_template.py

@@ -0,0 +1,373 @@
+from collections import OrderedDict
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import flwr
+import numpy as np
+from typing import Optional
+from flwr_datasets import FederatedDataset
+from flwr_datasets.partitioner import IidPartitioner
+from imblearn.over_sampling import SMOTE
+from loguru import logger
+from pandas import DataFrame
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from torch.utils.data import DataLoader, TensorDataset
+
+
+def get_device():
+    if torch.cuda.is_available():
+        return torch.device("cuda")
+    elif torch.backends.mps.is_available():
+        return torch.device("mps")
+    elif torch.xpu.is_available():
+        return torch.device("xpu")
+    else:
+        return torch.device("cpu")
+
+
+DEVICE = get_device()
+logger.info(f"Using device: {DEVICE}")
+
+
+class Net(nn.Module):
+    def __init__(self, input_dim=6):
+        super(Net, self).__init__()
+        self.trainloader = None
+        self.testloader = None
+        self.fds = None  # Cache FederatedDataset
+        # First layer with more units and batch normalization
+        self.layer1 = nn.Sequential(
+            nn.Linear(input_dim, 32),  # Increased from 20 to 32
+            nn.BatchNorm1d(32),  # Added batch normalization
+            nn.LeakyReLU(0.1),  # LeakyReLU instead of ReLU
+            nn.Dropout(0.2),  # Increased dropout
+        )
+
+        # Second layer with more units
+        self.layer2 = nn.Sequential(
+            nn.Linear(32, 24),  # Increased from 14 to 24
+            nn.BatchNorm1d(24),  # Added batch normalization
+            nn.LeakyReLU(0.1),
+            nn.Dropout(0.25),
+        )
+
+        # Third layer
+        self.layer3 = nn.Sequential(
+            nn.Linear(24, 16), nn.BatchNorm1d(16), nn.LeakyReLU(0.1)
+        )
+
+        # Output layer
+        self.output_layer = nn.Sequential(nn.Linear(16, 1), nn.Sigmoid())
+
+    def forward(self, x):
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.output_layer(x)
+        return x
+    
+    
+
+
+    def dataset_processing(
+        self, train_df: DataFrame, test_df: DataFrame
+    ) -> tuple[DataLoader, DataLoader]:
+        def preprocess_df(df: DataFrame) -> DataFrame:
+            columns_to_drop = ["SkinThickness", "Insulin"]
+            df_new: DataFrame = df.drop(columns_to_drop, axis=1)
+
+            # Calculate mean and median (excluding zeros)
+            mean_glucose = df_new[df_new["Glucose"] != 0]["Glucose"].mean()
+            median_bmi = df_new[df_new["BMI"] != 0]["BMI"].median()
+            median_bp = df_new[df_new["BloodPressure"] != 0]["BloodPressure"].median()
+
+            # Replace zeros values with mean/median
+            df_new.replace(
+                {
+                    "Glucose": {0: mean_glucose},
+                    "BMI": {0: median_bmi},
+                    "BloodPressure": {0: median_bp},
+                },
+                inplace=True,
+            )
+
+            return df_new
+
+        # Preprocess both datasets
+        train_processed = preprocess_df(train_df)
+        test_processed = preprocess_df(test_df)
+
+        # Split features and labels for both sets
+        X_train = train_processed.values[:, :6]
+        y_train = train_processed.values[:, 6:]
+        X_test = test_processed.values[:, :6]
+        y_test = test_processed.values[:, 6:]
+
+        from collections import Counter
+
+        def get_minority_class_count(y):
+            return min(Counter(y.flatten()).values())
+
+        minority_count = get_minority_class_count(y_train)
+        k_neighbors = min(5, minority_count - 1) if minority_count > 1 else 1
+
+        # Resample the training data to fix the class imbalance
+        smote = SMOTE(random_state=42, k_neighbors=k_neighbors)
+        X_train_resampled, y_train_resampled = smote.fit_resample(X_train, y_train)
+
+        # Scale the data to have zero mean and unit variance
+        scaler = StandardScaler()
+        X_train_resampled = scaler.fit_transform(X_train_resampled)
+        X_test = scaler.transform(X_test)
+
+        # Convert numpy arrays to PyTorch tensors
+        X_train_tensor = torch.FloatTensor(X_train_resampled)
+        y_train_tensor = torch.FloatTensor(y_train_resampled).reshape(
+            -1, 1
+        )  # Add this reshape
+        X_test_tensor = torch.FloatTensor(X_test)
+        y_test_tensor = torch.FloatTensor(y_test).reshape(-1, 1)
+
+        # Create datasets and dataloaders
+        train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
+        test_dataset = TensorDataset(X_test_tensor, y_test_tensor)
+
+        train_loader = DataLoader(dataset=train_dataset, batch_size=10, shuffle=True)
+        test_loader = DataLoader(
+            dataset=test_dataset, batch_size=len(test_dataset), shuffle=False
+        )
+
+        return train_loader, test_loader
+
+    def _parameters_to_dict(self, params_record: flwr.common.ParametersRecord) -> OrderedDict:
+        # Convert ParametersRecord to an OrderedDict
+        state_dict = OrderedDict()
+        for k, v in params_record.items():
+            state_dict[k] = self._basic_array_deserialisation(v)
+        return state_dict
+
+    def _dict_to_parameter_record(self, 
+        parameters: OrderedDict["str", flwr.common.NDArray],
+    ) -> flwr.common.ParametersRecord:
+        # Convert OrderedDict to ParametersRecord
+        state_dict = OrderedDict()
+        for k, v in parameters.items():
+            state_dict[k] = self._ndarray_to_array(v)
+
+        return flwr.common.ParametersRecord(state_dict)
+
+    def _ndarray_to_array(self, ndarray: flwr.common.NDArray) -> flwr.common.Array:
+        """Represent NumPy ndarray as Array."""
+        return flwr.common.Array(
+            data=ndarray.tobytes(),
+            dtype=str(ndarray.dtype),
+            stype="numpy.ndarray.tobytes",
+            shape=list(ndarray.shape),
+        )
+
+    def _basic_array_deserialisation(self, array: flwr.common.Array) -> flwr.common.NDArray:
+        # Deserialize Array to NumPy ndarray
+        return np.frombuffer(buffer=array.data, dtype=array.dtype).reshape(array.shape)
+
+    def load_syftbox_dataset(self) -> None: 
+        import pandas as pd
+
+        from syft_flwr.utils import get_syftbox_dataset_path
+
+        data_dir = get_syftbox_dataset_path()
+        logger.info(f"Loading dataset from {data_dir}")
+
+        train_df = pd.read_csv(data_dir / "train.csv")
+        test_df = pd.read_csv(data_dir / "test.csv")
+
+        self.trainloader, self.testloader = self.dataset_processing(train_df, test_df)
+
+
+    def load_flwr_data(
+        self, partition_id: int, num_partitions: int
+    ) -> None:
+        """
+        Load the `fl-diabetes-prediction` dataset to memory
+        """
+        # global fds
+        if self.fds is None:
+            partitioner = IidPartitioner(num_partitions=num_partitions)
+            self.fds = FederatedDataset(
+                dataset="khoaguin/pima-indians-diabetes-database",
+                partitioners={"train": partitioner},
+            )
+
+        partition: DataFrame = self.fds.load_partition(partition_id, "train").with_format(
+            "pandas"
+        )[:]
+        train_df, test_df = train_test_split(partition, test_size=0.2, random_state=95)
+
+        self.trainloader, self.testloader = self.dataset_processing(train_df, test_df)
+
+
+    def prepare_data(
+        self, partition_id: int, num_partitions: int
+    ) -> None:
+        from syft_flwr.utils import run_syft_flwr
+        if not run_syft_flwr():
+            logger.info("Running flwr locally")
+            self.load_flwr_data(
+                partition_id=partition_id,
+                num_partitions=num_partitions,
+            )
+        else:
+            logger.info("Running with syft_flwr")
+            self.load_syftbox_dataset()
+
+
+    def train_round(self, local_epochs=1):
+        criterion = nn.BCELoss()
+        optimizer = optim.Adam(self.parameters(), lr=0.001, weight_decay=0.0005)
+        history = {"train_loss": [], "train_acc": []}
+        self.to(DEVICE)
+
+        for epoch in range(local_epochs):
+            self.train()
+            running_loss = 0.0
+            correct = 0
+            total = 0
+
+            for inputs, labels in self.trainloader:
+                inputs, labels = inputs.to(DEVICE), labels.to(DEVICE)
+
+                optimizer.zero_grad()
+                outputs = self(inputs)
+                loss = criterion(outputs, labels)
+                loss.backward()
+                optimizer.step()
+
+                running_loss += loss.item() * inputs.size(0)
+                predicted = (outputs > 0.5).float()
+                total += labels.size(0)
+                correct += (predicted == labels).sum().item()
+
+            epoch_loss = running_loss / len(self.trainloader.dataset)
+            epoch_acc = correct / total
+            history["train_loss"].append(epoch_loss)
+            history["train_acc"].append(epoch_acc)
+
+        return history
+
+
+    def evaluate(self):
+        self.to(DEVICE)
+        self.eval()
+        criterion = nn.BCELoss()
+
+        running_loss = 0.0
+        correct = 0
+        total = 0
+
+        with torch.no_grad():
+            for inputs, labels in self.testloader:
+                inputs, labels = inputs.to(DEVICE), labels.to(DEVICE)
+                outputs = self(inputs)
+                loss = criterion(outputs, labels)
+                running_loss += loss.item() * inputs.size(0)
+                predicted = (outputs > 0.5).float()
+                total += labels.size(0)
+                correct += (predicted == labels).sum().item()
+
+        epoch_loss = running_loss / len(self.testloader.dataset)
+        epoch_acc = correct / total
+
+        return {"epoch_loss": epoch_loss, "epoch_accuracy": epoch_acc}
+
+
+    def get_parameters(self) -> flwr.common.ArrayRecord:
+        return self.pytorch_to_parameter_record(self.state_dict())
+
+    def set_parameters(self, parameters: flwr.common.ArrayRecord) -> None:
+        self.load_state_dict(self.parameters_to_pytorch_state_dict(parameters))
+
+    def pytorch_to_parameter_record(
+        self, state_dict: dict,
+    ) -> flwr.common.ArrayRecord:
+        """Serialise your PyTorch model."""
+        transformed_state_dict = OrderedDict()
+
+        for k, v in state_dict.items():
+            transformed_state_dict[k] = self._ndarray_to_array(v.cpu().numpy())
+
+        return flwr.common.ArrayRecord(transformed_state_dict)
+
+    def parameters_to_pytorch_state_dict(
+        self, params_record: flwr.common.ArrayRecord,
+    ) -> dict:
+        # Make sure to import locally torch as it is only available in the server
+        import torch
+
+        """Reconstruct PyTorch state_dict from its serialised representation."""
+        state_dict = {}
+        for k, v in params_record.items():
+            state_dict[k] = torch.tensor(self._basic_array_deserialisation(v))
+
+        return state_dict
+
+
+class Strategy:
+
+    def _parameters_to_dict(self, params_record: flwr.common.ArrayRecord) -> OrderedDict:
+        # Convert ParametersRecord to an OrderedDict
+        state_dict = OrderedDict()
+        for k, v in params_record.items():
+            state_dict[k] = self._basic_array_deserialisation(v)
+        return state_dict
+
+    def _dict_to_parameter_record(self, 
+        parameters: OrderedDict["str", flwr.common.NDArray],
+    ) -> flwr.common.ArrayRecord:
+        # Convert OrderedDict to ParametersRecord
+        state_dict = OrderedDict()
+        for k, v in parameters.items():
+            state_dict[k] = self._ndarray_to_array(v)
+
+        return flwr.common.ArrayRecord(state_dict)
+
+    def _ndarray_to_array(self, ndarray: flwr.common.NDArray) -> flwr.common.Array:
+        """Represent NumPy ndarray as Array."""
+        return flwr.common.Array(
+            data=ndarray.tobytes(),
+            dtype=str(ndarray.dtype),
+            stype="numpy.ndarray.tobytes",
+            shape=list(ndarray.shape),
+        )
+
+    def _basic_array_deserialisation(self, array: flwr.common.Array) -> flwr.common.NDArray:
+        # Deserialize Array to NumPy ndarray
+        return np.frombuffer(buffer=array.data, dtype=array.dtype).reshape(array.shape)
+
+    def aggregate_parameters(self, results: list[flwr.common.ArrayRecord], config: Optional[flwr.common.ConfigRecord]=None
+        ) -> flwr.common.ArrayRecord:
+            parameters = [self._parameters_to_dict(param) for param in results]
+            keys = parameters[0].keys()
+            result = OrderedDict()
+            for key in keys:
+                # Init array
+                this_array: np.ndarray = np.zeros_like(parameters[0][key])
+                for p in parameters:
+                    this_array += p[key]
+                result[key] = this_array / len(results)
+            return self._dict_to_parameter_record(result)
+
+    def aggregate_metrics(self, results: list[flwr.common.MetricRecord], config: Optional[flwr.common.ConfigRecord]=None) -> flwr.common.MetricRecord:
+            keys = results[0].keys()
+            result = OrderedDict()
+            for key in keys:
+                # Init array
+                cumsum = 0.0
+                for m in results:
+                    if not isinstance(m[key], (int, float)):
+                        raise ValueError(
+                            f"flwr.common.MetricsRecord value type not supported: {type(m[key])}"
+                        )
+                    cumsum += m[key]  # type: ignore
+                result[key] = cumsum / len(results)
+            return flwr.common.MetricRecord(result)

{fedmodelkit-0.6.1 → fedmodelkit-0.6.6}/src/FedModelKit/templates.py

@@ -24,17 +24,17 @@ def get_readme_template() -> str:
         return file.read()
     
 
-def get_server_template() -> str:
+def get_server_template(experiment_name: str) -> str:
     current_dir = os.path.dirname(__file__)
     template_path = os.path.join(current_dir, os.path.join("templates", 'server_app_template.py'))
     with open(template_path, 'r') as file:
-        return file.read()
+        return file.read().replace("EXPERIMENT_NAME", experiment_name)
     
-def get_client_template() -> str:  
+def get_client_template(experiment_name: str) -> str:  
     current_dir = os.path.dirname(__file__)
     template_path = os.path.join(current_dir, os.path.join("templates", 'client_app_template.py'))
     with open(template_path, 'r') as file:
-        return file.read()
+        return file.read().replace("EXPERIMENT_NAME", experiment_name)
     
 def get_pyproject_template(experiment_name: str) -> str:
     current_dir = os.path.dirname(__file__)
@@ -61,11 +61,11 @@ def get_init_template() -> str:
     with open(template_path, 'r') as file:
         return file.read()
     
-def get_ds_template() -> str:
+def get_ds_template(experiment_name: str) -> str:
     current_dir = os.path.dirname(__file__)
     template_path = os.path.join(current_dir, os.path.join("templates", 'ds_template.ipynb'))
     with open(template_path, 'r') as file:
-        return file.read()
+        return file.read().replace("EXPERIMENT_NAME", experiment_name)
     
 def get_images(output_folder) -> None:
     current_dir = os.path.dirname(__file__)

{fedmodelkit-0.6.1 → fedmodelkit-0.6.6}/uv.lock

@@ -476,7 +476,7 @@ wheels = [
 
 [[package]]
 name = "fedmodelkit"
-version = "0.5.0"
+version = "0.6.6"
 source = { editable = "." }
 dependencies = [
     { name = "flwr" },

fedmodelkit-0.6.1/src/FedModelKit/templates/client_app_template.py

@@ -1,49 +0,0 @@
-from flwr.client import ClientApp, NumPyClient
-from flwr.common import Context
-from loguru import logger
-
-from EXPERIMENT_NAME.task import (
-    Net,
-    evaluate,
-    get_weights,
-    load_flwr_data,
-    set_weights,
-    train,
-)
-
-
-class FlowerClient(NumPyClient):
-    def __init__(self, net, trainloader, testloader):
-        self.net = net
-        self.trainloader = trainloader
-        self.testloader = testloader
-
-    def fit(self, parameters, config):
-        set_weights(self.net, parameters)
-        train(self.net, self.trainloader)
-        return get_weights(self.net), len(self.trainloader), {}
-
-    def evaluate(self, parameters, config):
-        set_weights(self.net, parameters)
-        loss, accuracy = evaluate(self.net, self.testloader)
-        return loss, len(self.testloader), {"accuracy": accuracy}
-
-
-def client_fn(context: Context):
-    from EXPERIMENT_NAME.task import load_syftbox_dataset
-    from syft_flwr.utils import run_syft_flwr
-
-    if not run_syft_flwr():
-        logger.info("Running flwr locally")
-        train_loader, test_loader = load_flwr_data(
-            partition_id=context.node_config["partition-id"],
-            num_partitions=context.node_config["num-partitions"],
-        )
-    else:
-        logger.info("Running with syft_flwr")
-        train_loader, test_loader = load_syftbox_dataset()
-    net = Net()
-    return FlowerClient(net, train_loader, test_loader).to_client()
-
-
-app = ClientApp(client_fn=client_fn)

fedmodelkit-0.6.1/src/FedModelKit/templates/server_app_template.py

@@ -1,38 +0,0 @@
-"""fltabular: Flower Example on Adult Census Income Tabular Dataset."""
-
-from flwr.common import Context, ndarrays_to_parameters
-from flwr.server import ServerApp, ServerAppComponents, ServerConfig
-
-from EXPERIMENT_NAME.task import Net, get_weights
-
-
-def weighted_average(metrics):
-    accuracies = [num_examples * m["accuracy"] for num_examples, m in metrics]
-    examples = [num_examples for num_examples, _ in metrics]
-
-    return {"accuracy": sum(accuracies) / sum(examples)}
-
-
-def server_fn(context: Context) -> ServerAppComponents:
-    net = Net()
-    params = ndarrays_to_parameters(get_weights(net))
-
-    from pathlib import Path
-
-    from syft_flwr.strategy import FedAvgWithModelSaving
-
-    strategy = FedAvgWithModelSaving(
-        save_path=Path(__file__).parent.parent.parent / "weights",
-        fraction_fit=1.0,
-        fraction_evaluate=1.0,
-        min_available_clients=2,
-        initial_parameters=params,
-        evaluate_metrics_aggregation_fn=weighted_average,
-    )
-    num_rounds = context.run_config["num-server-rounds"]
-    config = ServerConfig(num_rounds=num_rounds)
-
-    return ServerAppComponents(config=config, strategy=strategy)
-
-
-app = ServerApp(server_fn=server_fn)

fedmodelkit-0.6.1/src/FedModelKit/templates/task_template.py

@@ -1,243 +0,0 @@
-from collections import OrderedDict
-
-import torch
-import torch.nn as nn
-import torch.optim as optim
-from flwr_datasets import FederatedDataset
-from flwr_datasets.partitioner import IidPartitioner
-from imblearn.over_sampling import SMOTE
-from loguru import logger
-from pandas import DataFrame
-from sklearn.model_selection import train_test_split
-from sklearn.preprocessing import StandardScaler
-from torch.utils.data import DataLoader, TensorDataset
-
-
-def get_device():
-    if torch.cuda.is_available():
-        return torch.device("cuda")
-    elif torch.backends.mps.is_available():
-        return torch.device("mps")
-    elif torch.xpu.is_available():
-        return torch.device("xpu")
-    else:
-        return torch.device("cpu")
-
-
-DEVICE = get_device()
-logger.info(f"Using device: {DEVICE}")
-
-
-class Net(nn.Module):
-    def __init__(self, input_dim=6):
-        super(Net, self).__init__()
-        # First layer with more units and batch normalization
-        self.layer1 = nn.Sequential(
-            nn.Linear(input_dim, 32),  # Increased from 20 to 32
-            nn.BatchNorm1d(32),  # Added batch normalization
-            nn.LeakyReLU(0.1),  # LeakyReLU instead of ReLU
-            nn.Dropout(0.2),  # Increased dropout
-        )
-
-        # Second layer with more units
-        self.layer2 = nn.Sequential(
-            nn.Linear(32, 24),  # Increased from 14 to 24
-            nn.BatchNorm1d(24),  # Added batch normalization
-            nn.LeakyReLU(0.1),
-            nn.Dropout(0.25),
-        )
-
-        # Third layer
-        self.layer3 = nn.Sequential(
-            nn.Linear(24, 16), nn.BatchNorm1d(16), nn.LeakyReLU(0.1)
-        )
-
-        # Output layer
-        self.output_layer = nn.Sequential(nn.Linear(16, 1), nn.Sigmoid())
-
-    def forward(self, x):
-        x = self.layer1(x)
-        x = self.layer2(x)
-        x = self.layer3(x)
-        x = self.output_layer(x)
-        return x
-
-
-def dataset_processing(
-    train_df: DataFrame, test_df: DataFrame
-) -> tuple[DataLoader, DataLoader]:
-    def preprocess_df(df: DataFrame) -> DataFrame:
-        columns_to_drop = ["SkinThickness", "Insulin"]
-        df_new: DataFrame = df.drop(columns_to_drop, axis=1)
-
-        # Calculate mean and median (excluding zeros)
-        mean_glucose = df_new[df_new["Glucose"] != 0]["Glucose"].mean()
-        median_bmi = df_new[df_new["BMI"] != 0]["BMI"].median()
-        median_bp = df_new[df_new["BloodPressure"] != 0]["BloodPressure"].median()
-
-        # Replace zeros values with mean/median
-        df_new.replace(
-            {
-                "Glucose": {0: mean_glucose},
-                "BMI": {0: median_bmi},
-                "BloodPressure": {0: median_bp},
-            },
-            inplace=True,
-        )
-
-        return df_new
-
-    # Preprocess both datasets
-    train_processed = preprocess_df(train_df)
-    test_processed = preprocess_df(test_df)
-
-    # Split features and labels for both sets
-    X_train = train_processed.values[:, :6]
-    y_train = train_processed.values[:, 6:]
-    X_test = test_processed.values[:, :6]
-    y_test = test_processed.values[:, 6:]
-
-    from collections import Counter
-
-    def get_minority_class_count(y):
-        return min(Counter(y.flatten()).values())
-
-    minority_count = get_minority_class_count(y_train)
-    k_neighbors = min(5, minority_count - 1) if minority_count > 1 else 1
-
-    # Resample the training data to fix the class imbalance
-    smote = SMOTE(random_state=42, k_neighbors=k_neighbors)
-    X_train_resampled, y_train_resampled = smote.fit_resample(X_train, y_train)
-
-    # Scale the data to have zero mean and unit variance
-    scaler = StandardScaler()
-    X_train_resampled = scaler.fit_transform(X_train_resampled)
-    X_test = scaler.transform(X_test)
-
-    # Convert numpy arrays to PyTorch tensors
-    X_train_tensor = torch.FloatTensor(X_train_resampled)
-    y_train_tensor = torch.FloatTensor(y_train_resampled).reshape(
-        -1, 1
-    )  # Add this reshape
-    X_test_tensor = torch.FloatTensor(X_test)
-    y_test_tensor = torch.FloatTensor(y_test).reshape(-1, 1)
-
-    # Create datasets and dataloaders
-    train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
-    test_dataset = TensorDataset(X_test_tensor, y_test_tensor)
-
-    train_loader = DataLoader(dataset=train_dataset, batch_size=10, shuffle=True)
-    test_loader = DataLoader(
-        dataset=test_dataset, batch_size=len(test_dataset), shuffle=False
-    )
-
-    return train_loader, test_loader
-
-
-def load_syftbox_dataset() -> tuple[DataLoader, DataLoader]:
-    import pandas as pd
-
-    from syft_flwr.utils import get_syftbox_dataset_path
-
-    data_dir = get_syftbox_dataset_path()
-    logger.info(f"Loading dataset from {data_dir}")
-
-    train_df = pd.read_csv(data_dir / "train.csv")
-    test_df = pd.read_csv(data_dir / "test.csv")
-
-    return dataset_processing(train_df, test_df)
-
-
-fds = None  # Cache FederatedDataset
-
-
-def load_flwr_data(
-    partition_id: int, num_partitions: int
-) -> tuple[DataLoader, DataLoader]:
-    """
-    Load the `fl-diabetes-prediction` dataset to memory
-    """
-    global fds
-    if fds is None:
-        partitioner = IidPartitioner(num_partitions=num_partitions)
-        fds = FederatedDataset(
-            dataset="khoaguin/pima-indians-diabetes-database",
-            partitioners={"train": partitioner},
-        )
-
-    partition: DataFrame = fds.load_partition(partition_id, "train").with_format(
-        "pandas"
-    )[:]
-    train_df, test_df = train_test_split(partition, test_size=0.2, random_state=95)
-
-    return dataset_processing(train_df, test_df)
-
-
-def train(model, train_loader, local_epochs=1):
-    criterion = nn.BCELoss()
-    optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=0.0005)
-    history = {"train_loss": [], "train_acc": []}
-    model.to(DEVICE)
-
-    for epoch in range(local_epochs):
-        model.train()
-        running_loss = 0.0
-        correct = 0
-        total = 0
-
-        for inputs, labels in train_loader:
-            inputs, labels = inputs.to(DEVICE), labels.to(DEVICE)
-
-            optimizer.zero_grad()
-            outputs = model(inputs)
-            loss = criterion(outputs, labels)
-            loss.backward()
-            optimizer.step()
-
-            running_loss += loss.item() * inputs.size(0)
-            predicted = (outputs > 0.5).float()
-            total += labels.size(0)
-            correct += (predicted == labels).sum().item()
-
-        epoch_loss = running_loss / len(train_loader.dataset)
-        epoch_acc = correct / total
-        history["train_loss"].append(epoch_loss)
-        history["train_acc"].append(epoch_acc)
-
-    return history
-
-
-def evaluate(model, data_loader):
-    model.to(DEVICE)
-    model.eval()
-    criterion = nn.BCELoss()
-
-    running_loss = 0.0
-    correct = 0
-    total = 0
-
-    with torch.no_grad():
-        for inputs, labels in data_loader:
-            inputs, labels = inputs.to(DEVICE), labels.to(DEVICE)
-            outputs = model(inputs)
-            loss = criterion(outputs, labels)
-            running_loss += loss.item() * inputs.size(0)
-            predicted = (outputs > 0.5).float()
-            total += labels.size(0)
-            correct += (predicted == labels).sum().item()
-
-    epoch_loss = running_loss / len(data_loader.dataset)
-    epoch_acc = correct / total
-
-    return epoch_loss, epoch_acc
-
-
-def set_weights(model, parameters):
-    params_dict = zip(model.state_dict().keys(), parameters)
-    state_dict = OrderedDict({k: torch.tensor(v) for k, v in params_dict})
-    model.load_state_dict(state_dict, strict=True)
-
-
-def get_weights(model):
-    ndarrays = [val.cpu().numpy() for _, val in model.state_dict().items()]
-    return ndarrays