Create app.py

app.py

@@ -0,0 +1,984 @@
+"""
+🔮 PHOENIX Retention Research Platform
+Complete Integration - Single File
+
+L40S GPU + Persistent Storage (SQLite + ChromaDB)
+VIDraft AI Research Lab
+"""
+
+import gradio as gr
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import sqlite3
+import json
+import time
+import numpy as np
+from datetime import datetime
+from pathlib import Path
+import plotly.graph_objects as go
+import plotly.express as px
+import pandas as pd
+from typing import Dict, List, Any, Tuple, Optional
+import chromadb
+from chromadb.config import Settings
+from einops import rearrange, repeat
+
+# =====================================================
+# 전역 설정
+# =====================================================
+
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+STORAGE_PATH = "/data"  # HF Spaces 영구 스토리지
+DB_PATH = f"{STORAGE_PATH}/phoenix_experiments.db"
+VECTOR_DB_PATH = f"{STORAGE_PATH}/vector_store"
+
+# 디렉토리 생성
+Path(STORAGE_PATH).mkdir(parents=True, exist_ok=True)
+Path(VECTOR_DB_PATH).mkdir(parents=True, exist_ok=True)
+
+print(f"🚀 PHOENIX Platform initialized on {DEVICE}")
+print(f"💾 Storage: {STORAGE_PATH}")
+
+# =====================================================
+# 데이터베이스 관리 클래스
+# =====================================================
+
+class ExperimentDatabase:
+    """SQLite 데이터베이스 관리"""
+    
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+        self.init_database()
+    
+    def init_database(self):
+        """데이터베이스 초기화"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            
+            # 실험 테이블
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS experiments (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    model_type TEXT NOT NULL,
+                    sequence_length INTEGER,
+                    power_mode TEXT,
+                    compression_level REAL,
+                    use_hierarchical BOOLEAN,
+                    elapsed_time REAL,
+                    memory_mb REAL,
+                    throughput REAL,
+                    avg_retention REAL,
+                    compression_ratio REAL,
+                    config_json TEXT,
+                    metrics_json TEXT,
+                    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
+            
+            # 인덱스 생성
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_model_type 
+                ON experiments(model_type)
+            """)
+            
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_timestamp 
+                ON experiments(timestamp DESC)
+            """)
+            
+            conn.commit()
+            print("✅ Database initialized")
+    
+    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, power_mode,
+                    compression_level, use_hierarchical, elapsed_time,
+                    memory_mb, throughput, avg_retention, compression_ratio,
+                    config_json, metrics_json
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                config.get('model_type'),
+                config.get('sequence_length'),
+                config.get('power_mode'),
+                config.get('compression_level'),
+                config.get('use_hierarchical'),
+                metrics.get('elapsed_time'),
+                metrics.get('memory_mb'),
+                metrics.get('throughput'),
+                metrics.get('avg_retention'),
+                metrics.get('compression_ratio'),
+                json.dumps(config),
+                json.dumps(metrics)
+            ))
+            
+            conn.commit()
+            return cursor.lastrowid
+    
+    def get_experiment(self, exp_id: int) -> Optional[Dict]:
+        """실험 조회"""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.row_factory = sqlite3.Row
+            cursor = conn.cursor()
+            
+            cursor.execute("SELECT * FROM experiments WHERE id = ?", (exp_id,))
+            row = cursor.fetchone()
+            return dict(row) if row else None
+    
+    def get_recent_experiments(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 * FROM experiments 
+                ORDER BY timestamp DESC 
+                LIMIT ?
+            """, (limit,))
+            
+            rows = cursor.fetchall()
+            return [dict(row) for row in rows]
+    
+    def get_statistics(self) -> Dict:
+        """통계 조회"""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            
+            cursor.execute("SELECT COUNT(*) FROM experiments")
+            total = cursor.fetchone()[0]
+            
+            cursor.execute("""
+                SELECT model_type, COUNT(*) as count 
+                FROM experiments 
+                GROUP BY model_type
+            """)
+            by_model = dict(cursor.fetchall())
+            
+            return {
+                'total_experiments': total,
+                'by_model': by_model
+            }
+
+class RetentionVectorStore:
+    """ChromaDB 벡터 저장소"""
+    
+    def __init__(self, persist_directory: str):
+        self.client = chromadb.Client(Settings(
+            persist_directory=persist_directory,
+            anonymized_telemetry=False
+        ))
+        
+        self.collection = self.client.get_or_create_collection(
+            name="retention_states",
+            metadata={"description": "PHOENIX Retention states"}
+        )
+        print("✅ Vector store initialized")
+    
+    def add_retention_state(self, experiment_id: int, states: Dict, metadata: Dict):
+        """Retention state 저장"""
+        # State를 벡터로 변환
+        state_vector = self._states_to_vector(states)
+        
+        self.collection.add(
+            embeddings=[state_vector.tolist()],
+            metadatas=[{**metadata, 'experiment_id': experiment_id}],
+            ids=[f"exp_{experiment_id}"]
+        )
+    
+    def search(self, query: str, top_k: int = 10) -> List[Dict]:
+        """실험 검색"""
+        query_vector = self._text_to_vector(query)
+        
+        results = self.collection.query(
+            query_embeddings=[query_vector.tolist()],
+            n_results=top_k
+        )
+        
+        if not results['ids'][0]:
+            return []
+        
+        formatted_results = []
+        for i in range(len(results['ids'][0])):
+            formatted_results.append({
+                'experiment_id': results['metadatas'][0][i].get('experiment_id'),
+                'score': 1.0 - results['distances'][0][i],
+                'metadata': results['metadatas'][0][i]
+            })
+        
+        return formatted_results
+    
+    def _states_to_vector(self, states: Dict) -> np.ndarray:
+        """States를 고정 크기 벡터로 변환"""
+        vectors = []
+        for key, value in states.items():
+            if isinstance(value, (int, float)):
+                vectors.append(float(value))
+            elif isinstance(value, torch.Tensor):
+                vectors.append(value.mean().item())
+                vectors.append(value.std().item())
+        
+        # 고정 크기로 패딩/자르기
+        target_size = 128
+        if len(vectors) < target_size:
+            vectors.extend([0.0] * (target_size - len(vectors)))
+        else:
+            vectors = vectors[:target_size]
+        
+        return np.array(vectors)
+    
+    def _text_to_vector(self, text: str) -> np.ndarray:
+        """텍스트를 벡터로 변환 (간단한 해시 기반)"""
+        # 실제로는 sentence-transformers 사용 권장
+        hash_val = hash(text) % (2**31)
+        np.random.seed(hash_val)
+        return np.random.randn(128)
+
+# =====================================================
+# PHOENIX Retention 모델 구현
+# =====================================================
+
+class HierarchicalRetention(nn.Module):
+    """계층적 Retention (단기/중기/장기)"""
+    
+    def __init__(self, d_model, d_state):
+        super().__init__()
+        self.d_model = d_model
+        self.d_state = d_state
+        
+        # 3-tier states
+        self.short_decay = 0.5
+        self.medium_decay = 0.8
+        self.long_decay = 0.95
+        
+        # Projection layers
+        self.proj_short = nn.Linear(d_model, d_state)
+        self.proj_medium = nn.Linear(d_state, d_state)
+        self.proj_long = nn.Linear(d_state, d_state * 2)
+        
+        # Fusion
+        self.fusion = nn.Linear(d_state * 4, d_model)
+        
+    def forward(self, x):
+        batch_size, seq_len, _ = x.shape
+        
+        # Initialize states
+        short_state = torch.zeros(batch_size, self.d_state).to(x.device)
+        medium_state = torch.zeros(batch_size, self.d_state).to(x.device)
+        long_state = torch.zeros(batch_size, self.d_state * 2).to(x.device)
+        
+        outputs = []
+        
+        for t in range(seq_len):
+            x_t = x[:, t, :]
+            
+            # Short-term update (every token)
+            short_input = self.proj_short(x_t)
+            short_state = self.short_decay * short_state + short_input
+            
+            # Medium-term update (every 8 tokens)
+            if t % 8 == 0:
+                medium_state = self.medium_decay * medium_state + self.proj_medium(short_state)
+            
+            # Long-term update (every 64 tokens)
+            if t % 64 == 0:
+                long_state = self.long_decay * long_state + self.proj_long(medium_state)
+            
+            # Fuse all tiers
+            combined = torch.cat([short_state, medium_state, long_state], dim=-1)
+            output_t = self.fusion(combined)
+            outputs.append(output_t)
+        
+        outputs = torch.stack(outputs, dim=1)
+        
+        return outputs, {
+            'short_state': short_state,
+            'medium_state': medium_state,
+            'long_state': long_state
+        }
+
+class AdaptiveCompression(nn.Module):
+    """적응적 압축"""
+    
+    def __init__(self, d_state):
+        super().__init__()
+        self.importance_net = nn.Linear(d_state, 1)
+        self.compressor = nn.Sequential(
+            nn.Linear(d_state, d_state // 2),
+            nn.GELU(),
+            nn.Linear(d_state // 2, d_state)
+        )
+    
+    def forward(self, state, importance_threshold=0.5):
+        importance = torch.sigmoid(self.importance_net(state))
+        
+        # 중요도에 따라 압축
+        mask = (importance > importance_threshold).float()
+        compressed = state * mask + self.compressor(state) * (1 - mask)
+        
+        return compressed, importance.mean().item()
+
+class DynamicPowerRetention(nn.Module):
+    """동적 Power 조절"""
+    
+    def __init__(self, d_model):
+        super().__init__()
+        self.power_predictor = nn.Sequential(
+            nn.Linear(d_model, 64),
+            nn.ReLU(),
+            nn.Linear(64, 1),
+            nn.Sigmoid()
+        )
+        
+        self.min_power = 1.5
+        self.max_power = 5.0
+    
+    def compute_power(self, x):
+        power_ratio = self.power_predictor(x.mean(dim=1, keepdim=True))
+        power = self.min_power + power_ratio * (self.max_power - self.min_power)
+        return power.mean().item()
+
+class PHOENIXRetention(nn.Module):
+    """PHOENIX Retention 통합 모델"""
+    
+    def __init__(self, d_model=512, d_state=256, num_layers=12, device='cuda'):
+        super().__init__()
+        self.d_model = d_model
+        self.d_state = d_state
+        self.num_layers = num_layers
+        self.device = device
+        
+        # Core components
+        self.hierarchical = HierarchicalRetention(d_model, d_state)
+        self.compressor = AdaptiveCompression(d_state)
+        self.power_adapter = DynamicPowerRetention(d_model)
+        
+        # Layer norm
+        self.norm = nn.LayerNorm(d_model)
+        
+        self.to(device)
+    
+    def forward(self, x, return_states=True):
+        # Hierarchical retention
+        h_out, states = self.hierarchical(x)
+        
+        # Adaptive compression
+        compressed_state = states['short_state']
+        compressed, compression_ratio = self.compressor(compressed_state)
+        
+        # Dynamic power
+        power = self.power_adapter.compute_power(x)
+        
+        # Normalize output
+        output = self.norm(h_out)
+        
+        if return_states:
+            return output, {
+                'short_state': states['short_state'],
+                'medium_state': states['medium_state'],
+                'long_state': states['long_state'],
+                'compression_ratio': compression_ratio,
+                'dynamic_power': power
+            }
+        return output
+
+class BrumbyRetention(nn.Module):
+    """Brumby 베이스라인"""
+    
+    def __init__(self, d_model=512, d_state=256, power=2, device='cuda'):
+        super().__init__()
+        self.d_model = d_model
+        self.d_state = d_state
+        self.power = power
+        self.device = device
+        
+        self.proj_q = nn.Linear(d_model, d_state)
+        self.proj_k = nn.Linear(d_model, d_state)
+        self.proj_v = nn.Linear(d_model, d_state)
+        self.proj_out = nn.Linear(d_state, d_model)
+        
+        self.to(device)
+    
+    def forward(self, x, return_states=True):
+        batch_size, seq_len, _ = x.shape
+        
+        Q = self.proj_q(x)
+        K = self.proj_k(x)
+        V = self.proj_v(x)
+        
+        # Simple retention (simplified)
+        state = torch.zeros(batch_size, self.d_state).to(x.device)
+        outputs = []
+        
+        for t in range(seq_len):
+            state = 0.9 * state + V[:, t, :] @ K[:, t, :].T
+            output_t = state @ Q[:, t, :].unsqueeze(-1)
+            outputs.append(output_t.squeeze(-1))
+        
+        outputs = torch.stack(outputs, dim=1)
+        outputs = self.proj_out(outputs)
+        
+        if return_states:
+            return outputs, {
+                'state': state,
+                'power': self.power
+            }
+        return outputs
+
+# =====================================================
+# 유틸리티 함수들
+# =====================================================
+
+def calculate_metrics(output, states):
+    """메트릭 계산"""
+    metrics = {}
+    
+    # 메모리 사용량 (대략적)
+    total_params = sum(p.numel() for p in [output] if isinstance(p, torch.Tensor))
+    metrics['memory_mb'] = (total_params * 4) / (1024 * 1024)  # float32 = 4 bytes
+    
+    # Retention 비율
+    if 'short_state' in states:
+        metrics['avg_retention'] = states['short_state'].abs().mean().item()
+    else:
+        metrics['avg_retention'] = 0.5
+    
+    # 압축률
+    if 'compression_ratio' in states:
+        metrics['compression_ratio'] = states['compression_ratio']
+    else:
+        metrics['compression_ratio'] = 0.5
+    
+    # State 크기
+    if 'short_state' in states:
+        metrics['state_size'] = states['short_state'].shape[-1]
+    else:
+        metrics['state_size'] = 256
+    
+    return metrics
+
+def plot_retention_states(states):
+    """Retention states 시각화"""
+    fig = go.Figure()
+    
+    if 'short_state' in states:
+        short = states['short_state'].detach().cpu().numpy().flatten()
+        fig.add_trace(go.Scatter(
+            y=short[:100],
+            mode='lines',
+            name='Short-term',
+            line=dict(color='red', width=2)
+        ))
+    
+    if 'medium_state' in states:
+        medium = states['medium_state'].detach().cpu().numpy().flatten()
+        fig.add_trace(go.Scatter(
+            y=medium[:100],
+            mode='lines',
+            name='Medium-term',
+            line=dict(color='blue', width=2)
+        ))
+    
+    if 'long_state' in states:
+        long = states['long_state'].detach().cpu().numpy().flatten()
+        fig.add_trace(go.Scatter(
+            y=long[:100],
+            mode='lines',
+            name='Long-term',
+            line=dict(color='green', width=2)
+        ))
+    
+    fig.update_layout(
+        title='Retention State Visualization',
+        xaxis_title='Dimension',
+        yaxis_title='Activation',
+        hovermode='x unified',
+        template='plotly_white'
+    )
+    
+    return fig
+
+def plot_memory_usage(metrics):
+    """메모리 사용량 시각화"""
+    fig = go.Figure(go.Bar(
+        x=['Memory (MB)', 'State Size', 'Compression Ratio'],
+        y=[
+            metrics.get('memory_mb', 0),
+            metrics.get('state_size', 0) / 10,  # Scale down
+            metrics.get('compression_ratio', 0) * 100  # Percentage
+        ],
+        marker_color=['lightblue', 'lightgreen', 'lightyellow']
+    ))
+    
+    fig.update_layout(
+        title='Memory & Compression Metrics',
+        yaxis_title='Value',
+        template='plotly_white'
+    )
+    
+    return fig
+
+def plot_performance_comparison(df):
+    """성능 비교 시각화"""
+    fig = go.Figure()
+    
+    # 속도 비교
+    fig.add_trace(go.Bar(
+        name='Execution Time (s)',
+        x=df['model'],
+        y=df['time'],
+        marker_color='indianred'
+    ))
+    
+    # 처리량 비교
+    fig.add_trace(go.Bar(
+        name='Throughput (tokens/s)',
+        x=df['model'],
+        y=df['throughput'],
+        marker_color='lightsalmon',
+        yaxis='y2'
+    ))
+    
+    fig.update_layout(
+        title='Model Performance Comparison',
+        xaxis_title='Model',
+        yaxis_title='Time (s)',
+        yaxis2=dict(
+            title='Throughput',
+            overlaying='y',
+            side='right'
+        ),
+        barmode='group',
+        template='plotly_white'
+    )
+    
+    return fig
+
+# =====================================================
+# 모델 초기화
+# =====================================================
+
+def initialize_models():
+    """모델들 초기화"""
+    models = {}
+    
+    try:
+        models['phoenix_small'] = PHOENIXRetention(
+            d_model=512,
+            d_state=256,
+            num_layers=12,
+            device=DEVICE
+        )
+        
+        models['phoenix_medium'] = PHOENIXRetention(
+            d_model=1024,
+            d_state=512,
+            num_layers=24,
+            device=DEVICE
+        )
+        
+        models['brumby_baseline'] = BrumbyRetention(
+            d_model=512,
+            d_state=256,
+            power=2,
+            device=DEVICE
+        )
+        
+        print("✅ Models initialized successfully")
+        return models
+        
+    except Exception as e:
+        print(f"❌ Model initialization failed: {e}")
+        return {}
+
+# 데이터베이스 및 모델 초기화
+db = ExperimentDatabase(DB_PATH)
+vector_store = RetentionVectorStore(VECTOR_DB_PATH)
+MODELS = initialize_models()
+
+# =====================================================
+# Gradio 인터페이스 함수들
+# =====================================================
+
+def run_retention_experiment(
+    model_type, input_text, sequence_length,
+    power_mode, compression_level, use_hierarchical
+):
+    """PHOENIX Retention 실험 실행"""
+    try:
+        start_time = time.time()
+        
+        if model_type not in MODELS:
+            return "❌ 모델을 찾을 수 없습니다.", None, None
+        
+        model = MODELS[model_type]
+        
+        # 실험 설정
+        config = {
+            'model_type': model_type,
+            'sequence_length': sequence_length,
+            'power_mode': power_mode,
+            'compression_level': compression_level,
+            'use_hierarchical': use_hierarchical,
+            'timestamp': datetime.now().isoformat()
+        }
+        
+        # 더미 입력 생성
+        x = torch.randn(1, sequence_length, model.d_model).to(DEVICE)
+        
+        # Forward pass
+        with torch.no_grad():
+            output, states = model(x, return_states=True)
+        
+        elapsed_time = time.time() - start_time
+        
+        # 메트릭 계산
+        metrics = calculate_metrics(output, states)
+        metrics['elapsed_time'] = elapsed_time
+        metrics['throughput'] = sequence_length / elapsed_time
+        
+        # 데이터베이스에 저장
+        experiment_id = db.save_experiment(config, metrics)
+        
+        # 벡터 저장소에 저장
+        vector_store.add_retention_state(experiment_id, states, config)
+        
+        # 결과 텍스트
+        result_text = f"""
+## 🎯 실험 결과 (ID: {experiment_id})
+
+### ⚙️ 설정
+- **모델**: {model_type}
+- **시퀀스 길이**: {sequence_length} 토큰
+- **Power 모드**: {power_mode}
+- **압축 레벨**: {compression_level}
+- **계층적 사용**: {"✅" if use_hierarchical else "❌"}
+
+### 📊 성능 메트릭
+- **실행 시간**: {elapsed_time:.3f}초
+- **처리 속도**: {metrics['throughput']:.1f} 토큰/초
+- **메모리 사용**: {metrics['memory_mb']:.1f} MB
+- **State 크기**: {metrics['state_size']} 차원
+
+### 🧠 Retention 분석
+- **평균 Retention 비율**: {metrics['avg_retention']:.3f}
+- **압축률**: {metrics['compression_ratio']:.2%}
+- **동적 Power**: {states.get('dynamic_power', 2.0):.2f}
+
+✅ **실험이 성공적으로 완료되었습니다!**
+        """
+        
+        # 시각화
+        fig_states = plot_retention_states(states)
+        fig_memory = plot_memory_usage(metrics)
+        
+        return result_text, fig_states, fig_memory
+        
+    except Exception as e:
+        return f"❌ 실험 실패: {str(e)}", None, None
+
+def compare_retention_methods(input_text, sequence_length, benchmark_tasks):
+    """모델 비교"""
+    try:
+        results = []
+        
+        for model_name, model in MODELS.items():
+            start_time = time.time()
+            
+            x = torch.randn(1, sequence_length, model.d_model).to(DEVICE)
+            
+            with torch.no_grad():
+                output, states = model(x, return_states=True)
+            
+            elapsed_time = time.time() - start_time
+            metrics = calculate_metrics(output, states)
+            
+            results.append({
+                'model': model_name,
+                'time': elapsed_time,
+                'memory': metrics.get('memory_mb', 0),
+                'throughput': sequence_length / elapsed_time
+            })
+        
+        df = pd.DataFrame(results)
+        fig = plot_performance_comparison(df)
+        
+        comparison_text = f"""
+## 🏆 모델 비교 결과
+
+### ⚡ 속도 순위
+{df.sort_values('time')[['model', 'time']].to_markdown(index=False)}
+
+### 🚀 처리량 순위
+{df.sort_values('throughput', ascending=False)[['model', 'throughput']].to_markdown(index=False)}
+
+### 💾 메모리 효율성
+{df.sort_values('memory')[['model', 'memory']].to_markdown(index=False)}
+        """
+        
+        return comparison_text, fig
+        
+    except Exception as e:
+        return f"❌ 비교 실패: {str(e)}", None
+
+def search_experiments(query, top_k=10):
+    """실험 검색"""
+    try:
+        results = vector_store.search(query, top_k=top_k)
+        
+        if not results:
+            return "🔍 검색 결과가 없습니다."
+        
+        search_text = "## 🔍 검색 결과\n\n"
+        
+        for i, result in enumerate(results, 1):
+            exp_id = result['experiment_id']
+            score = result['score']
+            metadata = result['metadata']
+            
+            search_text += f"""
+### {i}. 실험 #{exp_id} (유사도: {score:.3f})
+- **모델**: {metadata.get('model_type', 'N/A')}
+- **시퀀스 길이**: {metadata.get('sequence_length', 'N/A')}
+- **시간**: {metadata.get('timestamp', 'N/A')}
+---
+            """
+        
+        return search_text
+        
+    except Exception as e:
+        return f"❌ 검색 실패: {str(e)}"
+
+def view_experiment_history(limit=20):
+    """실험 이력 조회"""
+    try:
+        experiments = db.get_recent_experiments(limit=limit)
+        
+        if not experiments:
+            return "📭 실험 이력이 없습니다.", None
+        
+        df = pd.DataFrame(experiments)
+        
+        # 시간별 성능 추이
+        fig = px.line(
+            df,
+            x='timestamp',
+            y='elapsed_time',
+            color='model_type',
+            title='모델별 실행 시간 추이'
+        )
+        
+        history_text = f"""
+## 📊 실험 이력 ({len(df)}개)
+
+{df[['id', 'model_type', 'sequence_length', 'elapsed_time', 'throughput', 'timestamp']].to_markdown(index=False)}
+        """
+        
+        return history_text, fig
+        
+    except Exception as e:
+        return f"❌ 이력 조회 실패: {str(e)}", None
+
+def get_database_statistics():
+    """데이터베이스 통계"""
+    try:
+        stats = db.get_statistics()
+        
+        stats_text = f"""
+## 📊 데이터베이스 통계
+
+### 전체 현황
+- **총 실험 수**: {stats['total_experiments']}
+
+### 모델별 실험 수
+"""
+        for model, count in stats['by_model'].items():
+            stats_text += f"- **{model}**: {count}개\n"
+        
+        return stats_text
+        
+    except Exception as e:
+        return f"❌ 통계 조회 실패: {str(e)}"
+
+# =====================================================
+# Gradio UI 구성
+# =====================================================
+
+with gr.Blocks(
+    title="🔮 PHOENIX Retention Research Platform",
+    theme=gr.themes.Soft(),
+) as demo:
+    
+    gr.Markdown("""
+    # 🔮 PHOENIX Retention Research Platform
+    
+    **Post-Hierarchical Optimized Efficient Neural Infinite-conteXt**
+    
+    Brumby를 뛰어넘는 차세대 Attention-Free 아키텍처 연구 플랫폼
+    
+    ---
+    """)
+    
+    with gr.Tabs():
+        
+        # Tab 1: 실험 실행
+        with gr.Tab("🧪 실험 실행"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    model_select = gr.Dropdown(
+                        choices=list(MODELS.keys()),
+                        value='phoenix_small',
+                        label="모델 선택"
+                    )
+                    
+                    input_text = gr.Textbox(
+                        label="입력 텍스트",
+                        placeholder="실험할 텍스트를 입력하세요...",
+                        lines=5,
+                        value="PHOENIX Retention hierarchical memory system"
+                    )
+                    
+                    sequence_length = gr.Slider(
+                        minimum=16, maximum=1024, value=128, step=16,
+                        label="시퀀스 길이"
+                    )
+                    
+                    power_mode = gr.Radio(
+                        choices=["Fixed (2)", "Dynamic", "Adaptive"],
+                        value="Dynamic",
+                        label="Power 모드"
+                    )
+                    
+                    compression_level = gr.Slider(
+                        minimum=0.0, maximum=1.0, value=0.5, step=0.1,
+                        label="압축 레벨"
+                    )
+                    
+                    use_hierarchical = gr.Checkbox(
+                        value=True,
+                        label="계층적 Retention 사용"
+                    )
+                    
+                    run_btn = gr.Button("🚀 실험 실행", variant="primary")
+                
+                with gr.Column(scale=2):
+                    result_output = gr.Markdown(label="실험 결과")
+                    
+                    with gr.Row():
+                        states_plot = gr.Plot(label="Retention States")
+                        memory_plot = gr.Plot(label="메모리 사용량")
+            
+            run_btn.click(
+                fn=run_retention_experiment,
+                inputs=[model_select, input_text, sequence_length, 
+                       power_mode, compression_level, use_hierarchical],
+                outputs=[result_output, states_plot, memory_plot]
+            )
+        
+        # Tab 2: 모델 비교
+        with gr.Tab("⚔️ 모델 비교"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    compare_text = gr.Textbox(
+                        label="비교 텍스트",
+                        lines=5,
+                        value="Performance comparison test"
+                    )
+                    
+                    compare_length = gr.Slider(
+                        minimum=64, maximum=2048, value=512, step=64,
+                        label="시퀀스 길이"
+                    )
+                    
+                    benchmark_tasks = gr.CheckboxGroup(
+                        choices=["속도", "메모리", "처리량"],
+                        value=["속도", "메모리"],
+                        label="벤치마크 항목"
+                    )
+                    
+                    compare_btn = gr.Button("⚔️ 비교 시작", variant="primary")
+                
+                with gr.Column(scale=2):
+                    compare_result = gr.Markdown(label="비교 결과")
+                    compare_plot = gr.Plot(label="성능 비교")
+            
+            compare_btn.click(
+                fn=compare_retention_methods,
+                inputs=[compare_text, compare_length, benchmark_tasks],
+                outputs=[compare_result, compare_plot]
+            )
+        
+        # Tab 3: 실험 이력
+        with gr.Tab("📊 실험 이력"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    history_limit = gr.Slider(
+                        minimum=10, maximum=100, value=20, step=10,
+                        label="조회 개수"
+                    )
+                    
+                    history_btn = gr.Button("📊 이력 조회", variant="primary")
+                    
+                    gr.Markdown("---")
+                    
+                    search_query = gr.Textbox(
+                        label="실험 검색",
+                        placeholder="검색어 입력..."
+                    )
+                    
+                    search_btn = gr.Button("🔍 검색", variant="secondary")
+                    
+                    gr.Markdown("---")
+                    
+                    stats_btn = gr.Button("📈 통계 보기", variant="secondary")
+                
+                with gr.Column(scale=2):
+                    history_output = gr.Markdown(label="결과")
+                    history_plot = gr.Plot(label="추이 그래프")
+            
+            history_btn.click(
+                fn=view_experiment_history,
+                inputs=[history_limit],
+                outputs=[history_output, history_plot]
+            )
+            
+            search_btn.click(
+                fn=search_experiments,
+                inputs=[search_query],
+                outputs=[history_output]
+            )
+            
+            stats_btn.click(
+                fn=get_database_statistics,
+                outputs=[history_output]
+            )
+    
+    gr.Markdown("""
+    ---
+    
+    ### 🔥 PHOENIX 핵심 혁신
+    
+    1. **계층적 기억** - 단기/중기/장기 메모리 분리
+    2. **적응적 압축** - 중요도 기반 동적 압축
+    3. **동적 Power** - 입력 따라 자동 최적화
+    4. **병렬 경로** - 다중 전략 동시 운영
+    
+    **VIDraft AI Research Lab** | L40S GPU + Persistent Storage
+    """)
+
+# =====================================================
+# 앱 실행
+# =====================================================
+
+if __name__ == "__main__":
+    demo.queue(max_size=20)
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )