Upload 2 files

app.py

@@ -72,23 +72,24 @@ def load_franklin_model():
                     suggested_base = adapter_config["base_model_name_or_path"]
                     logger.info(f"🔧 Adapter suggests base model: {suggested_base}")
                     base_model_options = [suggested_base] + [
-                        "Qwen/Qwen3-8B-Base",  # The actual base model used for fine-tuning
-                        "Qwen/Qwen3-8B",
+                        "Qwen/Qwen3-8B-Base",
+                        "Qwen/Qwen3-8B", 
                         "QWEN/QWEN3-8B",
                         "Qwen/Qwen2.5-7B"
                     ]
                 else:
                     base_model_options = [
+                        "Qwen/Qwen3-8B-Base",
                         "Qwen/Qwen3-8B", 
-                        "Qwen/Qwen3-8B-Instruct",
-                        "Qwen/Qwen2.5-7B", 
-                        "Qwen/Qwen2.5-7B-Instruct"
+                        "QWEN/QWEN3-8B",
+                        "Qwen/Qwen2.5-7B"
                     ]
-            except:
+            except Exception as config_error:
+                logger.warning(f"⚠️ Could not read adapter config: {config_error}")
                 # If we can't read adapter config, use default options
                 base_model_options = [
-                    "Qwen/Qwen3-8B-Base",  # The actual base model used for fine-tuning
-                    "Qwen/Qwen3-8B",
+                    "Qwen/Qwen3-8B-Base",
+                    "Qwen/Qwen3-8B", 
                     "QWEN/QWEN3-8B",
                     "Qwen/Qwen2.5-7B"
                 ]
@@ -136,8 +137,93 @@ def load_franklin_model():
                 # Load the PEFT adapter on top of base model
                 from peft import PeftModel
                 logger.info(f"📥 Loading PEFT adapter from {model_name}...")
-                model = PeftModel.from_pretrained(base_model, model_name)
-                logger.info("✅ Franklin PEFT model loaded successfully!")
+                
+                # Try to load the adapter, but handle potential config issues
+                try:
+                    model = PeftModel.from_pretrained(base_model, model_name)
+                    logger.info("✅ Franklin PEFT model loaded successfully!")
+                except TypeError as e:
+                    if "corda_config" in str(e):
+                        logger.warning(f"⚠️ Adapter contains corda_config which is not supported in current PEFT version. Attempting to load with workaround...")
+                        try:
+                            # Try to load with a modified config
+                            from peft import LoraConfig
+                            import json
+                            from huggingface_hub import hf_hub_download
+                            
+                            # Download and modify the adapter config
+                            adapter_config_path = hf_hub_download(repo_id=model_name, filename="adapter_config.json")
+                            
+                            # Load the config file
+                            with open(adapter_config_path, "r") as f:
+                                adapter_config_data = json.load(f)
+                            
+                            # Remove unsupported parameters
+                            original_corda = None
+                            if "corda_config" in adapter_config_data:
+                                original_corda = adapter_config_data["corda_config"]
+                                del adapter_config_data["corda_config"]
+                                logger.info("🔧 Removed corda_config from adapter config for compatibility")
+                            
+                            # Create config without unsupported parameters
+                            modified_config = LoraConfig(**adapter_config_data)
+                            
+                            # Load the model with the modified config
+                            from peft import get_peft_model
+                            model = get_peft_model(base_model, modified_config)
+                            model.load_adapter(model_name, "default")
+                            logger.info("✅ Franklin PEFT model loaded successfully with config workaround!")
+                        except Exception as workaround_error:
+                            logger.error(f"❌ Config workaround failed: {workaround_error}")
+                            logger.info("🔄 Falling back to direct model loading...")
+                            # If workaround fails, try loading the model directly
+                            try:
+                                tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+                                model = AutoModelForCausalLM.from_pretrained(
+                                    model_name,
+                                    torch_dtype=torch.float16,
+                                    device_map="auto",
+                                    trust_remote_code=True,
+                                    low_cpu_mem_usage=True
+                                )
+                                logger.info("✅ Successfully loaded fine-tuned model directly as fallback!")
+                            except Exception as direct_error:
+                                logger.error(f"❌ Direct loading also failed: {direct_error}")
+                                return False
+                    else:
+                        logger.error(f"❌ Unexpected TypeError when loading adapter: {e}")
+                        # Try direct loading as fallback
+                        logger.info("🔄 Falling back to direct model loading...")
+                        try:
+                            tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+                            model = AutoModelForCausalLM.from_pretrained(
+                                model_name,
+                                torch_dtype=torch.float16,
+                                device_map="auto",
+                                trust_remote_code=True,
+                                low_cpu_mem_usage=True
+                            )
+                            logger.info("✅ Successfully loaded fine-tuned model directly as fallback!")
+                        except Exception as direct_error:
+                            logger.error(f"❌ Direct loading also failed: {direct_error}")
+                            return False
+                except Exception as e:
+                    logger.error(f"❌ Failed to load PEFT adapter: {e}")
+                    # As a fallback, try loading the fine-tuned model directly
+                    logger.info("🔄 Falling back to direct model loading...")
+                    try:
+                        tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+                        model = AutoModelForCausalLM.from_pretrained(
+                            model_name,
+                            torch_dtype=torch.float16,
+                            device_map="auto",
+                            trust_remote_code=True,
+                            low_cpu_mem_usage=True
+                        )
+                        logger.info("✅ Successfully loaded fine-tuned model directly as fallback!")
+                    except Exception as direct_error:
+                        logger.error(f"❌ Direct loading also failed: {direct_error}")
+                        return False
         else:
             # If using base model, load normally
             logger.info("📥 Loading tokenizer...")

requirements.txt

@@ -1,9 +1,9 @@
 gradio==4.44.0
-transformers==4.41.0
+transformers==4.45.2
 torch==2.3.0
 accelerate==0.26.0
-huggingface-hub>=0.19.3
+huggingface-hub==0.20.3
 sentencepiece==0.1.99
 protobuf==4.25.0
-peft==0.10.0
+peft==0.12.0
 bitsandbytes==0.43.1