fedbiomed.common.training_args

@classmethod
def default_scheme(cls) -> Dict:
    """
    Returns the default (base) scheme for TrainingArgs.
    """
    return {
        "optimizer_args": {
            "rules": [dict], "required": True, "default": {}
        },
        "batch_size": {
            "rules": [int], "required": True, "default": 1
        },
        "epochs": {
            "rules": [cls._nonnegative_integer_value_validator_hook('epochs')], "required": True, "default": None
        },
        "num_updates": {
            "rules": [cls._nonnegative_integer_value_validator_hook('num_updates')],
            "required": True, "default": None
        },
        "dry_run": {
            "rules": [bool], "required": True, "default": False
        },
        "batch_maxnum": {
            "rules": [cls._nonnegative_integer_value_validator_hook('batch_maxnum')],
            "required": True, "default": None
        },
        "test_ratio": {
            "rules": [float, cls._test_ratio_hook], "required": False, "default": 0.0
        },
        "test_on_local_updates": {
            "rules": [bool], "required": False, "default": False
        },
        "test_on_global_updates": {
            "rules": [bool], "required": False, "default": False
        },
        "test_metric": {
            "rules": [cls._metric_validation_hook], "required": False, "default": None
        },
        "test_metric_args": {
            "rules": [dict], "required": False, "default": {}
        },
        "log_interval": {
            "rules": [int], "required": False, "default": 10
        },
        "fedprox_mu": {
            "rules": [cls._fedprox_mu_validator], 'required': False, "default": None
        },
        "use_gpu": {
            "rules": [bool], 'required': False, "default": False
        },
        "dp_args": {
            "rules": [cls._validate_dp_args], "required": True, "default": None
        },
    }

def default_value(self, key: str) -> Any:
    """
    Returns the default value for the key.

    Args:
        key:  key

    Returns:
        value: the default value associated to the key

    Raises:
        FedbiomedUserInputError: in case of problem (invalid key or value)
    """
    if key in self._sc.scheme():
        if "default" in self._sc.scheme()[key]:
            return deepcopy(self._sc.scheme()[key]["default"])
        else:
            msg = ErrorNumbers.FB410.value + \
                  f"no default value defined for key: {key}"
            logger.critical(msg)
            raise FedbiomedUserInputError(msg)
    else:
        msg = ErrorNumbers.FB410.value + \
              f"no such key: {key}"
        logger.critical(msg)
        raise FedbiomedUserInputError(msg)

def dict(self):
    """Returns a copy of the training_args as a dictionary."""

    ta = deepcopy(self._ta)
    if 'test_metric' in ta and \
            isinstance(ta['test_metric'], MetricTypes):
        # replace MetricType value by a string
        ta['test_metric'] = ta['test_metric'].name
    return ta

def dp_arguments(self):
    """Extracts the arguments for differential privacy

    Returns:
        Contains differential privacy arguments
    """
    return self["dp_args"]

def get(self, key: str, default: Any = None) -> Any:
    """Mimics the get() method of dict, provided for backward compatibility.

    Args:
        key: a key for retrieving data fro the dictionary
        default: default value to return if key does not belong to dictionary
    """
    try:
        return deepcopy(self._ta[key])
    except KeyError:
        # TODO: test if provided defualt value is compliant with the scheme
        return default

def loader_arguments(self) -> Dict:
    """ Extracts data loader arguments

    Returns:
        Contains loader arguments for PyTorch dataloader
    """
    keys = ["batch_size"]

    return self._extract_args(keys)

def optimizer_arguments(self) -> Dict:

    return self["optimizer_args"]

def pure_training_arguments(self):
    """ Extracts the arguments that are only necessary for training_routine

    Returns:
        Contains training argument for training routine
    """

    keys = ["batch_maxnum",
            "fedprox_mu",
            "log_interval",
            "dry_run",
            "epochs",
            "use_gpu",
            "num_updates",
            "batch_size"]
    return self._extract_args(keys)

def scheme(self) -> Dict:
    """
    Returns the scheme of a TrainingArgs instance.

    The scheme is not necessarily the default_scheme (returned by TrainingArgs.default_scheme().

    Returns:
        scheme:  the current scheme used for validation
    """
    return deepcopy(self._scheme)

def testing_arguments(self) -> Dict:
    """ Extract testing arguments from training arguments

    Returns:
        Testing arguments as dictionary
    """
    keys = ['test_ratio', 'test_on_local_updates', 'test_on_global_updates',
            'test_metric', 'test_metric_args']
    return self._extract_args(keys)

def update(self, values: Dict) -> TypeVar("TrainingArgs"):
    """
    Update multiple keys of the training arguments.

    Args:
        values:  a dictionnary of (key, value) to validate/update

    Returns:
        the object itself after modification

    Raises:
        FedbiomedUserInputError: in case of bad key or value in values
    """
    for k in values:
        self.__setitem__(k, values[k])
    return self