FedLab

https://fedlab.readthedocs.io/en/master/
Admin
FedLab is a flexible federated learning framework that provides modular components for FL simulation...
Tokens:56,282
Snippets:440
Trust Score:9.6
Update:5 months ago
Show doc for...
Tokens:
Raw
### Launch Top Server for Hierarchical Example

Source: https://fedlab.readthedocs.io/en/master/examples/quick_start.html

Starts the top-level server for a hierarchical federated learning setup. This script should be run in the first terminal.

```bash
bash launch_topserver_eg.sh
```

--------------------------------

### Launch Client Group 1 for Hierarchical Example

Source: https://fedlab.readthedocs.io/en/master/examples/quick_start.html

Starts Scheduler1 and associated client groups (ordinary and serial trainers) for the hierarchical example. Run this in the second terminal.

```bash
bash launch_cgroup1_eg.sh
```

--------------------------------

### Launch Client Group 2 for Hierarchical Example

Source: https://fedlab.readthedocs.io/en/master/examples/quick_start.html

Starts Scheduler2 and associated client groups (ordinary and serial trainers) for the hierarchical example. Run this in the third terminal.

```bash
bash launch_cgroup2_eg.sh
```

--------------------------------

### Launch Hierarchical Example

Source: https://fedlab.readthedocs.io/en/master/examples/quick_start.html

Executes all scripts for the hierarchical federated learning example. This is a convenient way to start the entire multi-cluster simulation.

```bash
bash launch_eg.sh
```

--------------------------------

### Install Dependencies from Requirements

Source: https://fedlab.readthedocs.io/en/master/install.html

Install all necessary dependencies for FedLab using the provided requirements file.

```bash
pip install -r requirements.txt

```

--------------------------------

### Coordinator Class

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/core/coordinator/index.html

Initializes the Coordinator with a setup dictionary and an optional mode. The setup dictionary maps process ranks to the number of clients they manage. The mode can be 'GLOBAL' or 'LOCAL' to determine the type of ID mapping.

```APIDOC
## class Coordinator(setup_dict: dict, mode: str = 'LOCAL')

### Description
Deal with the mapping relation between client id and process rank in FL system.

### Parameters
* **setup_dict** (_dict_) – A dict like {rank:client_num …}, representing the map relation between process rank and client id.
* **mode** (_str_ _,__optional_) – “GLOBAL” and “LOCAL”. Coordinator will map client id to (rank, global id) or (rank, local id) according to mode.
```

--------------------------------

### Start FedLab Server

Source: https://fedlab.readthedocs.io/en/master/examples/quick_start.html

Launches the FedLab server process. Ensure the world_size matches the client configuration.

```bash
python server.py --ip 127.0.0.1 --port 3002 --world_size 11
```

--------------------------------

### Install FedLab via Pip

Source: https://fedlab.readthedocs.io/en/master/install.html

Install the stable version of FedLab using pip. Replace $version$ with the desired FedLab version.

```bash
pip install fedlab==$version$

```

--------------------------------

### Start FedLab Clients

Source: https://fedlab.readthedocs.io/en/master/examples/quick_start.html

Launches multiple FedLab client processes using a bash script. The script takes world_size, start rank, and end rank as arguments.

```bash
bash start_clt.sh 11 1 10
```

--------------------------------

### Preprocess Synthetic Dataset

Source: https://fedlab.readthedocs.io/en/master/examples/leaf_usage.html

Example of preprocessing the synthetic dataset with parameters for non-i.i.d. data, sampling, and train/test split.

```bash
cd fedlab_benchmarks/datasets/data/synthetic
bash ./preprocess.sh -s niid --sf 1.0 -k 5 -t sample --tf 0.6
```

--------------------------------

### Preprocess Shakespeare Dataset

Source: https://fedlab.readthedocs.io/en/master/examples/leaf_usage.html

Example of preprocessing the Shakespeare dataset, including parameters for non-i.i.d. data, sampling, and train/test split.

```bash
cd fedlab_benchmarks/datasets/data/shakespeare
bash preprocess.sh -s niid --sf 0.2 -k 0 -t sample -tf 0.8
```

--------------------------------

### Preprocess Celeba Dataset

Source: https://fedlab.readthedocs.io/en/master/examples/leaf_usage.html

Example of preprocessing the Celeba dataset with parameters for non-i.i.d. data and sampling.

```bash
cd fedlab_benchmarks/datasets/data/celeba
bash ./preprocess.sh -s niid --sf 0.05 -k 5 -t sample
```

--------------------------------

### Preprocess FEMNIST Dataset

Source: https://fedlab.readthedocs.io/en/master/examples/leaf_usage.html

Example of preprocessing the FEMNIST dataset with specific parameters for non-i.i.d. data distribution and sampling.

```bash
cd fedlab_benchmarks/datasets/data/femnist
bash preprocess.sh -s niid --sf 0.05 -k 0 -t sample
```

--------------------------------

### Preprocess Sentiment140 Dataset

Source: https://fedlab.readthedocs.io/en/master/examples/leaf_usage.html

Example of preprocessing the Sentiment140 dataset with parameters for non-i.i.d. data and sampling.

```bash
cd fedlab_benchmarks/datasets/data/sent140
bash ./preprocess.sh -s niid --sf 0.05 -k 3 -t sample
```

--------------------------------

### Dataset Partitioning Logic

Source: https://fedlab.readthedocs.io/en/master/examples/quick_start.html

