removed redundant class from src/config

src/config/config_loader.py

@@ -1,7 +1,7 @@
 import yaml
 import logging
 from pathlib import Path
-from typing import Union, Tuple
+from typing import Union, Tuple, Optional
 from pydantic import ValidationError
 
 from .schemas import SystemConfig, ModelConfig
@@ -13,58 +13,58 @@ class ConfigLoader:
     def __init__(self):
         self.logger = logging.getLogger(__name__)
 
-    def load_and_validate(self, system_config_path: Union[str, Path], model_config_path: Union[str, Path]) -> Tuple[SystemConfig, ModelConfig]:
+    def load_and_validate(self, system_config_path: Union[str, Path], model_config_path: Optional[Union[str, Path]] = None) -> Tuple[SystemConfig, Optional[ModelConfig]]:
         """
         Load and validate configuration files from YAML files.
 
         Args:
             system_config_path: Path to YAML configuration file for OFDM-related parameters
-            model_config_path: Path to YAML configuration file for model-related parameters
+            model_config_path: Optional path to YAML configuration file for model-related parameters
 
         Returns:
-            Tuple of (SystemConfig, ModelConfig): Validated configuration objects
+            Tuple of (SystemConfig, Optional[ModelConfig]): Validated configuration objects
 
         Raises:
-            FileNotFoundError: If one of the config files doesn't exist
+            FileNotFoundError: If the system config file doesn't exist
             ValueError: If configuration validation fails
         """
         system_config_path = Path(system_config_path)
-        model_config_path = Path(model_config_path)
+        model_config = None
+        if model_config_path is not None:
+            model_config_path = Path(model_config_path)
 
         if not system_config_path.exists():
             raise FileNotFoundError(f"System configuration file not found: {system_config_path}")
 
-        if not model_config_path.exists():
-            raise FileNotFoundError(f"Model configuration file not found: {model_config_path}")
-
         try:
             with open(system_config_path, 'r') as f:
                 system_raw_config = yaml.safe_load(f)
         except yaml.YAMLError as e:
             raise ValueError(f"Failed to parse YAML file {system_config_path}: {e}")
 
-        try:
-            with open(model_config_path, 'r') as f:
-                model_raw_config = yaml.safe_load(f)
-        except yaml.YAMLError as e:
-            raise ValueError(f"Failed to parse YAML file {model_config_path}: {e}")
-
         try:
             system_config = SystemConfig(**system_raw_config)
             self.logger.info(f"Successfully loaded system config from {system_config_path}")
         except ValidationError as e:
             raise ValueError(f"System configuration validation for {system_config_path} failed:\n{e}")
 
-        try:
-            model_config = ModelConfig(**model_raw_config)
-            self.logger.info(f"Successfully loaded model config from {model_config_path}")
-        except ValidationError as e:
-            raise ValueError(f"Model configuration validation for {model_config_path} failed:\n{e}")
+        # Only load model config if path is provided and file exists
+        if model_config_path is not None and model_config_path.exists():
+            try:
+                with open(model_config_path, 'r') as f:
+                    model_raw_config = yaml.safe_load(f)
+            except yaml.YAMLError as e:
+                raise ValueError(f"Failed to parse YAML file {model_config_path}: {e}")
+            try:
+                model_config = ModelConfig(**model_raw_config)
+                self.logger.info(f"Successfully loaded model config from {model_config_path}")
+            except ValidationError as e:
+                raise ValueError(f"Model configuration validation for {model_config_path} failed:\n{e}")
 
         return system_config, model_config
 
 
-def load_config(system_config_path: Union[str, Path], model_config_path: Union[str, Path]) -> Tuple[SystemConfig, ModelConfig]:
+def load_config(system_config_path: Union[str, Path], model_config_path: Optional[Union[str, Path]] = None) -> Tuple[SystemConfig, Optional[ModelConfig]]:
     """Convenience function to load and validate config."""
     config_loader = ConfigLoader()
     return config_loader.load_and_validate(system_config_path, model_config_path)

src/config/schemas.py

@@ -13,83 +13,6 @@ class PilotParams(BaseModel):
     num_symbols: int = Field(..., gt=0, description="Number of pilots across OFDM symbols")
 
 
-class ModelParams(BaseModel):
-    patch_size: Tuple[int, int] = Field(..., description="Patch size as (height, width)")
-    num_layers: int = Field(..., gt=0, description="Number of transformer layers")
-    model_dim: int = Field(..., gt=0, description="Model dimension")
-    num_head: int = Field(..., gt=0, description="Number of attention heads")
-    activation: str = Field(default="gelu", description="Activation function")
-    dropout: float = Field(default=0.1, ge=0.0, le=1.0, description="Dropout rate")
-    max_seq_len: int = Field(default=512, gt=0, description="Maximum sequence length")
-    pos_encoding_type: str = Field(default="learnable", description="Position encoding type")
-    adaptive_token_length: int = Field(default=6, gt=0, description="Adaptive token length")
-    channel_adaptivity_hidden_sizes: Optional[List[int]] = Field(
-        default=None, 
-        description="Hidden sizes for channel adaptation layers"
-    )
-    device: str = Field(default="cpu", description="Device to use")
-
-    @model_validator(mode='after')
-    def validate_device(self) -> Self:
-        """Validate that the specified device is available."""
-        device_str = self.device.lower()
-
-        # Handle 'auto' case - automatically select best available device
-        if device_str == 'auto':
-            if torch.cuda.is_available():
-                self.device = 'cuda'
-            elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
-                self.device = 'mps'  # Apple Silicon
-            else:
-                self.device = 'cpu'
-            return self
-
-        # Validate CPU
-        if device_str == 'cpu':
-            return self
-
-        # Validate CUDA devices
-        if device_str.startswith('cuda'):
-            if not torch.cuda.is_available():
-                raise ValueError("CUDA is not available on this system")
-
-            # Handle specific CUDA device (e.g., 'cuda:0', 'cuda:1')
-            if ':' in device_str:
-                try:
-                    device_id = int(device_str.split(':')[1])
-                    if device_id >= torch.cuda.device_count():
-                        available_devices = list(range(torch.cuda.device_count()))
-                        raise ValueError(
-                            f"CUDA device {device_id} not available. "
-                            f"Available CUDA devices: {available_devices}"
-                        )
-                except (ValueError, IndexError) as e:
-                    if "invalid literal" in str(e):
-                        raise ValueError(f"Invalid CUDA device format: {device_str}")
-                    raise
-
-            return self
-
-        # Validate MPS (Apple Silicon)
-        if device_str == 'mps':
-            if not (hasattr(torch.backends, 'mps') and torch.backends.mps.is_available()):
-                raise ValueError("MPS is not available on this system")
-            return self
-
-        # If we get here, the device is not recognized
-        available_devices = ['cpu']
-        if torch.cuda.is_available():
-            cuda_devices = [f'cuda:{i}' for i in range(torch.cuda.device_count())]
-            available_devices.extend(['cuda'] + cuda_devices)
-        if hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
-            available_devices.append('mps')
-
-        raise ValueError(
-            f"Unsupported device: '{self.device}'. "
-            f"Available devices: {available_devices}"
-        )
-
-
 class SystemConfig(BaseModel):
     ofdm: OFDMParams
     pilot: PilotParams