code/config/experiment_config.py

"""
Experiment Configuration System
Handles experiment parameters for training and evaluation
"""

import ast
from dataclasses import dataclass
from typing import List, Dict, Any
import os


# Per-model defaults for pretrained_weights and single_target_strategy.
# These are sourced from the experimentation plan used in the published results.
# Users can override both via --pretrained_weights and --single_target_strategy CLI flags.
MODEL_DEFAULTS: Dict[str, Dict[str, str]] = {
    "ResNet-18":   {"pretrained_weights": "ImageNet", "single_target_strategy": "Direct classification head"},
    "ResNet-34":   {"pretrained_weights": "ImageNet", "single_target_strategy": "Direct classification head"},
    "DenseNet-121":{"pretrained_weights": "ImageNet", "single_target_strategy": "Direct classification head"},
    "EfficientNet-B0": {"pretrained_weights": "ImageNet", "single_target_strategy": "Direct classification head"},
    "ViT-Small (DINOv2)": {"pretrained_weights": "DINOv2 (self-supervised)",  "single_target_strategy": "CLS token classification"},
    "Swin Transformer-Base": {"pretrained_weights": "ImageNet-22K", "single_target_strategy": "CLS token classification"},
    "ResNet-50 (RadImageNet)": {"pretrained_weights": "RadImageNet", "single_target_strategy": "Direct classification head"},
}

DEFAULT_AUGMENTATION_PARAMS: Dict[str, Any] = {
    "rotation": 15,
    "horizontal_flip": True,
    "random_crop": True,
    "color_jitter": True,
    "brightness": 0.2,
    "contrast": 0.2,
    "imagenet_norm": True,
}

DEFAULT_AUGMENTATIONS = DEFAULT_AUGMENTATION_PARAMS.copy()


def get_model_defaults(model_name: str) -> Dict[str, str]:
    """
    Return the default pretrained_weights and single_target_strategy for a given model.
    Falls back to ImageNet weights and Direct classification head for unknown models.
    """
    return MODEL_DEFAULTS.get(
        model_name,
        {"pretrained_weights": "ImageNet", "single_target_strategy": "Direct classification head"}
    )


@dataclass
class ExperimentConfig:
    """Configuration for a single experiment"""

    # Model configuration
    model: str
    loss_function: str
    must_include: bool
    learning_rate: List[float]
    batch_size: int
    weight_decay: float
    optimizer: str
    scheduler: str

    # Training configuration
    image_augmentations: Dict[str, Any]
    dropout: float
    loss_specific_params: str
    multi_target_strategy: str
    single_target_strategy: str
    pretrained_weights: str
    fine_tuning_strategy: str

    # System configuration
    expected_gpu_memory: str
    architectural_family: str
    class_weighting: str
    sampling_strategy: str
    threshold_selection: str

    # Additional configuration
    experiment_name: str = ""
    output_dir: str = ""

    # GradNorm configuration
    use_gradnorm: bool = False
    gradnorm_alpha: float = 0.16
    gradnorm_update_freq: int = 10

    def __post_init__(self):
        """Process configuration after initialization"""
        if isinstance(self.learning_rate, str):
            try:
                self.learning_rate = ast.literal_eval(self.learning_rate)
            except (ValueError, SyntaxError):
                try:
                    self.learning_rate = [float(self.learning_rate)]
                except ValueError:
                    self.learning_rate = [1e-4]

        if not isinstance(self.learning_rate, list):
            self.learning_rate = [self.learning_rate]

        self.image_augmentations = normalize_augmentation_params(self.image_augmentations)

        if not self.experiment_name:
            self.experiment_name = self._generate_experiment_name()

    def _generate_experiment_name(self) -> str:
        """Generate a unique experiment name based on configuration"""
        import datetime

        model_clean = self.model.replace('/', '_').replace(' ', '_').replace('(', '').replace(')', '')
        lr_str = f"lr{self.learning_rate[0]:.0e}" if len(self.learning_rate) == 1 else "lr_sweep"
        batch_str = f"bs{self.batch_size}"

        ft_suffix = ""
        if "frozen" in self.fine_tuning_strategy.lower() or "probe" in self.fine_tuning_strategy.lower():
            ft_suffix = "_frozen"
        elif "partial" in self.fine_tuning_strategy.lower():
            ft_suffix = "_partial"

        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
        return f"{model_clean}_{lr_str}_{batch_str}{ft_suffix}_{timestamp}"

    def get_output_directory(self, base_dir: str) -> str:
        """Get the output directory for this experiment"""
        if self.output_dir:
            return self.output_dir
        return os.path.join(base_dir, self.experiment_name)

    def to_dict(self) -> Dict[str, Any]:
        """Convert configuration to dictionary"""
        learning_rate_value = self.learning_rate[0] if len(self.learning_rate) == 1 else self.learning_rate

        return {
            'model': self.model,
            'loss_function': self.loss_function,
            'must_include': self.must_include,
            'learning_rate': learning_rate_value,
            'batch_size': self.batch_size,
            'weight_decay': self.weight_decay,
            'optimizer': self.optimizer,
            'scheduler': self.scheduler,
            'image_augmentations': self.image_augmentations,
            'dropout': self.dropout,
            'loss_specific_params': self.loss_specific_params,
            'multi_target_strategy': self.multi_target_strategy,
            'single_target_strategy': self.single_target_strategy,
            'pretrained_weights': self.pretrained_weights,
            'fine_tuning_strategy': self.fine_tuning_strategy,
            'expected_gpu_memory': self.expected_gpu_memory,
            'architectural_family': self.architectural_family,
            'class_weighting': self.class_weighting,
            'sampling_strategy': self.sampling_strategy,
            'threshold_selection': self.threshold_selection,
            'experiment_name': self.experiment_name,
        }


