Update app.py

app.py

@@ -1,12 +1,12 @@
 """
-🔮 PHOENIX Retention Research Platform
-Real Implementation - GQA Support (Final Version)
+🔮 PHOENIX Retention Research Platform - FINAL INTEGRATED VERSION
+Zero-shot Model Burning + Optional Fine-tuning
 
-✅ Supports Grouped Query Attention (GQA)
-✅ Adaptive K/V projection dimensions
-✅ L40S GPU + Persistent Storage
-✅ KV Cache with State Reuse
-✅ Robust Error Handling
+✅ Zero-shot Conversion (No Dataset Required)
+✅ Optional Fine-tuning (Dataset-based)
+✅ GQA Support
+✅ HuggingFace Hub Integration
+✅ Comprehensive Evaluation
 
 VIDraft AI Research Lab
 """
@@ -27,8 +27,16 @@ import pandas as pd
 from typing import Dict, List, Any, Tuple, Optional
 import chromadb
 from chromadb.config import Settings
-from transformers import AutoModel, AutoTokenizer, AutoConfig, AutoModelForCausalLM
+from transformers import (
+    AutoModel, AutoTokenizer, AutoConfig, AutoModelForCausalLM,
+    get_cosine_schedule_with_warmup, TrainingArguments, Trainer
+)
+from datasets import load_dataset
+from torch.utils.data import Dataset, DataLoader
+from accelerate import Accelerator
+from tqdm import tqdm
 import copy
+import shutil
 
 # =====================================================
 # 전역 설정
@@ -38,10 +46,12 @@ DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 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"
 
 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"💾 Storage: {STORAGE_PATH}")
@@ -52,13 +62,7 @@ print(f"🎯 Default Base Model: {DEFAULT_MODEL}")
 # =====================================================
 
 class MultiScaleRetention(nn.Module):
-    """
-    진짜 Retention Attention with GQA Support
-    
-    ✅ Supports Grouped Query Attention
-    ✅ Adaptive K/V dimensions
-    ✅ KV Cache with State Reuse
-    """
+    """진짜 Retention Attention with GQA Support"""
     
     def __init__(self, config, layer_idx=0):
         super().__init__()
@@ -77,32 +81,21 @@ class MultiScaleRetention(nn.Module):
             self.num_key_value_heads = self.num_heads
         
         self.num_key_value_groups = self.num_heads // self.num_key_value_heads
-        self.kv_head_dim = self.head_dim  # Same as Q head_dim
+        self.kv_head_dim = self.head_dim
         self.kv_dim = self.num_key_value_heads * self.kv_head_dim
         
-        # ✅ Internal state storage for KV cache simulation
+        # Internal state storage for KV cache simulation
         self.register_buffer('_internal_state', None, persistent=False)
         self.register_buffer('_state_initialized', torch.tensor(False), persistent=False)
         
-        print(f"  📐 Layer {layer_idx} Retention (GQA) initialized:")
-        print(f"     - hidden_size: {self.hidden_size}")
-        print(f"     - num_heads (Q): {self.num_heads}")
-        print(f"     - num_key_value_heads (K/V): {self.num_key_value_heads}")
-        print(f"     - head_dim: {self.head_dim}")
-        print(f"     - kv_dim: {self.kv_dim}")
-        print(f"     - groups: {self.num_key_value_groups}")
-        
-        # ✅ Projections with correct dimensions
-        # Check if model uses expanded projections (like Qwen3)
-        self.use_expanded_proj = False
-        
+        # Projections with correct dimensions
         self.q_proj = nn.Linear(self.hidden_size, self.hidden_size, bias=False)
-        self.k_proj = nn.Linear(self.hidden_size, self.kv_dim, bias=False)  # GQA!
-        self.v_proj = nn.Linear(self.hidden_size, self.kv_dim, bias=False)  # GQA!
+        self.k_proj = nn.Linear(self.hidden_size, self.kv_dim, bias=False)
+        self.v_proj = nn.Linear(self.hidden_size, self.kv_dim, bias=False)
         self.o_proj = nn.Linear(self.hidden_size, self.hidden_size, bias=False)
         
         # Retention parameters
-        decay_values = torch.linspace(0.95, 0.99, self.num_heads)  # ✅ 더 높은 decay (정보 유지)
+        decay_values = torch.linspace(0.95, 0.99, self.num_heads)
         self.decay = nn.Parameter(decay_values, requires_grad=True)
         
         # Group norm
@@ -112,10 +105,7 @@ class MultiScaleRetention(nn.Module):
         )
         
     def _repeat_kv(self, hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:
-        """
-        Repeat K/V heads to match Q heads (GQA)
-        [B, num_kv_heads, seq_len, head_dim] -> [B, num_heads, seq_len, head_dim]
-        """
+        """Repeat K/V heads to match Q heads (GQA)"""
         batch, num_key_value_heads, slen, head_dim = hidden_states.shape
         if n_rep == 1:
             return hidden_states
@@ -126,7 +116,7 @@ class MultiScaleRetention(nn.Module):
         return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim)
     
     def reset_state(self):
-        """Reset internal state (call at start of new sequence)"""
+        """Reset internal state"""
         self._internal_state = None
         self._state_initialized = torch.tensor(False)
         
@@ -142,25 +132,22 @@ class MultiScaleRetention(nn.Module):
         past_key_values: Optional[Tuple[torch.Tensor]] = None,
         **kwargs
     ):
-        """
-        O(n) Retention with GQA support
-        """
+        """O(n) Retention with GQA support"""
         batch_size, seq_len, _ = hidden_states.shape
         
         if past_key_values is not None:
             past_key_value = past_key_values
         
         # Q, K, V projections
-        query_states = self.q_proj(hidden_states)  # [B, L, hidden_size]
-        key_states = self.k_proj(hidden_states)    # [B, L, kv_dim]
-        value_states = self.v_proj(hidden_states)  # [B, L, kv_dim]
+        query_states = self.q_proj(hidden_states)
+        key_states = self.k_proj(hidden_states)
+        value_states = self.v_proj(hidden_states)
         
-        # Reshape Q: [B, L, hidden_size] -> [B, num_heads, L, head_dim]
+        # Reshape
         query_states = query_states.view(
             batch_size, seq_len, self.num_heads, self.head_dim
         ).transpose(1, 2)
         
-        # Reshape K/V: [B, L, kv_dim] -> [B, num_kv_heads, L, kv_head_dim]
         key_states = key_states.view(
             batch_size, seq_len, self.num_key_value_heads, self.kv_head_dim
         ).transpose(1, 2)
@@ -169,30 +156,28 @@ class MultiScaleRetention(nn.Module):
             batch_size, seq_len, self.num_key_value_heads, self.kv_head_dim
         ).transpose(1, 2)
         
-        # ✅ Repeat K/V to match Q heads (GQA)
+        # Repeat K/V to match Q heads (GQA)
         key_states = self._repeat_kv(key_states, self.num_key_value_groups)
         value_states = self._repeat_kv(value_states, self.num_key_value_groups)
         
-        # Now all have shape [B, num_heads, L, head_dim]
-        
-        # Retention computation with internal state
+        # Retention computation
         past_state = self._internal_state if (use_cache and self._state_initialized) else None
         retention_states, new_state = self._compute_retention(
             query_states, key_states, value_states, past_state
         )
         
-        # ✅ Store state internally for next iteration
+        # Store state internally
         if use_cache:
             self._internal_state = new_state.detach()
             self._state_initialized = torch.tensor(True)
         
-        # Reshape back: [B, num_heads, L, head_dim] -> [B, L, hidden_size]
+        # Reshape back
         retention_states = retention_states.transpose(1, 2).contiguous()
         retention_states = retention_states.reshape(
             batch_size, seq_len, self.hidden_size
         )
         
-        # ✅ Group norm - ensure it's on the correct device AND dtype
+        # Group norm
         if not next(self.group_norm.parameters()).is_cuda and retention_states.is_cuda:
             self.group_norm = self.group_norm.to(retention_states.device, dtype=retention_states.dtype)
         elif next(self.group_norm.parameters()).dtype != retention_states.dtype:
@@ -202,90 +187,60 @@ class MultiScaleRetention(nn.Module):
             retention_states.transpose(1, 2)
         ).transpose(1, 2)
         
-        # ✅ Additional stabilization: clip extreme values
         retention_states = torch.clamp(retention_states, min=-10.0, max=10.0)
         
         # Output projection
         attn_output = self.o_proj(retention_states)
         
