Comprehensive fix: Update transformers for Qwen3 support and improve LoRA adapter compatibility

backend/config.py

@@ -18,8 +18,9 @@ class Settings(BaseSettings):
     API_PORT: int = int(os.getenv("API_PORT", "8000"))
     DEBUG: bool = os.getenv("DEBUG", "True").lower() == "true"
     
-    # Model Configuration - MUST match your LoRA training base model
-    BASE_MODEL: str = os.getenv("BASE_MODEL", "Qwen/Qwen3-0.6B")  # Your LoRA adapters are trained on this exact model
+    # Model Configuration - Try Qwen3 first, fallback to compatible model
+    BASE_MODEL: str = os.getenv("BASE_MODEL", "Qwen/Qwen2.5-0.5B-Instruct")  # Use compatible model for now
+    QWEN3_MODEL: str = "Qwen/Qwen3-0.6B"  # Your original training model (will try first)
     DEVICE: str = os.getenv("DEVICE", "cpu")  # CPU for Spaces (you use cuda locally)
     MAX_LENGTH: int = int(os.getenv("MAX_LENGTH", "1024"))
     TEMPERATURE: float = float(os.getenv("TEMPERATURE", "0.8"))

backend/models/character_manager.py

@@ -35,16 +35,47 @@ class CharacterManager:
         logger.info(f"Working from directory: {parent_dir}")
         logger.info(f"LoRA adapters path: {settings.LORA_ADAPTERS_PATH}")
         
+        # First try your original Qwen3-0.6B model
+        qwen3_model = getattr(settings, 'QWEN3_MODEL', 'Qwen/Qwen3-0.6B')
+        
         try:
-            # Load tokenizer from HuggingFace Hub (for Spaces deployment)
-            logger.info(f"Loading tokenizer from: {settings.BASE_MODEL}")
+            logger.info(f"Attempting to load original training model: {qwen3_model}")
             self.tokenizer = AutoTokenizer.from_pretrained(
-                settings.BASE_MODEL,
+                qwen3_model,
                 trust_remote_code=True,
-                use_fast=True,  # Use fast tokenizer
-                cache_dir=None  # Use default HF cache
+                use_fast=True,
+                cache_dir=None
             )
             
+            # If tokenizer works, try the model
+            if settings.DEVICE == "cuda" and torch.cuda.is_available():
+                self.base_model = AutoModelForCausalLM.from_pretrained(
+                    qwen3_model,
+                    torch_dtype=torch.float16,
+                    device_map="auto",
+                    trust_remote_code=True
+                )
+            else:
+                self.base_model = AutoModelForCausalLM.from_pretrained(
+                    qwen3_model,
+                    torch_dtype=torch.float32,
+                    trust_remote_code=True
+                )
+            logger.info(f"✅ Successfully loaded original model: {qwen3_model}")
+            
+        except Exception as e:
+            logger.warning(f"Original model {qwen3_model} failed: {e}")
+            
+            # Fallback to compatible model
+            try:
+                logger.info(f"Loading compatible fallback model: {settings.BASE_MODEL}")
+                self.tokenizer = AutoTokenizer.from_pretrained(
+                    settings.BASE_MODEL,
+                    trust_remote_code=True,
+                    use_fast=True,
+                    cache_dir=None
+                )
+            
             # Smart GPU/CPU loading
             cuda_available = torch.cuda.is_available()
             use_gpu = settings.DEVICE == "cuda" and cuda_available
@@ -178,7 +209,9 @@ class CharacterManager:
                     # Remove problematic parameters that cause LoraConfig errors
                     problematic_params = [
                         'alora_invocation_tokens', 'arrow_config', 
-                        'ensure_weight_tying', 'peft_version'
+                        'ensure_weight_tying', 'peft_version', 'corda_config',
+                        'eva_config', 'megatron_config', 'megatron_core',
+                        'loftq_config', 'qalora_group_size'
                     ]
                     
                     for param in problematic_params:
@@ -199,15 +232,37 @@ class CharacterManager:
                     temp_model_file = os.path.join(temp_dir, "adapter_model.safetensors")
                     shutil.copy2(os.path.join(adapter_path, "adapter_model.safetensors"), temp_model_file)
                     
-                    # Load with cleaned config
+                    # Load with cleaned config - try different approaches
                     logger.info(f"Loading LoRA adapter with cleaned config for {character_id}")
-                    model_with_adapter = PeftModel.from_pretrained(
-                        self.base_model,
-                        temp_dir,
-                        adapter_name=character_id,
-                        is_trainable=False,
-                        torch_dtype=torch.float32,
-                    )
+                    
+                    try:
+                        # First attempt: Standard loading
+                        model_with_adapter = PeftModel.from_pretrained(
+                            self.base_model,
+                            temp_dir,
+                            adapter_name=character_id,
+                            is_trainable=False,
+                            torch_dtype=torch.float32,
+                        )
+                    except Exception as inner_e:
+                        logger.warning(f"Standard LoRA loading failed: {inner_e}")
+                        
+                        # Second attempt: Force compatibility mode
+                        logger.info("Trying compatibility mode for LoRA loading")
+                        
+                        # Update config to match current model architecture
+                        config_data['base_model_name_or_path'] = self.base_model.config._name_or_path
+                        
+                        with open(temp_config_file, 'w') as f:
+                            json.dump(config_data, f, indent=2)
+                        
+                        model_with_adapter = PeftModel.from_pretrained(
+                            self.base_model,
+                            temp_dir,
+                            adapter_name=character_id,
+                            is_trainable=False,
+                            torch_dtype=torch.float32,
+                        )
                     
                     self.character_models[character_id] = model_with_adapter
                     logger.info(f"✅ Successfully loaded LoRA adapter for {character_id} with cleaned config")

requirements.txt

@@ -1,7 +1,7 @@
-# Core ML Libraries - Fixed versions for compatibility
-torch>=2.0.0,<2.5.0
-transformers>=4.36.0,<4.50.0
-peft>=0.8.0,<0.14.0
+# Core ML Libraries - Latest versions for Qwen3 support
+torch>=2.0.0
+transformers>=4.45.0
+peft>=0.8.0
 accelerate>=0.24.0
 datasets>=2.14.0
 huggingface-hub>=0.19.0