This Python script demonstrates how to partition a dataset using FedLab's utility functions. It shows examples for non-I.I.D. and random slicing, saving the results to a dictionary.

```python
import torchvision
from fedlab.utils.functional import save_dict
from fedlab.utils.dataset.slicing import noniid_slicing, random_slicing

trainset = torchvision.datasets.CIFAR10(root=root, train=True, download=True)
# trainset = torchvision.datasets.MNIST(root=root, train=True, download=True)

data_indices = noniid_slicing(trainset, num_clients=100, num_shards=200)
save_dict(data_indices, "cifar10_noniid.pkl")

data_indices = random_slicing(trainset, num_clients=100)
save_dict(data_indices, "cifar10_iid.pkl")

```

--------------------------------

### Standalone FedAvg Simulation

Source: https://fedlab.readthedocs.io/en/master/examples/quick_start.html

Run this command to start a single-process simulation of the FedAvg algorithm. It configures the number of clients, communication rounds, sampling ratio, batch size, epochs, and learning rate.

```bash
$ python standalone.py --total_client 100 --com_round 3 --sample_ratio 0.1 --batch_size 100 --epochs 5 --lr 0.02
```

--------------------------------

### Client Launch Script

Source: https://fedlab.readthedocs.io/en/master/examples/quick_start.html

A bash script to launch multiple Python client processes in the background, with a delay for resource allocation. It iterates from a specified start rank to an end rank.

```bash
for ((i=$2; i<=$3; i++))
do
{
    echo "client ${i} started"
    python client.py --world_size $1 --rank ${i} &
    sleep 2s # wait for gpu resources allocation
}
done
wait

```

--------------------------------

### FedProxClientTrainer

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/algorithm/fedprox/index.html

Implements the client-side training logic for FedProx, including local SGD with a proximal term. It allows for setup of local optimization parameters and processing of local data.

```APIDOC
## Class FedProxClientTrainer

### Description
Federated client with local SGD with proximal term solver.

### Parameters
* **model** (torch.nn.Module) - Model used in this federation.
* **cuda** (bool, optional) - Whether to use GPUs. Defaults to False.
* **device** (str, optional) - Device to assign model/data to. E.g., ‘device:0’ or ‘device:0,1’. Defaults to None.
* **logger** (fedlab.utils.Logger, optional) - Logger object. Defaults to None.

### Bases
fedlab.contrib.algorithm.basic_client.SGDClientTrainer

## Method setup_optim

### Description
Set up local optimization configuration.

### Parameters
* **epochs** (int) – Local epochs.
* **batch_size** (int) – Local batch size.
* **lr** (float) – Learning rate.
* **mu** (float) - Parameter of FedProx.

## Method local_process

### Description
Manager of the upper layer will call this function with accepted payload. In synchronous mode, return True to end current FL round.

### Parameters
* **payload** - Accepted payload.
* **id** - Client ID.

## Method train

### Description
Client trains its local model on local dataset.

### Parameters
* **model_parameters** (torch.Tensor) – Serialized model parameters.
* **train_loader** (torch.utils.data.DataLoader) – `torch.utils.data.DataLoader` for this client.
* **mu** (float) – parameter of FedProx.
```

--------------------------------

### IFCAServerHander.setup_optim

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/algorithm/ifca/index.html

Sets up the optimizer for the server.

```APIDOC
## setup_optim

### Parameters
* **share_size** (__type__) – _description_
* **k** (__type__) – _description_
* **init_parameters** (__type__) – _description_
```

--------------------------------

### IFCASerialClientTrainer.setup_optim

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/algorithm/ifca/index.html

Set up local optimization configuration.

```APIDOC
## setup_optim

### Parameters
* **epochs** (_int_) – Local epochs.
* **batch_size** (_int_) – Local batch size.
* **lr** (_float_) – Learning rate.
```

--------------------------------

### IFCASerialClientTrainer.setup_dataset

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/algorithm/ifca/index.html

Override this function to set up local dataset for clients.

```APIDOC
## setup_dataset

### Parameters
* **dataset** (_description_) – _description_
```

--------------------------------

### IFCASerialClientTrainer.local_process

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/algorithm/ifca/index.html

Define the local main process.

```APIDOC
## local_process

### Parameters
* **payload** (_description_) – _description_
* **id_list** (_description_) – _description_
```

--------------------------------

### SyncServerHandler

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/algorithm/basic_server/index.html

Handles server-side operations in a synchronous federated learning setup, waiting for all clients before proceeding to the next round.

```APIDOC
## Class SyncServerHandler

### Description
Synchronous Parameter Server Handler. Backend of synchronous parameter server: this class is responsible for backend computing in synchronous server. Synchronous parameter server will wait for every client to finish local training process before the next FL round.

### Parameters
* **model** (_torch.nn.Module_) – model trained by federated learning.
* **global_round** (_int_) – stop condition. Shut down FL system when global round is reached.
* **num_clients** (_int_) – number of clients in FL. Default: 0 (initialized external).
* **sample_ratio** (_float_) – the result of `sample_ratio * num_clients` is the number of clients for every FL round.
* **cuda** (_bool_) – use GPUs or not. Default: `False`.
* **device** (_str_ _,__optional_) – assign model/data to the given GPUs. E.g., ‘device:0’ or ‘device:0,1’. Defaults to None. If device is None and cuda is True, FedLab will set the gpu with the largest memory as default.
* **sampler** (_FedSampler_ _,__optional_) – assign a sampler to define the client sampling strategy. Default: random sampling with `FedSampler`.
* **logger** (_Logger_ _,__optional_) – object of `Logger`.

### Properties
* **downlink_package** : List[torch.Tensor]
  Property for manager layer. Server manager will call this property when activates clients.
* **num_clients_per_round**
* **if_stop** : bool
  `NetworkManager` keeps monitoring this attribute, and it will stop all related processes and threads when `True` returned.

### Methods
* **sample_clients**(_num_to_sample =None_) -> List[int]
  Return a list of client rank indices selected randomly. The client ID is from `0` to `self.num_clients -1`.
* **global_update**(_buffer_)
* **load**(_payload : List[torch.Tensor]_) → bool
  Update global model with collected parameters from clients.
  Note: Server handler will call this method when its `client_buffer_cache` is full. User can overwrite the strategy of aggregation to apply on `model_parameters_list`, and use `SerializationTool.deserialize_model()` to load serialized parameters after aggregation into `self._model`.
  ### Parameters
  * **payload** (_list_ _[__torch.Tensor_ _]_) – A list of tensors passed by manager layer.
```