-        # ✅ Return format for compatibility
-        # Granite expects: (hidden_states, attn_weights)
-        # We return: (output, None) - no past_key_values in return signature
-        # State is stored internally but not returned
         return (attn_output, None)
     
     def _compute_retention(
         self,
-        queries: torch.Tensor,  # [B, H, L, D]
-        keys: torch.Tensor,     # [B, H, L, D]
-        values: torch.Tensor,   # [B, H, L, D]
+        queries: torch.Tensor,
+        keys: torch.Tensor,
+        values: torch.Tensor,
         past_state: Optional[torch.Tensor] = None
     ):
-        """
-        O(n) Retention computation with KV cache support
-        
-        Args:
-            past_state: Previous retention state [B, H, D, D]
-        
-        Returns:
-            output: [B, H, L, D]
-            new_state: Updated state [B, H, D, D]
-        """
+        """O(n) Retention computation"""
         batch_size, num_heads, seq_len, head_dim = queries.shape
         
-        # ✅ State initialization with correct dtype and device
         if past_state is not None:
             state = past_state.to(queries.device, dtype=queries.dtype)
         else:
-            # ✅ 작은 값으로 초기화 (완전한 0보다 안정적)
             state = torch.zeros(
                 batch_size, num_heads, head_dim, head_dim,
                 dtype=queries.dtype,
                 device=queries.device
-            ) + 1e-6  # Small epsilon for stability
+            ) + 1e-6
         
         outputs = []
         
-        # ✅ Decay를 입력과 같은 device/dtype으로
         decay = torch.sigmoid(self.decay).view(1, -1, 1, 1).to(
             device=queries.device, 
             dtype=queries.dtype
         )
         
-        # Sequential processing (O(n))
         for t in range(seq_len):
-            q_t = queries[:, :, t, :]  # [B, H, D]
-            k_t = keys[:, :, t, :]     # [B, H, D]
-            v_t = values[:, :, t, :]   # [B, H, D]
+            q_t = queries[:, :, t, :]
+            k_t = keys[:, :, t, :]
+            v_t = values[:, :, t, :]
             
-            # Decay application
             state = decay * state
-            
-            # State update: S = decay * S + k @ v^T
             kv_update = torch.einsum('bhd,bhe->bhde', k_t, v_t)
-            
-            # ✅ Clip update to prevent explosion
             kv_update = torch.clamp(kv_update, min=-5.0, max=5.0)
-            
             state = state + kv_update
-            
-            # ✅ Clip state to maintain stability
             state = torch.clamp(state, min=-10.0, max=10.0)
             
-            # Output: q @ S
             output_t = torch.einsum('bhd,bhde->bhe', q_t, state)
             outputs.append(output_t)
         
-        output = torch.stack(outputs, dim=2)  # [B, H, L, D]
+        output = torch.stack(outputs, dim=2)
         
-        # ✅ Return both output and updated state
         return output, state
 
 
 class HierarchicalRetention(nn.Module):
-    """
-    PHOENIX Hierarchical Retention with GQA
-    """
+    """PHOENIX Hierarchical Retention with GQA"""
     
     def __init__(self, config, layer_idx=0):
         super().__init__()
@@ -294,21 +249,17 @@ class HierarchicalRetention(nn.Module):
         hidden_size = config.hidden_size
         self.d_state = hidden_size // 2
         
-        # 3-tier hierarchical states
         self.short_proj = nn.Linear(hidden_size, self.d_state)
         self.medium_proj = nn.Linear(self.d_state, self.d_state)
         self.long_proj = nn.Linear(self.d_state, self.d_state * 2)
         self.fusion = nn.Linear(self.d_state * 4, hidden_size)
         
-        # Decay rates
         self.short_decay = 0.5
         self.medium_decay = 0.8
         self.long_decay = 0.95
         
-        # Layer norm
         self.norm = nn.LayerNorm(hidden_size)
         
-        # ✅ CRITICAL: Move all submodules to same device as base_retention
         if next(self.base_retention.parameters()).is_cuda:
             device = next(self.base_retention.parameters()).device
             dtype = next(self.base_retention.parameters()).dtype
@@ -336,7 +287,6 @@ class HierarchicalRetention(nn.Module):
         if past_key_values is not None:
             past_key_value = past_key_values
         
-        # ✅ Ensure all submodules are on correct device AND dtype
         target_device = hidden_states.device
         target_dtype = hidden_states.dtype
         
@@ -353,14 +303,12 @@ class HierarchicalRetention(nn.Module):
             self.fusion = self.fusion.to(dtype=target_dtype)
             self.norm = self.norm.to(dtype=target_dtype)
         
-        # ✅ Base Retention - now always returns 3 values
         base_result = self.base_retention(
             hidden_states, attention_mask, position_ids,
             past_key_value, output_attentions, use_cache
         )
         
         retention_output = base_result[0]
-        new_state = base_result[2] if len(base_result) > 2 else None
         
         # Hierarchical states
         short_state = torch.zeros(batch_size, self.d_state, dtype=hidden_states.dtype, device=target_device)
@@ -372,21 +320,17 @@ class HierarchicalRetention(nn.Module):
         for t in range(seq_len):
             x_t = retention_output[:, t, :]
             
-            # Short-term
             short_input = self.short_proj(x_t)
             short_state = self.short_decay * short_state + short_input
             
-            # Medium-term (every 8 tokens)
             if t % 8 == 0:
                 medium_state = self.medium_decay * medium_state + \
                               self.medium_proj(short_state)
             
-            # Long-term (every 64 tokens)
             if t % 64 == 0:
                 long_state = self.long_decay * long_state + \
                             self.long_proj(medium_state)
             
-            # Fusion
             combined = torch.cat([short_state, medium_state, long_state], dim=-1)
             output_t = self.fusion(combined)
             hierarchical_outputs.append(output_t)
@@ -394,8 +338,6 @@ class HierarchicalRetention(nn.Module):
         output = torch.stack(hierarchical_outputs, dim=1)
         output = self.norm(output)
         
-        # ✅ Return format for compatibility with Granite
-        # Granite expects: (hidden_states, attn_weights)
         return (output, None)
 
 
@@ -404,15 +346,12 @@ class HierarchicalRetention(nn.Module):
 # =====================================================
 
 def replace_attention_with_retention(model, use_hierarchical=True):
-    """
-    Transformer Attention → PHOENIX Retention (GQA Support)
-    """
+    """Transformer Attention → PHOENIX Retention (GQA Support)"""
     print("🔄 Starting Attention → Retention conversion (GQA support)...")
     
     replaced_count = 0
     total_layers = 0
     
-    # Layer structure
     if hasattr(model, 'transformer'):
         layers = model.transformer.h
     elif hasattr(model, 'model') and hasattr(model.model, 'layers'):
@@ -425,35 +364,26 @@ def replace_attention_with_retention(model, use_hierarchical=True):
     
     total_layers = len(layers)
     
-    # Check first layer for dimensions
+    # Check first layer for GQA
     first_layer = layers[0]
     if hasattr(first_layer, 'self_attn'):
         old_attn = first_layer.self_attn
         
-        print(f"\n📐 Detected attention structure:")
         if hasattr(old_attn, 'q_proj'):
             q_shape = old_attn.q_proj.weight.shape
             k_shape = old_attn.k_proj.weight.shape
-            v_shape = old_attn.v_proj.weight.shape
-            
-            print(f"   - Q projection: {q_shape}")
-            print(f"   - K projection: {k_shape}")
-            print(f"   - V projection: {v_shape}")
             
             if k_shape[0] != q_shape[0]:
                 print(f"   ✅ GQA detected! (K/V dim: {k_shape[0]} < Q dim: {q_shape[0]})")
-                # Update config for GQA
                 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
-                    print(f"   🔧 Set num_key_value_heads = {num_kv_heads}")
     
     for layer_idx, layer in enumerate(layers):
         try:
             if hasattr(layer, 'self_attn'):
                 old_attn = layer.self_attn
                 
-                # Create PHOENIX Retention
                 if use_hierarchical:
                     new_retention = HierarchicalRetention(model.config, layer_idx)
                 else:
@@ -467,88 +397,45 @@ def replace_attention_with_retention(model, use_hierarchical=True):
                         else:
                             target = new_retention
                         
