`fluke`¶

The fluke module is the entry module of the fluke framework. Here are defined generic classes used by the other modules.

Submodules

`algorithms`	This module contains (as submodules) the implementation of several the federated learning algorithms.
`data`	This module contains the data utilities for `fluke`.
`comm`	This module contains the classes for the communication between the clients and the server.
`client`	The module `fluke.client` provides the base classes for the clients in `fluke`.
`evaluation`	This module contains the definition of the evaluation classes used to perform the evaluation of the model client-side and server-side.
`nets`	This module contains the definition of several neural networks used in state-of-the-art federated learning papers.
`server`	The module `fluke.server` provides the base classes for the servers in `fluke`.
`utils`	This module contains utility functions and classes used in `fluke`.

Classes included in `fluke`

`DDict`	A dictionary that can be accessed with dot notation recursively.
`FlukeCache`	A cache class that can store data on disk.
`FlukeCache._ObjectRef`	A reference to an object in the cache.
`FlukeCache._RefCounter`	A reference counter for an object in the cache.
`FlukeENV`	Environment class for the `fluke` framework.
`ObserverSubject`	Subject class for the observer pattern.
`Singleton`	This metaclass is used to create singleton classes.

Classes¶

class `fluke.DDict`

class fluke.DDict(*args: dict, **kwargs: dict[str, Any])[source]¶

Bases: dict

A dictionary that can be accessed with dot notation recursively.

Important

The DDict is a subclass of the built-in dict class and it behaves like a dictionary. However, the keys must be strings.

Example

d = DDict(a=1, b=2, c={'d': 3, 'e': 4})
print(d.a)  # 1
print(d.b)  # 2
print(d.c.d)  # 3
print(d.c.e)  # 4

diff(other: DDict) → DDict[source]¶

Get the difference between two DDict.

Parameters:: other (DDict) – The other DDict.
Returns:: The difference between the two DDict.
Return type:: DDict

Example

d = DDict(a=1, b=2, c=3)
e = DDict(a=1, b=3, c=4)
print(d.diff(e)) # {'b': 3, 'c': 4}

exclude(*keys: str)[source]¶

Create a new DDict excluding the specified keys.

Parameters:: *keys – The keys to be excluded.
Returns:: The new DDict.
Return type:: DDict

Example

d = DDict(a=1, b=2, c=3)
e = d.exclude('b', 'c')
print(e) # {'a': 1}

match(other: DDict, full: bool = True) → bool[source]¶

Check if the two DDict match.

Parameters:

other (DDict) – The other DDict.
full (bool) – If True, the two DDict must match exactly. If False, the other DDict must be a subset of the current DDict.

Returns:

Whether the two DDict match.

Return type:

bool

update(*args: dict, **kwargs: dict[str, Any])[source]¶

Update the DDict with the specified key-value pairs.

Parameters:

*args (dict) – Dictionary with the key-value pairs.
**kwargs – The key-value pairs.

Example

d = DDict(a=1)
print(d) # {'a': 1}
d.update(b=2, c=3)
print(d) # {'a': 1, 'b': 2, 'c': 3}

class `fluke.FlukeCache`

class fluke.FlukeCache(path: str, **kwargs)[source]¶

Bases: object

A cache class that can store data on disk.

property cache_dir: str¶

Get the cache directory.

Returns:: The cache directory.
Return type:: str

cleanup() → None[source]¶

Clean up the cache by removing the objects that are not referenced.

This operation should not be necessary if the cache is used correctly.

close() → None[source]¶: Close the cache.

delete(key: str) → None[source]¶

Remove an object from the cache without returning it.

If the key is not in the cache, nothing happens.

Parameters:: key (str) – The key of the object.

get(key: str, default: Any = None)[source]¶

Get the object identified by the key from the cache.

If the object is not in the cache, the default value is returned.

Note

The object is still in the cache after this operation.

Parameters:

