Update config.py

config.py

@@ -1,85 +1,26 @@
 """
-Configuration, constants, and data classes for Enhanced SPG compression.
-RESEARCH-GRADE: All parameters configurable, no hardcoding.
+Configuration module for Enhanced SPG compression.
+Contains all research constants, configuration classes, and validation logic.
+STRICT COMPLIANCE: No hardcoding, all parameters from config.
 """
 
 import json
 import hashlib
+import logging
+import sys
+import os
+import platform
 from dataclasses import dataclass, field, asdict
+from typing import List, Optional, NamedTuple, Any
 from enum import Enum
-from typing import List, Optional, NamedTuple, Dict, Any
 from datetime import datetime
 import torch
 import transformers
-import logging
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# Model configurations - NO HARDCODING
-SUPPORTED_MODELS: Dict[str, Dict[str, Any]] = {
-    "gpt2": {
-        "name": "gpt2",
-        "requires_auth": False,
-        "max_context": 1024,
-        "default_dtype": "float16"
-    },
-    "llama2-7b": {
-        "name": "meta-llama/Llama-2-7b-hf",
-        "requires_auth": True,
-        "max_context": 4096,
-        "default_dtype": "float16"
-    },
-    "mistral-7b": {
-        "name": "mistralai/Mistral-7B-v0.1",
-        "requires_auth": False,
-        "max_context": 8192,
-        "default_dtype": "float16"
-    },
-    "opt-1.3b": {
-        "name": "facebook/opt-1.3b",
-        "requires_auth": False,
-        "max_context": 2048,
-        "default_dtype": "float16"
-    }
-}
-
-# Benchmark configurations - NO HARDCODING
-# FIXED: Changed "perplexity" to "wikitext" for consistency
-BENCHMARK_CONFIGS: Dict[str, Dict[str, Any]] = {
-    "wikitext": {  # CHANGED from "perplexity" to "wikitext"
-        "type": "wikitext",  # CHANGED
-        "default_samples": 50,
-        "default_prefill": 512,
-        "default_generation": 64
-    },
-    "niah": {
-        "type": "needle_in_haystack",
-        "depths": [10, 25, 50, 75, 90],  # Percentage depths
-        "needle": "The secret password is BANANA",
-        "default_samples": 10,
-        "default_context": 4096
-    },
-    "ruler": {
-        "type": "ruler",
-        "max_seq_lengths": [1024, 2048, 4096, 8192],
-        "default_samples": 10,
-        "default_n_facts": 10
-    },
-    "scbench": {
-        "type": "shared_context",
-        "num_turns": [5, 10, 20],
-        "default_samples": 10,
-        "default_context": 2048
-    },
-    "longbench": {
-        "type": "longbench",
-        "subsets": ["narrativeqa", "qasper", "multifieldqa_en", "hotpotqa", "2wikimqa"],
-        "default_samples": 20,
-        "max_context": 8192
-    }
-}
 
 class CompressionType(Enum):
     """RocketKV-enhanced SPG methods with explicit validation."""
@@ -89,12 +30,14 @@ class CompressionType(Enum):
     ENHANCED_SPG = "enhanced_spg"
     PROGRESSIVE_SPG = "progressive_spg"
 
+
 class PrecisionLevel(NamedTuple):
     """Precision level configuration with validation."""
     threshold: float
     bits: Optional[int]
     name: str
 
+
 @dataclass
 class ResearchConstants:
     """All constants/thresholds from validated research - NO HARDCODING."""
@@ -173,6 +116,7 @@ class ResearchConstants:
     MIN_COMPRESSION_RATIO: float = 1.0
     MAX_COMPRESSION_RATIO: float = 1000.0
 
+
 @dataclass
 class EnhancedSPGConfig:
     """Research-grade configuration with RocketKV-style 450x compression support."""
@@ -248,9 +192,6 @@ class EnhancedSPGConfig:
     stage_compression_min: float = 2.0    # Minimum stage compression ratio
     stage_compression_max: float = 500.0  # Maximum stage compression ratio (INCREASED for 450x)
     
-    # Flash Attention support
-    use_flash_attention: bool = False  # Try to use Flash Attention if available
-    
     def __post_init__(self):
         """Validate all parameters - fail fast on invalid config."""
         constants = ResearchConstants()
@@ -340,6 +281,7 @@ class EnhancedSPGConfig:
         else:
             return self.kernel_size_xlarge_seq
 
+
 @dataclass
 class ProvingConfig:
     """Configuration for attestable proof generation and verification - NO HARDCODING."""
@@ -364,6 +306,7 @@ class ProvingConfig:
         if not 0 < self.ppl_tolerance < 1:
             raise ValueError(f"ppl_tolerance must be in (0, 1), got {self.ppl_tolerance}")
 
+
 @dataclass
 class CompressionConfig:
     """Research-grade configuration for RocketKV-enhanced SPG methods."""
@@ -371,10 +314,6 @@ class CompressionConfig:
     compression_type: CompressionType = CompressionType.ENHANCED_SPG
     seed: int = 42
     
-    # Model selection
-    model_key: str = "gpt2"  # Key into SUPPORTED_MODELS
-    model_name: str = field(init=False)  # Will be set in __post_init__
-    
     # Enhanced SPG configuration
     enhanced_spg_config: EnhancedSPGConfig = field(default_factory=EnhancedSPGConfig)
     
@@ -398,25 +337,10 @@ class CompressionConfig:
     dataset_config: str = "wikitext-2-raw-v1"
     dataset_split: str = "test"
     
-    # Benchmark configuration
-    benchmark_type: str = "wikitext"  # wikitext, niah, ruler, scbench, longbench
-    benchmark_subset: Optional[str] = None  # For longbench subsets
-    
-    # NIAH-specific parameters
-    niah_needle: str = field(default_factory=lambda: BENCHMARK_CONFIGS["niah"]["needle"])
-    niah_depth_percent: float = 50.0
-    
-    # RULER-specific parameters
-    ruler_max_seq_length: int = 4096
-    
-    # SCBench-specific parameters
-    scbench_num_turns: int = 10
-    
     # Memory and system settings
     clear_cache_between_runs: bool = True
     use_memory_snapshot: bool = True
     fail_on_cpu_fallback: bool = True  # CHANGED: Default to True for strict compliance
-    use_flash_attention: bool = False  # Try to use Flash Attention if available
     
     # Output settings
     generate_latex: bool = True
@@ -430,25 +354,14 @@ class CompressionConfig:
     timestamp: str = field(default_factory=lambda: datetime.now().isoformat())
     
     def __post_init__(self):
-        """Comprehensive validation - FAIL FAST on any invalid parameter, NO SILENT DEFAULTS."""
+        """Comprehensive validation - fail fast on any invalid parameter."""
         constants = ResearchConstants()
         
-        # 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 - 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 - NO MAGIC NUMBERS
+        # Validate core parameters
         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 with explicit bounds
+        # Validate evaluation parameters
         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}]")
         
@@ -461,33 +374,14 @@ 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 - EXPLICIT BOUNDS
+        # Validate statistical parameters
         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("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}")
+        logger.info("RocketKV-enhanced SPG config validated successfully")
     
     def to_json(self) -> str:
         """Export config for reproducibility."""