Added configuration management using pydantic

GANDLF/configuration/README.md

@@ -0,0 +1,20 @@
+### Parameters Configuration
+We use the Pydantic library for parameter configuration. Parameters are organized by context within the base model classes described below.
+
+#### Basic Classes
+- **DefaultParameters**: Contains parameters initialized directly from the application.
+- **UserDefinedParameters**: Contains parameters that the user must define.
+##### Other Subclasses
+- **ModelConfig**: Contains parameters specific to the model.
+- **OptimizerConfig**: Contains parameters for the optimizer.
+- **SchedulerConfig**: Contains parameters for the scheduler.
+- **NestedTrainingConfig**: Contains parameters for nested training.
+- **PatchSampleConfig**: Contains parameters for the patch sampler.
+
+#### How to Define New Parameters
+To define new parameters, add new parameters directly in the classes. 
+Also, create a new BaseModel class and add it to one of the basic classes (UserDefinedParameters or DefaultParameters).
+
+If validation is required, you can define it in the validators file.
+For more details, refer to the [Pydantic documentation](https://docs.pydantic.dev/latest/).
+

GANDLF/configuration/default_config.py

@@ -0,0 +1,73 @@
+from pydantic import BaseModel, Field, AfterValidator
+from typing import Dict
+from typing_extensions import Literal, Optional, Annotated
+
+from GANDLF.configuration.validators import validate_postprocessing
+
+GRID_AGGREGATOR_OVERLAP_OPTIONS = Literal["crop", "average", "hann"]
+
+
+class DefaultParameters(BaseModel):
+    weighted_loss: bool = Field(
+        default=False, description="Whether weighted loss is to be used or not."
+    )
+    verbose: bool = Field(default=False, description="General application verbosity.")
+    q_verbose: bool = Field(default=False, description="Queue construction verbosity.")
+    medcam_enabled: bool = Field(
+        default=False, description="Enable interpretability via medcam."
+    )
+    save_training: bool = Field(
+        default=False, description="Save outputs during training."
+    )
+    save_output: bool = Field(
+        default=False, description="Save outputs during validation/testing."
+    )
+    in_memory: bool = Field(default=False, description="Pin data to CPU memory.")
+    pin_memory_dataloader: bool = Field(
+        default=False, description="Pin data to GPU memory."
+    )
+    scaling_factor: int = Field(
+        default=1, description="Scaling factor for regression problems."
+    )
+    q_max_length: int = Field(default=100, description="The max length of the queue.")
+    q_samples_per_volume: int = Field(
+        default=10, description="Number of samples per volume."
+    )
+    q_num_workers: int = Field(
+        default=4, description="Number of worker threads to use."
+    )
+    num_epochs: int = Field(default=100, description="Total number of epochs to train.")
+    patience: int = Field(
+        default=100, description="Number of epochs to wait for performance improvement."
+    )
+    batch_size: int = Field(default=1, description="Default batch size for training.")
+    learning_rate: float = Field(default=0.001, description="Default learning rate.")
+    clip_grad: Optional[float] = Field(
+        default=None, description="Gradient clipping value."
+    )
+    track_memory_usage: bool = Field(
+        default=False, description="Enable memory usage tracking."
+    )
+    memory_save_mode: bool = Field(
+        default=False,
+        description="Enable memory-saving mode. If enabled, resize/resample will save files to disk.",
+    )
+    print_rgb_label_warning: bool = Field(
+        default=True, description="Print a warning for RGB labels."
+    )
+    data_postprocessing: Annotated[
+        dict,
+        Field(description="Default data postprocessing configuration.", default={}),
+        AfterValidator(validate_postprocessing),
+    ]
+
+    grid_aggregator_overlap: GRID_AGGREGATOR_OVERLAP_OPTIONS = Field(
+        default="crop", description="Default grid aggregator overlap strategy."
+    )
+    determinism: bool = Field(
+        default=False, description="Enable deterministic computation."
+    )
+    previous_parameters: Optional[Dict] = Field(
+        default=None,
+        description="Previous parameters to be used for resuming training and performing sanity checks.",
+    )

GANDLF/configuration/differential_privacy_config.py

@@ -0,0 +1,16 @@
+from typing_extensions import Literal
+
+from pydantic import BaseModel, Field, ConfigDict
+
+ACCOUNTANT_OPTIONS = Literal["rdp", "gdp", "prv"]
+
+
+class DifferentialPrivacyConfig(BaseModel):
+    model_config = ConfigDict(extra="allow")
+    noise_multiplier: float = Field(default=10.0)
+    max_grad_norm: float = Field(default=1.0)
+    accountant: ACCOUNTANT_OPTIONS = Field(default="rdp")
+    secure_mode: bool = Field(default=False)
+    allow_opacus_model_fix: bool = Field(default=True)
+    delta: float = Field(default=1e-5)
+    physical_batch_size: int = Field(validate_default=True)

GANDLF/configuration/exclude_parameters.py

@@ -0,0 +1 @@
+exclude_parameters = {"differential_privacy"}

GANDLF/configuration/model_config.py

@@ -0,0 +1,82 @@
+from pydantic import BaseModel, model_validator, Field, AliasChoices, ConfigDict
+from typing_extensions import Self, Literal, Optional
+from typing import Union
+from GANDLF.configuration.validators import validate_class_list, validate_norm_type
+from GANDLF.models import global_models_dict
+
+# Define model architecture options
+ARCHITECTURE_OPTIONS = Literal[tuple(global_models_dict.keys())]
+# Define model norm_type options
+NORM_TYPE_OPTIONS = Literal["batch", "instance", "none"]
+# Define model final_layer options
+FINAL_LAYER_OPTIONS = Literal[
+    "sigmoid",
+    "softmax",
+    "logsoftmax",
+    "tanh",
+    "identity",
+    "logits",
+    "regression",
+    "None",
+    "none",
+]
+TYPE_OPTIONS = Literal["torch", "openvino"]
+DIMENSIONS_OPTIONS = Literal[2, 3]
+
+
+# You can define new parameters for model here. Please read the pydantic documentation.
+# It allows extra fields in model dict.
+class ModelConfig(BaseModel):
+    model_config = ConfigDict(
+        extra="allow"
+    )  #  it allows extra fields in the model dict
+    dimension: Optional[DIMENSIONS_OPTIONS] = Field(
+        description="model input dimension (2D or 3D)."
+    )
+    architecture: ARCHITECTURE_OPTIONS = Field(description="Architecture.")
+    final_layer: FINAL_LAYER_OPTIONS = Field(description="Final layer.")
+    norm_type: Optional[NORM_TYPE_OPTIONS] = Field(
+        description="Normalization type.", default="batch"
+    )  # TODO: check it again
+    base_filters: Optional[int] = Field(
+        description="Base filters.", default=None, validate_default=True
+    )  # default is 32
+    class_list: Union[list, str] = Field(default=[], description="Class list.")
+    num_channels: Optional[int] = Field(
+        description="Number of channels.",
+        validation_alias=AliasChoices(
+            "num_channels", "n_channels", "channels", "model_channels"
+        ),
+        default=3,
+    )  # TODO: check it
+    type: TYPE_OPTIONS = Field(description="Type of model.", default="torch")
+    data_type: str = Field(description="Data type.", default="FP32")
+    save_at_every_epoch: bool = Field(default=False, description="Save at every epoch.")
+    amp: bool = Field(default=False, description="Automatic mixed precision")
+    ignore_label_validation: Union[int, None] = Field(
+        default=None, description="Ignore label validation."
+    )  # TODO:  To check it
+    print_summary: bool = Field(default=True, description="Print summary.")
+
+    @model_validator(mode="after")
+    def model_validate(self) -> Self:
+        # TODO: Change the print to logging.warnings
+        self.class_list = validate_class_list(
+            self.class_list
+        )  # init and validate the class_list parameter
+        self.norm_type = validate_norm_type(
+            self.norm_type, self.architecture
+        )  # init and validate the norm type
+        if self.amp is False:
+            print("NOT using Mixed Precision Training")
+
+        if self.save_at_every_epoch:
+            print(
+                "WARNING: 'save_at_every_epoch' will result in TREMENDOUS storage usage; use at your own risk."
+            )  # TODO: It is better to use logging.warning
+
+        if self.base_filters is None:
+            self.base_filters = 32
+            print("Using default 'base_filters' in 'model': ", self.base_filters)
+
+        return self

GANDLF/configuration/nested_training_config.py

@@ -0,0 +1,25 @@
+from pydantic import BaseModel, Field, model_validator
+from typing_extensions import Self, Optional
+
+
+class NestedTraining(BaseModel):
+    stratified: bool = Field(
+        default=False,
+        description="this will perform stratified k-fold cross-validation but only with offline data splitting",
+    )
+    testing: int = Field(
+        default=-5,
+        description="this controls the number of testing data folds for final model evaluation; [NOT recommended] to disable this, use '1'",
+        le=10,
+    )
+    validation: int = Field(
+        default=-5,
+        description="this controls the number of validation data folds to be used for model *selection* during training (not used for back-propagation)",
+    )
+    proportional: Optional[bool] = Field(default=False)
+
+    @model_validator(mode="after")
+    def validate_nested_training(self) -> Self:
+        if self.proportional is not None:
+            self.stratified = self.proportional
+        return self

GANDLF/configuration/optimizer_config.py

@@ -0,0 +1,121 @@
+from typing import Tuple
+
+from pydantic import BaseModel, Field, ConfigDict
+from typing_extensions import Literal
+
+from GANDLF.optimizers import global_optimizer_dict
+
+# takes the keys from global optimizer
+OPTIMIZER_OPTIONS = Literal[tuple(global_optimizer_dict.keys())]
+
+
+class sgd_config(BaseModel):
+    momentum: float = Field(default=0.99)
+    weight_decay: float = Field(default=3e-05)
+    dampening: float = Field(default=0)
+    nesterov: bool = Field(default=True)
+
+
+class asgd_config(BaseModel):
+    alpha: float = Field(default=0.75)
+    t0: float = Field(default=1e6)
+    lambd: float = Field(default=1e-4)
+    weight_decay: float = Field(default=3e-05)
+
+
+class adam_config(BaseModel):
+    betas: Tuple[float, float] = Field(default=(0.9, 0.999))
+    weight_decay: float = Field(default=0.00005)
+    eps: float = Field(default=1e-8)
+    amsgrad: bool = Field(default=False)
+
+
+class adamax_config(BaseModel):
+    betas: Tuple[float, float] = Field(default=(0.9, 0.999))
+    weight_decay: float = Field(default=0.00005)
+    eps: float = Field(default=1e-8)
+
+
+class rprop_config(BaseModel):
+    etas: Tuple[float, float] = Field(default=(0.5, 1.2))
+    step_sizes: Tuple[float, float] = Field(default=(1e-6, 50))
+
+
+class adadelta_config(BaseModel):
+    rho: float = Field(default=0.9)
+    eps: float = Field(default=1e-6)
+    weight_decay: float = Field(default=3e-05)
+
+
+class adagrad_config(BaseModel):
+    lr_decay: float = Field(default=0)
+    eps: float = Field(default=1e-6)
+    weight_decay: float = Field(default=3e-05)
+
+
+class rmsprop_config(BaseModel):
+    alpha: float = Field(default=0.99)
+    eps: float = Field(default=1e-8)
+    centered: bool = Field(default=False)
+    momentum: float = Field(default=0)
+    weight_decay: float = Field(default=3e-05)
+
+
+class radam_config(BaseModel):
+    betas: Tuple[float, float] = Field(default=(0.9, 0.999))
+    eps: float = Field(default=1e-8)
+    weight_decay: float = Field(default=3e-05)
+    foreach: bool = Field(default=None)
+
+
+class nadam_config(BaseModel):
+    betas: Tuple[float, float] = Field(default=(0.9, 0.999))
+    eps: float = Field(default=1e-8)
+    weight_decay: float = Field(default=3e-05)
+    foreach: bool = Field(default=None)
+
+
+class novograd_config(BaseModel):
+    betas: Tuple[float, float] = Field(default=(0.9, 0.999))
+    eps: float = Field(default=1e-8)
+    weight_decay: float = Field(default=3e-05)
+    amsgrad: bool = Field(default=False)
+
+
+class ademamix_config(BaseModel):
+    pass  # TODO: Check it because the default parameters are not in the optimizer dict
+
+
+class lion_config(BaseModel):
+    betas: Tuple[float, float] = Field(default=(0.9, 0.999))
+    weight_decay: float = Field(default=0.0)
+    decoupled_weight_decay: bool = Field(default=False)
+
+
+class adopt_config(BaseModel):
+    pass  # TODO: Check it because the default parameters are not in the optimizer dict
+
+
+class OptimizerConfig(BaseModel):
+    model_config = ConfigDict(extra="allow")
+    type: OPTIMIZER_OPTIONS = Field(description="Type of optimizer to use")
+
+
+optimizer_dict_config = {
+    "sgd": sgd_config,
+    "asgd": asgd_config,
+    "adam": adam_config,
+    "adamw": adam_config,
+    "adamax": adamax_config,
+    # "sparseadam": sparseadam,
+    "rprop": rprop_config,
+    "adadelta": adadelta_config,
+    "adagrad": adagrad_config,
+    "rmsprop": rmsprop_config,
+    "radam": radam_config,
+    "novograd": novograd_config,
+    "nadam": nadam_config,
+    "ademamix": ademamix_config,
+    "lion": lion_config,
+    "adopt": adopt_config,
+}

GANDLF/configuration/parameters_config.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel, ConfigDict
+from GANDLF.configuration.user_defined_config import UserDefinedParameters
+
+
+class ParametersConfiguration(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+
+class Parameters(ParametersConfiguration, UserDefinedParameters):
+    pass

GANDLF/configuration/patch_sampler_config.py

@@ -0,0 +1,11 @@
+from pydantic import BaseModel, Field
+from typing_extensions import Literal
+
+TYPE_OPTIONS = Literal["uniform", "label"]
+
+
+class PatchSamplerConfig(BaseModel):
+    type: TYPE_OPTIONS = Field(default="uniform")
+    enable_padding: bool = Field(default=False)
+    padding_mode: str = Field(default="symmetric")
+    biased_sampling: bool = Field(default=False)

GANDLF/configuration/post_processing_config.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Any
+
+
+class PostProcessingConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid", exclude_none=True)
+    fill_holes: Any = Field(default=None)
+    mapping: dict = Field(default=None)
+    morphology: Any = Field(default=None)
+    cca: Any = Field(default=None)