Fix base model to Qwen2.5-0.5B and clean LoRA adapter config compatibility

backend/config.py

@@ -18,8 +18,8 @@ class Settings(BaseSettings):
     API_PORT: int = int(os.getenv("API_PORT", "8000"))
     DEBUG: bool = os.getenv("DEBUG", "True").lower() == "true"
     
-    # Model Configuration - Use proper Qwen model for Hugging Face Spaces
-    BASE_MODEL: str = os.getenv("BASE_MODEL", "Qwen/Qwen2.5-1.5B-Instruct")
+    # Model Configuration - Match your local Qwen3 model
+    BASE_MODEL: str = os.getenv("BASE_MODEL", "Qwen/Qwen2.5-0.5B-Instruct")
     DEVICE: str = os.getenv("DEVICE", "cpu")  # Default to CPU for Spaces
     MAX_LENGTH: int = int(os.getenv("MAX_LENGTH", "2048"))
     TEMPERATURE: float = float(os.getenv("TEMPERATURE", "0.7"))

backend/models/character_manager.py

@@ -167,52 +167,60 @@ class CharacterManager:
                 
                 # Try loading with compatibility fixes
                 try:
-                    # First attempt: Load directly on base model (shared approach)
-                    logger.info(f"Trying shared base model approach for {character_id}")
+                    # First: Fix the adapter config to remove incompatible parameters
+                    import json
+                    config_file = os.path.join(adapter_path, "adapter_config.json")
+                    
+                    with open(config_file, 'r') as f:
+                        config_data = json.load(f)
+                    
+                    # Remove problematic parameters that cause LoraConfig errors
+                    problematic_params = [
+                        'alora_invocation_tokens', 'arrow_config', 
+                        'ensure_weight_tying', 'peft_version'
+                    ]
+                    
+                    for param in problematic_params:
+                        if param in config_data:
+                            logger.info(f"Removing incompatible parameter: {param}")
+                            del config_data[param]
+                    
+                    # Write cleaned config to temp file
+                    import tempfile
+                    temp_dir = tempfile.mkdtemp()
+                    temp_config_file = os.path.join(temp_dir, "adapter_config.json")
+                    
+                    with open(temp_config_file, 'w') as f:
+                        json.dump(config_data, f, indent=2)
+                    
+                    # Copy adapter model to temp directory
+                    import shutil
+                    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
+                    logger.info(f"Loading LoRA adapter with cleaned config for {character_id}")
                     model_with_adapter = PeftModel.from_pretrained(
                         self.base_model,
-                        adapter_path,
+                        temp_dir,
                         adapter_name=character_id,
                         is_trainable=False,
-                        torch_dtype=torch.float32,  # Force float32 for compatibility
+                        torch_dtype=torch.float32,
                     )
+                    
                     self.character_models[character_id] = model_with_adapter
-                    logger.info(f"✅ Successfully loaded LoRA adapter for {character_id} (shared model)")
+                    logger.info(f"✅ Successfully loaded LoRA adapter for {character_id} with cleaned config")
+                    
+                    # Cleanup temp files
+                    shutil.rmtree(temp_dir, ignore_errors=True)
                     
                 except Exception as e1:
-                    logger.warning(f"Shared model approach failed for {character_id}: {e1}")
+                    logger.warning(f"LoRA loading failed for {character_id}: {e1}")
                     
-                    # Second attempt: Try with separate model instance and compatibility settings
-                    try:
-                        logger.info(f"Trying separate model instance for {character_id}")
-                        character_base_model = AutoModelForCausalLM.from_pretrained(
-                            settings.BASE_MODEL,
-                            torch_dtype=torch.float32,  # Force float32 for compatibility
-                            device_map=None,  # No device mapping for compatibility
-                            trust_remote_code=True,
-                            low_cpu_mem_usage=True,
-                            use_cache=False  # Disable cache for compatibility
-                        )
-                        
-                        # Load adapter with strict=False for compatibility
-                        model_with_adapter = PeftModel.from_pretrained(
-                            character_base_model,
-                            adapter_path,
-                            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} (separate model)")
-                        
-                    except Exception as e2:
-                        logger.warning(f"Separate model approach failed for {character_id}: {e2}")
-                        
-                        # Final fallback: Use base model only with enhanced character prompts
-                        logger.info(f"Using base model fallback for {character_id}")
-                        self.character_models[character_id] = self.base_model
-                        logger.info(f"⚠️ Using base model fallback for {character_id} - character behavior will rely on prompts only")
+                    # Ultimate fallback: Use base model only with enhanced character prompts
+                    logger.info(f"Using base model fallback for {character_id}")
+                    self.character_models[character_id] = self.base_model
+                    logger.info(f"⚠️ Using base model fallback for {character_id} - character behavior will rely on prompts only")
                         
             except Exception as e:
                 logger.error(f"❌ Complete failure loading LoRA adapter for {character_id}: {e}")