--------------------------------

### PartitionedCIFAR10.preprocess()

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/dataset/partitioned_cifar10/index.html

Performs FL partition on the dataset and saves each subset for each client into a local file.

```APIDOC
## def preprocess(balance=True, partition='iid', unbalance_sgm=0, num_shards=None, dir_alpha=None, verbose=True, seed=None, download=True)

### Description
Perform FL partition on the dataset, and save each subset for each client into `data{cid}.pkl` file. For details of partition schemes, please check Federated Dataset and DataPartitioner.

### Parameters
* **balance** (_bool_) – Balanced partition over all clients or not. Default as `True`.
* **partition** (_str_) – Partition type, only "iid", "shards", "dirichlet" are supported. Default as `"iid"`.
* **unbalance_sgm** (_float_) – Log-normal distribution variance for unbalanced data partition over clients. Default as `0` for balanced partition.
* **num_shards** (_int_) – Number of shards in non-iid "shards" partition. Only works if `partition="shards"`. Default as `None`.
* **dir_alpha** (_float_) – Dirichlet distribution parameter for non-iid partition. Only works if `partition="dirichlet"`. Default as `None`.
* **verbose** (_bool_) – Whether to print partition process. Default as `True`.
* **seed** (_int_) – Random seed. Default as `None`.
* **download** (_bool_) – Whether to download the raw dataset. Default as `True`.
```

--------------------------------

### PartitionCIFAR.preprocess

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/dataset/partitioned_cifar/index.html

Performs FL partition on the dataset and saves subsets for each client.

```APIDOC
## preprocess(balance=True, partition='iid', unbalance_sgm=0, num_shards=None, dir_alpha=None, verbose=True, seed=None, download=True)

### Description
Perform FL partition on the dataset, and save each subset for each client into `data{cid}.pkl` file. For details of partition schemes, please check Federated Dataset and DataPartitioner.

### Parameters
* **balance** (bool, optional) – Balanced partition over all clients or not. Default as `True`.
* **partition** (str, optional) – Partition type, only "iid", "shards", "dirichlet" are supported. Default as "iid".
* **unbalance_sgm** (float, optional) – Log-normal distribution variance for unbalanced data partition over clients. Default as `0` for balanced partition.
* **num_shards** (int, optional) – Number of shards in non-iid "shards" partition. Only works if `partition="shards"`. Default as `None`.
* **dir_alpha** (float, optional) – Dirichlet distribution parameter for non-iid partition. Only works if `partition="dirichlet"`. Default as `None`.
* **verbose** (bool, optional) – Whether to print partition process. Default as `True`.
* **seed** (int, optional) – Random seed. Default as `None`.
* **download** (bool, optional) – Whether to download the raw dataset. Default as `True`.
```

--------------------------------

### PowerofchoicePipeline

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/algorithm/powerofchoice/index.html

Pipeline for the Power of Choice algorithm, integrating the server handler and client trainer for a standalone federated learning setup.

```APIDOC
## class PowerofchoicePipeline(handler: fedlab.core.server.handler.ServerHandler, trainer: fedlab.core.client.trainer.SerialClientTrainer)

### Description
Main class for the Power of Choice pipeline.

### Methods
* **main()**: Entry point for the pipeline execution.
```

--------------------------------

### FedDynSerialClientTrainer

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/algorithm/feddyn/index.html

Handles client-side operations for the FedDyn algorithm in a serial manner. It manages local training, dataset setup, and optimization configurations.

```APIDOC
## FedDynSerialClientTrainer

### Description
Train multiple clients in a single process. Customize `_get_dataloader()` or `_train_alone()` for specific algorithm design in clients.

### Parameters
- **model** (_torch.nn.Module_): Model used in this federation.
- **num_clients** (_int_): Number of clients in current trainer.
- **cuda** (_bool_): Use GPUs or not. Default: `False`.
- **device** (_str_, optional): Assign model/data to the given GPUs. E.g., ‘device:0’ or ‘device:0,1’. Defaults to None.
- **logger** (_Logger_, optional): Object of `Logger`.
- **personal** (_bool_, optional): If True, SerialModelMaintainer will generate the copy of local parameters list and maintain them respectively. These parameters are indexed by [0, num-1]. Defaults to False.

### Methods
- `setup_dataset(dataset)`: Override this function to set up local dataset for clients.
- `setup_optim(epochs, batch_size, lr, alpha)`: Set up local optimization configuration.
  - **epochs** (_int_): Local epochs.
  - **batch_size** (_int_): Local batch size.
  - **lr** (_float_): Learning rate.
- `local_process(payload, id_list)`: Define the local main process.
- `train(id, model_parameters, train_loader)`: Single round of local training for one client.
  Note: Overwrite this method to customize the PyTorch training pipeline.
  - **model_parameters** (_torch.Tensor_): serialized model parameters.
  - **train_loader** (_torch.utils.data.DataLoader_): `torch.utils.data.DataLoader` for this client.
```

