Changelog

Unreleased

What’s new?

  • New built-in strategies (#549)
    • (abstract) FedOpt

    • FedAdagrad

v0.15.0 (2021-03-12)

What’s new?

  • Server-side parameter initialization (#658)

    Model parameters can now be initialized on the server-side. Server-side parameter initialization works via a new Strategy method called initialize_parameters.

    Built-in strategies support a new constructor argument called initial_parameters to set the initial parameters. Built-in strategies will provide these initial parameters to the server on startup and then delete them to free the memory afterwards.

    # Create model
    model = tf.keras.applications.EfficientNetB0(
        input_shape=(32, 32, 3), weights=None, classes=10
    )
    model.compile("adam", "sparse_categorical_crossentropy", metrics=["accuracy"])
    
    # Create strategy and initilize parameters on the server-side
    strategy = fl.server.strategy.FedAvg(
        # ... (other constructor arguments)
        initial_parameters=model.get_weights(),
    )
    
    # Start Flower server with the strategy
    fl.server.start_server("[::]:8080", config={"num_rounds": 3}, strategy=strategy)
    

    If no initial parameters are provided to the strategy, the server will continue to use the current behaviour (namely, it will ask one of the connected clients for its parameters and use these as the initial global parameters).

Deprecations

  • Deprecate flwr.server.strategy.DefaultStrategy (migrate to flwr.server.strategy.FedAvg, which is equivalent)

v0.14.0 (2021-02-18)

What’s new?

  • Generalized Client.fit and Client.evaluate return values (#610, #572, #633)

    Clients can now return an additional dictionary mapping str keys to values of the following types: bool, bytes, float, int, str. This means one can return almost arbitrary values from fit/evaluate and make use of them on the server side!

    This improvement also allowed for more consistent return types between fit and evaluate: evaluate should now return a tuple (float, int, dict) representing the loss, number of examples, and a dictionary holding arbitrary problem-specific values like accuracy.

    In case you wondered: this feature is compatible with existing projects, the additional dictionary return value is optional. New code should however migrate to the new return types to be compatible with upcoming Flower releases (fit: List[np.ndarray], int, Dict[str, Scalar], evaluate: float, int, Dict[str, Scalar]). See the example below for details.

    Code example: note the additional dictionary return values in both FlwrClient.fit and FlwrClient.evaluate:

    class FlwrClient(fl.client.NumPyClient):
        def fit(self, parameters, config):
            net.set_parameters(parameters)
            train_loss = train(net, trainloader)
            return net.get_weights(), len(trainloader), {"train_loss": train_loss}
    
        def evaluate(self, parameters, config):
            net.set_parameters(parameters)
            loss, accuracy, custom_metric = test(net, testloader)
            return loss, len(testloader), {"accuracy": accuracy, "custom_metric": custom_metric}
    
  • Generalized config argument in Client.fit and Client.evaluate (#595)

    The config argument used to be of type Dict[str, str], which means that dictionary values were expected to be strings. The new release generalizes this to enable values of the following types: bool, bytes, float, int, str.

    This means one can now pass almost arbitrary values to fit/evaluate using the config dictionary. Yay, no more str(epochs) on the server-side and int(config["epochs"]) on the client side!

    Code example: note that the config dictionary now contains non-str values in both Client.fit and Client.evaluate:

    class FlwrClient(fl.client.NumPyClient):
        def fit(self, parameters, config):
            net.set_parameters(parameters)
            epochs: int = config["epochs"]
            train_loss = train(net, trainloader, epochs)
            return net.get_weights(), len(trainloader), {"train_loss": train_loss}
    
        def evaluate(self, parameters, config):
            net.set_parameters(parameters)
            batch_size: int = config["batch_size"]
            loss, accuracy = test(net, testloader, batch_size)
            return loss, len(testloader), {"accuracy": accuracy}
    

v0.13.0 (2021-01-08)

What’s new?

  • New example: PyTorch From Centralized To Federated (#549)

  • Improved documentation
    • New documentation theme (#551)

    • New API reference (#554)

    • Updated examples documentation (#549)

    • Removed obsolete documentation (#548)

Bugfix:

  • Server.fit does not disconnect clients when finished, disconnecting the clients is now handled in flwr.server.start_server (#553, #540).

v0.12.0 (2020-12-07)

Important changes:

  • Added an example for embedded devices (#507)

  • Added a new NumPyClient (in addition to the existing KerasClient) (#504, #508)

  • Deprecated flwr_examples package and started to migrate examples into the top-level examples directory (#494, #512)

v0.11.0 (2020-11-30)

Incompatible changes:

  • Renamed strategy methods (#486) to unify the naming of Flower’s public APIs. Other public methods/functions (e.g., every method in Client, but also Strategy.evaluate) do not use the on_ prefix, which is why we’re removing it from the four methods in Strategy. To migrate rename the following Strategy methods accordingly:
    • on_configure_evaluate => configure_evaluate

    • on_aggregate_evaluate => aggregate_evaluate

    • on_configure_fit => configure_fit

    • on_aggregate_fit => aggregate_fit

Important changes:

  • Deprecated DefaultStrategy (#479). To migrate use FedAvg instead.

  • Simplified examples and baselines (#484).

  • Removed presently unused on_conclude_round from strategy interface (#483).

  • Set minimal Python version to 3.6.1 instead of 3.6.9 (#471).

  • Improved Strategy docstrings (#470).