-                        # ✅ Shape 확인 및 복사
                         q_match = old_attn.q_proj.weight.shape == target.q_proj.weight.shape
                         k_match = old_attn.k_proj.weight.shape == target.k_proj.weight.shape
                         v_match = old_attn.v_proj.weight.shape == target.v_proj.weight.shape
                         o_match = old_attn.o_proj.weight.shape == target.o_proj.weight.shape
                         
                         if q_match and k_match and v_match and o_match:
-                            # 완벽한 매칭 - 그대로 복사
                             target.q_proj.weight.data = old_attn.q_proj.weight.data.clone()
                             target.k_proj.weight.data = old_attn.k_proj.weight.data.clone()
                             target.v_proj.weight.data = old_attn.v_proj.weight.data.clone()
                             target.o_proj.weight.data = old_attn.o_proj.weight.data.clone()
-                            print(f"  ✅ Layer {layer_idx}: Weights copied (perfect match)")
+                            print(f"  ✅ Layer {layer_idx}: Perfect match")
                         
                         elif q_match and o_match:
-                            # Q와 O는 매칭 - K/V는 부분 복사
                             target.q_proj.weight.data = old_attn.q_proj.weight.data.clone()
                             target.o_proj.weight.data = old_attn.o_proj.weight.data.clone()
                             
-                            # K/V는 가능한 만큼 복사 (GQA의 경우 일부만)
-                            k_copy_size = min(old_attn.k_proj.weight.shape[0], target.k_proj.weight.shape[0])
-                            v_copy_size = min(old_attn.v_proj.weight.shape[0], target.v_proj.weight.shape[0])
-                            
-                            target.k_proj.weight.data[:k_copy_size] = old_attn.k_proj.weight.data[:k_copy_size].clone()
-                            target.v_proj.weight.data[:v_copy_size] = old_attn.v_proj.weight.data[:v_copy_size].clone()
-                            
-                            print(f"  ✅ Layer {layer_idx}: Weights copied (partial K/V: {k_copy_size}/{target.k_proj.weight.shape[0]})")
-                        
-                        elif old_attn.q_proj.weight.shape[0] == 2 * target.q_proj.weight.shape[0]:
-                            # Qwen3 스타일: Q가 2배 크기 (확장된 projection)
-                            # 중앙 부분을 추출
-                            q_out, q_in = old_attn.q_proj.weight.shape
-                            target_out = target.q_proj.weight.shape[0]
-                            
-                            # Q의 중앙 부분 추출
-                            start_idx = (q_out - target_out) // 2
-                            target.q_proj.weight.data = old_attn.q_proj.weight.data[start_idx:start_idx+target_out].clone()
-                            
-                            # O의 중앙 부분 추출 (transposed)
-                            o_out, o_in = old_attn.o_proj.weight.shape
-                            target_in = target.o_proj.weight.shape[1]
-                            start_idx = (o_in - target_in) // 2
-                            target.o_proj.weight.data = old_attn.o_proj.weight.data[:, start_idx:start_idx+target_in].clone()
-                            
-                            # K/V 부분 복사
                             k_copy_size = min(old_attn.k_proj.weight.shape[0], target.k_proj.weight.shape[0])
                             v_copy_size = min(old_attn.v_proj.weight.shape[0], target.v_proj.weight.shape[0])
                             
                             target.k_proj.weight.data[:k_copy_size] = old_attn.k_proj.weight.data[:k_copy_size].clone()
                             target.v_proj.weight.data[:v_copy_size] = old_attn.v_proj.weight.data[:v_copy_size].clone()
                             
-                            print(f"  ✅ Layer {layer_idx}: Weights copied (Qwen3 style: Q/O center extraction, K/V partial)")
+                            print(f"  ✅ Layer {layer_idx}: Partial (GQA)")
                         
                         else:
-                            # Shape mismatch - Xavier 초기화로 대체
-                            print(f"  ⚠️ Layer {layer_idx}: Shape mismatch, using Xavier init")
-                            print(f"     Q: {old_attn.q_proj.weight.shape} vs {target.q_proj.weight.shape}")
-                            print(f"     K: {old_attn.k_proj.weight.shape} vs {target.k_proj.weight.shape}")
-                            print(f"     V: {old_attn.v_proj.weight.shape} vs {target.v_proj.weight.shape}")
-                            print(f"     O: {old_attn.o_proj.weight.shape} vs {target.o_proj.weight.shape}")
-                            
-                            # ✅ Xavier initialization (better than random)
                             nn.init.xavier_uniform_(target.q_proj.weight)
                             nn.init.xavier_uniform_(target.k_proj.weight)
                             nn.init.xavier_uniform_(target.v_proj.weight)
                             nn.init.xavier_uniform_(target.o_proj.weight)
+                            print(f"  ⚠️ Layer {layer_idx}: Xavier init")
                             
                     except Exception as e:
                         print(f"  ⚠️ Layer {layer_idx}: Weight copy failed - {e}")
-                        import traceback
-                        traceback.print_exc()
                 
-                # Replace
                 layer.self_attn = new_retention
                 replaced_count += 1
                 
-                print(f"  ✅ Layer {layer_idx}: Attention → Retention (GQA)")
-                
         except Exception as e:
             print(f"  ❌ Layer {layer_idx}: Failed - {e}")
-            import traceback
-            traceback.print_exc()
             continue
     
     print(f"\n✅ Conversion complete: {replaced_count}/{total_layers} layers")
@@ -556,28 +443,6 @@ def replace_attention_with_retention(model, use_hierarchical=True):
     return model, replaced_count, total_layers
 
 
-def estimate_conversion_time(model_size_mb, gpu_type="L40S"):
-    """변환 시간 예측"""
-    gpu_specs = {
-        "L40S": {"memory_gb": 48, "tflops_fp16": 362},
-        "H100": {"memory_gb": 80, "tflops_fp16": 989}
-    }
-    
-    spec = gpu_specs.get(gpu_type, gpu_specs["L40S"])
-    base_time_seconds = 30
-    scale_factor = model_size_mb / 1400
-    performance_factor = 0.4 if gpu_type == "H100" else 1.0
-    estimated_time = base_time_seconds * scale_factor * performance_factor
-    
-    return {
-        'gpu_type': gpu_type,
-        'estimated_seconds': estimated_time,
-        'estimated_minutes': estimated_time / 60,
-        'memory_required_gb': model_size_mb / 1024,
-        'max_memory_gb': spec['memory_gb']
-    }
-
-
 # =====================================================
 # 데이터베이스
 # =====================================================
@@ -588,7 +453,6 @@ class ExperimentDatabase:
     def __init__(self, db_path: str):
         self.db_path = db_path
         self.init_database()
-        self.migrate_database()
     
     def init_database(self):
         with sqlite3.connect(self.db_path) as conn:
@@ -610,26 +474,22 @@ class ExperimentDatabase:
                     timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
                 )
             """)
-            conn.commit()
-    
-    def migrate_database(self):
-        with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.cursor()
-            cursor.execute("PRAGMA table_info(experiments)")
-            columns = [col[1] for col in cursor.fetchall()]
             
-            new_columns = [
-                ('attention_replaced', 'BOOLEAN'),
-                ('layers_converted', 'INTEGER'),
-                ('total_layers', 'INTEGER')
-            ]
-            
-            for col_name, col_type in new_columns:
-                if col_name not in columns:
-                    try:
-                        cursor.execute(f"ALTER TABLE experiments ADD COLUMN {col_name} {col_type}")
-                    except:
-                        pass
+            # Burning history table
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS burning_history (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    model_url TEXT NOT NULL,
+                    output_path TEXT NOT NULL,
+                    use_hierarchical BOOLEAN,
+                    dataset_used BOOLEAN,
+                    conversion_rate REAL,
+                    training_steps INTEGER,
+                    final_loss REAL,
+                    evaluation_score REAL,
+                    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
             conn.commit()
     
     def save_experiment(self, config: Dict, metrics: Dict) -> int:
@@ -658,106 +518,406 @@ class ExperimentDatabase:
             conn.commit()
             return cursor.lastrowid
     
-    def get_recent_experiments(self, limit: int = 20) -> List[Dict]:
+    def save_burning(self, burning_info: Dict) -> int:
         with sqlite3.connect(self.db_path) as conn:
-            conn.row_factory = sqlite3.Row
             cursor = conn.cursor()
-            cursor.execute("SELECT * FROM experiments ORDER BY timestamp DESC LIMIT ?", (limit,))
-            return [dict(row) for row in cursor.fetchall()]
+            cursor.execute("""
+                INSERT INTO burning_history (
+                    model_url, output_path, use_hierarchical,
+                    dataset_used, conversion_rate, training_steps,
+                    final_loss, evaluation_score
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                burning_info.get('model_url'),
+                burning_info.get('output_path'),
+                burning_info.get('use_hierarchical'),
+                burning_info.get('dataset_used'),
+                burning_info.get('conversion_rate'),
+                burning_info.get('training_steps', 0),
+                burning_info.get('final_loss'),
+                burning_info.get('evaluation_score'),
+            ))
+            conn.commit()
+            return cursor.lastrowid
     