--------------------------------

### StandalonePipeline

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/core/standalone/index.html

The StandalonePipeline class is used to manage the federated learning process in a standalone setup. It requires a server handler and a serial client trainer.

```APIDOC
## class StandalonePipeline

### Description
Manages the federated learning process in a standalone environment.

### Parameters
- **handler** (fedlab.core.server.handler.ServerHandler) - The server handler for managing communication.
- **trainer** (fedlab.core.client.trainer.SerialClientTrainer) - The serial client trainer for client-side operations.

### Methods
#### main()

Starts the federated learning process.

#### evaluate()

Evaluates the performance of the federated learning model.
```

--------------------------------

### AsyncServerHandler

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/algorithm/basic_server/index.html

Handles server-side operations in an asynchronous federated learning setup, updating the global model immediately upon receiving client updates.

```APIDOC
## Class AsyncServerHandler

### Description
Asynchronous Parameter Server Handler. Update global model immediately after receiving a ParameterUpdate message.

### Parameters
* **model** (_torch.nn.Module_) – Global model in server
* **global_round** (_int_) – stop condition. Shut down FL system when global round is reached.
* **num_clients** (_int_) – number of clients in FL.
* **cuda** (_bool_) – Use GPUs or not.
* **device** (_str_ _,__optional_) – Assign model/data to the given GPUs. E.g., ‘device:0’ or ‘device:0,1’. Defaults to None. If device is None and cuda is True, FedLab will set the gpu with the largest memory as default.
* **logger** (_Logger_ _,__optional_) – Object of `Logger`.

### Properties
* **if_stop** : bool
  `NetworkManager` keeps monitoring this attribute, and it will stop all related processes and threads when `True` returned.
* **downlink_package**
  Property for manager layer. Server manager will call this property when activates clients.

### Methods
* **setup_optim**(_alpha_ , _strategy ='constant'_, _a =10_, _b =4_)
  Setup optimization configuration.
  ### Parameters
  * **alpha** (_float_) – Weight used in async aggregation.
  * **strategy** (_str_ _,__optional_) – Adaptive strategy. `constant`, `hinge` and `polynomial` is optional. Default: `constant`.. Defaults to ‘constant’.
  * **a** (_int_ _,__optional_) – Parameter used in async aggregation.. Defaults to 10.
  * **b** (_int_ _,__optional_) – Parameter used in async aggregation.. Defaults to 4.
* **global_update**(_buffer_)
* **load**(_payload : List[torch.Tensor]_) → bool
  Override this function to define how to update global model (aggregation or optimization).
* **adapt_alpha**(_receive_model_time_)
  update the alpha according to staleness.
```

--------------------------------

### Create Pickle Dataset for Leaf

Source: https://fedlab.readthedocs.io/en/master/examples/leaf_usage.html

Run this script to convert raw Leaf datasets into pickle files for faster data loading. Ensure you have downloaded the raw data and specify the correct data root and save root paths.

```bash
cd fedlab_benchmarks/leaf/process_data
python create_pickle_dataset.py --data_root "../../datasets" --save_root "./pickle_dataset" --dataset_name "shakespeare"
```

--------------------------------

### Download Dataset Script

Source: https://fedlab.readthedocs.io/en/master/examples/quick_start.html

Navigate to the dataset directory and run the download script for MNIST or CIFAR10. Ensure you are in the correct directory before execution.

```bash
$ cd fedlab_benchamrks/datasets/{mnist or cifar10}/
$ python download_{dataset}.py
```

--------------------------------

### FedDataset

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/dataset/index.html

Base class for all datasets in FedLab. It provides methods for preprocessing and retrieving data, including abstract methods for getting datasets and dataloaders.

```APIDOC
## class FedDataset

Bases: `object`

### Methods

`preprocess()`
    Define the dataset partition process

`_get_dataset(_id_ , _type ='train'_)`
    Get dataset class

    Parameters:
        * **id** (_int_) – Client ID for the partial dataset to achieve.
        * **type** (_str_ _,__optional_) – Type of dataset, can be chosen from `["train", "val", "test"]`. Defaults as `"train"`.

    Raises:
        **NotImplementedError**

`_get_dataloader(_id_ , _batch_size_ , _type ='train'_)`
    Get data loader

`__len__()`
    
```

--------------------------------

### Get LEAF Dataloader

Source: https://fedlab.readthedocs.io/en/master/examples/leaf_usage.html

This function retrieves PyTorch Dataloaders for LEAF datasets. It supports 'femnist' and 'shakespeare' datasets and requires a client ID for partitioning.

```python
from leaf.dataloader import get_LEAF_dataloader
def get_femnist_shakespeare_dataset(args):
    if args.dataset == 'femnist' or args.dataset == 'shakespeare':
        trainloader, testloader = get_LEAF_dataloader(dataset=args.dataset,
                                                      client_id=args.rank)
    else:
        raise ValueError("Invalid dataset:", args.dataset)

    return trainloader, testloader
```

--------------------------------

### setup_seed(_seed_)

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/utils/functional/index.html

Sets the random seed for reproducibility.

