BaseValidator

Bases: BaseConfig

Base class for initializing classification, criterion, tuning, and HPO.

This class extends BaseConfig and validates classification types, evaluation criteria, and tuning methods.

Inherits

• BaseLoader: Provides loading and saving capabilities for processed data.

Parameters:

Name	Type	Description	Default
classification	str	Type of classification, either 'binary' or 'multiclass'.	required
criterion	str	Evaluation criterion (e.g., 'f1', 'macro_f1').	required
tuning	Optional[str]	Tuning method, either 'holdout' or 'cv'. Defaults to None.	None
hpo	Optional[str]	Hyperparameter optimization type, either 'rs' or 'hebo'. Defaults to None.	None

Attributes:

Name	Type	Description
classification	str	Type of classification, either 'binary' or 'multiclass'.
criterion	str	Evaluation criterion for model performance.
tuning	Optional[str]	Tuning method ('holdout' or 'cv').
hpo	Optional[str]	Type of hyperparameter optimization ('rs' or 'hebo').

Raises:

Type	Description
ValueError	If the classification, criterion, or tuning method is invalid.

Example

validator = BaseValidator(classification="binary", criterion="f1")
print(validator.criterion)

Source code in periomod/base.py

class BaseValidator(BaseConfig):
    """Base class for initializing classification, criterion, tuning, and HPO.

    This class extends `BaseConfig` and validates classification types, evaluation
    criteria, and tuning methods.

    Inherits:
        - `BaseLoader`: Provides loading and saving capabilities for processed data.

    Args:
        classification (str): Type of classification, either 'binary' or 'multiclass'.
        criterion (str): Evaluation criterion (e.g., 'f1', 'macro_f1').
        tuning (Optional[str], optional): Tuning method, either 'holdout' or 'cv'.
            Defaults to None.
        hpo (Optional[str], optional): Hyperparameter optimization type, either 'rs' or
            'hebo'. Defaults to None.

    Attributes:
        classification (str): Type of classification, either 'binary' or 'multiclass'.
        criterion (str): Evaluation criterion for model performance.
        tuning (Optional[str]): Tuning method ('holdout' or 'cv').
        hpo (Optional[str]): Type of hyperparameter optimization ('rs' or 'hebo').

    Raises:
        ValueError: If the classification, criterion, or tuning method is invalid.

    Example:
        ```
        validator = BaseValidator(classification="binary", criterion="f1")
        print(validator.criterion)
        ```
    """

    def __init__(
        self,
        classification: str,
        criterion: str,
        tuning: Optional[str] = None,
        hpo: Optional[str] = None,
    ) -> None:
        """Initializes BaseValidator method for with validation functions for inputs."""
        super().__init__()
        self.classification = classification
        self.criterion = criterion
        self.hpo = hpo
        self.tuning = tuning
        self._validate_classification()
        self._validate_hpo()
        self._validate_criterion()
        self._validate_tuning()

    def _validate_classification(self) -> None:
        """Validates the classification type for the model.

        Raises:
            ValueError: If `self.classification` is not 'binary' or 'multiclass'.

        Expected classification types:
            - 'binary'
            - 'multiclass'
        """
        if self.classification.lower().strip() not in ["binary", "multiclass"]:
            raise ValueError(
                f"{self.classification} is an invalid classification type. "
                f"Choose 'binary' or 'multiclass'."
            )

    def _validate_hpo(self) -> None:
        """Validates the hyperparameter optimization (HPO) type.

        Raises:
            ValueError: If `self.hpo` is not None, 'rs', or 'hebo'.

        Supported HPO types:
            - None
            - 'rs' (Random Search)
            - 'hebo' (Heteroscedastic Bayesian Optimization)
        """
        if self.hpo not in [None, "rs", "hebo"]:
            raise ValueError(
                f"{self.hpo} is an unsupported HPO type. Choose 'rs' or 'hebo'."
            )

    def _validate_criterion(self) -> None:
        """Validates the evaluation criterion for model performance.

        Raises:
            ValueError: If `self.criterion` is not a supported evaluation metrics.

        Supported evaluation criteria:
            - 'f1'
            - 'macro_f1'
            - 'brier_score'
        """
        if self.criterion not in ["f1", "macro_f1", "brier_score"]:
            raise ValueError(
                "Unsupported criterion. Choose either 'f1', 'macro_f1', or "
                "'brier_score'."
            )

    def _validate_tuning(self) -> None:
        """Validates the tuning method for hyperparameter optimization.

        Raises:
            ValueError: If `self.tuning` is not None, 'holdout', or 'cv'.

        Supported tuning methods:
            - None
            - 'holdout'
            - 'cv' (Cross-Validation)
        """
        if self.tuning not in [None, "holdout", "cv"]:
            raise ValueError(
                "Unsupported tuning method. Choose either 'holdout' or 'cv'."
            )

__init__(classification, criterion, tuning=None, hpo=None)

Initializes BaseValidator method for with validation functions for inputs.

Source code in periomod/base.py

def __init__(
    self,
    classification: str,
    criterion: str,
    tuning: Optional[str] = None,
    hpo: Optional[str] = None,
) -> None:
    """Initializes BaseValidator method for with validation functions for inputs."""
    super().__init__()
    self.classification = classification
    self.criterion = criterion
    self.hpo = hpo
    self.tuning = tuning
    self._validate_classification()
    self._validate_hpo()
    self._validate_criterion()
    self._validate_tuning()