-    def get_statistics(self) -> Dict:
+    def get_burning_history(self, limit: int = 20) -> List[Dict]:
         with sqlite3.connect(self.db_path) as conn:
+            conn.row_factory = sqlite3.Row
             cursor = conn.cursor()
-            cursor.execute("SELECT COUNT(*) FROM experiments")
-            total = cursor.fetchone()[0]
-            
-            cursor.execute("SELECT model_type, COUNT(*) FROM experiments GROUP BY model_type")
-            by_model = dict(cursor.fetchall())
-            
-            return {'total_experiments': total, 'by_model': by_model}
-
-
-class RetentionVectorStore:
-    """ChromaDB vector store"""
-    
-    def __init__(self, persist_directory: str):
-        try:
-            self.client = chromadb.Client(Settings(
-                persist_directory=persist_directory,
-                anonymized_telemetry=False
-            ))
-            self.collection = self.client.get_or_create_collection(name="retention_states")
-        except:
-            self.client = None
-            self.collection = None
+            cursor.execute("SELECT * FROM burning_history ORDER BY timestamp DESC LIMIT ?", (limit,))
+            return [dict(row) for row in cursor.fetchall()]
 
 
 # =====================================================
-# 유틸리티
+# 모델 버닝 (Zero-shot + Optional Fine-tuning)
 # =====================================================
 
-def calculate_metrics(output, states, config=None):
-    """Calculate metrics"""
-    metrics = {}
+def evaluate_model_quality(model, tokenizer, test_prompts=None):
+    """
+    간단한 모델 품질 평가
     
-    if isinstance(output, torch.Tensor):
-        metrics['memory_mb'] = (output.numel() * 4) / (1024 * 1024)
-    else:
-        metrics['memory_mb'] = 0
+    Returns:
+        score: 0.0 ~ 1.0 (높을수록 좋음)
+    """
+    if test_prompts is None:
+        test_prompts = [
+            "The capital of France is",
+            "In machine learning, overfitting means",
+            "2 + 2 =",
+        ]
     
-    if config:
-        metrics['attention_replaced'] = config.get('attention_replaced', False)
-        metrics['layers_converted'] = config.get('layers_converted', 0)
-        metrics['total_layers'] = config.get('total_layers', 0)
+    model.eval()
+    scores = []
     
-    return metrics
-
-
-def plot_retention_states(states):
-    """Plot retention states"""
-    fig = go.Figure()
-    fig.add_trace(go.Scatter(
-        y=np.random.randn(100),
-        mode='lines',
-        name='Retention Pattern'
-    ))
-    fig.update_layout(title='Retention State Visualization', template='plotly_white')
-    return fig
+    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 plot_memory_usage(metrics):
-    """Plot memory usage"""
-    fig = go.Figure(go.Bar(
-        x=['Memory (MB)', 'Layers', 'Rate %'],
-        y=[
-            metrics.get('memory_mb', 0),
-            metrics.get('layers_converted', 0),
-            (metrics.get('layers_converted', 0) / max(metrics.get('total_layers', 1), 1)) * 100
-        ]
-    ))
-    fig.update_layout(title='Performance Metrics', template='plotly_white')
-    return fig
+def burn_model_zero_shot(
+    model_url: str,
+    output_dir: str,
+    use_hierarchical: bool = True,
+    test_prompts: List[str] = None,
+):
+    """
+    Zero-shot Model Burning (데이터셋 불필요)
+    
+    1. 모델 로드
+    2. Attention → Retention 변환
+    3. 품질 평가
+    4. 저장
+    
+    Returns:
+        status, model_path, metrics
+    """
+    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")
+        
+        # 3. Evaluate
+        print(f"\n📊 Evaluating model quality...")
+        eval_start = time.time()
+        
+        quality_score = evaluate_model_quality(model, tokenizer, test_prompts)
+        
+        eval_time = time.time() - eval_start
+        print(f"✅ Quality Score: {quality_score:.2f}/1.00 (in {eval_time:.1f}s)")
+        
+        # 4. Save
+        print(f"\n💾 Saving PHOENIX model...")
+        save_start = time.time()
+        
+        model.save_pretrained(output_path)
+        tokenizer.save_pretrained(output_path)
+        
+        # Save metadata
+        metadata = {
+            'phoenix_version': '1.0.0',
+            'original_model': model_url,
+            'use_hierarchical': use_hierarchical,
+            'conversion_rate': conversion_rate,
+            'layers_converted': converted,
+            'total_layers': total,
+            'quality_score': quality_score,
+            'burning_type': 'zero_shot',
+            'timestamp': datetime.now().isoformat(),
+        }
+        
+        with open(output_path / 'phoenix_metadata.json', 'w') as f:
+            json.dump(metadata, f, indent=2)
+        
+        save_time = time.time() - save_start
+        print(f"✅ Saved to {output_path} in {save_time:.1f}s")
+        
+        # Total time
+        total_time = time.time() - start_time
+        
+        result = {
+            'status': 'success',
+            'model_path': str(output_path),
+            'conversion_rate': conversion_rate,
+            'quality_score': quality_score,
+            'total_time': total_time,
+            'load_time': load_time,
+            'convert_time': convert_time,
+            'eval_time': eval_time,
+            'save_time': save_time,
+        }
+        
+        print(f"\n{'='*80}")
+        print(f"✅ Zero-shot Burning Complete!")
+        print(f"   Total Time: {total_time:.1f}s")
+        print(f"   Model Path: {output_path}")
+        print(f"   Quality: {quality_score:.2f}/1.00")
+        print(f"{'='*80}\n")
+        
+        return result
+        
+    except Exception as e:
+        import traceback
+        error_msg = traceback.format_exc()
+        print(f"\n❌ Zero-shot burning failed:\n{error_msg}")
+        return {
+            'status': 'failed',
+            'error': str(e),
+            'traceback': error_msg
+        }
 
 
-# 전역 초기화
-db = ExperimentDatabase(DB_PATH)
-vector_store = RetentionVectorStore(VECTOR_DB_PATH)
-CONVERTED_MODELS = {}
+def burn_model_with_finetuning(
+    model_url: str,
+    output_dir: str,
+    dataset_path: str,
+    use_hierarchical: bool = True,
+    num_epochs: int = 1,
+    batch_size: int = 4,
+    learning_rate: float = 5e-5,
+    max_steps: int = 100,
+):
+    """
+    Fine-tuning Model Burning (데이터셋 기반)
+    
+    1. 모델 로드 & 변환
+    2. 데이터셋 로드
+    3. Fine-tuning
+    4. 평가 & 저장
+    
+    Returns:
+        status, model_path, metrics
+    """
+    print("="*80)
+    print("🔥 PHOENIX Fine-tuning Model Burning")
+    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}")
+        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
+        
+        print(f"\n🔄 Converting...")
+        model.model, converted, total = replace_attention_with_retention(
+            model.model,
+            use_hierarchical=use_hierarchical
+        )
+        
+        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}")
+        
+        if dataset_path.endswith('.txt'):
+            with open(dataset_path, 'r', encoding='utf-8') as f:
+                texts = [line.strip() for line in f if line.strip()]
+            
+            # Simple tokenization
+            def tokenize_fn(text):
+                return tokenizer(
+                    text,
+                    truncation=True,
+                    max_length=512,
+                    padding='max_length',
+                    return_tensors='pt'
+                )
+            
+            tokenized_data = [tokenize_fn(text) for text in texts[:1000]]  # Limit to 1000
+            
+        else:
+            # Try loading as HF dataset
+            from datasets import load_dataset
+            dataset = load_dataset('text', data_files=dataset_path)
+            
+            def tokenize_function(examples):
+                return tokenizer(
+                    examples['text'],
+                    truncation=True,
+                    max_length=512,
+                    padding='max_length',
+                )
+            
+            dataset = dataset.map(tokenize_function, batched=True)
+            tokenized_data = dataset['train']
+        
+        print(f"✅ Loaded {len(tokenized_data)} samples")
+        
+        # 3. Quick fine-tuning
+        print(f"\n🚀 Starting fine-tuning...")
+        print(f"   Epochs: {num_epochs}")
+        print(f"   Batch Size: {batch_size}")
+        print(f"   Max Steps: {max_steps}")
+        
+        model.train()
+        optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate)
+        
+        step = 0
+        total_loss = 0.0
+        
+        for epoch in range(num_epochs):
+            for i in range(0, len(tokenized_data), batch_size):
+                if step >= max_steps:
+                    break
+                
+                batch = tokenized_data[i:i+batch_size]
+                
+                # Simple batch processing
+                if isinstance(batch, list):
+                    input_ids = torch.stack([item['input_ids'].squeeze() for item in batch]).to(DEVICE)
+                    attention_mask = torch.stack([item['attention_mask'].squeeze() for item in batch]).to(DEVICE)
+                else:
+                    input_ids = torch.tensor(batch['input_ids']).to(DEVICE)
+                    attention_mask = torch.tensor(batch['attention_mask']).to(DEVICE)
+                
+                outputs = model(input_ids=input_ids, attention_mask=attention_mask, labels=input_ids)
+                loss = outputs.loss
+                
+                loss.backward()
+                optimizer.step()
+                optimizer.zero_grad()
+                
+                total_loss += loss.item()
+                step += 1
+                
+                if step % 10 == 0:
+                    avg_loss = total_loss / step
+                    print(f"   Step {step}/{max_steps} - Loss: {avg_loss:.4f}")
+        
+        final_loss = total_loss / step if step > 0 else 0.0
+        print(f"✅ Training complete - Final Loss: {final_loss:.4f}")
+        
+        # 4. Evaluate & Save
+        print(f"\n📊 Evaluating...")
+        model.eval()
+        quality_score = evaluate_model_quality(model, tokenizer)
+        print(f"✅ Quality Score: {quality_score:.2f}/1.00")
+        
+        print(f"\n💾 Saving model...")
+        model.save_pretrained(output_path)
+        tokenizer.save_pretrained(output_path)
+        
+        metadata = {
+            'phoenix_version': '1.0.0',
+            'original_model': model_url,
+            'use_hierarchical': use_hierarchical,
+            'conversion_rate': conversion_rate,
+            'quality_score': quality_score,
+            'burning_type': 'fine_tuning',
+            'training_steps': step,
+            'final_loss': final_loss,
+            'dataset': dataset_path,
+            'timestamp': datetime.now().isoformat(),
+        }
+        
+        with open(output_path / 'phoenix_metadata.json', 'w') as f:
+            json.dump(metadata, f, indent=2)
+        
+        print(f"✅ Saved to {output_path}")
+        
+        result = {
+            'status': 'success',
+            'model_path': str(output_path),
+            'conversion_rate': conversion_rate,
+            'quality_score': quality_score,
+            'training_steps': step,
+            'final_loss': final_loss,
+        }
+        
+        print(f"\n{'='*80}")
+        print(f"✅ Fine-tuning Burning Complete!")
+        print(f"{'='*80}\n")
+        
+        return result
+        
+    except Exception as e:
+        import traceback
+        error_msg = traceback.format_exc()
+        print(f"\n❌ Fine-tuning burning failed:\n{error_msg}")
+        return {
+            'status': 'failed',
+            'error': str(e),
+            'traceback': error_msg
+        }
 
 
 # =====================================================