```APIDOC
def setup_seed(_seed_):
    """Sets the random seed for reproducibility."""
    pass
```

--------------------------------

### Partition Dataset Script

Source: https://fedlab.readthedocs.io/en/master/examples/quick_start.html

Run this script to generate partition files for the dataset. It supports both random and non-I.I.D. slicing methods.

```bash
$ python {dataset}_partition.py
```

--------------------------------

### __getitem__

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/utils/dataset/index.html

Obtain sample indices for a specific client.

```APIDOC
## __getitem__(_index_)

### Description
Obtain sample indices for client `index`.

### Parameters
* **index** (_int_) – Client ID.

### Returns
List of sample indices for client ID `index`.

### Return type
list
```

--------------------------------

### SGDClientTrainer

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/algorithm/basic_client/index.html

Client backend handler that provides data process methods to the upper layer. It manages model parameters, dataset setup, optimization configuration, and local processing logic.

```APIDOC
## SGDClientTrainer

### Description
Client backend handler, this class provides data process method to upper layer.

### Parameters
* **model** (_torch.nn.Module_) – PyTorch model.
* **cuda** (_bool_, optional) – use GPUs or not. Default: `False`.
* **device** (_str_, optional) – Assign model/data to the given GPUs. E.g., ‘device:0’ or ‘device:0,1’. Defaults to None.
* **logger** (_Logger_, optional) – :object of `Logger`.

### Methods
* **uplink_package** (_property_) – Return a tensor list for uploading to server. This attribute will be called by client manager. Customize it for new algorithms.
* **setup_dataset** (_method_) – Set up local dataset `self.dataset` for clients.
* **setup_optim** (_method_) – Set up local optimization configuration.
    * Parameters:
        * **epochs** (_int_) – Local epochs.
        * **batch_size** (_int_) – Local batch size.
        * **lr** (_float_) – Learning rate.
* **local_process** (_method_) – Manager of the upper layer will call this function with accepted payload. In synchronous mode, return True to end current FL round.
* **train** (_method_) – Client trains its local model on local dataset.
    * Parameters:
        * **model_parameters** (_torch.Tensor_) – Serialized model parameters.
        * **train_loader** (_torch.utils.data.DataLoader_) – `torch.utils.data.DataLoader` for this client.
```

--------------------------------

### __str__ Method

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/core/coordinator/index.html

Returns a string representation of the Coordinator object.

```APIDOC
## __str__() -> str

### Description
Return str(self).
```

--------------------------------

### RotatedMNIST Class

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/dataset/rotated_mnist/index.html

The RotatedMNIST class allows users to load and partition the rotated MNIST dataset for federated learning experiments. It inherits from FedDataset and provides methods for preprocessing, getting specific client datasets, and creating data loaders.

```APIDOC
## class RotatedMNIST(root, path, num_clients)

### Description
Rotate MNIST and partition them.

### Parameters
* **root** (str) – Path to download raw dataset.
* **path** (str) – Path to save partitioned subdataset.
* **num_clients** (int) – Number of clients.

### Methods
#### preprocess(thetas=[0, 90, 180, 270], download=True)
Define the dataset partition process.

#### get_dataset(id, type='train')
Get dataset class.

Parameters:
* **id** (int) – Client ID for the partial dataset to achieve.
* **type** (str, optional) – Type of dataset, can be chosen from `["train", "val", "test"]`. Defaults as `"train"`.

Raises:
**NotImplementedError**

#### get_data_loader(id, batch_size=None, type='train')
Get data loader for a specific client.
```

--------------------------------

### switch Method

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/core/coordinator/index.html

This method is available but its specific functionality is not detailed in the provided documentation.

```APIDOC
## switch()

### Description
This method is part of the Coordinator class.
```

--------------------------------

### _FedDynServerHandler

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/algorithm/index.html

FedDyn server handler implementation.

```APIDOC
## _FedDynServerHandler

### Description
FedDyn server handler.

### Methods
- `setup_optim(alpha)`: Override this function to load your optimization hyperparameters.
- `global_update(buffer)`: Handles the global model update based on client updates.
```

--------------------------------

### IFCASerialClientTrainer

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/algorithm/ifca/index.html

Train multiple clients in a single process. Customize `_get_dataloader()` or `_train_alone()` for specific algorithm design in clients.

```APIDOC
## IFCASerialClientTrainer

### Description
Train multiple clients in a single process. Customize `_get_dataloader()` or `_train_alone()` for specific algorithm design in clients.

### Parameters
* **model** (_torch.nn.Module_) – Model used in this federation.
* **num_clients** (_int_) – Number of clients in current trainer.
* **cuda** (_bool_) – Use GPUs or not. Default: `False`.
* **device** (_str_ _,__optional_) – Assign model/data to the given GPUs. E.g., ‘device:0’ or ‘device:0,1’. Defaults to None.
* **logger** (_Logger_ _,__optional_) – Object of `Logger`.
* **personal** (_bool_ _,__optional_) – If Ture is passed, SerialModelMaintainer will generate the copy of local parameters list and maintain them respectively. These paremeters are indexed by [0, num-1]. Defaults to False.
```

--------------------------------

### init_network_connection()

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/core/network/index.html

Initializes the torch.distributed communication group.

```APIDOC
## init_network_connection()

### Description
Initialize `torch.distributed` communication group
```

--------------------------------

### PartitionedMNIST.preprocess

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/dataset/partitioned_mnist/index.html

Performs FL partition on the dataset and saves each subset for each client.

