Skip to content

Documentation for Stdmodelhandler Module

STDModelHandler

Bases: ModelHandler

Handles the selection and acquisition of the most up-to-date model during the discovery phase of the federation process.

This handler choose the first model received.

Inherits from

ModelHandler: Provides the base interface for model operations.

Intended Use

Used during the initial, when a node discovers others and must align itself with the most recent global model state.

Source code in nebula/core/situationalawareness/discovery/modelhandlers/stdmodelhandler.py 
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
class STDModelHandler(ModelHandler):
    """
    Handles the selection and acquisition of the most up-to-date model 
    during the discovery phase of the federation process.

    This handler choose the first model received.

    Inherits from:
        ModelHandler: Provides the base interface for model operations.

    Intended Use:
        Used during the initial, when a node discovers others and must 
        align itself with the most recent global model state.
    """

    def __init__(self):
        self.model = None
        self.rounds = 0
        self.round = 0
        self.epochs = 0
        self.model_lock = Locker(name="model_lock")
        self.params_lock = Locker(name="param_lock")

    def set_config(self, config):
        """
        Args:
            config[0] -> total rounds
            config[1] -> current round
            config[2] -> epochs
        """
        self.params_lock.acquire()
        self.rounds = config[0]
        if config[1] > self.round:
            self.round = config[1]
        self.epochs = config[2]
        self.params_lock.release()

    def accept_model(self, model):
        """
        save only first model received to set up own model later
        """
        if not self.model_lock.locked():
            self.model_lock.acquire()
            self.model = model
        return True

    async def get_model(self, model):
        """
        Returns:
            neccesary data to create trainer
        """
        if self.model is not None:
            return (self.model, self.rounds, self.round, self.epochs)
        else:
            return (None, 0, 0, 0)

    def pre_process_model(self):
        """
        no pre-processing defined
        """
        pass

accept_model(model)

save only first model received to set up own model later

Source code in nebula/core/situationalawareness/discovery/modelhandlers/stdmodelhandler.py 
42
43
44
45
46
47
48
49
def accept_model(self, model):
    """
    save only first model received to set up own model later
    """
    if not self.model_lock.locked():
        self.model_lock.acquire()
        self.model = model
    return True

get_model(model) async

Returns:

Type Description

neccesary data to create trainer
Source code in nebula/core/situationalawareness/discovery/modelhandlers/stdmodelhandler.py 
51
52
53
54
55
56
57
58
59
async def get_model(self, model):
    """
    Returns:
        neccesary data to create trainer
    """
    if self.model is not None:
        return (self.model, self.rounds, self.round, self.epochs)
    else:
        return (None, 0, 0, 0)

pre_process_model()

no pre-processing defined

Source code in nebula/core/situationalawareness/discovery/modelhandlers/stdmodelhandler.py 
61
62
63
64
65
def pre_process_model(self):
    """
    no pre-processing defined
    """
    pass

set_config(config)

Source code in nebula/core/situationalawareness/discovery/modelhandlers/stdmodelhandler.py 
28
29
30
31
32
33
34
35
36
37
38
39
40
def set_config(self, config):
    """
    Args:
        config[0] -> total rounds
        config[1] -> current round
        config[2] -> epochs
    """
    self.params_lock.acquire()
    self.rounds = config[0]
    if config[1] > self.round:
        self.round = config[1]
    self.epochs = config[2]
    self.params_lock.release()