Update config.py

config.py

@@ -429,23 +429,25 @@ class CompressionConfig:
     timestamp: str = field(default_factory=lambda: datetime.now().isoformat())
     
     def __post_init__(self):
-        """Comprehensive validation - fail fast on any invalid parameter."""
+        """Comprehensive validation - FAIL FAST on any invalid parameter, NO SILENT DEFAULTS."""
         constants = ResearchConstants()
         
-        # Set model name from key
+        # Set model name from key - FAIL FAST if invalid
         if self.model_key not in SUPPORTED_MODELS:
             raise ValueError(f"model_key {self.model_key} not in SUPPORTED_MODELS: {list(SUPPORTED_MODELS.keys())}")
         self.model_name = SUPPORTED_MODELS[self.model_key]["name"]
+        logger.info(f"Model selected: {self.model_name} (key: {self.model_key})")
         
-        # Validate benchmark type
+        # Validate benchmark type - FAIL FAST if invalid
         if self.benchmark_type not in BENCHMARK_CONFIGS:
             raise ValueError(f"benchmark_type {self.benchmark_type} not in BENCHMARK_CONFIGS: {list(BENCHMARK_CONFIGS.keys())}")
+        logger.info(f"Benchmark selected: {self.benchmark_type}")
         
-        # Validate core parameters
+        # Validate core parameters - NO MAGIC NUMBERS
         if not isinstance(self.seed, int) or self.seed < 0:
             raise ValueError(f"seed must be non-negative integer, got {self.seed}")
         
-        # Validate evaluation parameters
+        # Validate evaluation parameters with explicit bounds
         if not constants.MIN_EVAL_SAMPLES <= self.eval_samples <= constants.MAX_EVAL_SAMPLES:
             logger.warning(f"eval_samples {self.eval_samples} outside recommended range [{constants.MIN_EVAL_SAMPLES}, {constants.MAX_EVAL_SAMPLES}]")
         
@@ -458,17 +460,33 @@ class CompressionConfig:
         if not 1 <= self.n_seeds <= 10:
             logger.warning(f"n_seeds {self.n_seeds} outside recommended range [1, 10]")
         
-        # Validate statistical parameters
+        # Validate statistical parameters - EXPLICIT BOUNDS
         if not 0.5 <= self.confidence_level < 1.0:
             raise ValueError(f"confidence_level must be in [0.5, 1.0), got {self.confidence_level}")
         
         if not 100 <= self.n_bootstrap <= 10000:
             logger.warning(f"n_bootstrap {self.n_bootstrap} outside recommended range [100, 10000]")
         
+        # Validate benchmark-specific parameters
+        if self.benchmark_type == "longbench" and not self.benchmark_subset:
+            logger.warning("LongBench selected but no subset specified")
+        
+        if self.benchmark_type == "niah" and not self.niah_needle:
+            raise ValueError("NIAH benchmark requires niah_needle to be set")
+        
+        if self.benchmark_type == "ruler" and self.ruler_max_seq_length <= 0:
+            raise ValueError(f"ruler_max_seq_length must be positive, got {self.ruler_max_seq_length}")
+        
+        if self.benchmark_type == "scbench" and self.scbench_num_turns <= 0:
+            raise ValueError(f"scbench_num_turns must be positive, got {self.scbench_num_turns}")
+        
         # Pass Flash Attention setting to EnhancedSPGConfig
         self.enhanced_spg_config.use_flash_attention = self.use_flash_attention
         
-        logger.info("RocketKV-enhanced SPG config validated successfully")
+        logger.info("Configuration validated successfully - STRICT COMPLIANCE")
+        logger.info(f"Target compression: {self.enhanced_spg_config.target_compression_ratio}x")
+        logger.info(f"Fail on CPU fallback: {self.fail_on_cpu_fallback}")
+        logger.info(f"Proving enabled: {self.proving.enabled}")
     
     def to_json(self) -> str:
         """Export config for reproducibility."""