```APIDOC
## def preprocess(self, partition='iid', dir_alpha=None, verbose=True, seed=None, download=True, transform=None, target_transform=None)

### Description
Perform FL partition on the dataset, and save each subset for each client into `data{cid}.pkl` file. For details of partition schemes, please check Federated Dataset and DataPartitioner.

### Parameters
* **partition** (_str_ _,__optional_) – Partition name. Only supports `"noniid-#label"`, `"noniid-labeldir"`, `"unbalance"` and `"iid"` partition schemes. Default as `'iid'`.
* **dir_alpha** (_float_ _,__optional_) – Dirichlet distribution parameter for non-iid partition. Only works if `partition="dirichlet"`. Default as `None`.
* **verbose** (_bool_ _,__optional_) – Whether to print partition process. Default as `True`.
* **seed** (_int_ _,__optional_) – Random seed. Default as `None`.
* **download** (_bool_) – Whether to download the raw dataset. Default as `True`.
* **transform** (_callable_ _,__optional_) – A function/transform that takes in an PIL image and returns a transformed version.
* **target_transform** (_callable_ _,__optional_) – A function/transform that takes in the target and transforms it.
```

--------------------------------

### _FedNovaServerHandler

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/algorithm/index.html

FedNova server handler implementation.

```APIDOC
## _FedNovaServerHandler

### Description
FedNova server handler.

### Methods
- `setup_optim(option='weighted_scale')`: Override this function to load your optimization hyperparameters.
- `global_update(buffer)`: Handles the global model update based on client updates.
```

--------------------------------

### PartitionCIFAR Class

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/dataset/partitioned_cifar/index.html

Initializes a partitioned CIFAR dataset with various partitioning schemes.

```APIDOC
## class PartitionCIFAR(root, path, dataname, num_clients, download=True, preprocess=False, balance=True, partition='iid', unbalance_sgm=0, num_shards=None, dir_alpha=None, verbose=True, seed=None, transform=None, target_transform=None)

### Description
`FedDataset` with partitioning preprocess. For detailed partitioning, please check Federated Dataset and DataPartitioner.

### Parameters
* **root** (str) – Path to download raw dataset.
* **path** (str) – Path to save partitioned subdataset.
* **dataname** (str) – “cifar10” or “cifar100”
* **num_clients** (int) – Number of clients.
* **download** (bool, optional) – Whether to download the raw dataset. Default as `True`.
* **preprocess** (bool, optional) – Whether to preprocess the dataset. Default as `False`.
* **balance** (bool, optional) – Balanced partition over all clients or not. Default as `True`.
* **partition** (str, optional) – Partition type, only "iid", "shards", "dirichlet" are supported. Default as "iid".
* **unbalance_sgm** (float, optional) – Log-normal distribution variance for unbalanced data partition over clients. Default as `0` for balanced partition.
* **num_shards** (int, optional) – Number of shards in non-iid "shards" partition. Only works if `partition="shards"`. Default as `None`.
* **dir_alpha** (float, optional) – Dirichlet distribution parameter for non-iid partition. Only works if `partition="dirichlet"`. Default as `None`.
* **verbose** (bool, optional) – Whether to print partition process. Default as `True`.
* **seed** (int, optional) – Random seed. Default as `None`.
* **transform** (callable, optional) – A function/transform that takes in an PIL image and returns a transformed version.
* **target_transform** (callable, optional) – A function/transform that takes in the target and transforms it.
```

--------------------------------

### Clone FedLab Repository

Source: https://fedlab.readthedocs.io/en/master/contributing.html

Clone your fork of the FedLab repository to your local machine. Ensure you navigate into the cloned directory.

```bash
git clone git@github.com:YourLogin/FedLab.git
cd FedLab
```

--------------------------------

### ScaffoldSerialClientTrainer

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/algorithm/scaffold/index.html

Train multiple clients in a single process using the Scaffold algorithm.

```APIDOC
## ScaffoldSerialClientTrainer

### Description
Train multiple clients in a single process using the Scaffold algorithm. Customize `_get_dataloader()` or `_train_alone()` for specific algorithm design in clients.

### Parameters
* **model** (torch.nn.Module) - Model used in this federation.
* **num_clients** (int) - Number of clients in current trainer.
* **cuda** (bool, optional) - Use GPUs or not. Default: `False`.
* **device** (str, optional) - Assign model/data to the given GPUs. E.g., ‘device:0’ or ‘device:0,1’. Defaults to None.
* **logger** (Logger, optional) - Object of `Logger`.
* **personal** (bool, optional) - If True, `SerialModelMaintainer` will generate the copy of local parameters list and maintain them respectively. These parameters are indexed by [0, num-1]. Defaults to False.

### Methods
#### `setup_optim(epochs, batch_size, lr)`
Set up local optimization configuration.

* **Parameters**:
  * **epochs** (int) - Local epochs.
  * **batch_size** (int) - Local batch size.
  * **lr** (float) - Learning rate.

#### `local_process(payload, id_list)`
Define the local main process.

* **Parameters**:
  * **payload** - Data payload for local processing.
  * **id_list** (list) - List of client IDs.

#### `train(id, model_parameters, global_c, train_loader)`
Single round of local training for one client.

* **Note**: Overwrite this method to customize the PyTorch training pipeline.

* **Parameters**:
  * **id** (int) - The ID of the client.
  * **model_parameters** (torch.Tensor) - Serialized model parameters.
  * **global_c** (torch.Tensor) - Global control variates.
  * **train_loader** (torch.utils.data.DataLoader) - `torch.utils.data.DataLoader` for this client.
```