key (str) – The key of the object.
default (Any, optional) – The default value to return if the object is not in the cache. Defaults to None.

Returns:

The object in the cache or the default value.

Return type:

Any

property occupied: int¶

Get the number of different objects in the cache.

Returns:: The number of objects in the cache.
Return type:: int

pop(key: str, copy: bool = True) → Any[source]¶

Pop an object from the cache given its key.

If the key is not in the cache, None is returned.

Parameters:

key (str) – The key of the object.
copy (bool, optional) – If True, a copy of the object is returned. Defaults to True.

Returns:

The object in the cache or its copy.

Return type:

Any

push(key: str, value: Any) → _ObjectRef[source]¶

Push an object to the cache.

Note

If the object that is pushed is already a cache reference, then the referenced object is already in the cache and its reference counter is incremented.

Parameters:

key (str) – The key of the object.
value (Any) – The object to store in the cache.

Returns:

The reference to the object in the cache.

Return type:

FlukeCache._ObjectRef

private class `fluke.FlukeCache._ObjectRef`

class fluke.FlukeCache._ObjectRef¶

Bases: object

A reference to an object in the cache. The reference is a unique identifier that is used to store and retrieve the object from the cache.

property id: str¶

Get the unique identifier of the reference.

Returns:: The unique identifier.
Return type:: str

private class `fluke.FlukeCache._RefCounter`

class fluke.FlukeCache._RefCounter(value: Any, refs: int = 1)¶

Bases: object

A reference counter for an object in the cache.

dec() → Any¶

Decrement the number of references to the object in the cache.

Returns:: The reference counter.
Return type:: FlukeCache._RefCounter

property id: _ObjectRef¶

Get the unique identifier of the reference.

Returns:: The unique identifier.
Return type:: str

inc() → _RefCounter¶

Increment the number of references to the object in the cache.

Returns:: The reference counter.
Return type:: FlukeCache._RefCounter

property refs: int¶

Get the number of references to the object in the cache.

Returns:: The number of references.
Return type:: int

property value: Any¶

Get the value ppinted by the reference.

Returns:: The value.
Return type:: Any

class `fluke.FlukeENV`

class fluke.FlukeENV(*args, **kwargs: dict[str, Any])[source]¶

Bases: object

Environment class for the fluke framework. This class is a singleton and it contains environment settings that are used by the other classes. The environment includes:

The device ("cpu", "cuda[:N]", "auto", "mps");
The seed for reproducibility;
If the models are stored in memory or on disk (when not in use);
The evaluation configuration;
The saving settings;
The progress bars for the federated learning process, clients and the server;
The live renderer, which is used to render the progress bars.

auto_device() → device[source]¶

Set device to cuda or mps if available, otherwise cpu.

Returns:: The device.
Return type:: torch.device

close_cache() → None[source]¶: Close the cache.

configure(cfg: DDict) → None[source]¶

Configure the global settings.

Parameters:: config (DDict) – The configuration.

force_close() → None[source]¶: Force close the progress bars and the live renderer.

get_cache() → FlukeCache[source]¶

Get the cache.

Returns:: The cache.
Return type:: Cache

get_device() → device[source]¶

Get the current device.

Returns:: The device.
Return type:: torch.device

get_eval_cfg() → DDict[source]¶

Get the evaluation configuration.

Returns:: The evaluation configuration.
Return type:: DDict

get_evaluator() → Evaluator[source]¶

Get the evaluator.

Returns:: The evaluator.
Return type:: Evaluator

get_live_renderer() → Live[source]¶

Get the live renderer. The live renderer is used to render the progress bars.

Returns:: The live renderer.
Return type:: Live

get_progress_bar(progress_type: str) → Progress[source]¶

Get the progress bar. The possible progress bar types are:

FL: The progress bar for the federated learning process.
clients: The progress bar for the clients.
server: The progress bar for the server.

Parameters:: progress_type (str) – The type of progress bar.
Returns:: The progress bar.
Return type:: Progress
Raises:: ValueError – If the progress bar type is invalid.