-# Gradio Functions
+# Gradio UI Functions
 # =====================================================
 
 def convert_model_to_phoenix(model_url, use_hierarchical=True, gpu_type="L40S"):
-    """Convert model to PHOENIX"""
-    global CONVERTED_MODELS
-    
+    """Convert model to PHOENIX (기존 함수 유지)"""
     try:
-        cache_key = f"{model_url}_{use_hierarchical}"
-        if cache_key in CONVERTED_MODELS:
-            return CONVERTED_MODELS[cache_key], "✅ Using cached model"
-        
         start_time = time.time()
         
         print(f"📥 Loading model: {model_url}")
@@ -771,16 +931,6 @@ def convert_model_to_phoenix(model_url, use_hierarchical=True, gpu_type="L40S"):
         model, converted, total = replace_attention_with_retention(model, use_hierarchical)
         
         elapsed_time = time.time() - start_time
-        
-        model_info = {
-            'model': model,
-            'converted_layers': converted,
-            'total_layers': total,
-            'config': config,
-            'conversion_time': elapsed_time
-        }
-        CONVERTED_MODELS[cache_key] = model_info
-        
         conversion_pct = (converted / total * 100) if total > 0 else 0
         
         result = f"""
@@ -788,435 +938,253 @@ def convert_model_to_phoenix(model_url, use_hierarchical=True, gpu_type="L40S"):
 
 **Model**: {model_url}
 **Converted**: {converted}/{total} layers ({conversion_pct:.1f}%)
-**Time**: {elapsed_time:.1f}s ({elapsed_time/60:.2f}min)
+**Time**: {elapsed_time:.1f}s
 **GPU**: {gpu_type}
 
 🎯 GQA-aware O(n) complexity!
 """
         
-        return model_info, result
+        return result
         
     except Exception as e:
-        return None, f"❌ Conversion failed: {str(e)}"
+        return f"❌ Conversion failed: {str(e)}"
 
 
 def generate_text_phoenix(
     model_url, use_hierarchical, convert_attention, 
     prompt, max_new_tokens, temperature
 ):
-    """PHOENIX로 텍스트 생성"""
+    """PHOENIX 텍스트 생성 (기존 함수 - 간소화)"""
     try:
         if not convert_attention or not model_url.strip():
             return "⚠️ Enable 'Attention Replace' and provide model URL", ""
         
-        # 1. ✅ CausalLM 모델 로드 (lm_head 포함)
-        print(f"📥 Loading CausalLM model: {model_url}")
-        config = AutoConfig.from_pretrained(model_url, trust_remote_code=True)
-        
-        # Load full causal LM model
+        print(f"📥 Loading model: {model_url}")
         model = AutoModelForCausalLM.from_pretrained(
             model_url,
             trust_remote_code=True,
             torch_dtype=torch.float16
         ).to(DEVICE)
         
-        # 2. Attention → Retention 변환
-        print(f"🔄 Converting attention to retention...")
+        print(f"🔄 Converting...")
         model.model, converted, total = replace_attention_with_retention(
-            model.model,  # Convert the base model, keep lm_head
+            model.model,
             use_hierarchical=use_hierarchical
         )
         
-        print(f"✅ Converted {converted}/{total} layers")
-        
-        # ✅ Reset all retention states before generation
-        print(f"🔄 Resetting retention states...")
-        for layer in model.model.layers:
-            if hasattr(layer, 'self_attn') and hasattr(layer.self_attn, 'reset_state'):
-                layer.self_attn.reset_state()
-            elif hasattr(layer, 'self_attn') and hasattr(layer.self_attn, 'base_retention'):
-                if hasattr(layer.self_attn.base_retention, 'reset_state'):
-                    layer.self_attn.base_retention.reset_state()
+        tokenizer = AutoTokenizer.from_pretrained(model_url, trust_remote_code=True)
+        if tokenizer.pad_token is None:
+            tokenizer.pad_token = tokenizer.eos_token
         
-        # 3. Tokenizer 로드
-        try:
-            tokenizer = AutoTokenizer.from_pretrained(model_url, trust_remote_code=True)
-            if tokenizer.pad_token is None:
-                tokenizer.pad_token = tokenizer.eos_token
-        except Exception as e:
-            return f"❌ Tokenizer load failed: {e}", ""
-        
-        # 4. 입력 토크나이즈
         inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
-        input_ids = inputs["input_ids"]
-        
-        print(f"\n📝 Generating text...")
-        print(f"   Prompt: {prompt}")
-        print(f"   Input tokens: {input_ids.shape[1]}")
-        print(f"   Max new tokens: {max_new_tokens}")
         
-        # 5. 생성 (✅ KV Cache 시도, 실패시 Full Sequence)
+        print(f"🚀 Generating...")
         start_time = time.time()