--------------------------------

### Cross-Process Simulation Script Details

Source: https://fedlab.readthedocs.io/en/master/examples/quick_start.html

This script launches the server and client processes for a cross-process FedAvg simulation. It specifies IP addresses, ports, world size, and client ranks for communication.

```bash
python server.py --ip 127.0.0.1 --port 3001 --world_size 3 --round 3 &

python client.py --ip 127.0.0.1 --port 3001 --world_size 3 --rank 1 &

python client.py --ip 127.0.0.1 --port 3001 --world_size 3 --rank 2  &

wait

```

--------------------------------

### Read Configuration from JSON

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/utils/functional/index.html

Reads network configuration (IP, port, world size, rank) for a specified user from a JSON file. Useful for setting up distributed training environments.

```python
read_config_from_json(‘../../../tests/data/config.json’, ‘server’)
```

--------------------------------

### partition_report(targets, data_indices, class_num=None, verbose=True, file=None)

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/utils/functional/index.html

Generates a data partition report detailing the class distribution and dataset size for each client based on provided data indices.

```APIDOC
def partition_report(targets, data_indices, class_num=None, verbose=True, file=None):
    """Generate data partition report for clients in `data_indices`. 
    Generate data partition report for each client according to `data_indices`, including ratio of each class and dataset size in current client. Report can be printed in screen or into file. The output format is comma-separated values which can be read by `pandas.read_csv()` or `csv.reader()`. 

    Parameters:
      * **targets** (_list_ _or_ _numpy.ndarray_) – Targets for all data samples, with each element is in range of `0` to `class_num-1`.
      * **data_indices** (_dict_) – Dict of `client_id: [data indices]`.
      * **class_num** (_int_ _,__optional_) – Total number of classes. If set to `None`, then `class_num = max(targets) + 1`.
      * **verbose** (_bool_ _,__optional_) – Whether print data partition report in screen. Default as `True`.
      * **file** (_str_ _,__optional_) – Output file name of data partition report. If `None`, then no output in file. Default as `None`.

    Examples:
      First generate synthetic data labels and data partition to obtain `data_indices` (`{ client_id: sample indices}`):
      ```
      >>> sample_num = 15
      >>> class_num = 4
      >>> clients_num = 3
      >>> num_per_client = int(sample_num/clients_num)
      >>> labels = np.random.randint(class_num, size=sample_num)  # generate 15 labels, each label is 0 to 3
      >>> rand_per = np.random.permutation(sample_num)
      >>> # partition synthetic data into 3 clients
      >>> data_indices = {0: rand_per[0:num_per_client],
      ...                 1: rand_per[num_per_client:num_per_client*2],
      ...                 2: rand_per[num_per_client*2:num_per_client*3]}
      ```

      Check `data_indices` may look like:
      ```
      >>> data_indices
      {0: array([8, 6, 5, 7, 2]),
       1: array([ 3, 10, 14,  4,  1]),
       2: array([13,  9, 12, 11,  0])}
      ```

      Now generate partition report for each client and each class:
      ```
      >>> partition_report(labels, data_indices, class_num=class_num, verbose=True, file=None)
      Class frequencies:
      client,class0,class1,class2,class3,Amount
      Client   0,0.200,0.00,0.200,0.600,5
      Client   1,0.400,0.200,0.200,0.200,5
      Client   2,0.00,0.400,0.400,0.200,5
      ```
    """
    pass
```

--------------------------------

### _FedProxServerHandler

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/algorithm/index.html

FedProx server handler implementation.

```APIDOC
## _FedProxServerHandler

### Description
FedProx server handler.
```

--------------------------------

### ClientManager

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/core/client/manager/index.html

Base class for ClientManager. It defines client activation in different communication stages and requires network and trainer configurations.

```APIDOC
## ClientManager

### Description
Base class for ClientManager. `ClientManager` defines client activation in different communication stages.

### Parameters
* **network** (_DistNetwork_) – Network configuration and interfaces.
* **trainer** (_ModelMaintainer_) – Subclass of `ClientTrainer` or `SerialClientTrainer`. Provides `local_process()` and `uplink_package()`. Define local client training procedure.

### Methods
#### setup()
Initialization stage. `ClientManager` reports number of clients simulated by current client process.
```

--------------------------------

### ClientManager

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/core/client/index.html

Base class for client managers. It handles client activation in different communication stages and requires network and trainer configurations.

```APIDOC
## class ClientManager(network: fedlab.core.network.DistNetwork, trainer: fedlab.core.model_maintainer.ModelMaintainer)

### Description
Base class for ClientManager. `ClientManager` defines client activation in different communication stages.

### Parameters
* **network** (_DistNetwork_) – Network configuration and interfaces.
* **trainer** (_ModelMaintainer_) – Subclass of `ClientTrainer` or `SerialClientTrainer`. Provides `local_process()` and `uplink_package`. Define local client training procedure.

### Methods
#### setup()
Initialization stage. `ClientManager` reports number of clients simulated by current client process.
```

--------------------------------

### ClientTrainer

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/core/client/trainer/index.html

An abstract class representing a client trainer. Subclasses must implement `local_process()` and `uplink_package`.