get_save_options() → tuple[str, int, bool][source]¶

Get the save options.

Returns:: The save path, the save frequency and the global only flag.
Return type:: tuple[str, int, bool]

get_seed() → int[source]¶

Get the seed.

Returns:: The seed.
Return type:: int

is_inmemory() → bool[source]¶

Check if the data is stored in memory.

Returns:: If True, the data is stored in memory, otherwise it is stored on disk.
Return type:: bool

open_cache(path: str) → None[source]¶

Open the cache at the specified path if the inmemory flag is False.

Note

The full path to the cache is tmp/path where path is the specified path. We suggest to use as path the UUID of the experiment.

Parameters:: path (str) – The path to the cache.

set_device(device: str) → device[source]¶

Set the device. The device can be cpu, auto, mps, cuda or cuda:N, where N is the GPU index.

Parameters:: device (str) – The device as string.
Returns:: The selected device as torch.device.
Return type:: torch.device

set_eval_cfg(cfg: DDict) → None[source]¶

Set the evaluation configuration.

Parameters:: cfg (DDict) – The evaluation configuration.

set_evaluator(evaluator: Evaluator) → None[source]¶

Set the evaluator.

Parameters:: evaluator (Evaluator) – The evaluator.

set_inmemory(inmemory: bool) → None[source]¶

Set if the data is stored in memory.

Parameters:: inmemory (bool) – If True, the data is stored in memory, otherwise it is stored on disk.

set_save_options(path: str | None = None, save_every: int | None = None, global_only: bool | None = None) → None[source]¶

Set the save options.

Parameters:

path (str) – The path to save the checkpoints.
save_every (int) – The frequency of saving the checkpoints.
global_only (bool) – If True, only the global model is saved.

set_seed(seed: int) → None[source]¶

Set seed for reproducibility. The seed is used to set the random seed for the following libraries: torch, torch.cuda, numpy, random.

Parameters:: seed (int) – The seed.

interface `fluke.ObserverSubject`

class fluke.ObserverSubject[source]¶

Bases: object

Subject class for the observer pattern. The subject is the class that is observed and thus it holds the observers.

Example

class MySubject(ObserverSubject):
    def __init__(self):
        super().__init__()
        self._data = 0

    @property
    def data(self):
        return self._data

    @data.setter
    def data(self, value):
        self._data = value
        self.notify()

class MyObserver:
    def __init__(self, subject):
        subject.attach(self)

    def update(self):
        print("Data changed.")

subject = MySubject()
observer = MyObserver(subject)
subject.data = 1  # "Data changed."

attach(observer: Any | Iterable[Any])[source]¶

Attach one or more observers.

Parameters:: observer (Union[Any, Iterable[Any]]) – The observer or a list of observers.

detach(observer: Any)[source]¶

Detach an observer.

Parameters:: observer (Any) – The observer to be detached.

metaclass `fluke.Singleton`

class fluke.Singleton[source]¶

Bases: type

This metaclass is used to create singleton classes. A singleton class is a class that can have only one instance. If the instance does not exist, it is created; otherwise, the existing instance is returned.

Example

class MyClass(metaclass=Singleton):
    pass
a = MyClass()
b = MyClass()
print(a is b)  # True

fluke¶

Submodules

Classes included in fluke

Classes¶

class fluke.DDict

class fluke.FlukeCache

private class fluke.FlukeCache._ObjectRef

private class fluke.FlukeCache._RefCounter

class fluke.FlukeENV

interface fluke.ObserverSubject

metaclass fluke.Singleton

`fluke`¶

Classes included in `fluke`

class `fluke.DDict`

class `fluke.FlukeCache`

private class `fluke.FlukeCache._ObjectRef`

private class `fluke.FlukeCache._RefCounter`

class `fluke.FlukeENV`

interface `fluke.ObserverSubject`

metaclass `fluke.Singleton`