-        generated_ids = []
-        
-        model.eval()  # ✅ Set to eval mode
-        
-        # ✅ KV Cache 초기화
-        past_key_values = None
-        current_input_ids = input_ids
-        use_kv_cache = True  # KV Cache 사용 시도
-        
-        print(f"   🚀 Attempting KV Cache generation...")
-        
-        with torch.no_grad():
-            for step in range(max_new_tokens):
-                try:
-                    # ✅ KV Cache 모드 시도
-                    if use_kv_cache:
-                        if past_key_values is None:
-                            # 첫 forward: 전체 프롬프트 처리
-                            outputs = model(
-                                input_ids=current_input_ids,
-                                use_cache=True
-                            )
-                            
-                            # ✅ past_key_values 확인
-                            if hasattr(outputs, 'past_key_values') and outputs.past_key_values is not None:
-                                # KV Cache가 있는 경우
-                                if isinstance(outputs.past_key_values, (tuple, list)) and len(outputs.past_key_values) > 0:
-                                    # 각 레이어의 state 확인
-                                    valid_cache = True
-                                    for layer_cache in outputs.past_key_values:
-                                        if layer_cache is None or (isinstance(layer_cache, (tuple, list)) and layer_cache[0] is None):
-                                            valid_cache = False
-                                            break
-                                    
-                                    if valid_cache:
-                                        past_key_values = outputs.past_key_values
-                                        print(f"   ✅ KV Cache enabled (prompt tokens: {current_input_ids.shape[1]})")
-                                    else:
-                                        use_kv_cache = False
-                                        print(f"   ⚠️ Invalid cache structure, switching to full sequence mode")
-                                else:
-                                    use_kv_cache = False
-                                    print(f"   ⚠️ Empty cache, switching to full sequence mode")
-                            else:
-                                use_kv_cache = False
-                                print(f"   ℹ️ No past_key_values support, using full sequence mode")
-                                
-                        else:
-                            # 이후 forward: 새 토큰만 처리 (⚡ 빠름!)
-                            outputs = model(
-                                input_ids=current_input_ids[:, -1:],  # ✅ 마지막 토큰만
-                                past_key_values=past_key_values,       # ✅ 이전 state 재사용
-                                use_cache=True
-                            )
-                            
-                            # ✅ State 업데이트
-                            if hasattr(outputs, 'past_key_values') and outputs.past_key_values is not None:
-                                past_key_values = outputs.past_key_values
-                    
-                    # ✅ Full Sequence 모드 (KV Cache 없이)
-                    if not use_kv_cache:
-                        outputs = model(
-                            input_ids=current_input_ids,  # 전체 시퀀스 처리
-                            use_cache=False
-                        )
-                    
-                    # ✅ Get logits - handle different output formats
-                    if hasattr(outputs, 'logits'):
-                        logits = outputs.logits[:, -1, :]  # [B, vocab_size]
-                    elif isinstance(outputs, tuple):
-                        # Some models return (logits, ) or (logits, hidden_states, ...)
-                        logits = outputs[0][:, -1, :]
-                    else:
-                        raise ValueError(f"Unexpected output type: {type(outputs)}")
-                    
-                    # ✅ 디버깅: logits 확인
-                    if step == 0:
-                        print(f"   📊 Output type: {type(outputs)}")
-                        print(f"   📊 Logits shape: {logits.shape}")
-                        print(f"   📊 Logits range: [{logits.min().item():.2f}, {logits.max().item():.2f}]")
-                        print(f"   📊 Logits mean: {logits.mean().item():.2f}, std: {logits.std().item():.2f}")
-                    
-                    # ✅ Clamp logits to prevent numerical issues
-                    logits = torch.clamp(logits, min=-100, max=100)
-                    
-                    # Temperature sampling
-                    if temperature > 0.01:
-                        logits = logits / temperature
-                        probs = F.softmax(logits, dim=-1)
-                        
-                        # ✅ Check for NaN/Inf
-                        if torch.isnan(probs).any() or torch.isinf(probs).any():
-                            print(f"   ⚠️ NaN/Inf detected at step {step}, using greedy")
-                            next_token = logits.argmax(dim=-1, keepdim=True)
-                        else:
-                            # ✅ Add small epsilon to avoid zero probabilities
-                            probs = probs + 1e-10
-                            probs = probs / probs.sum(dim=-1, keepdim=True)
-                            
-                            # ✅ 디버깅: Top-5 tokens
-                            if step == 0:
-                                top5_probs, top5_indices = torch.topk(probs, 5, dim=-1)
-                                print(f"   🎯 Top 5 tokens:")
-                                for i, (prob, idx) in enumerate(zip(top5_probs[0], top5_indices[0])):
-                                    token_str = tokenizer.decode([idx.item()])
-                                    print(f"      {i+1}. '{token_str}' (prob: {prob.item():.4f})")
-                            
-                            next_token = torch.multinomial(probs, num_samples=1)
-                    else:
-                        next_token = logits.argmax(dim=-1, keepdim=True)
-                    
-                    next_token_id = next_token.item()
-                    
-                    # ✅ 디버깅: 생성된 토큰 정보
-                    if step < 3 or (step + 1) % 10 == 0:
-                        token_str = tokenizer.decode([next_token_id])
-                        print(f"   🔤 Step {step}: Generated token #{next_token_id} = '{token_str}'")
-                    
-                    # ✅ Validate token range
-                    if next_token_id < 0 or next_token_id >= model.config.vocab_size:
-                        print(f"   ⚠️ Invalid token {next_token_id}, stopping")
-                        break
-                    
-                    # Append
-                    generated_ids.append(next_token_id)
-                    current_input_ids = torch.cat([current_input_ids, next_token], dim=1)
-                    
-                    # ✅ Limit max sequence length
-                    if current_input_ids.shape[1] > 2048:
-                        print(f"   ⚠️ Max sequence length reached, stopping")
-                        break
-                    
-                    # Stop at EOS
-                    if next_token_id == tokenizer.eos_token_id:
-                        print(f"   ✅ Stopped at EOS token")
-                        break
-                    
-                    # Progress
-                    if (step + 1) % 10 == 0:
-                        speed = (step + 1) / (time.time() - start_time)
-                        print(f"   Generated {step + 1}/{max_new_tokens} tokens... ({speed:.1f} tok/s)")
-                        
-                except RuntimeError as e:
-                    print(f"   ❌ Runtime error at step {step}: {e}")
-                    if "CUDA" in str(e):
-                        print(f"   Stopping generation due to CUDA error")
-                    import traceback
-                    traceback.print_exc()
-                    break
-                except Exception as e:
-                    print(f"   ❌ Error at step {step}: {e}")
-                    print(f"   Error type: {type(e).__name__}")
-                    import traceback
-                    traceback.print_exc()
-                    break
+        
+        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
         
-        # 6. 디코드
-        if len(generated_ids) == 0:
-            generated_text = "[No tokens generated]"
-            full_text = prompt
-        else:
-            try:
-                generated_text = tokenizer.decode(generated_ids, skip_special_tokens=True)
-                full_text = prompt + " " + generated_text
-            except Exception as e:
-                generated_text = f"[Decode error: {e}]"
-                full_text = prompt
+        generated = tokenizer.decode(outputs[0], skip_special_tokens=True)
         
-        # 7. 결과
         output_md = f"""
 ## 📝 Generated Text
 
-**Prompt**: 
 ```
-{prompt}
-```
-
-**Generated** ({len(generated_ids)} tokens):
-```
-{generated_text}
-```
-
-**Full Text**:
-```
-{full_text}
+{generated}
 ```
 """
         
-        initial_tokens = input_ids.shape[1]
-        total_tokens = current_input_ids.shape[1]
         stats_md = f"""
-## 📊 Generation Statistics
+## 📊 Statistics
 
-### Performance
-- **Input tokens**: {initial_tokens}
-- **Generated tokens**: {len(generated_ids)}
-- **Total tokens**: {total_tokens}
 - **Time**: {elapsed:.2f}s
-- **Speed**: {len(generated_ids) / max(elapsed, 0.01):.1f} tokens/s ⚡
-
-### Model
-- **Architecture**: PHOENIX Retention (O(n))
-- **KV Cache**: {'✅ Enabled' if past_key_values is not None else '⚠️ Disabled'} 
-- **Temperature**: {temperature}
-- **Vocab size**: {model.config.vocab_size}
-
-### Efficiency
-- **First token latency**: ~{elapsed / max(len(generated_ids), 1):.3f}s per token
-- **Cache benefit**: ~10-20x speedup vs no cache
-- **Memory**: O(d²) constant per layer
+- **Converted**: {converted}/{total} layers
+- **Tokens/s**: {max_new_tokens/elapsed:.1f}
 """
         
         return output_md, stats_md
         
     except Exception as e:
         import traceback
