mattizza/fl-project

Code regarding the Semantic Segmentation in Federated Learning project for the Machine Learning and Deep Learning 2022/2023 project.

fl-project's Issues

Extract style like in FDA

Implement parameters initialization

Check whether it is possible to initialize the parameters (e.g., He or Xavier) and do it eventually.

Create GTA dataset class

Enhancement of the code

Added comments and made the code cleaner.

Implement run_epoch() function

Implement run_epoch() function in order to iterate over the different epochs in a smart way inside the train().

Do hyperparameter tuning

Tune learning rate, optimizer and transforms.

Implement other transforms

Explore other alternatives, e.g. horizontal flips, change of shading, random crop, ...

Update of the train() function

Armonization of the train() function; now it includes run_epoch(), the learning curves and the optimization input.

Implement learning curves

Implement learning curves and set the granularity for the plot of the loss.

Dynamic personalization of optimizer and rate decay

Implemented an efficient way to specify the optimizer (and its hyperparameters) and the rate decay (and its hyperparameters).

Evaluate whether to fine-tune the last layers of DeepLabV3 on IDDA

CNNs make use of transfer learning. Still there may be the need to fine tuning the last layers of our model to exploit it better on IDDA. I'm putting this here because it may be something we can add to the report of the first part. We can proceed, without tuning it and recover later when we will have more free time

Comment code

Comment functions and classes.

Consider implementing Bootstrapping in the Federated scenario

We can see the clients as sort of weak learners. What one could do is to do bootstrapping or to apply a sort of ensemble method: lot of weak learners are better than a single one. Explore this and how to exploit this crowd wisdom

Prepare Slide presentation

Implement wandb

Starting code already provided. Need to implement it into the most recent version in the best way possible.

Implement the average aggregation of FedAvg

Create a method that sends just the updates of each client for each round. Ideally, if we have W_star = W - alpha x gradient, the updates are only W_star - W = alpha x gradient, i.e. how much the parameters have changed within a round. This is characteristic of FedAvg and it is also privacy-oriented.

Implement function to build optimizer/scheduler into the client

The function is already provided in centralized.py. Armonize and implement it into the clients in order to build a optimizer/scheduler for each configuration.

Debug client class

All the methods of client.py are not up to date with those of centralized. Armonization needed in order to get rid of centralized.py and keep only client.py.

Validation and test sets

Implement model evaluation with validation and test sets.

Implementation of run without using wandb

Implement function to add different transforms to the client

The goal is to shuffle the transforms and pass them as argument to the client in the config. So in the config dictionary, there should be room also for different combinations of transformations. Notice this is done only when we have just one client and we are still tuning the hyperparameters. This will be done with WandB.

Assign to each client a random number of samples and analyze the performance

In a real world scenario, clients may have different numbers of pictures in their device. This means that client A may have 30 pictures, whereas client B may store 120 instead. In order to simulate this, it is useful to randomly assign a different number of sample to each client. What happens if the clients change the distribution over time? What happens if they add/remove pictures?

Comunicazione tra trainClient e i due testClient

Per tracciare la miou sui datastet test_same_dom.txt e test_diff_dom.txt dobbiamo passare ai test client i parametri del modello man mano che viene allenato.

To Do:

• implementare train in server.py
• modificare train in client.py (centralized.py)
• creare/vedere setup function per la creazione dei client