```APIDOC
## class ClientTrainer(model: torch.nn.Module, cuda: bool, device: str = None)

### Description
An abstract class representing a client trainer. In FedLab, this class manages the client's local model and requires subclasses to implement `local_process()` for model updates and `uplink_package` for uploading model parameters.

### Parameters
* **model** (_torch.nn.Module_) – PyTorch model.
* **cuda** (_bool_) – Whether to use GPUs.
* **device** (_str_, optional) – Specifies the GPU device(s) to use (e.g., ‘device:0’). Defaults to `None`.

### Abstract Properties
* **uplink_package** (_List[torch.Tensor]_) – Returns a list of tensors to be uploaded to the server.

### Abstract Methods
* **setup_dataset()**
  Set up local dataset `self.dataset` for clients.
* **setup_optim()**
  Set up variables for optimization algorithms.
* **local_process(payload: List[torch.Tensor])**
  Manager of the upper layer will call this function with accepted payload. In synchronous mode, return True to end current FL round.
* **_train()**
  Override this method to define the training procedure. This function should manipulate `self._model`.
* **_validate()**
  Validate quality of local model.
* **_evaluate()**
  Evaluate quality of local model.
```

--------------------------------

### FedProxSerialClientTrainer

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/algorithm/fedprox/index.html

Enables training multiple clients within a single process using the FedProx algorithm. This is useful for scenarios where parallel client simulation is desired.

```APIDOC
## Class FedProxSerialClientTrainer

### Description
Train multiple clients in a single process. Customize `_get_dataloader()` or `_train_alone()` for specific algorithm design in clients.

### Parameters
* **model** (torch.nn.Module) – Model used in this federation.
* **num_clients** (int) – Number of clients in current trainer.
* **cuda** (bool, optional) – Use GPUs or not. Default: `False`.
* **device** (str, optional) – Assign model/data to the given GPUs. E.g., ‘device:0’ or ‘device:0,1’. Defaults to None.
* **logger** (Logger, optional) – Object of `Logger`. Defaults to None.
* **personal** (bool, optional) – If True, SerialModelMaintainer will generate and maintain copies of local parameters. Defaults to False.

### Bases
fedlab.contrib.algorithm.basic_client.SGDSerialClientTrainer

## Method setup_optim

### Description
Set up local optimization configuration.

### Parameters
* **epochs** (int) – Local epochs.
* **batch_size** (int) – Local batch size.
* **lr** (float) – Learning rate.
* **mu** (float) - Parameter of FedProx.

## Method local_process

### Description
Define the local main process.

### Parameters
* **payload** - Accepted payload.
* **id_list** (list) - List of client IDs.

## Method train

### Description
Client trains its local model on local dataset.

### Parameters
* **model_parameters** (torch.Tensor) – Serialized model parameters.
* **train_loader** (torch.utils.data.DataLoader) – `torch.utils.data.DataLoader` for this client.
* **mu** (float) – parameter of FedProx.
```

--------------------------------

### PartitionedMNIST Class

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/dataset/partitioned_mnist/index.html

Initializes the PartitionedMNIST dataset with specified parameters for federated learning.

```APIDOC
## class PartitionedMNIST(FedDataset)

### Description
`FedDataset` with partitioning preprocess. For detailed partitioning, please check Federated Dataset and DataPartitioner.

### Parameters
* **root** (_str_) – Path to download raw dataset.
* **path** (_str_) – Path to save partitioned subdataset.
* **num_clients** (_int_) – Number of clients.
* **download** (_bool_) – Whether to download the raw dataset.
* **preprocess** (_bool_) – Whether to preprocess the dataset.
* **partition** (_str_ _,__optional_) – Partition name. Only supports `"noniid-#label"`, `"noniid-labeldir"`, `"unbalance"` and `"iid"` partition schemes.
* **dir_alpha** (_float_ _,__optional_) – Dirichlet distribution parameter for non-iid partition. Only works if `partition="dirichlet"`. Default as `None`.
* **verbose** (_bool_ _,__optional_) – Whether to print partition process. Default as `True`.
* **seed** (_int_ _,__optional_) – Random seed. Default as `None`.
* **transform** (_callable_ _,__optional_) – A function/transform that takes in an PIL image and returns a transformed version.
* **target_transform** (_callable_ _,__optional_) – A function/transform that takes in the target and transforms it.
```

--------------------------------

### IFCAServerHander

Source: https://fedlab.readthedocs.io/en/master/autoapi/fedlab/contrib/algorithm/ifca/index.html

Synchronous Parameter Server Handler. This class is responsible for backend computing in a synchronous parameter server, waiting for all clients to finish local training before proceeding to the next FL round.

```APIDOC
## IFCAServerHander

### Description
Synchronous Parameter Server Handler. Backend of synchronous parameter server: this class is responsible for backend computing in synchronous server. Synchronous parameter server will wait for every client to finish local training process before the next FL round.

### Parameters
* **model** (_torch.nn.Module_) – model trained by federated learning.
* **global_round** (_int_) – stop condition. Shut down FL system when global round is reached.
* **num_clients** (_int_) – number of clients in FL. Default: 0 (initialized external).
* **sample_ratio** (_float_) – the result of `sample_ratio * num_clients` is the number of clients for every FL round.
* **cuda** (_bool_) – use GPUs or not. Default: `False`.
* **device** (_str_ _,__optional_) – assign model/data to the given GPUs. E.g., ‘device:0’ or ‘device:0,1’. Defaults to None. If device is None and cuda is True, FedLab will set the gpu with the largest memory as default.
* **sampler** (_FedSampler_ _,__optional_) – assign a sampler to define the client sampling strategy. Default: random sampling with `FedSampler`.
* **logger** (_Logger_ _,__optional_) – object of `Logger`.
```
Tokens:
Raw