-        return f"❌ Generation failed:\n```\n{traceback.format_exc()}\n```", ""
+        return f"❌ Error:\n```\n{traceback.format_exc()}\n```", ""
 
 
-def run_phoenix_experiment(model_url, use_hierarchical, convert_attention, sequence_length, gpu_type):
-    """Run PHOENIX experiment"""
+def burn_phoenix_model_ui(
+    model_url,
+    use_hierarchical,
+    dataset_path,
+    output_name,
+    use_finetuning,
+    num_epochs,
+    batch_size,
+    learning_rate,
+    max_steps,
+):
+    """
+    Gradio UI용 모델 버닝 함수
+    """
     try:
-        if not convert_attention or not model_url.strip():
-            return "⚠️ Enable 'Attention Replace' and provide model URL", None, None
-        
-        model_info, msg = convert_model_to_phoenix(model_url, use_hierarchical, gpu_type)
-        
-        if model_info is None:
-            return msg, None, None
-        
-        model = model_info['model']
-        converted_layers = model_info['converted_layers']
-        total_layers = model_info['total_layers']
-        
-        config = {
-            'model_type': f"phoenix_{model_url.split('/')[-1]}",
-            'model_url': model_url,
-            'sequence_length': sequence_length,
-            'use_hierarchical': use_hierarchical,
-            'attention_replaced': convert_attention,
-            'layers_converted': converted_layers,
-            'total_layers': total_layers,
-            'gpu_type': gpu_type,
-            'timestamp': datetime.now().isoformat()
-        }
-        
-        # Generate input
-        hidden_size = model.config.hidden_size
-        x = torch.randn(1, sequence_length, hidden_size).to(DEVICE).half()
-        
-        # Forward pass
-        torch.cuda.synchronize()
-        start = time.time()
-        
-        with torch.no_grad():
-            output = model(inputs_embeds=x)
-        
-        torch.cuda.synchronize()
-        elapsed = time.time() - start
-        
-        # Metrics
-        metrics = calculate_metrics(output.last_hidden_state, {}, config)
-        metrics['elapsed_time'] = elapsed
-        metrics['throughput'] = sequence_length / elapsed
-        
-        # Save
-        exp_id = db.save_experiment(config, metrics)
-        conversion_rate = (converted_layers / total_layers * 100) if total_layers > 0 else 0
-        
-        # Result text
-        result = (
-            f"## 🎯 PHOENIX Experiment Results (ID: {exp_id})\n\n"
-            f"### ⚙️ Configuration\n"
-            f"- **Model**: {model_url}\n"
-            f"- **Sequence Length**: {sequence_length} tokens\n"
-            f"- **Hidden Size**: {hidden_size}\n"
-            f"- **Hierarchical**: {'✅' if use_hierarchical else '❌'}\n"
-            f"- **Converted Layers**: {converted_layers}/{total_layers} ({conversion_rate:.1f}%)\n\n"
-            f"### 📊 Performance\n"
-            f"- **Time**: {elapsed:.3f}s\n"
-            f"- **Throughput**: {metrics['throughput']:.1f} tokens/s\n"
-            f"- **Memory**: {metrics['memory_mb']:.1f} MB\n\n"
-            f"### 🔥 Complexity Analysis\n"
-            f"- **Theoretical**: O(n) ✅\n"
-            f"- **Linear Complexity**: {'✅ YES!' if converted_layers == total_layers else '⚠️ Partial'}\n\n"
-            f"✅ **Real PHOENIX with GQA Support!**\n"
-        )
-        
-        fig1 = plot_retention_states({})
-        fig2 = plot_memory_usage(metrics)
-        
-        return result, fig1, fig2
+        if not model_url.strip():
+            return "⚠️ Model URL 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}"
+        
+        # Dataset check
+        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
+        
+        # Choose burning method
+        if use_finetuning and has_dataset:
+            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:
+            result = burn_model_zero_shot(
+                model_url=model_url,
+                output_dir=output_dir,
+                use_hierarchical=use_hierarchical,
+            )
         
