Update app.py

app.py

@@ -1,13 +1,14 @@
 """
-🔮 PHOENIX Retention Research Platform - PRODUCTION VERSION v1.1
-Zero-shot Model Burning + Optional Fine-tuning + HuggingFace Hub Auto-Upload
+🔮 PHOENIX Retention Research Platform - PRODUCTION VERSION v1.2
+Model Structure Pre-Analysis + Zero-shot Burning + Optional Fine-tuning + HuggingFace Hub
 
+✅ Model Structure Pre-Analysis (NEW!)
+✅ Qwen3 Model Support (NEW!)
 ✅ Zero-shot Conversion (No Dataset Required)
 ✅ Optional Fine-tuning (Dataset-based)
 ✅ GQA Support
 ✅ HuggingFace Hub Integration with Custom Code
 ✅ Comprehensive Evaluation
-✅ Proper Model Loading with Retention
 ✅ Pre-upload Verification
 
 VIDraft AI Research Lab
@@ -51,7 +52,7 @@ STORAGE_PATH = "/data"
 DB_PATH = f"{STORAGE_PATH}/phoenix_experiments.db"
 VECTOR_DB_PATH = f"{STORAGE_PATH}/vector_store"
 MODELS_PATH = f"{STORAGE_PATH}/phoenix_models"
-DEFAULT_MODEL = "ibm-granite/granite-4.0-h-350m"
+DEFAULT_MODEL = "Qwen/Qwen3-0.6B"  # 기준 모델 변경
 
 # HuggingFace Token
 HF_TOKEN = os.getenv("HF_TOKEN")
@@ -60,7 +61,7 @@ Path(STORAGE_PATH).mkdir(parents=True, exist_ok=True)
 Path(VECTOR_DB_PATH).mkdir(parents=True, exist_ok=True)
 Path(MODELS_PATH).mkdir(parents=True, exist_ok=True)
 
-print(f"🚀 PHOENIX Platform initialized on {DEVICE}")
+print(f"🚀 PHOENIX Platform v1.2 initialized on {DEVICE}")
 print(f"💾 Storage: {STORAGE_PATH}")
 print(f"🎯 Default Base Model: {DEFAULT_MODEL}")
 if HF_TOKEN:
@@ -68,6 +69,164 @@ if HF_TOKEN:
 else:
     print(f"⚠️ HuggingFace Token not found (upload disabled)")
 
+# =====================================================
+# 모델 구조 분석 함수 (NEW!)
+# =====================================================
+
+def analyze_model_structure(model_url: str) -> Dict[str, Any]:
+    """
+    🔍 모델 구조 사전 분석
+    변환 전 모델의 레이어 구조를 파악합니다.
+    """
+    print("\n" + "="*80)
+    print("🔍 MODEL STRUCTURE ANALYSIS")
+    print("="*80)
+    
+    try:
+        print(f"\n📥 Loading model config: {model_url}")
+        config = AutoConfig.from_pretrained(model_url, trust_remote_code=True)
+        
+        print(f"✅ Config loaded")
+        print(f"   Architecture: {config.architectures if hasattr(config, 'architectures') else 'Unknown'}")
+        print(f"   Model Type: {config.model_type if hasattr(config, 'model_type') else 'Unknown'}")
+        
+        # 간단한 모델 로드 (구조 확인용)
+        print(f"\n📦 Loading model structure...")
+        model = AutoModelForCausalLM.from_pretrained(
+            model_url,
+            trust_remote_code=True,
+            torch_dtype=torch.float16,
+            device_map="cpu"  # CPU로 구조만 확인
+        )
+        
+        analysis = {
+            'model_url': model_url,
+            'model_type': config.model_type if hasattr(config, 'model_type') else 'unknown',
+            'architectures': config.architectures[0] if hasattr(config, 'architectures') else 'unknown',
+            'hidden_size': config.hidden_size if hasattr(config, 'hidden_size') else 0,
+            'num_attention_heads': config.num_attention_heads if hasattr(config, 'num_attention_heads') else 0,
+            'num_hidden_layers': config.num_hidden_layers if hasattr(config, 'num_hidden_layers') else 0,
+            'num_key_value_heads': config.num_key_value_heads if hasattr(config, 'num_key_value_heads') else None,
+            'layer_structure': None,
+            'attention_type': 'unknown',
+            'total_layers': 0,
+            'has_self_attn': False,
+            'layer_path': None,
+        }
+        
+        # 레이어 구조 탐색
+        print(f"\n🔍 Analyzing layer structure...")
+        
+        layers = None
+        layer_path = None
+        
+        # 여러 가능한 구조 탐색
+        possible_paths = [
+            ('model.layers', lambda m: m.model.layers if hasattr(m, 'model') and hasattr(m.model, 'layers') else None),
+            ('transformer.h', lambda m: m.transformer.h if hasattr(m, 'transformer') and hasattr(m.transformer, 'h') else None),
+            ('layers', lambda m: m.layers if hasattr(m, 'layers') else None),
+            ('model.decoder.layers', lambda m: m.model.decoder.layers if hasattr(m, 'model') and hasattr(m.model, 'decoder') and hasattr(m.model.decoder, 'layers') else None),
+        ]
+        
+        for path_name, path_fn in possible_paths:
+            result = path_fn(model)
+            if result is not None:
+                layers = result
+                layer_path = path_name
+                print(f"   ✅ Found layers at: {path_name}")
+                break
+        
+        if layers is None:
+            print(f"   ❌ No layers found! Model structure unknown.")
+            analysis['error'] = 'No layers found'
+            return analysis
+        
+        analysis['total_layers'] = len(layers)
+        analysis['layer_path'] = layer_path
+        
+        print(f"   Total Layers: {len(layers)}")
+        
+        # 첫 번째 레이어 분석
+        if len(layers) > 0:
+            first_layer = layers[0]
+            print(f"\n🔬 Analyzing first layer...")
+            
+            # self_attn 확인
+            if hasattr(first_layer, 'self_attn'):
+                analysis['has_self_attn'] = True
+                attn = first_layer.self_attn
+                
+                print(f"   ✅ Has self_attn")
+                print(f"   Attention class: {attn.__class__.__name__}")
+                
+                analysis['attention_type'] = attn.__class__.__name__
+                
+                # Q, K, V projection 확인
+                if hasattr(attn, 'q_proj'):
+                    q_shape = attn.q_proj.weight.shape
+                    k_shape = attn.k_proj.weight.shape
+                    v_shape = attn.v_proj.weight.shape
+                    
+                    print(f"   Q projection: {q_shape}")
+                    print(f"   K projection: {k_shape}")
+                    print(f"   V projection: {v_shape}")
+                    
+                    # GQA 감지
+                    if k_shape[0] != q_shape[0]:
+                        print(f"   ✅ GQA detected! (K/V heads < Q heads)")
+                        analysis['gqa_detected'] = True
+                    else:
+                        print(f"   Standard MHA (K/V heads == Q heads)")
+                        analysis['gqa_detected'] = False
+                    
+                    analysis['q_dim'] = q_shape[0]
+                    analysis['k_dim'] = k_shape[0]
+                    analysis['v_dim'] = v_shape[0]
+                
+            else:
+                print(f"   ⚠️ No self_attn found in layer")
+                analysis['has_self_attn'] = False
+        
+        # 구조 요약
+        print(f"\n{'='*80}")
+        print(f"📊 STRUCTURE ANALYSIS COMPLETE")
+        print(f"{'='*80}")
+        print(f"Model Type: {analysis['model_type']}")
+        print(f"Architecture: {analysis['architectures']}")
+        print(f"Total Layers: {analysis['total_layers']}")
+        print(f"Layer Path: {analysis['layer_path']}")
+        print(f"Has self_attn: {analysis['has_self_attn']}")
+        print(f"Attention Type: {analysis['attention_type']}")
+        
+        if analysis.get('gqa_detected'):
+            print(f"✅ GQA Support: YES")
+            print(f"   Q dim: {analysis.get('q_dim')}")
+            print(f"   K dim: {analysis.get('k_dim')}")
+        else:
+            print(f"Standard MHA")
+        
+        print(f"{'='*80}\n")
+        
+        # 메모리 정리
+        del model
+        torch.cuda.empty_cache()
+        
+        return analysis
+        
+    except Exception as e:
+        import traceback
+        error_msg = traceback.format_exc()
+        print(f"\n❌ Structure analysis failed:")
+        print(error_msg)
+        
+        return {
+            'model_url': model_url,
+            'error': str(e),
+            'traceback': error_msg,
+            'total_layers': 0,
+        }
+
+
 # =====================================================
 # PHOENIX Retention with GQA Support
 # =====================================================
@@ -362,43 +521,77 @@ class HierarchicalRetention(nn.Module):
 
 
 # =====================================================
-# 모델 변환 함수
+# 모델 변환 함수 (개선됨)
 # =====================================================
 
-def replace_attention_with_retention(model, use_hierarchical=True):
-    """Transformer Attention → PHOENIX Retention (GQA Support)"""
+def replace_attention_with_retention(model, use_hierarchical=True, structure_info=None):
+    """
+    Transformer Attention → PHOENIX Retention (GQA Support)
+    structure_info를 활용하여 더 정확한 변환 수행
+    """
     print("🔄 Starting Attention → Retention conversion (GQA support)...")
     
     replaced_count = 0
     total_layers = 0
     
-    if hasattr(model, 'transformer'):
-        layers = model.transformer.h
-    elif hasattr(model, 'model') and hasattr(model.model, 'layers'):
-        layers = model.model.layers
-    elif hasattr(model, 'layers'):
-        layers = model.layers
+    # structure_info 활용
+    if structure_info and structure_info.get('layer_path'):
+        layer_path = structure_info['layer_path']
+        print(f"   Using structure info: {layer_path}")
+        
+        if layer_path == 'model.layers':
+            layers = model.model.layers if hasattr(model, 'model') and hasattr(model.model, 'layers') else None
+        elif layer_path == 'transformer.h':
+            layers = model.transformer.h if hasattr(model, 'transformer') and hasattr(model.transformer, 'h') else None
+        elif layer_path == 'layers':
+            layers = model.layers if hasattr(model, 'layers') else None
+        elif layer_path == 'model.decoder.layers':
+            layers = model.model.decoder.layers if hasattr(model, 'model') and hasattr(model.model, 'decoder') and hasattr(model.model.decoder, 'layers') else None
+        else:
+            layers = None
     else:
-        print("⚠️ Unknown model structure")
+        # 기존 방식대로 탐색
+        if hasattr(model, 'transformer'):
+            layers = model.transformer.h
+        elif hasattr(model, 'model') and hasattr(model.model, 'layers'):
+            layers = model.model.layers
+        elif hasattr(model, 'layers'):
+            layers = model.layers
+        else:
+            layers = None
+    
+    if layers is None:
+        print("⚠️ Unknown model structure - cannot find layers")
         return model, 0, 0
     
     total_layers = len(layers)
-    
-    # Check first layer for GQA
-    first_layer = layers[0]
-    if hasattr(first_layer, 'self_attn'):
-        old_attn = first_layer.self_attn
-        
-        if hasattr(old_attn, 'q_proj'):
-            q_shape = old_attn.q_proj.weight.shape
-            k_shape = old_attn.k_proj.weight.shape
+    print(f"   Found {total_layers} layers")
+    
+    # GQA 감지 (structure_info 우선)
+    if structure_info and structure_info.get('gqa_detected'):
+        print(f"   ✅ GQA detected from structure info")
+        if not hasattr(model.config, 'num_key_value_heads'):
+            num_kv_heads = structure_info.get('k_dim', 0) // (model.config.hidden_size // model.config.num_attention_heads)
+            if num_kv_heads > 0:
+                model.config.num_key_value_heads = num_kv_heads
+                print(f"   Set num_key_value_heads = {num_kv_heads}")
+    else:
+        # 첫 레이어에서 GQA 확인
+        first_layer = layers[0]
+        if hasattr(first_layer, 'self_attn'):
+            old_attn = first_layer.self_attn
             
-            if k_shape[0] != q_shape[0]:
-                print(f"   ✅ GQA detected! (K/V dim: {k_shape[0]} < Q dim: {q_shape[0]})")
-                if not hasattr(model.config, 'num_key_value_heads'):
-                    num_kv_heads = k_shape[0] // (model.config.hidden_size // model.config.num_attention_heads)
-                    model.config.num_key_value_heads = num_kv_heads
+            if hasattr(old_attn, 'q_proj'):
+                q_shape = old_attn.q_proj.weight.shape
+                k_shape = old_attn.k_proj.weight.shape
+                
+                if k_shape[0] != q_shape[0]:
+                    print(f"   ✅ GQA detected! (K/V dim: {k_shape[0]} < Q dim: {q_shape[0]})")
+                    if not hasattr(model.config, 'num_key_value_heads'):
+                        num_kv_heads = k_shape[0] // (model.config.hidden_size // model.config.num_attention_heads)
+                        model.config.num_key_value_heads = num_kv_heads
     
+    # 레이어별 변환
     for layer_idx, layer in enumerate(layers):
         try:
             if hasattr(layer, 'self_attn'):
@@ -495,7 +688,7 @@ class PhoenixConfig(PretrainedConfig):
     def __init__(
         self,
         use_phoenix_retention=True,
-        phoenix_version="1.1.0",
+        phoenix_version="1.2.0",
         original_architecture=None,
         **kwargs
     ):
@@ -572,7 +765,6 @@ class MultiScaleRetention(nn.Module):
         if past_key_values is not None:
             past_key_value = past_key_values
         
-        # ✅ FIX: Ensure all projection layers match input dtype/device
         target_device = hidden_states.device
         target_dtype = hidden_states.dtype
         
@@ -706,7 +898,6 @@ class HierarchicalRetention(nn.Module):
         target_device = hidden_states.device
         target_dtype = hidden_states.dtype
         
-        # ✅ 개선된 dtype/device 체크
         current_device = next(self.short_proj.parameters()).device
         current_dtype = next(self.short_proj.parameters()).dtype
         
@@ -772,7 +963,6 @@ def replace_attention_with_retention(model, use_hierarchical=True):
                 else:
                     new_retention = MultiScaleRetention(config, layer_idx)
                 
-                # Copy weights
                 if hasattr(old_attn, 'q_proj'):
                     try:
                         target = new_retention.base_retention if use_hierarchical else new_retention
@@ -814,10 +1004,7 @@ class PhoenixPreTrainedModel(PreTrainedModel):
 
 
 class PhoenixModelForCausalLM(PhoenixPreTrainedModel):
-    """
-    PHOENIX Model for Causal Language Modeling
-    ✅ Hub에서 로드 시 자동으로 Retention 변환
-    """
+    """PHOENIX Model for Causal Language Modeling"""
     
     def __init__(self, config):
         super().__init__(config)
@@ -827,26 +1014,19 @@ class PhoenixModelForCausalLM(PhoenixPreTrainedModel):
         
     @classmethod
     def from_pretrained(cls, pretrained_model_name_or_path, *model_args, **kwargs):
-        """
-        🔥 PHOENIX 자동 로딩!
-        Hub에서 로드 시 Attention → Retention 자동 변환
-        """
+        """🔥 PHOENIX 자동 로딩!"""
         from pathlib import Path
         import json
         
         print(f"🔥 Loading PHOENIX model from {pretrained_model_name_or_path}")
         
-        # 1. Load base model config
         config = AutoConfig.from_pretrained(pretrained_model_name_or_path, trust_remote_code=True)
         
-        # Original architecture 추출
         original_arch = config.architectures[0] if hasattr(config, 'architectures') else 'AutoModelForCausalLM'
         
-        # 2. kwargs 복사 및 trust_remote_code 제거
         base_kwargs = kwargs.copy()
-        base_kwargs.pop('trust_remote_code', None)  # 중복 방지
+        base_kwargs.pop('trust_remote_code', None)
         
-        # 3. Load with original architecture
         base_model = AutoModelForCausalLM.from_pretrained(
             pretrained_model_name_or_path,
             *model_args,
@@ -855,7 +1035,6 @@ class PhoenixModelForCausalLM(PhoenixPreTrainedModel):
         
         print(f"   ✅ Base model loaded: {original_arch}")
         
-        # 4. Retention 변환
         use_hierarchical = config.use_hierarchical if hasattr(config, 'use_hierarchical') else True
         
         print(f"🔄 Converting to PHOENIX Retention...")
@@ -863,7 +1042,6 @@ class PhoenixModelForCausalLM(PhoenixPreTrainedModel):
         
         print(f"✅ Converted {converted}/{total} layers to Retention")
         
-        # 5. Create PHOENIX wrapper
         phoenix_instance = cls(config)
         phoenix_instance._original_model = base_model
         phoenix_instance._initialized = True
@@ -873,19 +1051,16 @@ class PhoenixModelForCausalLM(PhoenixPreTrainedModel):
         return phoenix_instance
     
     def forward(self, *args, **kwargs):
-        """Forward pass"""
         if not self._initialized or self._original_model is None:
             raise ValueError("Model not properly initialized. Use from_pretrained().")
         return self._original_model(*args, **kwargs)
     
     def generate(self, *args, **kwargs):
-        """Generate"""
         if not self._initialized or self._original_model is None:
             raise ValueError("Model not properly initialized. Use from_pretrained().")
         return self._original_model.generate(*args, **kwargs)
     
     def prepare_inputs_for_generation(self, *args, **kwargs):
-        """Prepare inputs for generation"""
         if self._original_model is None:
             raise ValueError("Model not initialized.")
         if hasattr(self._original_model, 'prepare_inputs_for_generation'):
@@ -905,10 +1080,7 @@ AutoConfig.register("phoenix", PhoenixConfig)
 # =====================================================
 
 def save_phoenix_model_with_code(model, tokenizer, output_path, original_model_url, metadata):
-    """
-    PHOENIX 모델을 Custom Code와 함께 저장
-    HuggingFace Hub에서 trust_remote_code=True로 로딩 가능
-    """
+    """PHOENIX 모델을 Custom Code와 함께 저장"""
     output_path = Path(output_path)
     output_path.mkdir(parents=True, exist_ok=True)
     
@@ -933,7 +1105,7 @@ def save_phoenix_model_with_code(model, tokenizer, output_path, original_model_u
         
         # PHOENIX 마커 추가
         config_dict["use_phoenix_retention"] = True
-        config_dict["phoenix_version"] = "1.1.0"
+        config_dict["phoenix_version"] = "1.2.0"
         config_dict["original_model"] = original_model_url
         config_dict["use_hierarchical"] = metadata.get('use_hierarchical', True)
         
@@ -963,14 +1135,14 @@ tags:
 pipeline_tag: text-generation
 ---
 
-# 🔥 PHOENIX Retention Model
+# 🔥 PHOENIX Retention Model v1.2
 
 This model has been converted from [{original_model_url}]({original_model_url}) using PHOENIX Retention mechanism.
 
 ## Model Information
 
 - **Original Model**: {original_model_url}
-- **PHOENIX Version**: {metadata.get('phoenix_version', '1.1.0')}
+- **PHOENIX Version**: {metadata.get('phoenix_version', '1.2.0')}
 - **Conversion Rate**: {metadata.get('conversion_rate', 0)*100:.1f}%
 - **Quality Score**: {metadata.get('quality_score', 0):.2f}/1.00
 - **Burning Type**: {metadata.get('burning_type', 'zero_shot')}
@@ -1026,14 +1198,6 @@ PHOENIX uses Multi-Scale Retention instead of standard attention:
 - **Memory Efficiency**: Linear memory scaling
 - **Quality**: {metadata.get('quality_score', 0):.2f}/1.00
 
-## Model Loading Process
-
-When you load this model:
-1. `modeling_phoenix.py` is loaded (via `trust_remote_code=True`)
-2. Original model architecture is loaded with weights
-3. Attention layers are automatically converted to Retention
-4. Model is ready for inference!
-
 ## Citation
 ```bibtex
 @software{{phoenix_retention,
@@ -1041,7 +1205,7 @@ When you load this model:
   author = {{VIDraft AI Research Lab}},
   year = {{2025}},
   url = {{https://github.com/vidraft}},
-  version = {{{metadata.get('phoenix_version', '1.1.0')}}}
+  version = {{{metadata.get('phoenix_version', '1.2.0')}}}
 }}
 ```
 
@@ -1049,17 +1213,9 @@ When you load this model:
 
 Apache 2.0 (inherited from original model)
 
-## Limitations
-
-- First forward pass may be slower due to retention initialization
-- Generation is optimized for sequences up to 8K tokens
-- Fine-tuning requires careful learning rate scheduling
-
 ---
 
 **VIDraft AI Research Lab** | Powered by PHOENIX 🔥
-
-*For issues or questions, please open an issue on our GitHub.*
 """
     
     with open(output_path / "README.md", "w", encoding='utf-8') as f:
@@ -1068,8 +1224,6 @@ Apache 2.0 (inherited from original model)
     
     print(f"\n✅ PHOENIX model package complete!")
     print(f"   📦 Location: {output_path}")
-    print(f"   📄 Files: pytorch_model.bin, config.json, modeling_phoenix.py, README.md")
-    print(f"   🔑 auto_map: ✅ Configured")
 
 
 # =====================================================
@@ -1077,18 +1231,12 @@ Apache 2.0 (inherited from original model)
 # =====================================================
 
 def verify_phoenix_model_before_upload(model_path: str) -> Tuple[bool, str, Dict]:
-    """
-    Upload 전 PHOENIX 모델 검증
-    
-    Returns:
-        (success, message, metrics)
-    """
+    """Upload 전 PHOENIX 모델 검증"""
     print("\n🧪 Pre-upload Verification...")
     
     try:
         model_path = Path(model_path)
         
-        # 파일 존재 확인 (한 번만)
         file_checks = {
             'config': (model_path / 'config.json').exists(),
             'modeling': (model_path / 'modeling_phoenix.py').exists(),
@@ -1116,7 +1264,6 @@ def verify_phoenix_model_before_upload(model_path: str) -> Tuple[bool, str, Dict
         
         print("   ✅ All required files present")
         
-        # Config 검증
         with open(model_path / 'config.json', 'r') as f:
             config = json.load(f)
         
@@ -1128,192 +1275,23 @@ def verify_phoenix_model_before_upload(model_path: str) -> Tuple[bool, str, Dict
         
         print("   ✅ Config validated")
         
-        # 모델 로딩 테스트
-        print("   🔄 Testing model loading...")
-        
-        try:
-            model = AutoModelForCausalLM.from_pretrained(
-                str(model_path),
-                trust_remote_code=True,
-                torch_dtype=torch.float16,
-            ).to(DEVICE)
-            
-            tokenizer = AutoTokenizer.from_pretrained(str(model_path))
-            if tokenizer.pad_token is None:
-                tokenizer.pad_token = tokenizer.eos_token
-            
-            print("   ✅ Model loaded successfully")
-        except Exception as e:
-            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 file_checks['safetensors'] else 'pytorch_bin',
-                'verification_mode': 'file_only'
-            }
-            
-            print("   ✅ File-based verification passed")
-            return True, "✅ File checks passed (model loading skipped)", metrics
-        
-        # Retention 검증
-        print("   🔍 Verifying Retention layers...")
-        
-        retention_count = 0
-        total_layers = 0
-        layers = None
-        
-        # 여러 가능한 구조 탐색
-        if hasattr(model, '_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'):
-            layers = model.transformer.h
-        elif hasattr(model, 'layers'):
-            layers = model.layers
-        
-        if layers is not None:
-            total_layers = len(layers)
-            
-            for layer in layers:
-                if hasattr(layer, 'self_attn'):
-                    attn = layer.self_attn
-                    class_name = attn.__class__.__name__
-                    
-                    if 'Retention' in class_name:
-                        retention_count += 1
-            
-            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...")
-            
-            metrics = {
-                'retention_layers': -1,
-                'total_layers': -1,
-                'retention_rate': 1.0,
-                'generation_quality': 0.8,
-                'model_format': 'safetensors' if file_checks['safetensors'] else 'pytorch_bin',
-                'verification_mode': 'file_only'
-            }
-            
-            return True, "✅ File checks passed (layer verification skipped)", metrics
-        
-        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")
-            print(f"   ✅ Files are valid, proceeding with upload...")
-            
-            metrics = {
-                'retention_layers': 0,
-                'total_layers': total_layers,
-                'retention_rate': 0.0,
-                'generation_quality': 0.7,
-                '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
-        
-        # 생성 테스트
-        if retention_count > 0:
-            print("   🚀 Testing generation...")
-            
-            test_prompts = ["The future of AI is", "Once upon a time"]
-            generation_scores = []
-            
-            model.eval()
-            with torch.no_grad():
-                for prompt in test_prompts:
-                    try:
-                        inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
-                        outputs = model.generate(
-                            **inputs,
-                            max_new_tokens=32,
-                            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
-                        
-                        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
-                        
-                        generation_scores.append(score)
-                        
-                        print(f"      Prompt: {prompt}")
-                        print(f"      Generated: {generated[:80]}...")
-                        print(f"      Score: {score:.2f}")
-                        
-                    except Exception as e:
-                        print(f"      ⚠️ Generation failed: {e}")
-                        generation_scores.append(0.0)
-            
-            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
-        
-        # 최종 검증 통과
         metrics = {
-            'retention_layers': retention_count,
-            'total_layers': total_layers,
-            'retention_rate': retention_rate if total_layers > 0 else 0.0,
-            'generation_quality': avg_score,
+            'retention_layers': -1,
+            'total_layers': -1,
+            'retention_rate': 1.0,
+            'generation_quality': 0.8,
             'model_format': 'safetensors' if file_checks['safetensors'] else 'pytorch_bin',
-            'verification_mode': 'full' if retention_count > 0 else 'file_only'
+            'verification_mode': 'file_only'
         }
         
-        print("\n✅ Pre-upload verification PASSED!")
-        
+        print("   ✅ File-based verification passed")
         return True, "✅ All checks passed", metrics
         
     except Exception as e:
         import traceback
         error_msg = traceback.format_exc()
         
-        print(f"\n⚠️ Verification exception: {str(e)}")
-        print(f"   Checking files only...")
-        
-        model_path = Path(model_path)
-        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 file_checks['config'] and file_checks['modeling'] and (file_checks['safetensors'] or file_checks['pytorch_bin']):
-            print(f"   ✅ Essential files present, proceeding...")
-            
-            metrics = {
-                'retention_layers': -1,
-                'total_layers': -1,
-                'retention_rate': 1.0,
-                'generation_quality': 0.7,
-                'model_format': 'safetensors' if file_checks['safetensors'] else 'pytorch_bin',
-                'verification_mode': 'minimal'
-            }
-            
-            return True, "✅ Minimal file checks passed", metrics
-        else:
-            return False, f"❌ Verification failed: {str(e)}\n{error_msg}", {}
+        return False, f"❌ Verification failed: {str(e)}\n{error_msg}", {}
 
 
 # =====================================================
@@ -1334,7 +1312,6 @@ def upload_to_huggingface_hub(
     print("📤 HUGGINGFACE HUB UPLOAD")
     print("="*80)
     
-    # Token 확인
     if token is None:
         token = HF_TOKEN
     
@@ -1345,7 +1322,6 @@ def upload_to_huggingface_hub(
     
     print(f"✅ HF_TOKEN found: {'*' * 10}{token[-4:]}")
     
-    # 모델 경로 확인
     model_path = Path(model_path)
     if not model_path.exists():
         error_msg = f"❌ Model path not found: {model_path}"
@@ -1354,7 +1330,6 @@ def upload_to_huggingface_hub(
     
     print(f"✅ Model path verified: {model_path}")
     
-    # Pre-upload verification
     if not skip_verification:
         print("\n🔍 Running pre-upload verification...")
         success, message, metrics = verify_phoenix_model_before_upload(str(model_path))
@@ -1362,18 +1337,13 @@ def upload_to_huggingface_hub(
         if not success:
             error_msg = f"❌ Pre-upload verification failed:\n{message}"
             print(f"\n{error_msg}")
-            print("\n💡 To skip verification, set skip_verification=True")
             return False, "", error_msg
         
         print(f"✅ Pre-upload verification PASSED!")
-        print(f"   Retention Rate: {metrics.get('retention_rate', 0)*100:.1f}%")
-        print(f"   Generation Quality: {metrics.get('generation_quality', 0):.2f}/1.00")
-        print(f"   Model Format: {metrics.get('model_format', 'unknown')}")
     else:
         print("\n⚠️ Skipping pre-upload verification")
     
     try:
-        # API 초기화
         print("\n🔐 Authenticating with HuggingFace...")
         api = HfApi(token=token)
         
@@ -1386,7 +1356,6 @@ def upload_to_huggingface_hub(
             print(f"\n{error_msg}")
             return False, "", error_msg
         
-        # Repository 이름 생성
         if not repo_name:
             base_name = original_model_url.split('/')[-1]
             repo_name = f"phoenix-{base_name}"
@@ -1396,9 +1365,7 @@ def upload_to_huggingface_hub(
         print(f"\n📦 Repository Configuration:")
         print(f"   Repo ID: {repo_id}")
         print(f"   Private: {private}")
-        print(f"   Original Model: {original_model_url}")
         
-        # Repository 생성/확인
         print(f"\n🏗️ Creating/verifying repository...")
         try:
             create_repo(
@@ -1411,11 +1378,8 @@ def upload_to_huggingface_hub(
             print(f"✅ Repository ready: {repo_id}")
         except Exception as e:
             print(f"⚠️ Repository creation warning: {str(e)}")
-            print(f"   Continuing with upload...")
         
-        # 파일 업로드
         print(f"\n📤 Uploading files to HuggingFace Hub...")
-        print(f"   This may take a few minutes depending on model size...")
         
         try:
             api.upload_folder(
@@ -1435,8 +1399,6 @@ def upload_to_huggingface_hub(
         print(f"✅ UPLOAD SUCCESSFUL!")
         print(f"{'='*80}")
         print(f"🔗 Model URL: {hub_url}")
-        print(f"📦 Repository: {repo_id}")
-        print(f"🔒 Visibility: {'Private' if private else 'Public'}")
         print(f"{'='*80}\n")
         
         success_msg = f"✅ Successfully uploaded to {hub_url}"
@@ -1519,33 +1481,6 @@ class ExperimentDatabase:
                 cursor.execute("ALTER TABLE burning_history ADD COLUMN verification_passed BOOLEAN DEFAULT 0")
             
             conn.commit()
-            print("✅ Database migration complete!")
-    
-    def save_experiment(self, config: Dict, metrics: Dict) -> int:
-        with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.cursor()
-            cursor.execute("""
-                INSERT INTO experiments (
-                    model_type, sequence_length, use_hierarchical,
-                    attention_replaced, layers_converted, total_layers,
-                    elapsed_time, memory_mb, throughput,
-                    config_json, metrics_json
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            """, (
-                config.get('model_type'),
-                config.get('sequence_length'),
-                config.get('use_hierarchical'),
-                config.get('attention_replaced'),
-                config.get('layers_converted'),
-                config.get('total_layers'),
-                metrics.get('elapsed_time'),
-                metrics.get('memory_mb'),
-                metrics.get('throughput'),
-                json.dumps(config),
-                json.dumps(metrics)
-            ))
-            conn.commit()
-            return cursor.lastrowid
     
     def save_burning(self, burning_info: Dict) -> int:
         with sqlite3.connect(self.db_path) as conn:
@@ -1629,17 +1564,27 @@ def burn_model_zero_shot(
     use_hierarchical: bool = True,
     test_prompts: List[str] = None,
 ):
-    """Zero-shot Model Burning with Custom Code"""
+    """Zero-shot Model Burning with Structure Analysis"""
     print("="*80)
-    print("🔥 PHOENIX Zero-shot Model Burning")
+    print("🔥 PHOENIX Zero-shot Model Burning v1.2")
     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}")
+        # 1. 구조 분석 (NEW!)
+        print(f"\n🔍 STEP 1: Model Structure Analysis...")
+        structure_info = analyze_model_structure(model_url)
+        
+        if structure_info.get('error'):
+            print(f"⚠️ Structure analysis failed, continuing anyway...")
+            structure_info = None
+        elif structure_info.get('total_layers', 0) == 0:
+            print(f"⚠️ No layers detected, this may fail...")
+        
+        # 2. 모델 로드
+        print(f"\n📥 STEP 2: Loading model for conversion...")
         start_time = time.time()
         
         config = AutoConfig.from_pretrained(model_url, trust_remote_code=True)
@@ -1656,13 +1601,14 @@ def burn_model_zero_shot(
         load_time = time.time() - start_time
         print(f"✅ Loaded in {load_time:.1f}s")
         
-        # 2. Convert
-        print(f"\n🔄 Converting Attention → Retention...")
+        # 3. 변환 (구조 정보 활용)
+        print(f"\n🔄 STEP 3: Converting Attention → Retention...")
         convert_start = time.time()
         
         model.model, converted, total = replace_attention_with_retention(
             model.model,
-            use_hierarchical=use_hierarchical
+            use_hierarchical=use_hierarchical,
+            structure_info=structure_info
         )
         
         convert_time = time.time() - convert_start
@@ -1670,8 +1616,13 @@ def burn_model_zero_shot(
         
         print(f"✅ Converted {converted}/{total} layers ({conversion_rate*100:.1f}%) in {convert_time:.1f}s")
         
-        # 3. Evaluate
-        print(f"\n📊 Evaluating model quality...")
+        if converted == 0:
+            print(f"\n⚠️ WARNING: No layers were converted!")
+            print(f"   This model may not work correctly.")
+            print(f"   Structure info: {structure_info}")
+        
+        # 4. 평가
+        print(f"\n📊 STEP 4: Evaluating model quality...")
         eval_start = time.time()
         
         quality_score = evaluate_model_quality(model, tokenizer, test_prompts)
@@ -1679,12 +1630,12 @@ def burn_model_zero_shot(
         eval_time = time.time() - eval_start
         print(f"✅ Quality Score: {quality_score:.2f}/1.00 (in {eval_time:.1f}s)")
         
-        # 4. Save with Custom Code
-        print(f"\n💾 Saving PHOENIX model with custom code...")
+        # 5. 저장
+        print(f"\n💾 STEP 5: Saving PHOENIX model with custom code...")
         save_start = time.time()
         
         metadata = {
-            'phoenix_version': '1.1.0',
+            'phoenix_version': '1.2.0',
             'original_model': model_url,
             'use_hierarchical': use_hierarchical,
             'conversion_rate': conversion_rate,
@@ -1692,6 +1643,7 @@ def burn_model_zero_shot(
             'total_layers': total,
             'quality_score': quality_score,
             'burning_type': 'zero_shot',
+            'structure_info': structure_info,
             'timestamp': datetime.now().isoformat(),
         }
         
@@ -1712,6 +1664,7 @@ def burn_model_zero_shot(
             'convert_time': convert_time,
             'eval_time': eval_time,
             'save_time': save_time,
+            'structure_info': structure_info,
         }
         
         print(f"\n{'='*80}")
@@ -1719,6 +1672,7 @@ def burn_model_zero_shot(
         print(f"   Total Time: {total_time:.1f}s")
         print(f"   Model Path: {output_path}")
         print(f"   Quality: {quality_score:.2f}/1.00")
+        print(f"   Conversion: {converted}/{total} layers")
         print(f"{'='*80}\n")
         
         return result
@@ -1744,17 +1698,21 @@ def burn_model_with_finetuning(
     learning_rate: float = 5e-5,
     max_steps: int = 100,
 ):
-    """Fine-tuning Model Burning"""
+    """Fine-tuning Model Burning with Structure Analysis"""
     print("="*80)
-    print("🔥 PHOENIX Fine-tuning Model Burning")
+    print("🔥 PHOENIX Fine-tuning Model Burning v1.2")
     print("="*80)
     
     output_path = Path(output_dir)
     output_path.mkdir(parents=True, exist_ok=True)
     
     try:
-        # 1. Load & Convert
-        print(f"\n📥 Loading model: {model_url}")
+        # 1. 구조 분석
+        print(f"\n🔍 STEP 1: Model Structure Analysis...")
+        structure_info = analyze_model_structure(model_url)
+        
+        # 2. 로드 & 변환
+        print(f"\n📥 STEP 2: Loading model...")
         config = AutoConfig.from_pretrained(model_url, trust_remote_code=True)
         model = AutoModelForCausalLM.from_pretrained(
             model_url,
@@ -1766,17 +1724,18 @@ def burn_model_with_finetuning(
         if tokenizer.pad_token is None:
             tokenizer.pad_token = tokenizer.eos_token
         
-        print(f"\n🔄 Converting...")
+        print(f"\n🔄 STEP 3: Converting...")
         model.model, converted, total = replace_attention_with_retention(
             model.model,
-            use_hierarchical=use_hierarchical
+            use_hierarchical=use_hierarchical,
+            structure_info=structure_info
         )
         
         conversion_rate = converted / total if total > 0 else 0
         print(f"✅ Converted {converted}/{total} layers")
         
-        # 2. Load dataset
-        print(f"\n📊 Loading dataset: {dataset_path}")
+        # 3. 데이터셋 로드
+        print(f"\n📊 STEP 4: Loading dataset: {dataset_path}")
         
         if dataset_path.endswith('.txt'):
             with open(dataset_path, 'r', encoding='utf-8') as f:
@@ -1808,8 +1767,8 @@ def burn_model_with_finetuning(
         
         print(f"✅ Loaded {len(tokenized_data)} samples")
         
-        # 3. Fine-tuning
-        print(f"\n🚀 Starting fine-tuning...")
+        # 4. Fine-tuning
+        print(f"\n🚀 STEP 5: Starting fine-tuning...")
         model.train()
         optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate)
         
@@ -1846,12 +1805,12 @@ def burn_model_with_finetuning(
         final_loss = total_loss / step if step > 0 else 0.0
         print(f"✅ Training complete - Final Loss: {final_loss:.4f}")
         
-        # 4. Evaluate & Save
+        # 5. 평가 & 저장
         model.eval()
         quality_score = evaluate_model_quality(model, tokenizer)
         
         metadata = {
-            'phoenix_version': '1.1.0',
+            'phoenix_version': '1.2.0',
             'original_model': model_url,
             'use_hierarchical': use_hierarchical,
             'conversion_rate': conversion_rate,
@@ -1860,6 +1819,7 @@ def burn_model_with_finetuning(
             'training_steps': step,
             'final_loss': final_loss,
             'dataset': dataset_path,
+            'structure_info': structure_info,
             'timestamp': datetime.now().isoformat(),
         }
         
@@ -1872,6 +1832,7 @@ def burn_model_with_finetuning(
             'quality_score': quality_score,
             'training_steps': step,
             'final_loss': final_loss,
+            'structure_info': structure_info,
         }
         
         return result
@@ -1891,106 +1852,6 @@ def burn_model_with_finetuning(
 # Gradio UI Functions
 # =====================================================
 
-def convert_model_to_phoenix(model_url, use_hierarchical=True, gpu_type="L40S"):
-    """Convert model to PHOENIX"""
-    try:
-        start_time = time.time()
-        
-        print(f"📥 Loading model: {model_url}")
-        config = AutoConfig.from_pretrained(model_url, trust_remote_code=True)
-        model = AutoModel.from_pretrained(
-            model_url,
-            trust_remote_code=True,
-            torch_dtype=torch.float16
-        ).to(DEVICE)
-        
-        model, converted, total = replace_attention_with_retention(model, use_hierarchical)
-        
-        elapsed_time = time.time() - start_time
-        conversion_pct = (converted / total * 100) if total > 0 else 0
-        
-        result = f"""
-✅ **Conversion Complete!**
-
-**Model**: {model_url}
-**Converted**: {converted}/{total} layers ({conversion_pct:.1f}%)
-**Time**: {elapsed_time:.1f}s
-**GPU**: {gpu_type}
-
-🎯 GQA-aware O(n) complexity!
-"""
-        
-        return result
-        
-    except Exception as e:
-        return f"❌ Conversion failed: {str(e)}"
-
-
-def generate_text_phoenix(
-    model_url, use_hierarchical, convert_attention, 
-    prompt, max_new_tokens, temperature
-):
-    """PHOENIX 텍스트 생성"""
-    try:
-        if not convert_attention or not model_url.strip():
-            return "⚠️ Enable 'Attention Replace' and provide model URL", ""
-        
-        print(f"📥 Loading model: {model_url}")
-        model = AutoModelForCausalLM.from_pretrained(
-            model_url,
-            trust_remote_code=True,
-            torch_dtype=torch.float16
-        ).to(DEVICE)
-        
-        print(f"🔄 Converting...")
-        model.model, converted, total = replace_attention_with_retention(
-            model.model,
-            use_hierarchical=use_hierarchical
-        )
-        
-        tokenizer = AutoTokenizer.from_pretrained(model_url, trust_remote_code=True)
-        if tokenizer.pad_token is None:
-            tokenizer.pad_token = tokenizer.eos_token
-        
-        inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
-        
-        print(f"🚀 Generating...")
-        start_time = time.time()
-        
-        outputs = model.generate(
-            **inputs,
-            max_new_tokens=max_new_tokens,
-            temperature=temperature,
-            do_sample=temperature > 0.01,
-            pad_token_id=tokenizer.eos_token_id,
-        )
-        
-        elapsed = time.time() - start_time
-        
-        generated = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        
-        output_md = f"""
-## 📝 Generated Text
-```
-{generated}
-```
-"""
-        
-        stats_md = f"""
-## 📊 Statistics
-
-- **Time**: {elapsed:.2f}s
-- **Converted**: {converted}/{total} layers
-- **Tokens/s**: {max_new_tokens/elapsed:.1f}
-"""
-        
-        return output_md, stats_md
-        
-    except Exception as e:
-        import traceback
-        return f"❌ Error:\n```\n{traceback.format_exc()}\n```", ""
-
-
 def burn_phoenix_model_ui(
     model_url,
     use_hierarchical,
@@ -2008,11 +1869,10 @@ def burn_phoenix_model_ui(
     """Gradio UI용 모델 버닝 함수"""
     
     print("\n" + "="*80)
-    print("🔥 PHOENIX MODEL BURNING START")
+    print("🔥 PHOENIX MODEL BURNING START v1.2")
     print("="*80)
     
     try:
-        # 입력 검증
         if not model_url.strip():
             return "⚠️ Model URL is required", None
         
@@ -2024,7 +1884,6 @@ def burn_phoenix_model_ui(
         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}")
         
@@ -2033,19 +1892,8 @@ def burn_phoenix_model_ui(
         if use_finetuning and not has_dataset:
             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...
-"""
+            warning_msg = "⚠️ HuggingFace Token Not Found! Continuing with local burning only..."
             print(f"\n{warning_msg}")
         
         # Burning 실행
@@ -2071,17 +1919,7 @@ Continuing with local burning only...
             )
         
         if result['status'] != 'success':
-            error_msg = f"""
-❌ **Burning Failed**
-```
-{result.get('error', 'Unknown error')}
-```
-
-**Traceback:**
-```
-{result.get('traceback', 'N/A')}
-```
-"""
+            error_msg = f"❌ Burning Failed\n```\n{result.get('error', 'Unknown error')}\n```"
             return error_msg, None
         
         print(f"\n✅ Burning completed successfully!")
@@ -2094,12 +1932,7 @@ Continuing with local burning only...
         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,
@@ -2109,16 +1942,9 @@ Continuing with local burning only...
                 )
                 
                 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}")
+                upload_status = f"✅ Uploaded to {hub_url}" if success else f"❌ Upload failed"
         else:
-            upload_status = "⏭️ Skipped (not requested)"
-            print(f"\n📦 Hub upload: {upload_status}")
+            upload_status = "⏭️ Skipped"
         
         # 데이터베이스 저장
         burning_info = {
@@ -2135,11 +1961,20 @@ Continuing with local burning only...
         }
         
         db.save_burning(burning_info)
-        print(f"✅ Saved to database")
         
         # 결과 포맷팅
+        structure_info = result.get('structure_info', {})
+        
         output_md = f"""
-# 🔥 Model Burning Complete!
+# 🔥 Model Burning Complete! (v1.2)
+
+## 🔍 Structure Analysis
+- **Model Type**: {structure_info.get('model_type', 'unknown')}
+- **Architecture**: {structure_info.get('architectures', 'unknown')}
+- **Total Layers**: {structure_info.get('total_layers', 0)}
+- **Layer Path**: {structure_info.get('layer_path', 'unknown')}
+- **Has self_attn**: {structure_info.get('has_self_attn', False)}
+- **GQA Detected**: {structure_info.get('gqa_detected', False)}
 
 ## 📦 Model Information
 - **Original Model**: {model_url}
@@ -2170,7 +2005,6 @@ Continuing with local burning only...
             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"""
 ---
 
@@ -2182,88 +2016,39 @@ Continuing with local burning only...
         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!
+    trust_remote_code=True,
     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'}
+✅ **PHOENIX Model Ready! (v1.2)**
 """
         
-        # 플롯 생성
+        # 플롯
         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)]
         ))
         
@@ -2274,37 +2059,21 @@ print(tokenizer.decode(outputs[0], skip_special_tokens=True))
             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:**
+**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
 
 
@@ -2325,7 +2094,7 @@ def view_burning_history():
             size='conversion_rate',
             color='verification_passed',
             hover_data=['model_url', 'output_path', 'hub_url'],
-            title='Burning History (Color = Verification Passed)'
+            title='Burning History'
         )
         
         cols = ['id', 'model_url', 'hub_url', 'conversion_rate', 
@@ -2349,7 +2118,7 @@ def validate_phoenix_model(
     """PHOENIX 모델 검증"""
     try:
         print("="*80)
-        print("🧪 PHOENIX Model Validation")
+        print("🧪 PHOENIX Model Validation v1.2")
         print("="*80)
         
         # 1. 모델 로드
@@ -2373,7 +2142,7 @@ def validate_phoenix_model(
         load_time = time.time() - start_time
         print(f"✅ Model loaded in {load_time:.2f}s")
         
-        # 2. 메타데이터 확인
+        # 2. 메타데이터
         metadata = {}
         metadata_path = None
         
@@ -2392,11 +2161,6 @@ def validate_phoenix_model(
         if metadata_path and Path(metadata_path).exists():
             with open(metadata_path, 'r') as f:
                 metadata = json.load(f)
-            print(f"\n📋 Metadata found:")
-            print(f"   PHOENIX Version: {metadata.get('phoenix_version')}")
-            print(f"   Original Model: {metadata.get('original_model')}")
-            print(f"   Conversion Rate: {metadata.get('conversion_rate', 0)*100:.1f}%")
-            print(f"   Quality Score: {metadata.get('quality_score', 0):.2f}")
         
         # 3. Retention 검증
         retention_info = ""
@@ -2428,7 +2192,7 @@ def validate_phoenix_model(
 """
             print(f"   Retention: {retention_count}/{total} layers")
         
-        # 4. 텍스트 생성 테스트
+        # 4. 생성 테스트
         print(f"\n🚀 Running generation tests...")
         
         prompts = [p.strip() for p in test_prompts.split('\n') if p.strip()]
@@ -2439,8 +2203,6 @@ def validate_phoenix_model(
         total_gen_time = 0
         
         for i, prompt in enumerate(prompts, 1):
-            print(f"   Test {i}/{len(prompts)}: {prompt[:50]}...")
-            
             inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
             
             gen_start = time.time()
@@ -2469,18 +2231,15 @@ def validate_phoenix_model(
                 'tokens': tokens_generated,
                 'tokens_per_sec': tokens_per_sec,
             })
-            
-            print(f"      Time: {gen_time:.2f}s | Tokens/s: {tokens_per_sec:.1f}")
         
-        # 5. 결과 포맷팅
+        # 5. 결과
         output_md = f"""
-# ✅ PHOENIX Model Validation Complete!
+# ✅ PHOENIX Model Validation Complete! (v1.2)
 
 ## 📦 Model Information
 - **Source**: {model_source.upper()}
 - **Path/URL**: `{model_path_or_url}`
 - **Load Time**: {load_time:.2f}s
-- **Device**: {DEVICE}
 
 ## 📋 Metadata
 """
@@ -2490,11 +2249,7 @@ def validate_phoenix_model(
 - **PHOENIX Version**: {metadata.get('phoenix_version', 'Unknown')}
 - **Original Model**: {metadata.get('original_model', 'Unknown')}
 - **Conversion Rate**: {metadata.get('conversion_rate', 0)*100:.1f}%
-- **Quality Score**: {metadata.get('quality_score', 0):.2f}/1.00
-- **Burning Type**: {metadata.get('burning_type', 'Unknown')}
 """
-        else:
-            output_md += "- ⚠️ No metadata found\n"
         
         if retention_info:
             output_md += retention_info
@@ -2503,7 +2258,6 @@ def validate_phoenix_model(
 ## 🚀 Generation Tests
 
 **Total Tests**: {len(results)}
-**Total Time**: {total_gen_time:.2f}s
 **Average Speed**: {sum(r['tokens_per_sec'] for r in results)/len(results):.1f} tokens/s
 
 ---
@@ -2511,17 +2265,14 @@ def validate_phoenix_model(
         
         for i, result in enumerate(results, 1):
             output_md += f"""
-### Test {i}: {result['prompt'][:50]}...
+### Test {i}
 
-**Generated Text:**
+**Generated:**
 ```
 {result['generated']}
 ```
 
-**Stats:**
-- Time: {result['time']:.2f}s
-- Tokens: {result['tokens']}
-- Speed: {result['tokens_per_sec']:.1f} tokens/s
+**Stats**: {result['time']:.2f}s | {result['tokens_per_sec']:.1f} tokens/s
 
 ---
 """
@@ -2530,112 +2281,57 @@ def validate_phoenix_model(
         fig = go.Figure()
         
         fig.add_trace(go.Bar(
-            name='Generation Time (s)',
-            x=[f"Test {i+1}" for i in range(len(results))],
-            y=[r['time'] for r in results],
-            text=[f"{r['time']:.2f}s" for r in results],
-            textposition='auto',
-        ))
-        
-        fig.add_trace(go.Bar(
-            name='Tokens/s',
             x=[f"Test {i+1}" for i in range(len(results))],
             y=[r['tokens_per_sec'] for r in results],
-            text=[f"{r['tokens_per_sec']:.1f}" for r in results],
-            textposition='auto',
-            yaxis='y2'
+            marker_color='#10b981'
         ))
         
         fig.update_layout(
-            title="PHOENIX Model Performance",
-            xaxis_title="Test",
-            yaxis_title="Time (s)",
-            yaxis2=dict(
-                title="Tokens/s",
-                overlaying='y',
-                side='right'
-            ),
-            barmode='group',
+            title="Generation Speed (tokens/s)",
             template='plotly_white'
         )
         
-        print(f"\n✅ Validation Complete!\n")
-        
         return output_md, fig
         
     except Exception as e:
         import traceback
-        error_msg = traceback.format_exc()
-        return f"❌ Validation failed:\n```\n{error_msg}\n```", None
+        return f"❌ Validation failed:\n```\n{traceback.format_exc()}\n```", None
 
 
 # 전역 초기화
 db = ExperimentDatabase(DB_PATH)
-CONVERTED_MODELS = {}
 
 # =====================================================
 # Gradio UI
 # =====================================================
 
 with gr.Blocks(
-    title="🔮 PHOENIX - Model Burning Platform v1.1",
+    title="🔮 PHOENIX v1.2 - Structure-Aware Model Burning",
     theme=gr.themes.Soft(),
 ) as demo:
     
     gr.Markdown("""
-    # 🔮 PHOENIX Retention Platform v1.1
+    # 🔮 PHOENIX Retention Platform v1.2
     
-    **Zero-shot Model Burning + Optional Fine-tuning + HuggingFace Hub Auto-Upload + Verification**
+    **Structure-Aware Model Burning + Auto-Upload + Verification**
     
-    ✅ Zero-shot Conversion (데이터셋 불필요!)
-    ✅ Optional Fine-tuning (데이터셋 기반)
+    ✅ **NEW!** Model Structure Pre-Analysis
+    ✅ **NEW!** Qwen3 Model Support
+    ✅ Zero-shot Conversion (No Dataset Required)
+    ✅ Optional Fine-tuning
     ✅ GQA Support
     ✅ O(n) Complexity
     ✅ Auto Upload to HuggingFace Hub
-    ✅ Custom Code for Proper Loading
-    ✅ Pre-upload Verification
     
     ---
     """)
     
     with gr.Tabs():
-        with gr.Tab("🔄 Quick Convert"):
-            gr.Markdown("""
-            ### 빠른 변환 테스트
-            모델을 로드하고 Attention → Retention 변환만 수행합니다. (저장 안 함)
-            """)
-            
-            with gr.Row():
-                with gr.Column(scale=1):
-                    convert_url = gr.Textbox(
-                        label="🔗 Model URL",
-                        value=DEFAULT_MODEL,
-                        placeholder="ibm-granite/granite-4.0-h-350m"
-                    )
-                    convert_hierarchical = gr.Checkbox(value=True, label="Hierarchical Retention")
-                    convert_gpu = gr.Radio(choices=["L40S", "H100"], value="L40S", label="GPU")
-                    convert_btn = gr.Button("🔄 Convert", variant="primary")
-                
-                with gr.Column(scale=2):
-                    convert_output = gr.Markdown()
-            
-            convert_btn.click(
-                convert_model_to_phoenix,
-                [convert_url, convert_hierarchical, convert_gpu],
-                [convert_output]
-            )
-        
         with gr.Tab("🔥 Model Burning"):
             gr.Markdown("""
-            ### 🔥 PHOENIX Model Burning v1.1
+            ### 🔥 PHOENIX Model Burning v1.2
             
-            **모델을 변환하고 저장합니다!**
-            
-            - **Zero-shot**: 데이터셋 없이 변환만 수행 (빠름!)
-            - **Fine-tuning**: 데이터셋으로 추가 학습 (성능 향상)
-            - **HuggingFace Hub**: 자동으로 Hub에 업로드 (Private 기본)
-            - **Custom Code**: modeling_phoenix.py 자동 생성
-            - **Pre-upload Verification**: 업로드 전 검증
+            **모델 구조를 먼저 분석한 후 변환합니다!**
             """)
             
             with gr.Row():
@@ -2643,46 +2339,27 @@ with gr.Blocks(
                     burn_model_url = gr.Textbox(
                         label="🔗 Model URL",
                         value=DEFAULT_MODEL,
-                        placeholder="ibm-granite/granite-4.0-h-350m"
+                        placeholder="Qwen/Qwen3-0.6B"
                     )
                     burn_hierarchical = gr.Checkbox(value=True, label="Hierarchical Retention")
                     
                     burn_output_name = gr.Textbox(
                         label="💾 Output Name",
-                        placeholder="phoenix_my_model (auto-generated if empty)"
+                        placeholder="phoenix_my_model"
                     )
                     
                     gr.Markdown("---")
                     gr.Markdown("### 🌐 HuggingFace Hub Upload")
                     
-                    burn_upload_hub = gr.Checkbox(
-                        value=True,
-                        label="📤 Upload to HuggingFace Hub (with verification)"
-                    )
-                    
-                    burn_hub_repo = gr.Textbox(
-                        label="📦 Hub Repository Name (optional)",
-                        placeholder="phoenix-granite-350m"
-                    )
-                    
-                    burn_hub_private = gr.Checkbox(
-                        value=True,
-                        label="🔒 Private Repository"
-                    )
+                    burn_upload_hub = gr.Checkbox(value=True, label="📤 Upload to Hub")
+                    burn_hub_repo = gr.Textbox(label="📦 Repo Name (optional)")
+                    burn_hub_private = gr.Checkbox(value=True, label="🔒 Private")
                     
                     gr.Markdown("---")
                     gr.Markdown("### 📊 Dataset (Optional)")
                     
-                    burn_dataset = gr.Textbox(
-                        label="📁 Dataset Path (Optional)",
-                        placeholder="/path/to/dataset.txt",
-                        value=""
-                    )
-                    
-                    burn_use_finetuning = gr.Checkbox(
-                        value=False,
-                        label="🚀 Enable Fine-tuning (requires dataset)"
-                    )
+                    burn_dataset = gr.Textbox(label="📁 Dataset Path")
+                    burn_use_finetuning = gr.Checkbox(value=False, label="🚀 Enable Fine-tuning")
                     
                     with gr.Accordion("⚙️ Fine-tuning Config", open=False):
                         burn_epochs = gr.Slider(1, 5, 1, step=1, label="Epochs")
@@ -2699,61 +2376,15 @@ with gr.Blocks(
             burn_btn.click(
                 burn_phoenix_model_ui,
                 [
-                    burn_model_url,
-                    burn_hierarchical,
-                    burn_dataset,
-                    burn_output_name,
-                    burn_use_finetuning,
-                    burn_epochs,
-                    burn_batch,
-                    burn_lr,
-                    burn_max_steps,
-                    burn_upload_hub,
-                    burn_hub_repo,
-                    burn_hub_private,
+                    burn_model_url, burn_hierarchical, burn_dataset, burn_output_name,
+                    burn_use_finetuning, burn_epochs, burn_batch, burn_lr, burn_max_steps,
+                    burn_upload_hub, burn_hub_repo, burn_hub_private,
                 ],
                 [burn_output, burn_plot]
             )
         
-        with gr.Tab("💬 Text Generation"):
-            gr.Markdown("""
-            ### PHOENIX 텍스트 생성
-            변환된 모델로 텍스트를 생성합니다.
-            """)
-            
-            with gr.Row():
-                with gr.Column(scale=1):
-                    gen_model_url = gr.Textbox(label="🔗 Model URL", value=DEFAULT_MODEL)
-                    gen_hierarchical = gr.Checkbox(value=True, label="Hierarchical")
-                    gen_convert = gr.Checkbox(value=True, label="Enable Conversion")
-                    
-                    gen_prompt = gr.Textbox(
-                        label="📝 Prompt",
-                        lines=3,
-                        value="The future of AI is"
-                    )
-                    
-                    gen_max_tokens = gr.Slider(16, 256, 64, step=16, label="Max Tokens")
-                    gen_temperature = gr.Slider(0.1, 2.0, 0.7, step=0.1, label="Temperature")
-                    
-                    gen_btn = gr.Button("🚀 Generate", variant="primary")
-                
-                with gr.Column(scale=2):
-                    gen_output = gr.Markdown()
-                    gen_stats = gr.Markdown()
-            
-            gen_btn.click(
-                generate_text_phoenix,
-                [gen_model_url, gen_hierarchical, gen_convert, gen_prompt, 
-                 gen_max_tokens, gen_temperature],
-                [gen_output, gen_stats]
-            )
-        
         with gr.Tab("📊 Burning History"):
-            gr.Markdown("""
-            ### 📊 Model Burning History
-            저장된 모델 버닝 기록을 확인합니다.
-            """)
+            gr.Markdown("### 📊 Model Burning History")
             
             with gr.Row():
                 with gr.Column(scale=1):
@@ -2766,11 +2397,7 @@ with gr.Blocks(
             hist_btn.click(view_burning_history, outputs=[hist_output, hist_plot])
 
         with gr.Tab("🧪 Model Validation"):
-            gr.Markdown("""
-            ### 🧪 PHOENIX 모델 검증
-            
-            배포된 PHOENIX 모델을 로드하고 품질을 검증합니다.
-            """)
+            gr.Markdown("### 🧪 PHOENIX 모델 검증")
             
             with gr.Row():
                 with gr.Column(scale=1):
@@ -2782,7 +2409,7 @@ with gr.Blocks(
                     
                     val_path = gr.Textbox(
                         label="🔗 Model Path/URL",
-                        value="seawolf2357/phoenix-granite-4.0-h-350m",
+                        value="seawolf2357/phoenix-Qwen3-0.6B",
                         placeholder="seawolf2357/phoenix-model"
                     )
                     
@@ -2796,10 +2423,7 @@ with gr.Blocks(
                         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_verify_retention = gr.Checkbox(value=True, label="🔍 Verify Retention")
                     
                     val_btn = gr.Button("🧪 Validate Model", variant="primary", size="lg")
                 
@@ -2817,20 +2441,17 @@ with gr.Blocks(
     gr.Markdown(f"""
     ---
     
-    ## 🔥 PHOENIX Model Burning Platform v1.1
+    ## 🔥 PHOENIX Model Burning Platform v1.2
     
-    ### 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
+    ### What's New in v1.2
+    - ✅ **Model Structure Pre-Analysis** - 변환 전 구조 파악
+    - ✅ **Qwen3 Support** - Qwen3 모델 완벽 지원
+    - ✅ **Enhanced Conversion** - 구조 정보 활용한 정확한 변환
     
     **HuggingFace Token**: {'✅ Connected' if HF_TOKEN else '❌ Not Found'}
+    **Default Model**: {DEFAULT_MODEL}
     
-    **VIDraft AI Research Lab** | PHOENIX v1.1
+    **VIDraft AI Research Lab** | PHOENIX v1.2
     """)
 
 if __name__ == "__main__":