def normalize_augmentation_params(aug_input: Any) -> Dict[str, Any]:
    """Normalize augmentation params into a validated parameter dictionary."""
    aug_params = DEFAULT_AUGMENTATION_PARAMS.copy()

    if aug_input is None:
        return aug_params

    if isinstance(aug_input, str):
        try:
            parsed = ast.literal_eval(aug_input)
        except (ValueError, SyntaxError) as exc:
            raise ValueError(
                "image_augmentations must be a dict (or a dict-like string), "
                "not a free-form text description."
            ) from exc
        aug_input = parsed

    if not isinstance(aug_input, dict):
        raise ValueError("image_augmentations must be a dictionary of augmentation params.")

    aug_params.update(aug_input)

    # Enforce expected types
    aug_params["rotation"] = int(aug_params["rotation"])
    aug_params["horizontal_flip"] = bool(aug_params["horizontal_flip"])
    aug_params["random_crop"] = bool(aug_params["random_crop"])
    aug_params["color_jitter"] = bool(aug_params["color_jitter"])
    aug_params["brightness"] = float(aug_params["brightness"])
    aug_params["contrast"] = float(aug_params["contrast"])
    aug_params["imagenet_norm"] = bool(aug_params["imagenet_norm"])

    return aug_params


def parse_augmentation_string(aug_input: Any) -> Dict[str, Any]:
    """Backward-compatible alias for older imports/call sites."""
    return normalize_augmentation_params(aug_input)


def create_optimizer(model_parameters, config: 'ExperimentConfig'):
    """Create optimizer based on configuration"""
    import torch.optim as optim

    if config.optimizer == 'AdamW':
        return optim.AdamW(
            model_parameters,
            lr=config.learning_rate[0],
            weight_decay=config.weight_decay
        )
    elif config.optimizer == 'Adam':
        return optim.Adam(
            model_parameters,
            lr=config.learning_rate[0],
            weight_decay=config.weight_decay
        )
    elif config.optimizer == 'SGD':
        return optim.SGD(
            model_parameters,
            lr=config.learning_rate[0],
            weight_decay=config.weight_decay,
            momentum=0.9
        )
    else:
        raise ValueError(f"Unsupported optimizer: {config.optimizer}")


def create_scheduler(optimizer, config: 'ExperimentConfig', total_epochs: int):
    """Create learning rate scheduler based on configuration"""
    import torch.optim.lr_scheduler as lr_scheduler

    if config.scheduler == 'CosineAnnealing':
        return lr_scheduler.CosineAnnealingLR(optimizer, T_max=total_epochs)
    elif config.scheduler == 'CosineAnnealingWarmRestarts':
        return lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_0=10, T_mult=2)
    elif config.scheduler == 'ReduceLROnPlateau':
        return lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', patience=10, factor=0.5)
    elif config.scheduler == 'StepLR':
        return lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)
    elif config.scheduler == 'ExponentialLR':
        return lr_scheduler.ExponentialLR(optimizer, gamma=0.95)
    else:
        raise ValueError(f"Unsupported scheduler: {config.scheduler}")