-    except Exception as e:
-        import traceback
-        return f"❌ Experiment failed:\n```\n{traceback.format_exc()}\n```", None, None
+        if result['status'] == 'success':
+            # Save to database
+            burning_info = {
+                'model_url': model_url,
+                'output_path': result['model_path'],
+                '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),
+            }
+            
+            db.save_burning(burning_info)
+            
+            # Format output
+            output_md = f"""
+# 🔥 Model Burning Complete!
 
+## 📦 Model Information
+- **Original**: {model_url}
+- **Output**: `{result['model_path']}`
+- **Type**: {'Fine-tuning' if has_dataset else 'Zero-shot'}
 
-def estimate_conversion_ui(model_url, gpu_type):
-    """Estimate conversion time"""
-    estimate = estimate_conversion_time(1400, gpu_type)
-    return f"""
-## ⏱️ Conversion Time Estimate
+## 📊 Metrics
+- **Conversion Rate**: {result['conversion_rate']*100:.1f}%
+- **Quality Score**: {result.get('quality_score', 0.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"
+            
+            output_md += f"""
+## 🎯 Usage
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
 
-### GPU: {gpu_type}
-- **Time**: {estimate['estimated_minutes']:.1f}min
-- **Memory**: {estimate['memory_required_gb']:.1f} GB / {estimate['max_memory_gb']} GB
+model = AutoModelForCausalLM.from_pretrained("{result['model_path']}")
+tokenizer = AutoTokenizer.from_pretrained("{result['model_path']}")
+
+inputs = tokenizer("Your prompt", return_tensors="pt")
+outputs = model.generate(**inputs, max_new_tokens=50)
+print(tokenizer.decode(outputs[0]))
+```
 
-### Notes
-- Conversion is cached after first run
-- GQA models supported
+✅ **PHOENIX Model Ready!**
 """
+            
+            # Create simple plot
+            fig = go.Figure()
+            fig.add_trace(go.Bar(
+                x=['Conversion', 'Quality'],
+                y=[result['conversion_rate'], result.get('quality_score', 0.0)],
+                text=[f"{result['conversion_rate']*100:.1f}%", f"{result.get('quality_score', 0.0):.2f}"],
+                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
+            
+    except Exception as e:
+        import traceback
+        return f"❌ Error:\n```\n{traceback.format_exc()}\n```", None
 
 
-def view_experiment_history(limit=20):
-    """View experiment history"""
+def view_burning_history():
+    """View burning history"""
     try:
-        experiments = db.get_recent_experiments(limit)
+        history = db.get_burning_history(limit=20)
         
-        if not experiments:
-            return "📭 No experiments yet", None
+        if not history:
+            return "📭 No burning history yet", None
         
-        df = pd.DataFrame(experiments)
+        df = pd.DataFrame(history)
         
         fig = px.scatter(
-            df, x='timestamp', y='throughput',
-            size='sequence_length', color='attention_replaced',
-            title='Experiment Performance'
+            df,
+            x='timestamp',
+            y='evaluation_score',
+            size='conversion_rate',
+            color='dataset_used',
+            hover_data=['model_url', 'output_path'],
+            title='Burning History'
         )
         
-        cols = ['id', 'model_type', 'sequence_length', 'layers_converted', 
-                'elapsed_time', 'throughput', 'timestamp']
+        cols = ['id', 'model_url', 'output_path', 'conversion_rate', 
+                'evaluation_score', 'training_steps', 'timestamp']
         available = [c for c in cols if c in df.columns]
         
-        return f"## 📊 Experiment History\n\n{df[available].to_markdown(index=False)}", fig
+        return f"## 📊 Burning History\n\n{df[available].to_markdown(index=False)}", fig
         
     except Exception as e:
         return f"❌ Error: {e}", None
 
 
-def get_database_statistics():
-    """Get database stats"""
-    try:
-        stats = db.get_statistics()
-        
-        text = f"""
-## 📊 Database Statistics
-
-**Total Experiments**: {stats['total_experiments']}
-
-### By Model
-"""
-        for model, count in stats['by_model'].items():
-            text += f"- **{model}**: {count}\n"
-        
-        return text
-    except Exception as e:
-        return f"❌ Error: {e}"
+# 전역 초기화
+db = ExperimentDatabase(DB_PATH)
+CONVERTED_MODELS = {}
 
 
 # =====================================================
@@ -1224,26 +1192,30 @@ def get_database_statistics():
 # =====================================================
 
 with gr.Blocks(
-    title="🔮 PHOENIX - GQA Support",
+    title="🔮 PHOENIX - Model Burning Platform",
     theme=gr.themes.Soft(),
 ) as demo:
     
     gr.Markdown("""
     # 🔮 PHOENIX Retention Platform
     
-    **Real O(n) Complexity with GQA Support - Final Version**
+    **Zero-shot Model Burning + Optional Fine-tuning**
     
-    ✅ Supports Grouped Query Attention (GQA)
-    ✅ Adaptive K/V projection dimensions
-    ✅ Full Attention → Retention replacement
-    ✅ KV Cache with State Reuse
-    ✅ Robust Error Handling
+    ✅ Zero-shot Conversion (데이터셋 불필요!)
+    ✅ Optional Fine-tuning (데이터셋 기반)
+    ✅ GQA Support
+    ✅ O(n) Complexity
     
     ---
     """)
     
     with gr.Tabs():
-        with gr.Tab("🔄 Model Conversion"):
+        with gr.Tab("🔄 Quick Convert"):
+            gr.Markdown("""
+            ### 빠른 변환 테스트
+            모델을 로드하고 Attention → Retention 변환만 수행합니다. (저장 안 함)
+            """)
+            
             with gr.Row():
                 with gr.Column(scale=1):
                     convert_url = gr.Textbox(
@@ -1253,24 +1225,87 @@ with gr.Blocks(
                     )
                     convert_hierarchical = gr.Checkbox(value=True, label="Hierarchical Retention")
                     convert_gpu = gr.Radio(choices=["L40S", "H100"], value="L40S", label="GPU")
-                    
-                    estimate_btn = gr.Button("⏱️ Estimate Time", variant="secondary")
                     convert_btn = gr.Button("🔄 Convert", variant="primary")
                 
                 with gr.Column(scale=2):
                     convert_output = gr.Markdown()
             
-            estimate_btn.click(estimate_conversion_ui, [convert_url, convert_gpu], [convert_output])
-            convert_btn.click(convert_model_to_phoenix, 
-                            [convert_url, convert_hierarchical, convert_gpu],
-                            [gr.State(), convert_output])
+            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
+            
+            **모델을 변환하고 저장합니다!**
+            
+            - **Zero-shot**: 데이터셋 없이 변환만 수행 (빠름!)
+            - **Fine-tuning**: 데이터셋으로 추가 학습 (성능 향상)
+            """)
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    burn_model_url = gr.Textbox(
+                        label="🔗 Model URL",
+                        value=DEFAULT_MODEL,
+                        placeholder="ibm-granite/granite-4.0-h-350m"
+                    )
+                    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)"
+                    )
+                    
+                    gr.Markdown("---")
+                    gr.Markdown("### 📊 Dataset (Optional)")
+                    
+                    burn_dataset = gr.Textbox(
+                        label="📁 Dataset Path (Optional)",
+                        placeholder="/path/to/dataset.txt (leave empty for zero-shot)",
+                        value=""
+                    )
+                    
+                    burn_use_finetuning = gr.Checkbox(
+                        value=False,
+                        label="🚀 Enable Fine-tuning (requires dataset)"
+                    )
+                    
+                    with gr.Accordion("⚙️ Fine-tuning Config", open=False):
+                        burn_epochs = gr.Slider(1, 5, 1, step=1, label="Epochs")
+                        burn_batch = gr.Slider(1, 16, 4, step=1, label="Batch Size")
+                        burn_lr = gr.Number(value=5e-5, label="Learning Rate")
+                        burn_max_steps = gr.Slider(10, 500, 100, step=10, label="Max Steps")
+                    
+                    burn_btn = gr.Button("🔥 Burn Model", variant="primary", size="lg")
+                
+                with gr.Column(scale=2):
+                    burn_output = gr.Markdown()
+                    burn_plot = gr.Plot()
+            
+            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_output, burn_plot]
+            )
         
         with gr.Tab("💬 Text Generation"):
             gr.Markdown("""
             ### PHOENIX 텍스트 생성
-            
-            변환된 모델로 실제 텍스트를 생성합니다.
-            **KV Cache를 활용한 O(n) 복잡도 생성!**
+            변환된 모델로 텍스트를 생성합니다.
             """)
             
             with gr.Row():
@@ -1280,78 +1315,59 @@ with gr.Blocks(
                     gen_convert = gr.Checkbox(value=True, label="Enable Conversion")
                     
                     gen_prompt = gr.Textbox(
-                        label="📝 Input Prompt",
-                        placeholder="Enter your prompt here...",
+                        label="📝 Prompt",
                         lines=3,
                         value="The future of AI is"
                     )
                     
-                    gen_max_tokens = gr.Slider(16, 256, 64, step=16, label="Max New Tokens")
+                    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 Text", variant="primary")
+                    gen_btn = gr.Button("🚀 Generate", variant="primary")
                 
                 with gr.Column(scale=2):
-                    gen_output = gr.Markdown(label="Generated Text")
-                    gen_stats = gr.Markdown(label="Statistics")
+                    gen_output = gr.Markdown()
+                    gen_stats = gr.Markdown()
             
             gen_btn.click(
-                fn=generate_text_phoenix,
-                inputs=[gen_model_url, gen_hierarchical, gen_convert, gen_prompt, 
-                       gen_max_tokens, gen_temperature],
-                outputs=[gen_output, gen_stats]
+                generate_text_phoenix,
+                [gen_model_url, gen_hierarchical, gen_convert, gen_prompt, 
+                 gen_max_tokens, gen_temperature],
+                [gen_output, gen_stats]
             )
         
-        with gr.Tab("🧪 Experiment"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    exp_url = gr.Textbox(label="🔗 Model URL", value=DEFAULT_MODEL)
-                    exp_hierarchical = gr.Checkbox(value=True, label="Hierarchical")
-                    exp_convert = gr.Checkbox(value=True, label="Enable Conversion")
-                    exp_seq = gr.Slider(64, 4096, 1024, step=64, label="Sequence Length")
-                    exp_gpu = gr.Radio(choices=["L40S", "H100"], value="L40S", label="GPU")
-                    
-                    run_btn = gr.Button("🚀 Run Experiment", variant="primary")
-                
-                with gr.Column(scale=2):
-                    exp_output = gr.Markdown()
-                    with gr.Row():
-                        exp_fig1 = gr.Plot()
-                        exp_fig2 = gr.Plot()
+        with gr.Tab("📊 Burning History"):
+            gr.Markdown("""
+            ### 📊 Model Burning History
+            저장된 모델 버닝 기록을 확인합니다.
+            """)
             
-            run_btn.click(run_phoenix_experiment,
-                         [exp_url, exp_hierarchical, exp_convert, exp_seq, exp_gpu],
-                         [exp_output, exp_fig1, exp_fig2])
-        
-        with gr.Tab("📊 History"):
             with gr.Row():
                 with gr.Column(scale=1):
-                    hist_limit = gr.Slider(10, 100, 20, step=10, label="Limit")
-                    hist_btn = gr.Button("📊 View History", variant="primary")
-                    stats_btn = gr.Button("📈 Statistics", variant="secondary")
+                    hist_btn = gr.Button("📊 Load History", variant="primary")
                 
                 with gr.Column(scale=2):
                     hist_output = gr.Markdown()
                     hist_plot = gr.Plot()
             
-            hist_btn.click(view_experiment_history, [hist_limit], [hist_output, hist_plot])
-            stats_btn.click(get_database_statistics, outputs=[hist_output])
+            hist_btn.click(view_burning_history, outputs=[hist_output, hist_plot])
     
     gr.Markdown("""
     ---
     
-    ## 🔥 PHOENIX + GQA (Final Version)
+    ## 🔥 PHOENIX Model Burning
     
-    **Grouped Query Attention** support means PHOENIX now works with modern efficient architectures!
+    ### Zero-shot (데이터셋 불필요!)
+    1. 모델 URL 입력
+    2. "Burn Model" 클릭
+    3. 완료! → `/data/phoenix_models/` 에 저장
     
-    - ✅ Llama 2/3 (GQA)
-    - ✅ Mistral (GQA)
-    - ✅ Granite 4.0 H (GQA)
-    - ✅ Traditional MHA models
-    - ✅ KV Cache with State Reuse
-    - ✅ Robust Error Handling
+    ### Fine-tuning (선택사항)
+    1. Dataset Path 입력
+    2. "Enable Fine-tuning" 체크
+    3. "Burn Model" 클릭
     
-    **VIDraft AI Research Lab** | PHOENIX GQA Implementation (Final)
+    **VIDraft AI Research Lab** | PHOENIX v1.0
     """)
 
 if __name__ == "__main__":