Update app.py

app.py

@@ -455,7 +455,7 @@ def replace_attention_with_retention(model, use_hierarchical=True):
 
 
 # =====================================================
-# Custom Modeling Code 생성 (완전 개선!)
+# Custom Modeling Code 생성
 # =====================================================
 
 def generate_modeling_phoenix_code():
@@ -868,187 +868,13 @@ class PhoenixModelForCausalLM(PhoenixPreTrainedModel):
 
 # Auto-registration
 AutoConfig.register("phoenix", PhoenixConfig)
-
-    
-    return modeling_code
-
-
-class PhoenixPreTrainedModel(PreTrainedModel):
-    """
-    Base PHOENIX PreTrainedModel
-    Handles weight initialization and loading
-    """
-    config_class = PhoenixConfig
-    base_model_prefix = "phoenix"
-    supports_gradient_checkpointing = True
-    _no_split_modules = ["MultiScaleRetention", "HierarchicalRetention"]
-    
-    def _init_weights(self, module):
-        """Initialize weights"""
-        if isinstance(module, nn.Linear):
-            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range if hasattr(self.config, 'initializer_range') else 0.02)
-            if module.bias is not None:
-                module.bias.data.zero_()
-        elif isinstance(module, nn.Embedding):
-            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range if hasattr(self.config, 'initializer_range') else 0.02)
-            if module.padding_idx is not None:
-                module.weight.data[module.padding_idx].zero_()
-        elif isinstance(module, nn.LayerNorm):
-            module.bias.data.zero_()
-            module.weight.data.fill_(1.0)
-
-
-class PhoenixModel(PhoenixPreTrainedModel):
-    """
-    PHOENIX Model with Retention layers
-    This is the actual model class loaded by AutoModel
-    """
-    
-    def __init__(self, config):
-        super().__init__(config)
-        self.config = config
-        
-        # Store original model for delegation
-        self._original_model = None
-        
-    def set_original_model(self, model):
-        """Set the original model with converted retention layers"""
-        self._original_model = model
-        
-    def forward(self, *args, **kwargs):
-        """Forward pass delegates to original model"""
-        if self._original_model is None:
-            raise ValueError("Original model not set. Use set_original_model() first.")
-        return self._original_model(*args, **kwargs)
-    
-    def generate(self, *args, **kwargs):
-        """Generate delegates to original model"""
-        if self._original_model is None:
-            raise ValueError("Original model not set. Use set_original_model() first.")
-        return self._original_model.generate(*args, **kwargs)
-
-
-
-
-
-def load_phoenix_model(pretrained_model_name_or_path, **kwargs):
-    """
-    Load PHOENIX model with automatic Retention conversion
-    
-    This function is called by AutoModel/AutoModelForCausalLM when trust_remote_code=True
-    
-    Args:
-        pretrained_model_name_or_path: Model path or Hub URL
-        **kwargs: Additional arguments for model loading
-        
-    Returns:
-        PhoenixModelForCausalLM: Model with Retention mechanism
-    """
-    import json
-    from pathlib import Path
-    
-    print(f"🔥 Loading PHOENIX model from {pretrained_model_name_or_path}")
-    
-    # Load config
-    config_path = Path(pretrained_model_name_or_path) / "config.json"
-    if config_path.exists():
-        with open(config_path, 'r') as f:
-            config_dict = json.load(f)
-    else:
-        # Try to download from Hub
-        from huggingface_hub import hf_hub_download
-        config_path = hf_hub_download(
-            repo_id=pretrained_model_name_or_path,
-            filename="config.json"
-        )
-        with open(config_path, 'r') as f:
-            config_dict = json.load(f)
-    
-    # Check PHOENIX markers
-    use_phoenix = config_dict.get('use_phoenix_retention', False)
-    original_model_url = config_dict.get('original_model', 'unknown')
-    
-    if not use_phoenix:
-        print("⚠️ Warning: This doesn't appear to be a PHOENIX model")
-    
-    print(f"   Original model: {original_model_url}")
-    print(f"   PHOENIX version: {config_dict.get('phoenix_version', 'unknown')}")
-    
-    # Load original model architecture
-    from transformers import AutoModelForCausalLM, AutoConfig
-    
-    # Create base config
-    base_config = AutoConfig.from_pretrained(
-        pretrained_model_name_or_path,
-        trust_remote_code=True
-    )
-    
-    # Load base model structure with weights
-    base_model = AutoModelForCausalLM.from_pretrained(
-        pretrained_model_name_or_path,
-        config=base_config,
-        **kwargs
-    )
-    
-    # Apply retention conversion
-    print("🔄 Applying Retention conversion...")
-    use_hierarchical = config_dict.get('use_hierarchical', True)
-    
-    if hasattr(base_model, 'model') and hasattr(base_model.model, 'layers'):
-        layers = base_model.model.layers
-        converted_count = 0
-        
-        for layer_idx, layer in enumerate(layers):
-            if hasattr(layer, 'self_attn'):
-                old_attn = layer.self_attn
-                
-                # Create new retention layer
-                if use_hierarchical:
-                    new_retention = HierarchicalRetention(base_config, layer_idx)
-                else:
-                    new_retention = MultiScaleRetention(base_config, layer_idx)
-                
-                # Copy weights if available
-                if hasattr(old_attn, 'q_proj'):
-                    try:
-                        target = new_retention.base_retention if use_hierarchical else new_retention
-                        
-                        # Copy Q, K, V, O projection weights
-                        if old_attn.q_proj.weight.shape == target.q_proj.weight.shape:
-                            target.q_proj.weight.data = old_attn.q_proj.weight.data.clone()
-                        
-                        if old_attn.k_proj.weight.shape == target.k_proj.weight.shape:
-                            target.k_proj.weight.data = old_attn.k_proj.weight.data.clone()
-                        
-                        if old_attn.v_proj.weight.shape == target.v_proj.weight.shape:
-                            target.v_proj.weight.data = old_attn.v_proj.weight.data.clone()
-                        
-                        if old_attn.o_proj.weight.shape == target.o_proj.weight.shape:
-                            target.o_proj.weight.data = old_attn.o_proj.weight.data.clone()
-                            
-                    except Exception as e:
-                        print(f"  ⚠️ Layer {layer_idx}: Could not copy weights - {e}")
-                
-                # Replace attention with retention
-                layer.self_attn = new_retention
-                converted_count += 1
-        
-        print(f"✅ Converted {converted_count}/{len(layers)} layers to Retention")
-    
-    # Create PHOENIX wrapper
-    phoenix_model = PhoenixModelForCausalLM(base_config)
-    phoenix_model.set_original_model(base_model)
-    
-    print("✅ PHOENIX model loaded successfully!")
-    
-    return phoenix_model
 '''
     
     return modeling_code
 
 
 # =====================================================
-# 향상된 저장 함수 (완전 수정!)
+# 저장 함수
 # =====================================================
 
 def save_phoenix_model_with_code(model, tokenizer, output_path, original_model_url, metadata):
@@ -1084,9 +910,8 @@ def save_phoenix_model_with_code(model, tokenizer, output_path, original_model_u
         config_dict["original_model"] = original_model_url
         config_dict["use_hierarchical"] = metadata.get('use_hierarchical', True)
         
-        # ✅ auto_map 설정 (핵심!)
+        # auto_map 설정
         config_dict["auto_map"] = {
-            "AutoModel": "modeling_phoenix.PhoenixModel",
             "AutoModelForCausalLM": "modeling_phoenix.PhoenixModelForCausalLM",
         }
         
@@ -1221,16 +1046,12 @@ Apache 2.0 (inherited from original model)
 
 
 # =====================================================
-# 업로드 전 검증 함수 (신규!)
-# =====================================================
-
-# =====================================================
-# 업로드 전 검증 함수 (완전 수정!)
+# 업로드 전 검증 함수
 # =====================================================
 
 def verify_phoenix_model_before_upload(model_path: str) -> Tuple[bool, str, Dict]:
     """
-    Upload 전 PHOENIX 모델 검증 (구조 탐색 개선!)
+    Upload 전 PHOENIX 모델 검증
     
     Returns:
         (success, message, metrics)
@@ -1238,37 +1059,37 @@ def verify_phoenix_model_before_upload(model_path: str) -> Tuple[bool, str, Dict
     print("\n🧪 Pre-upload Verification...")
     
     try:
-        # 1. 파일 존재 확인 (safetensors OR pytorch_model.bin)
         model_path = Path(model_path)
         
-        # 필수 파일 체크 (모델 가중치는 둘 중 하나만 있으면 됨)
-        config_exists = (model_path / 'config.json').exists()
-        modeling_exists = (model_path / 'modeling_phoenix.py').exists()
-        readme_exists = (model_path / 'README.md').exists()
+        # 파일 존재 확인 (한 번만)
+        file_checks = {
+            'config': (model_path / 'config.json').exists(),
+            'modeling': (model_path / 'modeling_phoenix.py').exists(),
+            'readme': (model_path / 'README.md').exists(),
+            'safetensors': (model_path / 'model.safetensors').exists(),
+            'pytorch_bin': (model_path / 'pytorch_model.bin').exists(),
+        }
         
-        # 모델 가중치 파일 확인 (safetensors 우선)
-        safetensors_exists = (model_path / 'model.safetensors').exists()
-        pytorch_bin_exists = (model_path / 'pytorch_model.bin').exists()
-        model_weights_exist = safetensors_exists or pytorch_bin_exists
+        model_weights_exist = file_checks['safetensors'] or file_checks['pytorch_bin']
         
         print(f"   📄 File Check:")
-        print(f"      config.json: {'✅' if config_exists else '❌'}")
-        print(f"      modeling_phoenix.py: {'✅' if modeling_exists else '❌'}")
-        print(f"      README.md: {'✅' if readme_exists else '❌'}")
-        print(f"      model weights: {'✅ (safetensors)' if safetensors_exists else '✅ (pytorch_model.bin)' if pytorch_bin_exists else '❌'}")
+        print(f"      config.json: {'✅' if file_checks['config'] else '❌'}")
+        print(f"      modeling_phoenix.py: {'✅' if file_checks['modeling'] else '❌'}")
+        print(f"      README.md: {'✅' if file_checks['readme'] else '❌'}")
+        print(f"      model weights: {'✅ (safetensors)' if file_checks['safetensors'] else '✅ (pytorch_model.bin)' if file_checks['pytorch_bin'] else '❌'}")
         
-        if not config_exists:
+        if not file_checks['config']:
             return False, "❌ Missing file: config.json", {}
-        if not modeling_exists:
+        if not file_checks['modeling']:
             return False, "❌ Missing file: modeling_phoenix.py", {}
-        if not readme_exists:
+        if not file_checks['readme']:
             return False, "❌ Missing file: README.md", {}
         if not model_weights_exist:
-            return False, "❌ Missing model weights (need model.safetensors or pytorch_model.bin)", {}
+            return False, "❌ Missing model weights", {}
         
         print("   ✅ All required files present")
         
-        # 2. Config 검증
+        # Config 검증
         with open(model_path / 'config.json', 'r') as f:
             config = json.load(f)
         
@@ -1280,7 +1101,7 @@ def verify_phoenix_model_before_upload(model_path: str) -> Tuple[bool, str, Dict
         
         print("   ✅ Config validated")
         
-        # 3. 모델 로딩 테스트
+        # 모델 로딩 테스트
         print("   🔄 Testing model loading...")
         
         try:
@@ -1299,20 +1120,19 @@ def verify_phoenix_model_before_upload(model_path: str) -> Tuple[bool, str, Dict
             print(f"   ⚠️ Model loading warning: {e}")
             print(f"   Continuing with basic checks...")
             
-            # 로딩 실패해도 파일들이 있으면 통과
             metrics = {
                 'retention_layers': -1,
                 'total_layers': -1,
-                'retention_rate': 1.0,  # 파일 검증만 통과
-                'generation_quality': 0.8,  # 기본값
-                'model_format': 'safetensors' if safetensors_exists else 'pytorch_bin',
+                'retention_rate': 1.0,
+                'generation_quality': 0.8,
+                'model_format': 'safetensors' if file_checks['safetensors'] else 'pytorch_bin',
                 'verification_mode': 'file_only'
             }
             
             print("   ✅ File-based verification passed")
             return True, "✅ File checks passed (model loading skipped)", metrics
         
-        # 4. Retention 검증 (여러 경로 시도)
+        # Retention 검증
         print("   🔍 Verifying Retention layers...")
         
         retention_count = 0
@@ -1321,18 +1141,14 @@ def verify_phoenix_model_before_upload(model_path: str) -> Tuple[bool, str, Dict
         
         # 여러 가능한 구조 탐색
         if hasattr(model, '_original_model'):
-            # PhoenixModelForCausalLM의 _original_model
             actual_model = model._original_model
             if hasattr(actual_model, 'model') and hasattr(actual_model.model, 'layers'):
                 layers = actual_model.model.layers
         elif hasattr(model, 'model') and hasattr(model.model, 'layers'):
-            # 일반적인 구조
             layers = model.model.layers
         elif hasattr(model, 'transformer') and hasattr(model.transformer, 'h'):
-            # GPT 스타일
             layers = model.transformer.h
         elif hasattr(model, 'layers'):
-            # 직접 layers
             layers = model.layers
         
         if layers is not None:
@@ -1349,7 +1165,6 @@ def verify_phoenix_model_before_upload(model_path: str) -> Tuple[bool, str, Dict
             retention_rate = retention_count / total_layers if total_layers > 0 else 0
             print(f"   ✅ Retention layers: {retention_count}/{total_layers} ({retention_rate*100:.1f}%)")
         else:
-            # 레이어 구조를 못 찾았지만, 파일들이 정상이면 통과
             print(f"   ⚠️ Could not verify layer structure (custom architecture)")
             print(f"   ✅ Files are valid, proceeding...")
             
@@ -1358,13 +1173,12 @@ def verify_phoenix_model_before_upload(model_path: str) -> Tuple[bool, str, Dict
                 'total_layers': -1,
                 'retention_rate': 1.0,
                 'generation_quality': 0.8,
-                'model_format': 'safetensors' if safetensors_exists else 'pytorch_bin',
+                'model_format': 'safetensors' if file_checks['safetensors'] else 'pytorch_bin',
                 'verification_mode': 'file_only'
             }
             
             return True, "✅ File checks passed (layer verification skipped)", metrics
         
-        # Retention이 하나도 없으면 경고만 하고 통과 (파일은 정상)
         if retention_count == 0:
             print(f"   ⚠️ No Retention layers detected in loaded model")
             print(f"   ⚠️ This may be normal if custom code hasn't loaded yet")
@@ -1375,13 +1189,13 @@ def verify_phoenix_model_before_upload(model_path: str) -> Tuple[bool, str, Dict
                 'total_layers': total_layers,
                 'retention_rate': 0.0,
                 'generation_quality': 0.7,
-                'model_format': 'safetensors' if safetensors_exists else 'pytorch_bin',
+                'model_format': 'safetensors' if file_checks['safetensors'] else 'pytorch_bin',
                 'verification_mode': 'file_only'
             }
             
             return True, "✅ File checks passed (Retention will load on Hub)", metrics
         
-        # 5. 생성 테스트 (Retention이 있으면)
+        # 생성 테스트
         if retention_count > 0:
             print("   🚀 Testing generation...")
             
@@ -1404,17 +1218,13 @@ def verify_phoenix_model_before_upload(model_path: str) -> Tuple[bool, str, Dict
                         
                         # 품질 점수
                         score = 0.0
-                        
-                        # 길이 체크
                         if len(generated) > len(prompt):
                             score += 0.3
                         
-                        # 이상한 토큰 체크
                         weird_tokens = ['�', '[UNK]', 'priv', 'Brah', '__,__']
                         if not any(token in generated for token in weird_tokens):
                             score += 0.4
                         
-                        # 의미있는 생성
                         if len(generated.split()) > len(prompt.split()) + 3:
                             score += 0.3
                         
@@ -1431,15 +1241,15 @@ def verify_phoenix_model_before_upload(model_path: str) -> Tuple[bool, str, Dict
             avg_score = sum(generation_scores) / len(generation_scores) if generation_scores else 0.0
             print(f"   ✅ Generation quality: {avg_score:.2f}/1.00")
         else:
-            avg_score = 0.7  # 기본값
+            avg_score = 0.7
         
-        # 6. 최종 검증 통과
+        # 최종 검증 통과
         metrics = {
             'retention_layers': retention_count,
             'total_layers': total_layers,
             'retention_rate': retention_rate if total_layers > 0 else 0.0,
             'generation_quality': avg_score,
-            'model_format': 'safetensors' if safetensors_exists else 'pytorch_bin',
+            'model_format': 'safetensors' if file_checks['safetensors'] else 'pytorch_bin',
             'verification_mode': 'full' if retention_count > 0 else 'file_only'
         }
         
@@ -1451,18 +1261,18 @@ def verify_phoenix_model_before_upload(model_path: str) -> Tuple[bool, str, Dict
         import traceback
         error_msg = traceback.format_exc()
         
-        # 예외 발생해도 파일만 체크하고 통과
         print(f"\n⚠️ Verification exception: {str(e)}")
         print(f"   Checking files only...")
         
         model_path = Path(model_path)
-        config_exists = (model_path / 'config.json').exists()
-        modeling_exists = (model_path / 'modeling_phoenix.py').exists()
-        readme_exists = (model_path / 'README.md').exists()
-        safetensors_exists = (model_path / 'model.safetensors').exists()
-        pytorch_bin_exists = (model_path / 'pytorch_model.bin').exists()
+        file_checks = {
+            'config': (model_path / 'config.json').exists(),
+            'modeling': (model_path / 'modeling_phoenix.py').exists(),
+            'safetensors': (model_path / 'model.safetensors').exists(),
+            'pytorch_bin': (model_path / 'pytorch_model.bin').exists(),
+        }
         
-        if config_exists and modeling_exists and (safetensors_exists or pytorch_bin_exists):
+        if file_checks['config'] and file_checks['modeling'] and (file_checks['safetensors'] or file_checks['pytorch_bin']):
             print(f"   ✅ Essential files present, proceeding...")
             
             metrics = {
@@ -1470,7 +1280,7 @@ def verify_phoenix_model_before_upload(model_path: str) -> Tuple[bool, str, Dict
                 'total_layers': -1,
                 'retention_rate': 1.0,
                 'generation_quality': 0.7,
-                'model_format': 'safetensors' if safetensors_exists else 'pytorch_bin',
+                'model_format': 'safetensors' if file_checks['safetensors'] else 'pytorch_bin',
                 'verification_mode': 'minimal'
             }
             
@@ -1480,7 +1290,7 @@ def verify_phoenix_model_before_upload(model_path: str) -> Tuple[bool, str, Dict
 
 
 # =====================================================
-# HuggingFace Hub Upload (수정!)
+# HuggingFace Hub Upload
 # =====================================================
 
 def upload_to_huggingface_hub(
@@ -1580,21 +1390,6 @@ def upload_to_huggingface_hub(
         print(f"\n📤 Uploading files to HuggingFace Hub...")
         print(f"   This may take a few minutes depending on model size...")
         
-        # 필수 파일 체크 (safetensors OR pytorch_model.bin)
-        config_exists = (model_path / 'config.json').exists()
-        modeling_exists = (model_path / 'modeling_phoenix.py').exists()
-        safetensors_exists = (model_path / 'model.safetensors').exists()
-        pytorch_bin_exists = (model_path / 'pytorch_model.bin').exists()
-        
-        if not config_exists:
-            return False, "", "❌ config.json not found"
-        if not modeling_exists:
-            return False, "", "❌ modeling_phoenix.py not found"
-        if not (safetensors_exists or pytorch_bin_exists):
-            return False, "", "❌ Model weights not found (need model.safetensors or pytorch_model.bin)"
-        
-        print(f"✅ All required files present")
-        
         try:
             api.upload_folder(
                 folder_path=str(model_path),
@@ -1757,420 +1552,96 @@ class ExperimentDatabase:
             return [dict(row) for row in cursor.fetchall()]
 
 
-
-
-
 # =====================================================
-# 모델 버닝 UI 함수 (개선!)
+# 모델 버닝 함수
 # =====================================================
 
-def burn_phoenix_model_ui(
-    model_url,
-    use_hierarchical,
-    dataset_path,
-    output_name,
-    use_finetuning,
-    num_epochs,
-    batch_size,
-    learning_rate,
-    max_steps,
-    upload_to_hub,
-    hub_repo_name,
-    hub_private,
-):
-    """Gradio UI용 모델 버닝 함수 (업로드 개선!)"""
+def evaluate_model_quality(model, tokenizer, test_prompts=None):
+    """간단한 모델 품질 평가"""
+    if test_prompts is None:
+        test_prompts = [
+            "The capital of France is",
+            "In machine learning, overfitting means",
+            "2 + 2 =",
+        ]
     
-    print("\n" + "="*80)
-    print("🔥 PHOENIX MODEL BURNING START")
+    model.eval()
+    scores = []
+    
+    with torch.no_grad():
+        for prompt in test_prompts:
+            try:
+                inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+                outputs = model.generate(
+                    **inputs,
+                    max_new_tokens=20,
+                    do_sample=False,
+                    pad_token_id=tokenizer.eos_token_id,
+                )
+                generated = tokenizer.decode(outputs[0], skip_special_tokens=True)
+                
+                score = 0.0
+                if len(generated) > len(prompt):
+                    score += 0.3
+                if not any(char in generated[len(prompt):] for char in ['�', '[UNK]']):
+                    score += 0.3
+                if len(generated.split()) > len(prompt.split()) + 2:
+                    score += 0.4
+                
+                scores.append(score)
+            except Exception as e:
+                print(f"  ⚠️ Evaluation error for '{prompt}': {e}")
+                scores.append(0.0)
+    
+    return sum(scores) / len(scores) if scores else 0.0
+
+
+def burn_model_zero_shot(
+    model_url: str,
+    output_dir: str,
+    use_hierarchical: bool = True,
+    test_prompts: List[str] = None,
+):
+    """Zero-shot Model Burning with Custom Code"""
+    print("="*80)
+    print("🔥 PHOENIX Zero-shot Model Burning")
     print("="*80)
     
+    output_path = Path(output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+    
     try:
-        # 입력 검증
-        if not model_url.strip():
-            return "⚠️ Model URL is required", None
+        # 1. Load model
+        print(f"\n📥 Loading model: {model_url}")
+        start_time = time.time()
         
-        if not output_name.strip():
-            output_name = f"phoenix_{model_url.split('/')[-1]}_{int(time.time())}"
+        config = AutoConfig.from_pretrained(model_url, trust_remote_code=True)
+        model = AutoModelForCausalLM.from_pretrained(
+            model_url,
+            trust_remote_code=True,
+            torch_dtype=torch.float16,
+        ).to(DEVICE)
         
-        output_dir = f"{MODELS_PATH}/{output_name}"
+        tokenizer = AutoTokenizer.from_pretrained(model_url, trust_remote_code=True)
+        if tokenizer.pad_token is None:
+            tokenizer.pad_token = tokenizer.eos_token
         
-        print(f"📋 Configuration:")
-        print(f"   Model URL: {model_url}")
-        print(f"   Output Name: {output_name}")
-        print(f"   Output Dir: {output_dir}")
-        print(f"   Hierarchical: {use_hierarchical}")
-        print(f"   Upload to Hub: {upload_to_hub}")
+        load_time = time.time() - start_time
+        print(f"✅ Loaded in {load_time:.1f}s")
         
-        has_dataset = dataset_path and dataset_path.strip() and Path(dataset_path).exists()
+        # 2. Convert
+        print(f"\n🔄 Converting Attention → Retention...")
+        convert_start = time.time()
         
-        if use_finetuning and not has_dataset:
-            return "⚠️ Fine-tuning requires a valid dataset path", None
+        model.model, converted, total = replace_attention_with_retention(
+            model.model,
+            use_hierarchical=use_hierarchical
+        )
         
-        # HF Token 확인 (업로드 예정인 경우)
-        if upload_to_hub and not HF_TOKEN:
-            warning_msg = """
-⚠️ **HuggingFace Token Not Found!**
-
-Model will be burned locally, but upload will fail.
-
-To enable upload:
-1. Set `HF_TOKEN` environment variable
-2. Restart the application
-
-Continuing with local burning only...
-"""
-            print(f"\n{warning_msg}")
+        convert_time = time.time() - convert_start
+        conversion_rate = converted / total if total > 0 else 0
         
-        # Burning 실행
-        print(f"\n{'='*80}")
-        if use_finetuning and has_dataset:
-            print("🚀 Starting Fine-tuning Burning...")
-            result = burn_model_with_finetuning(
-                model_url=model_url,
-                output_dir=output_dir,
-                dataset_path=dataset_path,
-                use_hierarchical=use_hierarchical,
-                num_epochs=num_epochs,
-                batch_size=batch_size,
-                learning_rate=learning_rate,
-                max_steps=max_steps,
-            )
-        else:
-            print("🚀 Starting Zero-shot Burning...")
-            result = burn_model_zero_shot(
-                model_url=model_url,
-                output_dir=output_dir,
-                use_hierarchical=use_hierarchical,
-            )
-        
-        if result['status'] != 'success':
-            error_msg = f"""
-❌ **Burning Failed**
-```
-{result.get('error', 'Unknown error')}
-```
-
-**Traceback:**
-```
-{result.get('traceback', 'N/A')}
-```
-"""
-            return error_msg, None
-        
-        print(f"\n✅ Burning completed successfully!")
-        
-        # HuggingFace Hub 업로드
-        hub_url = None
-        verification_passed = False
-        upload_status = "Not attempted"
-        
-        if upload_to_hub:
-            if not HF_TOKEN:
-                upload_status = "❌ Failed - No HF_TOKEN"
-                print(f"\n{upload_status}")
-            else:
-                print(f"\n{'='*80}")
-                print("📤 Starting HuggingFace Hub Upload...")
-                print(f"{'='*80}")
-                
-                success, hub_url, upload_msg = upload_to_huggingface_hub(
-                    model_path=result['model_path'],
-                    original_model_url=model_url,
-                    repo_name=hub_repo_name if hub_repo_name.strip() else None,
-                    private=hub_private,
-                    skip_verification=False
-                )
-                
-                verification_passed = success
-                
-                if success:
-                    upload_status = f"✅ Uploaded successfully to {hub_url}"
-                    print(f"\n{upload_status}")
-                else:
-                    upload_status = f"❌ Upload failed\n\n{upload_msg}"
-                    print(f"\n{upload_status}")
-        else:
-            upload_status = "⏭️ Skipped (not requested)"
-            print(f"\n📦 Hub upload: {upload_status}")
-        
-        # 데이터베이스 저장
-        burning_info = {
-            'model_url': model_url,
-            'output_path': result['model_path'],
-            'hub_url': hub_url,
-            'use_hierarchical': use_hierarchical,
-            'dataset_used': has_dataset,
-            'conversion_rate': result.get('conversion_rate', 0.0),
-            'training_steps': result.get('training_steps', 0),
-            'final_loss': result.get('final_loss'),
-            'evaluation_score': result.get('quality_score', 0.0),
-            'verification_passed': verification_passed,
-        }
-        
-        db.save_burning(burning_info)
-        print(f"✅ Saved to database")
-        
-        # 결과 포맷팅
-        output_md = f"""
-# 🔥 Model Burning Complete!
-
-## 📦 Model Information
-- **Original Model**: {model_url}
-- **Output Path**: `{result['model_path']}`
-- **Burning Type**: {'Fine-tuning' if has_dataset else 'Zero-shot'}
-- **Hierarchical**: {use_hierarchical}
-
-## 📊 Metrics
-- **Conversion Rate**: {result.get('conversion_rate', 0)*100:.1f}%
-- **Quality Score**: {result.get('quality_score', 0):.2f}/1.00
-"""
-        
-        if 'training_steps' in result:
-            output_md += f"""
-## 🚀 Training
-- **Steps**: {result['training_steps']}
-- **Final Loss**: {result.get('final_loss', 0.0):.4f}
-"""
-        
-        output_md += f"""
-## ⏱️ Time Breakdown
-- **Total**: {result.get('total_time', 0):.1f}s
-"""
-        
-        if 'load_time' in result:
-            output_md += f"- **Load**: {result['load_time']:.1f}s\n"
-            output_md += f"- **Convert**: {result['convert_time']:.1f}s\n"
-            output_md += f"- **Evaluate**: {result['eval_time']:.1f}s\n"
-            output_md += f"- **Save**: {result['save_time']:.1f}s\n"
-        
-        # Hub Upload 상태
-        output_md += f"""
----
-
-## 🌐 HuggingFace Hub Upload
-
-**Status**: {upload_status}
-"""
-        
-        if hub_url:
-            output_md += f"""
-**Model URL**: [{hub_url}]({hub_url})
-**Privacy**: {'🔒 Private' if hub_private else '🌍 Public'}
-**Verification**: {'✅ Passed' if verification_passed else '⚠️ Not verified'}
-
-### 🚀 Load from Hub
-```python
-from transformers import AutoModelForCausalLM, AutoTokenizer
-
-# ⚠️ MUST use trust_remote_code=True
-model = AutoModelForCausalLM.from_pretrained(
-    "{hub_url.replace('https://huggingface.co/', '')}",
-    trust_remote_code=True,  # Required!
-    torch_dtype="auto",
-    device_map="auto"
-)
-tokenizer = AutoTokenizer.from_pretrained(
-    "{hub_url.replace('https://huggingface.co/', '')}"
-)
-
-# Generate
-inputs = tokenizer("Your prompt here", return_tensors="pt")
-outputs = model.generate(**inputs, max_new_tokens=50)
-print(tokenizer.decode(outputs[0], skip_special_tokens=True))
-```
-"""
-        elif upload_to_hub:
-            output_md += f"""
-**Upload failed!** Check logs for details.
-
-💡 **Troubleshooting:**
-1. Ensure `HF_TOKEN` environment variable is set
-2. Check token permissions (write access required)
-3. Verify network connectivity
-4. Review error messages above
-"""
-        
-        output_md += f"""
----
-
-## 🎯 Local Usage
-```python
-from transformers import AutoModelForCausalLM, AutoTokenizer
-
-# Load from local path
-model = AutoModelForCausalLM.from_pretrained(
-    "{result['model_path']}",
-    trust_remote_code=True  # Important!
-)
-tokenizer = AutoTokenizer.from_pretrained("{result['model_path']}")
-
-# Generate
-inputs = tokenizer("Your prompt", return_tensors="pt")
-outputs = model.generate(**inputs, max_new_tokens=50)
-print(tokenizer.decode(outputs[0], skip_special_tokens=True))
-```
-
----
-
-✅ **PHOENIX Model Ready!**
-
-{'📤 Model uploaded to HuggingFace Hub' if hub_url else '💾 Model saved locally'}
-"""
-        
-        # 플롯 생성
-        fig = go.Figure()
-        
-        metrics_names = ['Conversion', 'Quality']
-        metrics_values = [result.get('conversion_rate', 0), result.get('quality_score', 0)]
-        metrics_text = [
-            f"{result.get('conversion_rate', 0)*100:.1f}%",
-            f"{result.get('quality_score', 0):.2f}"
-        ]
-        
-        if verification_passed:
-            metrics_names.append('Upload')
-            metrics_values.append(1.0)
-            metrics_text.append('✅')
-        
-        fig.add_trace(go.Bar(
-            x=metrics_names,
-            y=metrics_values,
-            text=metrics_text,
-            textposition='auto',
-            marker_color=['#3b82f6', '#10b981', '#8b5cf6'][:len(metrics_names)]
-        ))
-        
-        fig.update_layout(
-            title="🔥 Burning Metrics",
-            yaxis_range=[0, 1],
-            template='plotly_white',
-            height=400
-        )
-        
-        print(f"\n{'='*80}")
-        print(f"✅ PHOENIX MODEL BURNING COMPLETE!")
-        print(f"{'='*80}\n")
-        
-        return output_md, fig
-        
-    except Exception as e:
-        import traceback
-        error_msg = traceback.format_exc()
-        
-        print(f"\n{'='*80}")
-        print(f"❌ BURNING FAILED")
-        print(f"{'='*80}")
-        print(f"{error_msg}")
-        print(f"{'='*80}\n")
-        
-        return f"""
-❌ **Burning Failed**
-
-**Error:** {str(e)}
-
-**Full Traceback:**
-```
-{error_msg}
-```
-
-**Troubleshooting:**
-1. Check model URL is valid
-2. Ensure sufficient disk space
-3. Verify GPU availability
-4. Check logs above for details
-""", None
-
-
-# =====================================================
-# 모델 버닝 (Zero-shot + Optional Fine-tuning)
-# =====================================================
-
-def evaluate_model_quality(model, tokenizer, test_prompts=None):
-    """간단한 모델 품질 평가"""
-    if test_prompts is None:
-        test_prompts = [
-            "The capital of France is",
-            "In machine learning, overfitting means",
-            "2 + 2 =",
-        ]
-    
-    model.eval()
-    scores = []
-    
-    with torch.no_grad():
-        for prompt in test_prompts:
-            try:
-                inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
-                outputs = model.generate(
-                    **inputs,
-                    max_new_tokens=20,
-                    do_sample=False,
-                    pad_token_id=tokenizer.eos_token_id,
-                )
-                generated = tokenizer.decode(outputs[0], skip_special_tokens=True)
-                
-                score = 0.0
-                if len(generated) > len(prompt):
-                    score += 0.3
-                if not any(char in generated[len(prompt):] for char in ['�', '[UNK]']):
-                    score += 0.3
-                if len(generated.split()) > len(prompt.split()) + 2:
-                    score += 0.4
-                
-                scores.append(score)
-            except Exception as e:
-                print(f"  ⚠️ Evaluation error for '{prompt}': {e}")
-                scores.append(0.0)
-    
-    return sum(scores) / len(scores) if scores else 0.0
-
-
-def burn_model_zero_shot(
-    model_url: str,
-    output_dir: str,
-    use_hierarchical: bool = True,
-    test_prompts: List[str] = None,
-):
-    """Zero-shot Model Burning with Custom Code"""
-    print("="*80)
-    print("🔥 PHOENIX Zero-shot Model Burning")
-    print("="*80)
-    
-    output_path = Path(output_dir)
-    output_path.mkdir(parents=True, exist_ok=True)
-    
-    try:
-        # 1. Load model
-        print(f"\n📥 Loading model: {model_url}")
-        start_time = time.time()
-        
-        config = AutoConfig.from_pretrained(model_url, trust_remote_code=True)
-        model = AutoModelForCausalLM.from_pretrained(
-            model_url,
-            trust_remote_code=True,
-            torch_dtype=torch.float16,
-        ).to(DEVICE)
-        
-        tokenizer = AutoTokenizer.from_pretrained(model_url, trust_remote_code=True)
-        if tokenizer.pad_token is None:
-            tokenizer.pad_token = tokenizer.eos_token
-        
-        load_time = time.time() - start_time
-        print(f"✅ Loaded in {load_time:.1f}s")
-        
-        # 2. Convert
-        print(f"\n🔄 Converting Attention → Retention...")
-        convert_start = time.time()
-        
-        model.model, converted, total = replace_attention_with_retention(
-            model.model,
-            use_hierarchical=use_hierarchical
-        )
-        
-        convert_time = time.time() - convert_start
-        conversion_rate = converted / total if total > 0 else 0
-        
-        print(f"✅ Converted {converted}/{total} layers ({conversion_rate*100:.1f}%) in {convert_time:.1f}s")
+        print(f"✅ Converted {converted}/{total} layers ({conversion_rate*100:.1f}%) in {convert_time:.1f}s")
         
         # 3. Evaluate
         print(f"\n📊 Evaluating model quality...")
@@ -2508,22 +1979,52 @@ def burn_phoenix_model_ui(
     hub_private,
 ):
     """Gradio UI용 모델 버닝 함수"""
+    
+    print("\n" + "="*80)
+    print("🔥 PHOENIX MODEL BURNING START")
+    print("="*80)
+    
     try:
+        # 입력 검증
         if not model_url.strip():
-            return "⚠️ Model URL required", None
+            return "⚠️ Model URL is required", None
         
         if not output_name.strip():
             output_name = f"phoenix_{model_url.split('/')[-1]}_{int(time.time())}"
         
         output_dir = f"{MODELS_PATH}/{output_name}"
         
+        print(f"📋 Configuration:")
+        print(f"   Model URL: {model_url}")
+        print(f"   Output Name: {output_name}")
+        print(f"   Output Dir: {output_dir}")
+        print(f"   Hierarchical: {use_hierarchical}")
+        print(f"   Upload to Hub: {upload_to_hub}")
+        
         has_dataset = dataset_path and dataset_path.strip() and Path(dataset_path).exists()
         
         if use_finetuning and not has_dataset:
-            return "⚠️ Fine-tuning requires dataset path", None
+            return "⚠️ Fine-tuning requires a valid dataset path", None
+        
+        # HF Token 확인
+        if upload_to_hub and not HF_TOKEN:
+            warning_msg = """
+⚠️ **HuggingFace Token Not Found!**
+
+Model will be burned locally, but upload will fail.
+
+To enable upload:
+1. Set `HF_TOKEN` environment variable
+2. Restart the application
+
+Continuing with local burning only...
+"""
+            print(f"\n{warning_msg}")
         
-        # Burning
+        # Burning 실행
+        print(f"\n{'='*80}")
         if use_finetuning and has_dataset:
+            print("🚀 Starting Fine-tuning Burning...")
             result = burn_model_with_finetuning(
                 model_url=model_url,
                 output_dir=output_dir,
@@ -2535,155 +2036,249 @@ def burn_phoenix_model_ui(
                 max_steps=max_steps,
             )
         else:
+            print("🚀 Starting Zero-shot Burning...")
             result = burn_model_zero_shot(
                 model_url=model_url,
                 output_dir=output_dir,
                 use_hierarchical=use_hierarchical,
             )
         
-        if result['status'] == 'success':
-            hub_url = None
-            verification_passed = False
-            
-            # Upload to Hub with verification
-            if upload_to_hub:
+        if result['status'] != 'success':
+            error_msg = f"""
+❌ **Burning Failed**
+```
+{result.get('error', 'Unknown error')}
+```
+
+**Traceback:**
+```
+{result.get('traceback', 'N/A')}
+```
+"""
+            return error_msg, None
+        
+        print(f"\n✅ Burning completed successfully!")
+        
+        # HuggingFace Hub 업로드
+        hub_url = None
+        verification_passed = False
+        upload_status = "Not attempted"
+        
+        if upload_to_hub:
+            if not HF_TOKEN:
+                upload_status = "❌ Failed - No HF_TOKEN"
+                print(f"\n{upload_status}")
+            else:
+                print(f"\n{'='*80}")
+                print("📤 Starting HuggingFace Hub Upload...")
+                print(f"{'='*80}")
+                
                 success, hub_url, upload_msg = upload_to_huggingface_hub(
                     model_path=result['model_path'],
                     original_model_url=model_url,
                     repo_name=hub_repo_name if hub_repo_name.strip() else None,
                     private=hub_private,
-                    skip_verification=False  # 검증 활성화!
+                    skip_verification=False
                 )
                 
                 verification_passed = success
                 
-                if not success:
-                    print(f"\n{upload_msg}")
-            
-            # Save to DB
-            burning_info = {
-                'model_url': model_url,
-                'output_path': result['model_path'],
-                'hub_url': hub_url,
-                'use_hierarchical': use_hierarchical,
-                'dataset_used': has_dataset,
-                'conversion_rate': result.get('conversion_rate', 0.0),
-                'training_steps': result.get('training_steps', 0),
-                'final_loss': result.get('final_loss'),
-                'evaluation_score': result.get('quality_score', 0.0),
-                'verification_passed': verification_passed,
-            }
-            
-            db.save_burning(burning_info)
-            
-            # Format output
-            output_md = f"""
+                if success:
+                    upload_status = f"✅ Uploaded successfully to {hub_url}"
+                    print(f"\n{upload_status}")
+                else:
+                    upload_status = f"❌ Upload failed\n\n{upload_msg}"
+                    print(f"\n{upload_status}")
+        else:
+            upload_status = "⏭️ Skipped (not requested)"
+            print(f"\n📦 Hub upload: {upload_status}")
+        
+        # 데이터베이스 저장
+        burning_info = {
+            'model_url': model_url,
+            'output_path': result['model_path'],
+            'hub_url': hub_url,
+            'use_hierarchical': use_hierarchical,
+            'dataset_used': has_dataset,
+            'conversion_rate': result.get('conversion_rate', 0.0),
+            'training_steps': result.get('training_steps', 0),
+            'final_loss': result.get('final_loss'),
+            'evaluation_score': result.get('quality_score', 0.0),
+            'verification_passed': verification_passed,
+        }
+        
+        db.save_burning(burning_info)
+        print(f"✅ Saved to database")
+        
+        # 결과 포맷팅
+        output_md = f"""
 # 🔥 Model Burning Complete!
 
 ## 📦 Model Information
-- **Original**: {model_url}
-- **Output**: `{result['model_path']}`
-- **Type**: {'Fine-tuning' if has_dataset else 'Zero-shot'}
+- **Original Model**: {model_url}
+- **Output Path**: `{result['model_path']}`
+- **Burning Type**: {'Fine-tuning' if has_dataset else 'Zero-shot'}
+- **Hierarchical**: {use_hierarchical}
+
+## 📊 Metrics
+- **Conversion Rate**: {result.get('conversion_rate', 0)*100:.1f}%
+- **Quality Score**: {result.get('quality_score', 0):.2f}/1.00
 """
-            
-            if hub_url:
-                output_md += f"""
-## 🌐 HuggingFace Hub
-- **URL**: [{hub_url}]({hub_url})
-- **Private**: {hub_private}
-- **Status**: ✅ Uploaded & Verified
+        
+        if 'training_steps' in result:
+            output_md += f"""
+## 🚀 Training
+- **Steps**: {result['training_steps']}
+- **Final Loss**: {result.get('final_loss', 0.0):.4f}
+"""
+        
+        output_md += f"""
+## ⏱️ Time Breakdown
+- **Total**: {result.get('total_time', 0):.1f}s
+"""
+        
+        if 'load_time' in result:
+            output_md += f"- **Load**: {result['load_time']:.1f}s\n"
+            output_md += f"- **Convert**: {result['convert_time']:.1f}s\n"
+            output_md += f"- **Evaluate**: {result['eval_time']:.1f}s\n"
+            output_md += f"- **Save**: {result['save_time']:.1f}s\n"
+        
+        # Hub Upload 상태
+        output_md += f"""
+---
+
+## 🌐 HuggingFace Hub Upload
+
+**Status**: {upload_status}
+"""
+        
+        if hub_url:
+            output_md += f"""
+**Model URL**: [{hub_url}]({hub_url})
+**Privacy**: {'🔒 Private' if hub_private else '🌍 Public'}
+**Verification**: {'✅ Passed' if verification_passed else '⚠️ Not verified'}
 
 ### 🚀 Load from Hub
 ```python
 from transformers import AutoModelForCausalLM, AutoTokenizer
 
-# ⚠️ CRITICAL: Must use trust_remote_code=True
+# ⚠️ MUST use trust_remote_code=True
 model = AutoModelForCausalLM.from_pretrained(
     "{hub_url.replace('https://huggingface.co/', '')}",
     trust_remote_code=True,  # Required!
     torch_dtype="auto",
     device_map="auto"
 )
-tokenizer = AutoTokenizer.from_pretrained("{hub_url.replace('https://huggingface.co/', '')}")
+tokenizer = AutoTokenizer.from_pretrained(
+    "{hub_url.replace('https://huggingface.co/', '')}"
+)
 
 # Generate
-inputs = tokenizer("Your prompt", return_tensors="pt")
+inputs = tokenizer("Your prompt here", return_tensors="pt")
 outputs = model.generate(**inputs, max_new_tokens=50)
-print(tokenizer.decode(outputs[0]))
+print(tokenizer.decode(outputs[0], skip_special_tokens=True))
 ```
 """
-            elif upload_to_hub:
-                output_md += f"""
-## 🌐 HuggingFace Hub
-- **Status**: ❌ Upload/Verification failed (check logs)
-"""
-            
-            output_md += f"""
-## 📊 Metrics
-- **Conversion Rate**: {result['conversion_rate']*100:.1f}%
-- **Quality Score**: {result.get('quality_score', 0.0):.2f}/1.00
-- **Verification**: {'✅ Passed' if verification_passed else '⚠️ Not verified'}
-"""
-            
-            if 'training_steps' in result:
-                output_md += f"""
-## 🚀 Training
-- **Steps**: {result['training_steps']}
-- **Final Loss**: {result.get('final_loss', 0.0):.4f}
-"""
-            
+        elif upload_to_hub:
             output_md += f"""
-## ⏱️ Time Breakdown
-- **Total**: {result.get('total_time', 0):.1f}s
+**Upload failed!** Check logs for details.
+
+💡 **Troubleshooting:**
+1. Ensure `HF_TOKEN` environment variable is set
+2. Check token permissions (write access required)
+3. Verify network connectivity
+4. Review error messages above
 """
-            
-            if 'load_time' in result:
-                output_md += f"- **Load**: {result['load_time']:.1f}s\n"
-                output_md += f"- **Convert**: {result['convert_time']:.1f}s\n"
-                output_md += f"- **Evaluate**: {result['eval_time']:.1f}s\n"
-                output_md += f"- **Save**: {result['save_time']:.1f}s\n"
-            
-            output_md += f"""
+        
+        output_md += f"""
+---
+
 ## 🎯 Local Usage
 ```python
 from transformers import AutoModelForCausalLM, AutoTokenizer
 
+# Load from local path
 model = AutoModelForCausalLM.from_pretrained(
     "{result['model_path']}",
     trust_remote_code=True  # Important!
 )
 tokenizer = AutoTokenizer.from_pretrained("{result['model_path']}")
 
+# Generate
 inputs = tokenizer("Your prompt", return_tensors="pt")
 outputs = model.generate(**inputs, max_new_tokens=50)
-print(tokenizer.decode(outputs[0]))
+print(tokenizer.decode(outputs[0], skip_special_tokens=True))
 ```
 
-✅ **PHOENIX Model Ready with Custom Code & Verification!**
+---
+
+✅ **PHOENIX Model Ready!**
+
+{'📤 Model uploaded to HuggingFace Hub' if hub_url else '💾 Model saved locally'}
 """
-            
-            # Plot
-            fig = go.Figure()
-            fig.add_trace(go.Bar(
-                x=['Conversion', 'Quality', 'Verification'],
-                y=[result['conversion_rate'], result.get('quality_score', 0.0), 1.0 if verification_passed else 0.0],
-                text=[f"{result['conversion_rate']*100:.1f}%", f"{result.get('quality_score', 0.0):.2f}", '✅' if verification_passed else '❌'],
-                textposition='auto',
-            ))
-            fig.update_layout(
-                title="Burning Metrics",
-                yaxis_range=[0, 1],
-                template='plotly_white'
-            )
-            
-            return output_md, fig
-            
-        else:
-            return f"❌ Burning failed:\n```\n{result.get('error', 'Unknown error')}\n```", None
-            
+        
+        # 플롯 생성
+        fig = go.Figure()
+        
+        metrics_names = ['Conversion', 'Quality']
+        metrics_values = [result.get('conversion_rate', 0), result.get('quality_score', 0)]
+        metrics_text = [
+            f"{result.get('conversion_rate', 0)*100:.1f}%",
+            f"{result.get('quality_score', 0):.2f}"
+        ]
+        
+        if verification_passed:
+            metrics_names.append('Upload')
+            metrics_values.append(1.0)
+            metrics_text.append('✅')
+        
+        fig.add_trace(go.Bar(
+            x=metrics_names,
+            y=metrics_values,
+            text=metrics_text,
+            textposition='auto',
+            marker_color=['#3b82f6', '#10b981', '#8b5cf6'][:len(metrics_names)]
+        ))
+        
+        fig.update_layout(
+            title="🔥 Burning Metrics",
+            yaxis_range=[0, 1],
+            template='plotly_white',
+            height=400
+        )
+        
+        print(f"\n{'='*80}")
+        print(f"✅ PHOENIX MODEL BURNING COMPLETE!")
+        print(f"{'='*80}\n")
+        
+        return output_md, fig
+        
     except Exception as e:
         import traceback
-        return f"❌ Error:\n```\n{traceback.format_exc()}\n```", None
+        error_msg = traceback.format_exc()
+        
+        print(f"\n{'='*80}")
+        print(f"❌ BURNING FAILED")
+        print(f"{'='*80}")
+        print(f"{error_msg}")
+        print(f"{'='*80}\n")
+        
+        return f"""
+❌ **Burning Failed**
+
+**Error:** {str(e)}
+
+**Full Traceback:**
+```
+{error_msg}
+```
+
+**Troubleshooting:**
+1. Check model URL is valid
+2. Ensure sufficient disk space
+3. Verify GPU availability
+4. Check logs above for details
+""", None
 
 
 def view_burning_history():
@@ -2971,7 +2566,7 @@ with gr.Blocks(
     ✅ O(n) Complexity
     ✅ Auto Upload to HuggingFace Hub
     ✅ Custom Code for Proper Loading
-    ✅ Pre-upload Verification (NEW!)
+    ✅ Pre-upload Verification
     
     ---
     """)
@@ -3012,8 +2607,8 @@ with gr.Blocks(
             - **Zero-shot**: 데이터셋 없이 변환만 수행 (빠름!)
             - **Fine-tuning**: 데이터셋으로 추가 학습 (성능 향상)
             - **HuggingFace Hub**: 자동으로 Hub에 업로드 (Private 기본)
-            - **Custom Code**: modeling_phoenix.py 자동 생성 (trust_remote_code=True)
-            - **Pre-upload Verification**: 업로드 전 Retention 동작 확인 (NEW!)
+            - **Custom Code**: modeling_phoenix.py 자동 생성
+            - **Pre-upload Verification**: 업로드 전 검증
             """)
             
             with gr.Row():
@@ -3040,7 +2635,7 @@ with gr.Blocks(
                     
                     burn_hub_repo = gr.Textbox(
                         label="📦 Hub Repository Name (optional)",
-                        placeholder="phoenix-granite-350m (auto-generated if empty)"
+                        placeholder="phoenix-granite-350m"
                     )
                     
                     burn_hub_private = gr.Checkbox(
@@ -3053,7 +2648,7 @@ with gr.Blocks(
                     
                     burn_dataset = gr.Textbox(
                         label="📁 Dataset Path (Optional)",
-                        placeholder="/path/to/dataset.txt (leave empty for zero-shot)",
+                        placeholder="/path/to/dataset.txt",
                         value=""
                     )
                     
@@ -3148,13 +2743,6 @@ with gr.Blocks(
             ### 🧪 PHOENIX 모델 검증
             
             배포된 PHOENIX 모델을 로드하고 품질을 검증합니다.
-            
-            - **HuggingFace Hub**: 공개/비공개 모델 로드
-            - **Local Path**: 로컬 저장 모델 로드
-            - **Generation Test**: 실제 텍스트 생성 테스트
-            - **Retention Verification**: PHOENIX 메커니즘 확인
-            
-            ⚠️ **Important**: Use `trust_remote_code=True` when loading PHOENIX models!
             """)
             
             with gr.Row():
@@ -3168,38 +2756,25 @@ with gr.Blocks(
                     val_path = gr.Textbox(
                         label="🔗 Model Path/URL",
                         value="seawolf2357/phoenix-granite-4.0-h-350m",
-                        placeholder="seawolf2357/phoenix-granite-4.0-h-350m or /data/phoenix_models/..."
+                        placeholder="seawolf2357/phoenix-model"
                     )
                     
                     val_prompts = gr.Textbox(
                         label="📝 Test Prompts (one per line)",
                         lines=5,
                         value="The future of AI is\nOnce upon a time\nIn machine learning,",
-                        placeholder="Enter test prompts..."
                     )
                     
                     with gr.Row():
-                        val_max_tokens = gr.Slider(
-                            16, 256, 64,
-                            step=16,
-                            label="Max Tokens"
-                        )
-                        val_temp = gr.Slider(
-                            0.1, 2.0, 0.7,
-                            step=0.1,
-                            label="Temperature"
-                        )
+                        val_max_tokens = gr.Slider(16, 256, 64, step=16, label="Max Tokens")
+                        val_temp = gr.Slider(0.1, 2.0, 0.7, step=0.1, label="Temperature")
                     
                     val_verify_retention = gr.Checkbox(
                         value=True,
                         label="🔍 Verify Retention Mechanism"
                     )
                     
-                    val_btn = gr.Button(
-                        "🧪 Validate Model",
-                        variant="primary",
-                        size="lg"
-                    )
+                    val_btn = gr.Button("🧪 Validate Model", variant="primary", size="lg")
                 
                 with gr.Column(scale=2):
                     val_output = gr.Markdown()
@@ -3211,54 +2786,22 @@ with gr.Blocks(
                  val_temp, val_verify_retention],
                 [val_output, val_plot]
             )
-            
-            gr.Markdown("""
-            ---
-            
-            ### 💡 Quick Validation
-            
-            1. Select **"hub"** as source
-            2. Enter model URL (e.g., `seawolf2357/phoenix-granite-4.0-h-350m`)
-            3. Click **"Validate Model"**
-            4. Check generation quality and Retention verification!
-            
-            **Example prompts:**
-            - `The future of AI is`
-            - `Once upon a time`
-            - `In machine learning,`
-            - `Explain quantum computing`
-            """)
     
     gr.Markdown(f"""
     ---
     
-    ## 🔥 PHOENIX Model Burning v1.1
+    ## 🔥 PHOENIX Model Burning Platform v1.1
     
-    ### What's New in v1.1
-    - ✅ auto_map configuration (proper model loading)
-    - ✅ PreTrainedModel base classes
-    - ✅ Pre-upload verification (Retention + Generation quality)
-    - ✅ Enhanced error handling
-    
-    ### Zero-shot (데이터셋 불필요!)
-    1. 모델 URL 입력
-    2. "Upload to HuggingFace Hub" 체크 (기본 Private)
-    3. "Burn Model" 클릭
-    4. 자동 검증 → 통과 시 Hub 업로드!
-    
-    ### Loading PHOENIX Models
-```python
-from transformers import AutoModelForCausalLM
-
-# ⚠️ trust_remote_code=True 필수!
-model = AutoModelForCausalLM.from_pretrained(
-    "your-username/phoenix-model",
-    trust_remote_code=True,  # Required!
-    torch_dtype="auto"
-)
-```
+    ### Features
+    - ✅ Zero-shot Conversion (No Dataset Required)
+    - ✅ Optional Fine-tuning
+    - ✅ GQA Support (Grouped Query Attention)
+    - ✅ O(n) Complexity
+    - ✅ HuggingFace Hub Auto-Upload
+    - ✅ Custom Code Generation
+    - ✅ Pre-upload Verification
     
-    **HuggingFace Token Status**: {'✅ Connected' if HF_TOKEN else '❌ Not Found (set HF_TOKEN env)'}
+    **HuggingFace Token**: {'✅ Connected' if HF_TOKEN else '❌ Not Found'}
     
     **VIDraft AI Research Lab** | PHOENIX v1.1
     """)