GANDLF 0.1.3.dev20250202__py3-none-any.whl → 0.1.6.dev20251109__py3-none-any.whl

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=0, 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 SgdConfig(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 AsgdConfig(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 AdamConfig(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 AdamaxConfig(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 RpropConfig(BaseModel):
+    etas: Tuple[float, float] = Field(default=(0.5, 1.2))
+    step_sizes: Tuple[float, float] = Field(default=(1e-6, 50))
+
+
+class AdadeltaConfig(BaseModel):
+    rho: float = Field(default=0.9)
+    eps: float = Field(default=1e-6)
+    weight_decay: float = Field(default=3e-05)
+
+
+class AdagradConfig(BaseModel):
+    lr_decay: float = Field(default=0)
+    eps: float = Field(default=1e-6)
+    weight_decay: float = Field(default=3e-05)
+
+
+class RmspropConfig(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 RadamConfig(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 NadamConfig(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 NovogradConfig(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 AdemamixConfig(BaseModel):
+    pass
+
+
+class LionConfig(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 AdoptConfig(BaseModel):
+    pass
+
+
+class OptimizerConfig(BaseModel):
+    model_config = ConfigDict(extra="allow")
+    type: OPTIMIZER_OPTIONS = Field(description="Type of optimizer to use")
+
+
+optimizer_dict_config = {
+    "sgd": SgdConfig,
+    "asgd": AsgdConfig,
+    "adam": AdamConfig,
+    "adamw": AdamConfig,
+    "adamax": AdamaxConfig,
+    # "sparseadam": sparseadam,
+    "rprop": RpropConfig,
+    "adadelta": AdadeltaConfig,
+    "adagrad": AdagradConfig,
+    "rmsprop": RmspropConfig,
+    "radam": RadamConfig,
+    "novograd": NovogradConfig,
+    "nadam": NadamConfig,
+    "ademamix": AdemamixConfig,
+    "lion": LionConfig,
+    "adopt": AdoptConfig,
+}

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)

GANDLF/configuration/pre_processing_config.py

@@ -0,0 +1,94 @@
+from pydantic import BaseModel, ConfigDict, Field, AliasChoices, model_validator
+from typing_extensions import Any, Literal, Self
+
+
+class ThresholdConfig(BaseModel):
+    min: int = Field()
+    max: int = Field()
+
+
+class ClipConfig(BaseModel):
+    min: int = Field()
+    max: int = Field()
+
+
+class RescaleConfig(BaseModel):
+    in_min_max: list[float] = Field(default=[15, 125])
+    out_min_max: list[float] = Field(default=[0, 1])
+    percentiles: list[float] = Field(default=[5, 95])
+
+
+class HistogramMatchingConfig(BaseModel):
+    num_hist_level: int = Field(default=1024)
+    num_match_points: int = Field(default=16)
+    target: Any = Field(default=None)
+
+
+class ResampleMinConfig(BaseModel):
+    resolution: list[float] = Field(default=None)
+
+
+class ResampleConfig(BaseModel):
+    resolution: list[float] = Field(default=None)
+
+
+class StainNormalizationConfig(BaseModel):
+    target: Any = Field()
+    extractor: Literal["vahadane", "ruifrok", "macenko"] = Field(default="ruifrok")
+
+
+class PreProcessingConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid", exclude_none=True)
+    to_canonical: Any = Field(default=None)
+    threshold: ThresholdConfig = Field(default=None)
+    clip: ClipConfig = Field(default=None)
+    clamp: ClipConfig = Field(default=None)
+    crop_external_zero_planes: Any = Field(default=None)
+    crop: list[int] = Field(default=None)
+    centercrop: list[int] = Field(default=None)
+    normalize_by_val: Any = Field(default=None)
+    normalize_imagenet: Any = Field(default=None)
+    normalize_standardize: Any = Field(default=None)
+    normalize_div_by_255: Any = Field(default=None)
+    normalize: Any = Field(default=None)
+    normalize_nonZero: Any = Field(
+        default=None,
+        validation_alias=AliasChoices("normalize_nonZero", "normalize_nonzero"),
+    )
+    normalize_nonZero_masked: Any = Field(
+        default=None,
+        validation_alias=AliasChoices(
+            "normalize_nonZero_masked", "normalize_nonzero_masked"
+        ),
+    )
+    rescale: RescaleConfig = Field(default=None)
+    rgba2rgb: Any = Field(
+        default=None,
+        validation_alias=AliasChoices("rgba2rgb", "rgbatorgb", "rgba_to_rgb"),
+    )
+    rgb2rgba: Any = Field(
+        default=None,
+        validation_alias=AliasChoices("rgb2rgba", "rgbtorgba", "rgb_to_rgba"),
+    )
+    histogram_matching: HistogramMatchingConfig = Field(default=None)
+    histogram_equalization: HistogramMatchingConfig = Field(default=None)
+    adaptive_histogram_equalization: Any = Field(default=None)
+    resample: ResampleConfig = Field(default=None)
+    resize_image: list[int] = Field(
+        default=None,
+        validation_alias=AliasChoices(
+            "resize_image", "resize", "resize_image", "resize_images"
+        ),
+    )
+    resize_patch: list[int] = Field(default=None)
+    stain_normalization: StainNormalizationConfig = Field(default=None)
+    resample_min: ResampleMinConfig = Field(
+        default=None, validation_alias=AliasChoices("resample_min", "resample_minimum")
+    )
+
+    @model_validator(mode="after")
+    def pre_processing_validate(self) -> Self:
+        if self.adaptive_histogram_equalization is not None:
+            self.histogram_matching = HistogramMatchingConfig(target="adaptive")
+            self.adaptive_histogram_equalization = None
+        return self

GANDLF/configuration/scheduler_config.py

@@ -0,0 +1,92 @@
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Literal, Union
+from GANDLF.schedulers import global_schedulers_dict
+
+TYPE_OPTIONS = Literal[tuple(global_schedulers_dict.keys())]
+
+
+class BaseTriangleConfig(BaseModel):
+    min_lr: float = Field(default=(10**-3))
+    max_lr: float = Field(default=1)
+    step_size: float = Field(description="step_size", default=None)
+
+
+class TriangleModifiedConfig(BaseModel):
+    min_lr: float = Field(default=0.000001)
+    max_lr: float = Field(default=0.001)
+    max_lr_multiplier: float = Field(default=1.0)
+    step_size: float = Field(description="step_size", default=None)
+
+
+class CyclicLrBaseConfig(BaseModel):
+    # More details https://pytorch.org/docs/stable/generated/torch.optim.lr_scheduler.CyclicLR.html
+    min_lr: float = Field(
+        default=None
+    )  # The default value is calculated according the learning rate  * 0.001
+    max_lr: float = Field(default=None)  # calculate in the validation stage
+    gamma: float = Field(default=0.1)
+    scale_mode: Literal["cycle", "iterations"] = Field(default="cycle")
+    cycle_momentum: bool = Field(default=False)
+    base_momentum: float = Field(default=0.8)
+    max_momentum: float = Field(default=0.9)
+    step_size: float = Field(description="step_size", default=None)
+
+
+class ExpConfig(BaseModel):
+    gamma: float = Field(default=0.1)
+
+
+class StepConfig(BaseModel):
+    gamma: float = Field(default=0.1)
+    step_size: float = Field(description="step_size", default=None)
+
+
+class CosineannealingConfig(BaseModel):
+    # More details https://pytorch.org/docs/stable/generated/torch.optim.lr_scheduler.CosineAnnealingWarmRestarts.html
+    T_0: int = Field(default=5)
+    T_mult: float = Field(default=1)
+    min_lr: float = Field(default=0.001)
+
+
+class ReduceOnPlateauConfig(BaseModel):
+    # More details https://pytorch.org/docs/stable/generated/torch.optim.lr_scheduler.ReduceLROnPlateau.html
+    min_lr: Union[float, list] = Field(default=None)
+    gamma: float = Field(default=0.1)
+    mode: Literal["min", "max"] = Field(default="min")
+    factor: float = Field(default=0.1)
+    patience: int = Field(default=10)
+    threshold: float = Field(default=0.0001)
+    cooldown: int = Field(default=0)
+    threshold_mode: Literal["rel", "abs"] = Field(default="rel")
+
+
+class WarmupcosinescheduleConfig(BaseModel):
+    # More details https://docs.monai.io/en/stable/optimizers.html#monai.optimizers.WarmupCosineSchedule
+    warmup_steps: int = Field(default=None)
+
+
+# It allows extra parameters
+class SchedulerConfig(BaseModel):
+    model_config = ConfigDict(extra="allow")
+    type: TYPE_OPTIONS = Field(description="scheduler type")
+
+
+# Define the type and the scheduler base model class
+schedulers_dict_config = {
+    "triangle": BaseTriangleConfig,
+    "triangle_modified": TriangleModifiedConfig,
+    "triangular": CyclicLrBaseConfig,
+    "exp_range": CyclicLrBaseConfig,
+    "exp": ExpConfig,
+    "exponential": ExpConfig,
+    "step": StepConfig,
+    "reduce_on_plateau": ReduceOnPlateauConfig,
+    "reduce-on-plateau": ReduceOnPlateauConfig,
+    "plateau": ReduceOnPlateauConfig,
+    "reduceonplateau": ReduceOnPlateauConfig,
+    "cosineannealingwarmrestarts": CosineannealingConfig,
+    "cosineannealing": CosineannealingConfig,
+    "cosineannealinglr": CosineannealingConfig,
+    "warmupcosineschedule": WarmupcosinescheduleConfig,
+    "wcs": WarmupcosinescheduleConfig,
+}

GANDLF/configuration/user_defined_config.py

@@ -0,0 +1,131 @@
+from typing import Union
+from pydantic import BaseModel, model_validator, Field, AfterValidator
+from GANDLF.configuration.default_config import DefaultParameters
+from GANDLF.configuration.differential_privacy_config import DifferentialPrivacyConfig
+from GANDLF.configuration.nested_training_config import NestedTraining
+from GANDLF.configuration.optimizer_config import OptimizerConfig
+from GANDLF.configuration.patch_sampler_config import PatchSamplerConfig
+from GANDLF.configuration.scheduler_config import SchedulerConfig
+from GANDLF.utils import version_check
+from importlib.metadata import version
+from typing_extensions import Self, Literal, Annotated
+from GANDLF.configuration.validators import (
+    validate_scheduler,
+    validate_optimizer,
+    validate_loss_function,
+    validate_metrics,
+    validate_data_preprocessing,
+    validate_patch_size,
+    validate_parallel_compute_command,
+    validate_patch_sampler,
+    validate_data_augmentation,
+    validate_data_postprocessing_after_reverse_one_hot_encoding,
+    validate_differential_privacy,
+)
+from GANDLF.configuration.model_config import ModelConfig
+
+
+class Version(BaseModel):
+    minimum: str
+    maximum: str
+
+    @model_validator(mode="after")
+    def validate_version(self) -> Self:
+        if version_check(self.model_dump(), version_to_check=version("GANDLF")):
+            return self
+
+
+class InferenceMechanismConfig(BaseModel):
+    grid_aggregator_overlap: Literal["crop", "average"] = Field(default="crop")
+    patch_overlap: int = Field(default=0)
+
+
+class UserDefinedParameters(DefaultParameters):
+    version: Version = Field(
+        default=Version(minimum=version("GANDLF"), maximum=version("GANDLF")),
+        description="GANDLF version",
+    )
+    patch_size: Union[list[Union[int, float]], int, float] = Field(
+        description="Patch size."
+    )
+    model: ModelConfig = Field(description="The model to use. ")
+    modality: Literal["rad", "histo", "path"] = Field(description="Modality.")
+    loss_function: Annotated[
+        Union[dict, str],
+        Field(description="Loss function."),
+        AfterValidator(validate_loss_function),
+    ]
+    metrics: Annotated[
+        Union[dict, list[Union[str, dict, set]]],
+        Field(description="Metrics."),
+        AfterValidator(validate_metrics),
+    ]
+    nested_training: NestedTraining = Field(description="Nested training.")
+    parallel_compute_command: str = Field(
+        default="", description="Parallel compute command."
+    )
+    scheduler: Union[str, SchedulerConfig] = Field(
+        description="Scheduler.", default=SchedulerConfig(type="triangle_modified")
+    )
+    optimizer: Union[str, OptimizerConfig] = Field(
+        description="Optimizer.", default=OptimizerConfig(type="adam")
+    )
+    patch_sampler: Union[str, PatchSamplerConfig] = Field(
+        description="Patch sampler.", default=PatchSamplerConfig()
+    )
+    inference_mechanism: InferenceMechanismConfig = Field(
+        description="Inference mechanism.", default=InferenceMechanismConfig()
+    )
+    data_postprocessing_after_reverse_one_hot_encoding: dict = Field(
+        description="data_postprocessing_after_reverse_one_hot_encoding.", default={}
+    )
+    differential_privacy: Union[bool, DifferentialPrivacyConfig] = Field(
+        description="Differential privacy.", default=None
+    )
+    clip_mode: Literal["norm", "value"] = Field(
+        description="Clip mode.", default="norm"
+    )
+    data_preprocessing: Annotated[
+        dict,
+        Field(description="Data preprocessing."),
+        AfterValidator(validate_data_preprocessing),
+    ] = {}
+    data_augmentation: Annotated[dict, Field(description="Data augmentation.")] = {}
+
+    # Validators
+    @model_validator(mode="after")
+    def validate(self) -> Self:
+        # validate the patch_size
+        self.patch_size, self.model.dimension = validate_patch_size(
+            self.patch_size, self.model.dimension
+        )
+        # validate the parallel_compute_command
+        self.parallel_compute_command = validate_parallel_compute_command(
+            self.parallel_compute_command
+        )
+        # validate scheduler
+        self.scheduler = validate_scheduler(
+            self.scheduler, self.learning_rate, self.num_epochs
+        )
+        # validate optimizer
+        self.optimizer = validate_optimizer(self.optimizer)
+        # validate patch_sampler
+        self.patch_sampler = validate_patch_sampler(self.patch_sampler)
+        # validate_data_augmentation
+        self.data_augmentation = validate_data_augmentation(
+            self.data_augmentation, self.patch_size
+        )
+        # validate data_postprocessing_after_reverse_one_hot_encoding
+        (
+            self.data_postprocessing_after_reverse_one_hot_encoding,
+            self.data_postprocessing,
+        ) = validate_data_postprocessing_after_reverse_one_hot_encoding(
+            self.data_postprocessing_after_reverse_one_hot_encoding,
+            self.data_postprocessing,
+        )
+        # validate differential_privacy
+        self.differential_privacy = validate_differential_privacy(
+            self.differential_privacy, self.batch_size
+        )
+
+        return self